'use strict';

var Promise = require('bluebird');
Promise.longStackTraces();
var assert = require('assert');

/*jshint -W079 */
var openDatabase = require('../');

function expectError(promise) {
  return promise.then(function () {
    throw new Error('expected an error');
  }, function (err) {
    assert(err, 'error was thrown');
  });
}

describe('basic test suite', function () {

  this.timeout(60000);

  it('throw error for openDatabase args < 1', function () {
    return expectError(Promise.resolve().then(function () {
      openDatabase();
    }));
  });
  it('throw error for openDatabase args < 2', function () {
    return expectError(Promise.resolve().then(function () {
      openDatabase(':memory:');
    }));
  });
  it('throw error for openDatabase args < 3', function () {
    return expectError(Promise.resolve().then(function () {
      openDatabase(':memory:', 'yolo');
    }));
  });

  it('throw error for openDatabase args < 4', function () {
    return expectError(Promise.resolve().then(function () {
      openDatabase(':memory:', 'yolo', 'hey');
    }));
  });

  it('does a basic database operation', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);
    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('SELECT 1 + 1', [], function (txn, result) {
          resolve(result);
        }, function (txn, err) {
          reject(err);
        });
      });
    }).then(function (res) {
      assert.equal(res.rowsAffected, 0);
      assert.equal(res.rows.length, 1);
      assert.equal(res.rows.item(0)['1 + 1'], 2);
    });
  });

  it('handles an error - select', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);
    return expectError(new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('SELECT foo FROM yolo', [], function (txn, result) {
          resolve(result);
        }, function (txn, err) {
          reject(err);
        });
      });
    }));
  });

  it('handles an error - drop', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);
    return expectError(new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('DROP TABLE blargy blah', [], function (txn, result) {
          resolve(result);
        }, function (txn, err) {
          reject(err);
        });
      });
    }));
  });

  it('handles an error - delete', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);
    return expectError(new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('DELETE FROM yolo', [], function (txn, result) {
          resolve(result);
        }, function (txn, err) {
          reject(err);
        });
      });
    }));
  });

  it('handles an error - create', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);
    return expectError(new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE blargy blah', [], function (txn, result) {
          resolve(result);
        }, function (txn, err) {
          reject(err);
        });
      });
    }));
  });

  it('handles an error - insert', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);
    return expectError(new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('INSERT INTO blargy blah', [], function (txn, result) {
          resolve(result);
        }, function (txn, err) {
          reject(err);
        });
      });
    }));
  });

  it('does multiple queries', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);
    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('SELECT 1 + 1', [], function (txn, result) {
          resolve(result);
        }, function (txn, err) {
          reject(err);
        });
      });
    }).then(function (res) {
      assert.equal(res.rowsAffected, 0);
      assert.equal(res.rows.length, 1);
      assert.equal(res.rows.item(0)['1 + 1'], 2);

      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT 2 + 1', [], function (txn, result) {
            resolve(result);
          }, function (txn, err) {
            reject(err);
          });
        });
      });
    }).then(function (res) {
      assert.equal(res.rowsAffected, 0);
      assert.equal(res.rows.length, 1);
      assert.equal(res.rows.item(0)['2 + 1'], 3);
    });
  });

  it('does multiple queries, same event loop', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);
    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        var results = new Array(2);
        var done = 0;
        function checkDone() {
          if (++done === 2) {
            resolve(results);
          }
        }

        txn.executeSql('SELECT 1 + 1', [], function (txn, result) {
          results[0] = result;
          checkDone();
        }, function (txn, err) {
          reject(err);
        });

        txn.executeSql('SELECT 2 + 1', [], function (txn, result) {
          results[1] = result;
          checkDone();
        }, function (txn, err) {
          reject(err);
        });

      });
    }).then(function (results) {
      assert.equal(results[0].rowsAffected, 0);
      assert.equal(results[0].rows.length, 1);
      assert.equal(results[0].rows.item(0)['1 + 1'], 2);

      assert.equal(results[1].rowsAffected, 0);
      assert.equal(results[1].rows.length, 1);
      assert.equal(results[1].rows.item(0)['2 + 1'], 3);
    });
  });

  it('calls transaction complete callback', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);

    var called = 0;

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('SELECT 1 + 1', [], function () {
          called++;
        });
        txn.executeSql('SELECT 1 + 1', [], function () {
          called++;
          txn.executeSql('SELECT 1 + 1', [], function () {
            called++;
            txn.executeSql('SELECT 1 + 1', [], function () {
              called++;
            });
          });
        });
      }, reject, resolve);
    }).then(function () {
      assert.equal(called, 4);
    });
  });

  it('calls transaction complete callback - empty txn', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);

    var called = 0;

    return new Promise(function (resolve, reject) {
      db.transaction(function () {
      }, reject, resolve);
    }).then(function () {
      assert.equal(called, 0);
    });
  });

  it('calls transaction complete callback - null txn', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);

    return expectError(new Promise(function (resolve, reject) {
      try {
        db.transaction(null, reject, resolve);
      } catch (err) {
        reject(err);
      }
    }));
  });

  it('calls transaction error callback', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);

    var called = 0;

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('SELECT 1 + 1', [], function () {
          called++;
        });
        txn.executeSql('SELECT 1 + 1', [], function () {
          called++;
          txn.executeSql('SELECT 1 + 1', [], function () {
            called++;
            txn.executeSql('SELECT yolo from baz', [], function () {
              called++;
            });
          });
        });
      }, function (err) {
        if (!err) {
          return reject(new Error('expected an error here'));
        }
        resolve();
      }, reject);
    }).then(function () {
      assert.equal(called, 3);
    });
  });

  it('recovers from errors', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);

    var called = 0;

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('SELECT 1 + 1', [], function () {
          called++;
        });
        txn.executeSql('SELECT 1 + 1', [], function () {
          called++;
          txn.executeSql('SELECT 1 + 1', [], function () {
            called++;
            txn.executeSql('SELECT yolo from baz', [], function () {
              called++;
            }, function (err) {
              if (!err) {
                return reject(new Error('expected an error here'));
              }
              return false; // ack that the error was handled
            });
          });
        });
      }, reject, resolve);
    }).then(function () {
      assert.equal(called, 3);
    });
  });

  it('recovers from errors, returning undefined', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);

    var called = 0;

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('SELECT 1 + 1', [], function () {
          called++;
        });
        txn.executeSql('SELECT 1 + 1', [], function () {
          called++;
          txn.executeSql('SELECT 1 + 1', [], function () {
            called++;
            txn.executeSql('SELECT yolo from baz', [], function () {
              called++;
            }, function (err) {
              if (!err) {
                return reject(new Error('expected an error here'));
              }
            });
          });
        });
      }, reject, resolve);
    }).then(function () {
      assert.equal(called, 3);
    });
  });

  it('doesn\'t recover if you return true', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);

    var called = 0;

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('SELECT 1 + 1', [], function () {
          called++;
        });
        txn.executeSql('SELECT 1 + 1', [], function () {
          called++;
          txn.executeSql('SELECT 1 + 1', [], function () {
            called++;
            txn.executeSql('SELECT yolo from baz', [], function () {
              called++;
            }, function (err) {
              if (!err) {
                return reject(new Error('expected an error here'));
              }
              return true;
            });
          });
        });
      }, function (err) {
        if (!err) {
          return reject(new Error('expected an error here'));
        }
        resolve();
      }, reject);
    }).then(function () {
      assert.equal(called, 3);
    });
  });

  it('queries executed in right order', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);

    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('a');
        });
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('k');
        });
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('b');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('l');
          });
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('c');
            txn.executeSql('SELECT 1 + 1', [], function () {
              called.push('m');
            });
            txn.executeSql('SELECT 1 + 1', [], function () {
              called.push('n');
            });
            txn.executeSql('SELECT yolo from baz', [], function () {
            }, function () {
              called.push('e');
              txn.executeSql('SELECT 1 + 1', [], function () {
                called.push('f');
                txn.executeSql('SELECT yolo from baz', [], function () {
                }, function () {
                  called.push('h');
                  txn.executeSql('SELECT 1 + 1', [], function () {
                    called.push('g');
                  });
                });
                txn.executeSql('SELECT 1 + 1', [], function () {
                  called.push('o');
                });
              });
            });
            txn.executeSql('SELECT 1 + 1', [], function () {
              called.push('i');
            });
          });
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('j');
          });
        });
      }, reject, resolve);
    }).then(function () {
      assert.deepEqual(called,
        ["a","k","b","l","c","j","m","n","e","i","f","h","o","g"]);
    });
  });

  it('has a version', function () {
    var db = openDatabase(':memory:', '1.0', 'yolo', 100000);
    assert.equal(db.version, '1.0');
  });

});

function transactionPromise(db, sql, sqlArgs) {
  return new Promise(function (resolve, reject) {
    var result;
    db.transaction(function (txn) {
      txn.executeSql(sql, sqlArgs, function (txn, res) {
        result = res;
      });
    }, reject, function () {
      resolve(result);
    });
  });
}

function readTransactionPromise(db, sql, sqlArgs) {
  return new Promise(function (resolve, reject) {
    var result;
    db.readTransaction(function (txn) {
      txn.executeSql(sql, sqlArgs, function (txn, res) {
        result = res;
      });
    }, reject, function () {
      resolve(result);
    });
  });
}

function getInsertId(res) {
  try {
    return res.insertId; // WebSQL will normally throw an error on access here
  } catch (err) {
    return void 0;
  }
}

describe('dedicated db test suite - in-memory', function () {
  this.timeout(60000);

  var db;

  beforeEach(function () {
    db = openDatabase(':memory:', '1.0', 'yolo', 100000);
  });

  afterEach(function () {
    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('DROP TABLE IF EXISTS table1');
        txn.executeSql('DROP TABLE IF EXISTS table2');
        txn.executeSql('DROP TABLE IF EXISTS table3');
      }, reject, resolve);
    }).then(function () {
      db = null;
    });
  });

  it('returns correct rowsAffected/insertId 1', function () {
    var sql = 'SELECT 1 + 1';
    return transactionPromise(db, sql).then(function (res) {
      assert.equal(getInsertId(res), void 0, 'no insertId');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 1, 'rows.length');
    }).then(function () {
      var sql = 'SELECT 1 + 2';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0, 'no insertId');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 1, 'rows.length');
    });
  });

  it('returns correct rowsAffected/insertId 2', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function (res) {
      assert.equal(getInsertId(res), 0, 'insertId 1');
      assert.equal(res.rowsAffected, 0, '1 rowsAffected == ' + res.rowsAffected);
      assert.equal(res.rows.length, 0, 'rows.length');
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("foo", "bar")';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), 1, 'insertId 2');
      assert.equal(res.rowsAffected, 1, '2 rowsAffected == ' + res.rowsAffected);
      assert.equal(res.rows.length, 0, 'rows.length');
      var sql = 'SELECT * from table1';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0, 'no insertId');
      assert.equal(res.rowsAffected, 0, '3 rowsAffected == ' + res.rowsAffected);
      assert.equal(res.rows.length, 1, 'rows.length');
      assert.deepEqual(res.rows.item(0), {
        text1: 'foo',
        text2: 'bar'
      });
    });
  });

  it('returns correct rowsAffected/insertId 3', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function (res) {
      assert.equal(getInsertId(res), 0, 'insertId');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 0, 'rows.length');
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("baz", "quux")';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), 1, 'insertId');
      assert.equal(res.rowsAffected, 1, 'rowsAffected');
      assert.equal(res.rows.length, 0, 'rows.length');
      var sql = 'SELECT * from table1';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0, 'no insertId');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 1, 'rows.length');
      assert.deepEqual(res.rows.item(0), {
        text1: 'baz',
        text2: 'quux'
      });
    });
  });

  it('returns correct rowsAffected/insertId 4', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function (res) {
      assert.equal(getInsertId(res), 0, 'insertId');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 0, 'rows.length');
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("baz", "quux")';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), 1, 'insertId');
      assert.equal(res.rowsAffected, 1, 'rowsAffected');
      assert.equal(res.rows.length, 0, 'rows.length');
      var sql = 'INSERT INTO table1 VALUES ("toto", "haha")';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), 2);
      assert.equal(res.rowsAffected, 1, 'rowsAffected');
      assert.equal(res.rows.length, 0, 'rows.length');
      var sql = 'UPDATE table1 SET text1 = "baz" WHERE text2 = "foobar";';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0, 'no insertId 1');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 0, 'rows.length');
      var sql = 'UPDATE table1 SET text1 = "bongo" WHERE text2 = "haha";';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0);
      assert.equal(res.rowsAffected, 1, 'rowsAffected');
      assert.equal(res.rows.length, 0, 'rows.length');
      var sql = 'SELECT * from table1';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0, 'no insertId 2');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 2, 'rows.length');
      assert.deepEqual(res.rows.item(0), {
        text1: 'baz',
        text2: 'quux'
      });
      assert.deepEqual(res.rows.item(1), {
        text1: 'bongo',
        text2: 'haha'
      });
    });
  });

  it('returns correct rowsAffected/insertId 5', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function (res) {
      assert.equal(getInsertId(res), 0, 'insertId 1');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 0, 'rows.length');
    }).then(function () {
      var sql = 'CREATE TABLE table2 (text1 string, text2 string)';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), 0, 'insertId 2');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 0, 'rows.length');
      var sql = 'CREATE TABLE table3 (text1 string, text2 string)';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), 0, 'insertId 3');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 0, 'rows.length');
    });
  });

  it('returns correct rowsAffected/insertId - delete', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function () {
    }).then(function () {
      var sql = 'DELETE FROM table1';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0);
      assert.equal(res.rowsAffected, 0);
      assert.equal(res.rows.length, 0);
      var sql = 'INSERT INTO table1 VALUES ("toto", "haha")';
      return transactionPromise(db, sql);
    }).then(function () {
      var sql = 'DELETE FROM table1';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0);
      assert.equal(res.rowsAffected, 1);
      assert.equal(res.rows.length, 0);
    });
  });

  it('returns correct rowsAffected/insertId - delete 2', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function () {
    }).then(function () {
      var sql = 'DELETE FROM table1';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0);
      assert.equal(res.rowsAffected, 0);
      assert.equal(res.rows.length, 0);
      var sql = 'INSERT INTO table1 VALUES ("toto", "haha")';
      return transactionPromise(db, sql);
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("baz", "bar")';
      return transactionPromise(db, sql);
    }).then(function () {
      var sql = 'DELETE FROM table1';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0);
      assert.equal(res.rowsAffected, 2);
      assert.equal(res.rows.length, 0);
    });
  });

  it('returns correct rowsAffected/insertId - drop 1', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function () {
    }).then(function () {
      var sql = 'DROP TABLE table1';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0);
      assert.equal(res.rowsAffected, 0);
      assert.equal(res.rows.length, 0);
    });
  });

  it('returns correct rowsAffected/insertId - drop 2', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function () {
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("toto", "haha")';
      return transactionPromise(db, sql);
    }).then(function () {
      var sql = 'DROP TABLE table1';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0);
      assert.equal(res.rowsAffected, 0);
      assert.equal(res.rows.length, 0);
    });
  });

  it('returns correct rowsAffected/insertId - drop 3', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function () {
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("toto", "haha")';
      return transactionPromise(db, sql);
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("baz", "bar")';
      return transactionPromise(db, sql);
    }).then(function () {
      var sql = 'DROP TABLE table1';
      return transactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0);
      assert.equal(res.rowsAffected, 0);
      assert.equal(res.rows.length, 0);
    });
  });

  it('valid read transaction', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function () {
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("toto", "haha")';
      return transactionPromise(db, sql);
    }).then(function () {
      var sql = 'SELECT * from table1';
      return readTransactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0, 'no insertId 2');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 1, 'rows.length');
      assert.deepEqual(res.rows.item(0), {
        text1: 'toto',
        text2: 'haha'
      });
    });
  });

  it('throws error for writes during read-only transaction', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function () {
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("toto", "haha")';
      return transactionPromise(db, sql);
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("quux", "haha")';
      return expectError(readTransactionPromise(db, sql));
    });
  });

  it('query ignored for invalid read-only transaction write', function () {
    var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
    return transactionPromise(db, sql).then(function () {
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("toto", "haha")';
      return transactionPromise(db, sql);
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("quux", "haha")';
      return expectError(readTransactionPromise(db, sql));
    }).then(function () {
      var sql = 'SELECT * from table1';
      return readTransactionPromise(db, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0, 'no insertId 2');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 1, 'rows.length');
      assert.deepEqual(res.rows.item(0), {
        text1: 'toto',
        text2: 'haha'
      });
    });
  });
});

describe('dedicated db test suite - actual DB', function () {

  this.timeout(60000);

  var db;

  beforeEach(function () {
    db = openDatabase('testdb', '1.0', 'yolo', 100000);
  });

  afterEach(function () {
    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('DROP TABLE IF EXISTS table1');
        txn.executeSql('DROP TABLE IF EXISTS table2');
        txn.executeSql('DROP TABLE IF EXISTS table3');
      }, reject, resolve);
    }).then(function () {
      db = null;
    });
  });


  it('stores data between two DBs', function () {
    var db1 = openDatabase('testdb', '1.0', 'yolo', 100000);
    var db2 = openDatabase('testdb', '1.0', 'yolo', 100000);

    return Promise.resolve().then(function () {
      var sql = 'CREATE TABLE table1 (text1 string, text2 string)';
      return transactionPromise(db1, sql);
    }).then(function () {
      var sql = 'INSERT INTO table1 VALUES ("foo", "bar")';
      return transactionPromise(db1, sql);
    }).then(function () {
      var sql = 'SELECT * from table1;';
      return transactionPromise(db1, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0, 'no insertId');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 1, 'rows.length');
      assert.deepEqual(res.rows.item(0), {
        text1: 'foo',
        text2: 'bar'
      });
      var sql = 'SELECT * from table1;';
      return transactionPromise(db2, sql);
    }).then(function (res) {
      assert.equal(getInsertId(res), void 0, 'no insertId');
      assert.equal(res.rowsAffected, 0, 'rowsAffected');
      assert.equal(res.rows.length, 1, 'rows.length');
      assert.deepEqual(res.rows.item(0), {
        text1: 'foo',
        text2: 'bar'
      });
    });
  });
});

describe('advanced test suite - actual DB', function () {

  this.timeout(60000);

  var db;

  beforeEach(function () {
    db = openDatabase('testdb', '1.0', 'yolo', 100000);
  });

  afterEach(function () {
    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('DROP TABLE IF EXISTS table1');
        txn.executeSql('DROP TABLE IF EXISTS table2');
        txn.executeSql('DROP TABLE IF EXISTS table3');
        txn.executeSql('DROP TABLE IF EXISTS foo');
        txn.executeSql('DROP TABLE IF EXISTS yolo');
      }, reject, resolve);
    }).then(function () {
      db = null;
    });
  });

  function rowsToJson(res) {
    var output = [];
    for (var i = 0; i < res.rows.length; i++) {
      output.push(res.rows.item(i));
    }
    return JSON.parse(JSON.stringify(output));
  }

  it('handles errors and callback correctly 0', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE foo (bar text);', [], function () {
          called.push('a');
        });
        txn.executeSql('INSERT INTO foo VALUES ("baz")', [], function () {
          called.push('b');
        });
      }, function (err) {
        console.log(err);
        reject(err);
      }, resolve);
    }).then(function () {
      assert.deepEqual(called, ["a", "b"]);
    });
  });

  it('handles errors and callback correctly 1', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE foo (bar text);', [], function () {
          called.push('a');
        });
        txn.executeSql('INSERT INTO foo VALUES ("baz")', [], function () {
          called.push('b');
          txn.executeSql('INSERT INTO yolo VALUES ("hey")', [], function () {
            called.push('z');
          }, function () {
            called.push('c');
            txn.executeSql('INSERT INTO foo VALUES ("baz")', [], function () {
              called.push('f');
            });
          });
          txn.executeSql('INSERT INTO foo VALUES ("haha")', [], null, function () {
            called.push('e');
          });
        });
      }, function (err) {
        console.log(err);
        reject(err);
      }, resolve);
    }).then(function () {
      assert.deepEqual(called, ["a","b","c","f"]);
    });
  });

  it('handles errors and callback correctly 2', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (bar text);', [], function () {
          called.push('a');
        });
        txn.executeSql('INSERT INTO table1 VALUES ("buzz")', [], function () {
          called.push('b');
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'a': rowsToJson(res)});
          });
          txn.executeSql('INSERT INTO table1 VALUES ("hey")', [], null, function () {
            called.push('c');
            txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
              called.push({'d': rowsToJson(res)});
            });
            txn.executeSql('INSERT INTO table1 VALUES ("baz")', [], function () {
              called.push('f');
              txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
                called.push({'f': rowsToJson(res)});
              });
            });
            txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
              called.push({'e': rowsToJson(res)});
            });
          });
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'b': rowsToJson(res)});
          });
          txn.executeSql('INSERT INTO table1 VALUES ("haha")', [], null, function () {
            called.push('e');
            txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
              called.push({'d': rowsToJson(res)});
            });
          });
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'c': rowsToJson(res)});
          });
        });
      }, function (err) {
        console.log(err);
        reject(err);
      }, resolve);
    }).then(function () {
      assert.deepEqual(called, [
        "a",
        "b",
        {
          "a": [
            { "bar": "buzz"}
          ]
        },
        {
          "b": [
            { "bar": "buzz"},
            { "bar": "hey"}
          ]
        },
        {
          "c": [
            { "bar": "buzz"},
            { "bar": "hey"},
            { "bar": "haha"}
          ]
        }
      ]);
    });
  });

  it('handles errors and callback correctly 3', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (bar text);', [], function () {
          called.push('a');
        });
        txn.executeSql('INSERT INTO table1 VALUES ("buzz")', [], function () {
          called.push('b');
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'a': rowsToJson(res)});
          });
          txn.executeSql('INSERT INTO yolo VALUES ("hey")', [], null, function () {
            called.push('c');
            txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
              called.push({'d': rowsToJson(res)});
            });
            txn.executeSql('INSERT INTO table1 VALUES ("baz")', [], function () {
              called.push('f');
              txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
                called.push({'f': rowsToJson(res)});
              });
            });
            txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
              called.push({'e': rowsToJson(res)});
            });
          });
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'b': rowsToJson(res)});
          });
          txn.executeSql('INSERT INTO table1 VALUES ("haha")', [], null, function () {
            called.push('e');
            txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
              called.push({'d': rowsToJson(res)});
            });
          });
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'c': rowsToJson(res)});
          });
        });
      }, function (err) {
        console.log(err);
        reject(err);
      }, resolve);
    }).then(function () {
      assert.deepEqual(called, [
          "a",
          "b",
          {
            "a": [{"bar": "buzz"}]
          },
          "c",
          {
            "b": [{"bar": "buzz"}]
          },
          {
            "c": [{"bar": "buzz"}, {"bar": "haha"}
            ]
          },
          {
            "d": [{"bar": "buzz"}, {"bar": "haha"}]
          },
          "f",
          {
            "e": [{"bar": "buzz"}, {"bar": "haha"}, {"bar": "baz"}]
          },
          {
            "f": [{"bar": "buzz"}, {"bar": "haha"}, {"bar": "baz"}]
          }
        ]
      );
    });
  });

  it('handles errors and callback correctly 4', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (bar text);', [], function () {
          called.push('a');
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'1': rowsToJson(res)});
          });
        });
        txn.executeSql('INSERT INTO table1 VALUES ("a")', [], function () {
          called.push('b');
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'2': rowsToJson(res)});
          });
        });
        txn.executeSql('INSERT INTO table1 VALUES ("c")', [], function () {
          called.push('c');
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'3': rowsToJson(res)});
          });
        });
        txn.executeSql('DROP TABLE table1', [], function () {
          called.push('d');
        });
        txn.executeSql('CREATE TABLE table1 (bar text);', [], function () {
          called.push('e');
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'4': rowsToJson(res)});
          });
        });

      }, function (err) {
        console.log(err);
        reject(err);
      }, resolve);
    }).then(function () {
      assert.deepEqual(called, ["a","b","c","d","e",{"1":[]},{"2":[]},{"3":[]},{"4":[]}]
      );
    });
  });

  it('handles errors and callback correctly 5', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (bar text);', [], function () {
          called.push('a');
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'1': rowsToJson(res)});
          });
        });
        txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
          called.push({'z': rowsToJson(res)});
        });
        txn.executeSql('INSERT INTO table1 VALUES ("a")', [], function () {
          called.push('b');
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'2': rowsToJson(res)});
          });
        });
        txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
          called.push({'x': rowsToJson(res)});
        });
        txn.executeSql('INSERT INTO table1 VALUES ("b")', [], function () {
          called.push('c');
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'3': rowsToJson(res)});
          });
        });
        txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
          called.push({'y': rowsToJson(res)});
        });
        txn.executeSql('DROP TABLE table1', [], function () {
          called.push('d');
        });
        txn.executeSql('SELECT * FROM table1', [], function () {
          called.push('should not happen');
        }, function () {
          called.push('expected error');
        });
        txn.executeSql('CREATE TABLE table1 (bar text);', [], function () {
          called.push('e');
          txn.executeSql('INSERT INTO table1 VALUES ("c")', [], function () {
            called.push('w');
            txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
              called.push({'v': rowsToJson(res)});
            });
          });
          txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
            called.push({'4': rowsToJson(res)});
          });
        });
        txn.executeSql('SELECT * FROM table1', [], function (txn, res) {
          called.push({'x': rowsToJson(res)});
        });

      }, function (err) {
        console.log(err);
        reject(err);
      }, resolve);
    }).then(function () {
      assert.deepEqual(called, [
          "a",
          { "z": []},
          "b",
          { "x": [{"bar": "a"}]},
          "c",
          { "y": [{"bar": "a"}, {"bar": "b"}]},
          "d",
          "expected error",
          "e",
          { "x": []},
          { "1": []},
          { "2": []},
          { "3": []},
          "w",
          { "4": [{"bar": "c"}]},
          { "v": [{"bar": "c"}]}
        ]
      );
    });
  });

  it('rolls back after an error 1', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('INSERT INTO table1 VALUES ("a")', [], function () {
            called.push('b');
          });
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('DELETE FROM table1', [], function () {
            called.push('c');
          });
          txn.executeSql('SELECT * FROM notexist', function () {
            called.push('z');
          });
        }, resolve, reject);
      });
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["a","b","c",[{"foo":"a"}]]);
    });
  });

  it('rolls back after an error 2', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('INSERT INTO table1 VALUES ("a")', [], function () {
            called.push('b');
          });
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('DELETE FROM table1', [], function () {
            called.push('c');
            txn.executeSql('SELECT * FROM notexist', function () {
              called.push('z');
            });
          });
        }, resolve, reject);
      });
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["a","b","c",[{"foo":"a"}]]);
    });
  });

  it('rolls back after an error 3', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('INSERT INTO table1 VALUES ("a")', [], function () {
            called.push('b');
          });
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('INSERT INTO table1 VALUES ("y")', [], function () {
            called.push('d');
          });
          txn.executeSql('INSERT INTO table1 VALUES ("z")', [], function () {
            called.push('c');
            txn.executeSql('INSERT INTO table1 VALUES ("v")', [], function () {
              called.push('f');
            });
            txn.executeSql('SELECT * FROM notexist', function () {
              called.push('z');
            });
            txn.executeSql('INSERT INTO table1 VALUES ("u")', [], function () {
              called.push('g');
            });
          });
          txn.executeSql('INSERT INTO table1 VALUES ("w")', [], function () {
            called.push('e');
          });
        }, resolve, reject);
      });
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["a","b","d","c","e","f",[{"foo":"a"}]]);
    });
  });

  it('rolls back after an error 4', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('INSERT INTO table1 VALUES ("a")', [], function () {
            called.push('b');
          });
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.readTransaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function () {
            called.push('d');
          });
          // readTransaction throws an error here
          txn.executeSql('INSERT INTO table1 VALUES ("z")', [], function () {
            called.push('c');
          });
          txn.executeSql('SELECT * FROM table1', [], function () {
            called.push('e');
          });
        }, resolve, reject);
      });
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["a","b","d",[{"foo":"a"}]]);
    });
  });

  it('rolls back after an error 5', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('INSERT INTO table1 VALUES ("a")', [], function () {
            called.push('b');
          });
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.readTransaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function () {
            called.push('d');
          });
          txn.executeSql('SELECT * FROM table1', [], function () {
            called.push('e');
            txn.executeSql('SELECT * FROM table1', [], function () {
              called.push('f');
              // readTransaction throws an error here
              txn.executeSql('INSERT INTO table1 VALUES ("z")', [], function () {
                called.push('c');
              });
            });
          });
        }, resolve, reject);
      });
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["a","b","d","e","f",[{"foo":"a"}]]);
    });
  });

  it('does not roll back if caught 1', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('INSERT INTO table1 VALUES ("a")', [], function () {
            called.push('b');
          });
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.readTransaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function () {
            called.push('d');
          });
          // readTransaction throws an error here
          txn.executeSql('INSERT INTO table1 VALUES ("z")', [], function () {
            called.push('c');
          }, function () {
            called.push('g');
          });
          txn.executeSql('SELECT * FROM table1', [], function () {
            called.push('e');
          });
        }, reject, resolve);
      });
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["a","b","d","g","e",[{"foo":"a"}]]);
    });
  });

  it('does not roll back if caught 2', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('INSERT INTO table1 VALUES ("a")', [], function () {
            called.push('b');
          });
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('INSERT INTO table1 VALUES ("n")', [], function () {
            called.push('d');
          });
          txn.executeSql('INSERT INTO yolo VALUES ("z")', [], function () {
            called.push('c');
          }, function () {
            called.push('g');
            txn.executeSql('INSERT INTO table1 VALUES ("p")', [], function () {
              called.push('f');
            });
          });
          txn.executeSql('INSERT INTO table1 VALUES ("o")', [], function () {
            called.push('e');
          });
        }, reject, resolve);
      });
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, [
        "a","b","d","g","e","f",[{"foo":"a"},
          {"foo":"n"},{"foo":"o"},{"foo":"p"}]]);
    });
  });

  it('does not roll back if caught 3', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('INSERT INTO table1 VALUES ("a")', [], function () {
            called.push('b');
          });
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('INSERT INTO table1 VALUES ("n")', [], function () {
            called.push('d');
          });
          txn.executeSql('INSERT INTO yolo VALUES ("z")', [], function () {
            called.push('c');
          }, function () {
            called.push('g');
            txn.executeSql('INSERT INTO yolo VALUES ("p")', [], function () {
              called.push('f');
            }, function () {
              called.push('h');
              txn.executeSql('INSERT INTO table1 VALUES ("x")', [], function () {
                called.push('i');
              });
              txn.executeSql('INSERT INTO table1 VALUES ("y")', [], function () {
                called.push('j');
              });
              txn.executeSql('INSERT INTO table1 VALUES ("z")', [], function () {
                called.push('k');
              });
            });
          });
          txn.executeSql('INSERT INTO table1 VALUES ("o")', [], function () {
            called.push('e');
          });
        }, reject, resolve);
      });
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, [
        "a","b","d","g","e","h","i","j","k",
        [{"foo":"a"},{"foo":"n"},{"foo":"o"},{"foo":"x"},
          {"foo":"y"},{"foo":"z"}]]);
    });
  });

  it('query order matters 1', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('INSERT INTO table1 VALUES ("x")', [], function () {
          called.push('x');
        }, function () {
          called.push('y');
        });
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
        });
        txn.executeSql('INSERT INTO table1 VALUES ("y")', [], function () {
          called.push('z');
        }, function () {
          called.push('w');
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["y","a","z",[{"foo":"y"}]]);
    });
  });

  it('query order matters 2', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('INSERT INTO table1 VALUES ("x")', [], function () {
          called.push('x');
        }, function () {
          called.push('y');
        });
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('DELETE FROM table1 WHERE foo="y"', [], function () {
            called.push('c');
          });
        });
        txn.executeSql('INSERT INTO table1 VALUES ("y")', [], function () {
          called.push('z');
        }, function () {
          called.push('w');
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["y","a","z","c",[]]);
    });
  });

  it('query order matters 3', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
        });
        txn.executeSql('INSERT INTO table1 VALUES ("y")', [], function () {
          called.push('b');
        });
        txn.executeSql('DELETE FROM table1 WHERE foo="y"', [], function () {
          called.push('c');
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["a","b","c",[]]);
    });
  });

  it('query order matters 4', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('DELETE FROM table1 WHERE foo="y"', [], function () {
            called.push('c');
          });
        });
        txn.executeSql('INSERT INTO table1 VALUES ("y")', [], function () {
          called.push('b');
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["a","b","c",[]]);
    });
  });

  it('query order matters 5', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
        });
        txn.executeSql('DELETE FROM table1 WHERE foo="y"', [], function () {
          called.push('c');
        });
        txn.executeSql('INSERT INTO table1 VALUES ("y")', [], function () {
          called.push('b');
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["a","c","b",[{"foo":"y"}]]);
    });
  });

  it('query order matters 6', function () {
    var called = [];

    return new Promise(function (resolve, reject) {
      db.transaction(function (txn) {
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('a');
          txn.executeSql('DROP TABLE table1;', [], function () {
            called.push('b');
          });
          txn.executeSql('CREATE TABLE table1 (foo text);', [], function () {
            called.push('c');
          });
          txn.executeSql('INSERT INTO table1 VALUES ("x")', [], function () {
            called.push('d');
          });
        });
        txn.executeSql('INSERT INTO table1 VALUES ("y")', [], function () {
          called.push('e');
        });
      }, reject, resolve);
    }).then(function () {
      return new Promise(function (resolve, reject) {
        db.transaction(function (txn) {
          txn.executeSql('SELECT * FROM table1', [], function (tx, res) {
            called.push(rowsToJson(res));
          });
        }, reject, resolve);
      });
    }).then(function () {
      assert.deepEqual(called, ["a","e","b","c","d",[{"foo":"x"}]]);
    });
  });

  it('callback order 1', function () {
    var called = [];
    return new Promise(function (resolve, reject) {
      var numTransactions = 2;
      var rejected;
      function done() {
        if (rejected) {
          return reject();
        }
        resolve();
      }
      function resolveOne() {
        if (!--numTransactions) {
          done();
        }
      }
      function rejectOne() {
        rejected = true;
        if (!--numTransactions) {
          done();
        }
      }

      called.push('a');
      db.transaction(function (txn) {
        called.push('b');
        txn.executeSql('CREATE TABLE table1 (foo text)', [], function () {
          called.push('c');
          txn.executeSql('DROP TABLE table1;', [], function () {
            called.push('d');
          });
          called.push('e');
          txn.executeSql('CREATE TABLE table1 (foo text);', [], function () {
            called.push('f');
          });
          called.push('g');
          txn.executeSql('INSERT INTO table1 VALUES ("x")', [], function () {
            called.push('h');
          });
          called.push('i');
        });
        called.push('j');
        txn.executeSql('INSERT INTO table1 VALUES ("y")', [], function () {
          called.push('k');
        });
        called.push('l');
      }, rejectOne, resolveOne);
      called.push('m');
      db.transaction(function (txn) {
        called.push('n');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('o');
        });
        called.push('p');
      }, rejectOne, resolveOne);
    }).then(function () {
      var expected = [
        "a","m","b","j","l","c","e","g","i","k","d","f","h","n","p","o"
      ];
      assert.deepEqual(called, expected);
    });
  });

  it('callback order 2', function () {
    var called = [];
    return new Promise(function (resolve, reject) {
      var numTransactions = 7;
      var rejected;
      function done() {
        if (rejected) {
          return reject();
        }
        resolve();
      }
      function resolveOne() {
        if (!--numTransactions) {
          done();
        }
      }
      function rejectOne() {
        rejected = true;
        if (!--numTransactions) {
          done();
        }
      }

      called.push('a');
      db.readTransaction(function (txn) {
        called.push('b');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('c');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('d');
          });
          called.push('e');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('f');
          });
          called.push('g');
        });
        called.push('j');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('k');
        });
        called.push('l');
      }, rejectOne, resolveOne);
      called.push('m');
      db.transaction(function (txn) {
        called.push('n');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('o');
        });
        called.push('p');
      }, rejectOne, resolveOne);
      called.push('1');
      db.readTransaction(function (txn) {
        called.push('2');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('3');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('4');
          });
          called.push('5');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('6');
          });
          called.push('7');
        });
        called.push('8');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('9');
        });
        called.push('10');
      }, rejectOne, resolveOne);
      called.push('11');
      db.readTransaction(function (txn) {
        called.push('alpha');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('beta');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('gamma');
          });
          called.push('delta');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('epsilon');
          });
          called.push('zeta');
        });
        called.push('eta');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('theta');
        });
        called.push('iota');
      }, rejectOne, resolveOne);
      called.push('ichi');
      db.readTransaction(function (txn) {
        called.push('ni');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('san');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('shi');
          });
          called.push('go');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('roku');
          });
          called.push('shichi');
        });
        called.push('hachi');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('kyuu');
        });
        called.push('juu');
      }, rejectOne, resolveOne);
      called.push('un');
      db.readTransaction(function (txn) {
        called.push('deux');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('trois');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('quatre');
          });
          called.push('cinq');
          txn.executeSql('SELECT 1 + 1', [], function () {
            called.push('six');
          });
          called.push('sept');
        });
        called.push('huit');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('neuf');
        });
        called.push('dix');
      }, rejectOne, resolveOne);
      called.push('onze');
      db.transaction(function (txn) {
        called.push('12');
        txn.executeSql('SELECT 1 + 1', [], function () {
          called.push('13');
        });
        called.push('14');
      }, rejectOne, resolveOne);
    }).then(function () {
      var expected = ["a", "m", "1", "11", "ichi", "un", "onze", "b", "j",
        "l", "c", "e", "g", "k", "d", "f", "n", "p", "o", "2", "8", "10",
        "3", "5", "7", "9", "4", "6", "alpha", "eta", "iota", "beta",
        "delta", "zeta", "theta", "gamma", "epsilon", "ni", "hachi", "juu",
        "san", "go", "shichi", "kyuu", "shi", "roku", "deux", "huit", "dix",
        "trois", "cinq", "sept", "neuf", "quatre", "six", "12", "14", "13"];
      assert.deepEqual(called, expected);
    });
  });

  it('callback order 3', function () {
    var called = [];
    return new Promise(function (resolve) {
      called.push('a');
      var db2 = openDatabase('testdbs/testdb-' + Math.random(),
        '1.0', 'yolo', 1, function (db3) {
        called.push('b');
        resolve([db2, db3]);
      });
      called.push('c');
    }).then(function (dbs) {
      assert(dbs[0] === dbs[1]);
      assert.deepEqual(called, ['a', 'c', 'b']);
    });
  });

});