├── .bowerrc
├── .editorconfig
├── .gitattributes
├── .gitignore
├── .jshintignore
├── .jshintrc
├── .npmignore
├── .travis.yml
├── CONTRIBUTING.md
├── EXAMPLES.md
├── LICENSE
├── README.md
├── beautify.json
├── bin
└── publish.sh
├── bower.json
├── examples
├── hello
│ ├── index-local.html
│ └── index.html
├── index.html
└── todomvc-angular
│ ├── .gitignore
│ ├── index.html
│ ├── js
│ ├── app.js
│ ├── controllers
│ │ └── todoCtrl.js
│ └── directives
│ │ ├── todoBlur.js
│ │ ├── todoEscape.js
│ │ └── todoFocus.js
│ ├── node_modules
│ ├── angular
│ │ └── angular.js
│ ├── todomvc-app-css
│ │ └── index.css
│ └── todomvc-common
│ │ ├── base.css
│ │ └── base.js
│ ├── package.json
│ └── readme.md
├── index.js
├── package.json
├── scripts
├── adapter-store.js
├── adapter.js
├── authentication-error.js
├── auto-adapter-store.js
├── collection.js
├── config.js
├── config.json
├── db.js
├── delta-db.js
├── delta-error.js
├── disabled-error.js
├── doc.js
├── index.js
├── log.js
├── sender.js
├── socket.js
└── utils.js
└── test
├── browser-coverage
├── index.html
├── phantom-hooks.js
├── server.js
└── test.js
├── browser
├── index.html
├── index.js
├── sauce-results-updater.js
├── server.js
├── test.js
└── webrunner.js
├── config.json
├── index.js
├── node
└── index.js
├── spec
├── adapter.js
├── client.js
├── config.js
├── db
│ ├── index.js
│ ├── mock-socket.js
│ ├── with-socket.js
│ └── without-socket.js
├── delta-db.js
├── doc.js
├── events.js
├── index.js
├── multiple.js
├── persist.js
├── sender.js
├── socket.js
└── utils.js
└── utils.js
/.bowerrc:
--------------------------------------------------------------------------------
1 | {
2 | "directory": "bower_components"
3 | }
4 |
--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
1 | # EditorConfig helps developers define and maintain consistent
2 | # coding styles between different editors and IDEs
3 | # editorconfig.org
4 |
5 | root = true
6 |
7 |
8 | [*]
9 |
10 | # Change these settings to your own preference
11 | indent_style = space
12 | indent_size = 2
13 |
14 | # We recommend you to keep these unchanged
15 | end_of_line = lf
16 | charset = utf-8
17 | trim_trailing_whitespace = true
18 | insert_final_newline = true
19 |
20 | [*.md]
21 | trim_trailing_whitespace = false
22 |
--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | * text=auto
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | bower_components
2 | coverage
3 | dist
4 | /node_modules
5 | test/browser/bundle.js
6 | test/browser-coverage/bundle.js
7 | .DS_Store
8 | *~
9 | npm-debug.log
10 |
--------------------------------------------------------------------------------
/.jshintignore:
--------------------------------------------------------------------------------
1 | test/browser/bundle.js
2 | test/browser-coverage/bundle.js
3 |
--------------------------------------------------------------------------------
/.jshintrc:
--------------------------------------------------------------------------------
1 | {
2 | "curly": true,
3 | "eqeqeq": true,
4 | "immed": true,
5 | "newcap": true,
6 | "noarg": true,
7 | "sub": true,
8 | "undef": true,
9 | "unused": true,
10 | "eqnull": true,
11 | "browser": true,
12 | "node": true,
13 | "strict": true,
14 | "globalstrict": true,
15 | "white": true,
16 | "indent": 2,
17 | "maxlen": 100,
18 | "globals": {
19 | "process": false,
20 | "global": false,
21 | "require": false,
22 | "console": false,
23 | "describe": false,
24 | "before": false,
25 | "beforeEach": false,
26 | "after": false,
27 | "afterEach": false,
28 | "it": false,
29 | "emit": false
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | bower_components
2 | coverage
3 | dist
4 |
--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 |
3 | node_js:
4 | - "0.12"
5 |
6 | script: npm run $COMMAND
7 |
8 | after_script: cat ./coverage/node/lcov.info ./coverage/browser/lcov.info | ./node_modules/coveralls/bin/coveralls.js
9 |
10 | after_failure:
11 | - cat /home/travis/build/delta-db/deltadb/npm-debug.log
12 |
13 | env:
14 | matrix:
15 | - COMMAND=assert-beautified
16 | - COMMAND=node-full-test
17 | - COMMAND=browser-coverage-full-test
18 |
19 | # Saucelabs tests
20 | #
21 | # NOTE: according to http://caniuse.com/#feat=sql-storage, Android 4.1-4.3 should support WebSQL,
22 | # but there appears to be some issues when testing with saucelabs. It appears extra configurations
23 | # are needed to prevent "SECURITY_ERR: DOM Exception 18" exceptions:
24 | # http://stackoverflow.com/questions/16062591. It doesn't appear that these configurations can be
25 | # made in the saucelabs environment so we will not run the IndexedDB tests in Android 4.1-4.3.
26 | - CLIENT="saucelabs:firefox" COMMAND=browser-test
27 | - CLIENT="saucelabs:firefox:34" COMMAND=browser-test
28 | - CLIENT="saucelabs:chrome" COMMAND=browser-test
29 | - CLIENT="saucelabs:internet explorer" COMMAND=browser-test
30 | - CLIENT="saucelabs:internet explorer:10" COMMAND=browser-test
31 | - CLIENT="saucelabs:internet explorer:9" COMMAND=browser-test
32 | - CLIENT="saucelabs:microsoftedge" COMMAND=browser-test
33 | - CLIENT="saucelabs:safari:9" COMMAND=browser-test
34 | - CLIENT="saucelabs:safari:8" COMMAND=browser-test
35 | - CLIENT="saucelabs:safari:7" COMMAND=browser-test
36 | - CLIENT="saucelabs:iphone:7.1" COMMAND=browser-test
37 | - CLIENT="saucelabs:iphone:8.4" COMMAND=browser-test
38 | - CLIENT="saucelabs:android:4.1" NOINDEXEDDB=true COMMAND=browser-test
39 | - CLIENT="saucelabs:android:4.2" NOINDEXEDDB=true COMMAND=browser-test
40 | - CLIENT="saucelabs:android:4.3" NOINDEXEDDB=true COMMAND=browser-test
41 | - CLIENT="saucelabs:android:4.4" COMMAND=browser-test
42 | - CLIENT="saucelabs:android:5.1" COMMAND=browser-test
43 |
44 | # NOTE: there is currently no construct that allows us to encrypt the SAUCE_USERNAME and
45 | # SAUCE_ACCESS_KEY while also allowing saucelabs testing in forked projects. See
46 | # https://github.com/travis-ci/travis-ci/issues/1946 and
47 | # https://github.com/angular/angular.js/issues/5596 for more information.
48 | global:
49 | - SAUCE_USERNAME=deltadb-user
50 | - SAUCE_ACCESS_KEY=f74addf5-f68b-4607-8005-6a1de33a3228
51 |
52 | branches:
53 | only:
54 | - master
55 | - /^pull*$/
56 |
--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | Contributing
2 | ====
3 |
4 | Committing Changes
5 | ---
6 | [Commit Message Format](https://github.com/angular/angular.js/blob/master/CONTRIBUTING.md#commit)
7 |
8 | npm run coverage
9 | npm run beautify
10 | git add -A
11 | git commit -m msg
12 | git push
13 |
14 |
15 | Updating Dependencies
16 | ---
17 | This requires having david installed globally, which is already handled by our vagrant setup.
18 |
19 | david update
20 |
21 |
22 | Building
23 | ---
24 |
25 | npm run build
26 |
27 |
28 | Publishing to npm/bowser
29 | ---
30 |
31 | First, make sure that you have previously issued `npm adduser`. Then:
32 |
33 | tin -v VERSION
34 | git diff # check that only version changed
35 | npm run build-and-publish
36 |
37 |
38 | Updating gh-pages
39 | ---
40 |
41 | git checkout gh-pages
42 | git merge master
43 | git push origin gh-pages
44 | git checkout master
45 |
46 |
47 | Run all local tests
48 | ---
49 |
50 | npm run test
51 |
52 |
53 | Run single node test
54 | ---
55 |
56 | node_modules/mocha/bin/mocha -g regex test
57 |
58 |
59 | Run subset of tests and analyze coverage
60 | ---
61 |
62 | node_modules/istanbul/lib/cli.js cover _mocha -- -g regex test
63 |
64 |
65 | Debugging Tests Using Node Inspector
66 | ---
67 |
68 | $ node-inspector # leave this running in this window
69 | Use *Chrome* to visit http://127.0.0.1:8080/?ws=127.0.0.1:8080&port=5858
70 | $ mocha -g regex test/index.js --debug-brk
71 |
72 |
73 | Run tests in a browser
74 | ---
75 |
76 | $ npm run browser-server
77 | Use browser to visit http://127.0.0.1:8001/test/browser/index.html
78 |
79 |
80 | Run Saucelabs Tests In a Specific Browser
81 | ---
82 |
83 | $ CLIENT="saucelabs:internet explorer:9" SAUCE_USERNAME=deltadb-user
84 | SAUCE_ACCESS_KEY=f74addf5-f68b-4607-8005-6a1de33a3228 npm run browser-test
85 |
--------------------------------------------------------------------------------
/EXAMPLES.md:
--------------------------------------------------------------------------------
1 | Examples
2 | ====
3 |
4 | Note:
5 | ---
6 |
7 | The examples are currently configured to work with a remote instance of deltadb-server. We recommend that you start with this configuration, but you can also run the examples against a [local deltadb-server instance](https://github.com/delta-db/deltadb-server/blob/master/INSTALL.md).
8 |
9 |
10 | Launch Web Server & View Examples
11 | ---
12 |
13 | $ npm run browser-server # Runs a http server for serving the example
14 | Visit http://127.0.0.1:8001/examples
15 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2015
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
23 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
14 | DeltaDB says
16 |
17 |
18 | DeltaDB says
20 |
21 |
49 |
50 |
51 |
52 |
53 |
--------------------------------------------------------------------------------
/examples/hello/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
9 |
10 |
11 |
12 |
13 |
14 | DeltaDB says
16 |
17 |
18 | DeltaDB says
20 |
21 |
50 |
51 |
52 |
53 |
54 |
--------------------------------------------------------------------------------
/examples/index.html:
--------------------------------------------------------------------------------
1 | Examples
2 |
3 |
7 |
--------------------------------------------------------------------------------
/examples/todomvc-angular/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/angular/*
2 | !node_modules/angular/angular.js
3 |
4 | node_modules/todomvc-app-css/*
5 | !node_modules/todomvc-app-css/index.css
6 |
7 | node_modules/todomvc-common/*
8 | !node_modules/todomvc-common/base.css
9 | !node_modules/todomvc-common/base.js
10 |
--------------------------------------------------------------------------------
/examples/todomvc-angular/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | DeltaDB & AngularJS • TodoMVC
6 | Tests Reporter Output to File
4 |
9 |
10 |
11 |
16 |
17 |
25 |
26 |
27 |
--------------------------------------------------------------------------------
/test/browser-coverage/phantom-hooks.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | module.exports = {
4 | afterEnd: function (runner) {
5 | var fs = require('fs');
6 | var coverage = runner.page.evaluate(function () {
7 | return window.__coverage__;
8 | });
9 |
10 | if (coverage) {
11 | console.log('Writing coverage to coverage/browser/coverage.json');
12 | fs.write('coverage/browser/coverage.json', JSON.stringify(coverage), 'w');
13 | } else {
14 | console.log('No coverage data generated');
15 | }
16 | }
17 | };
18 |
--------------------------------------------------------------------------------
/test/browser-coverage/server.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 |
3 | 'use strict';
4 |
5 | var HTTP_PORT = 8001;
6 | var http_server = require("http-server");
7 |
8 | http_server.createServer().listen(HTTP_PORT);
9 | console.log('Tests: http://127.0.0.1:' + HTTP_PORT + '/test/browser-coverage/index.html');
10 |
--------------------------------------------------------------------------------
/test/browser-coverage/test.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 |
3 | 'use strict';
4 |
5 | require('./server');
6 |
7 | // Uncomment for debugging
8 | // (function() {
9 | // var childProcess = require("child_process");
10 | // var oldSpawn = childProcess.spawn;
11 | // function mySpawn() {
12 | // console.log('spawn called');
13 | // console.log(arguments);
14 | // var result = oldSpawn.apply(this, arguments);
15 | // return result;
16 | // }
17 | // childProcess.spawn = mySpawn;
18 | // })();
19 |
20 | var spawn = require('child_process').spawn;
21 |
22 | var options = [
23 | 'http://127.0.0.1:8001/test/browser-coverage/index.html',
24 | '--timeout', '25000',
25 | '--hooks', 'test/browser-coverage/phantom-hooks.js'
26 | ];
27 |
28 | if (process.env.GREP) {
29 | options.push('-g');
30 | options.push(process.env.GREP);
31 | }
32 |
33 | // Unless we have mocha-phantomjs installed globally we have to specify the full path
34 | // var child = spawn('mocha-phantomjs', options);
35 | var child = spawn('./node_modules/mocha-phantomjs/bin/mocha-phantomjs', options);
36 |
37 | child.stdout.on('data', function (data) {
38 | console.log(data.toString()); // echo output, including what could be errors
39 | });
40 |
41 | child.stderr.on('data', function (data) {
42 | console.error(data.toString());
43 | });
44 |
45 | child.on('error', function (err) {
46 | console.error(err);
47 | });
48 |
49 | child.on('close', function (code) {
50 | console.log('Mocha process exited with code ' + code);
51 | if (code > 0) {
52 | process.exit(1);
53 | } else {
54 | process.exit(0);
55 | }
56 | });
57 |
--------------------------------------------------------------------------------
/test/browser/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Mocha Tests
7 |
33 |
35 |
36 |
37 |
38 |
--------------------------------------------------------------------------------
/test/browser/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | require('../node');
4 |
--------------------------------------------------------------------------------
/test/browser/sauce-results-updater.js:
--------------------------------------------------------------------------------
1 | // TODO: Is this really the best way to update the sauce lab job with the build and test status? If
2 | // so, then this should be made into a separate GH repo.
3 |
4 | 'use strict';
5 |
6 | var request = require('request'),
7 | SauceLabs = require('saucelabs'),
8 | Promise = require('bluebird');
9 |
10 | var Sauce = function (username, accessKey) {
11 | this._username = username;
12 | this._sauceLabs = new SauceLabs({
13 | username: username,
14 | password: accessKey
15 | });
16 | };
17 |
18 | Sauce.prototype.findJob = function (jobName) {
19 | // NOTE: it appears that there is no way to retrieve the job id when launching a test via the
20 | // sauce-connect-launcher package. Therefore, we will use the sauce API to look up the job id. The
21 | // saucelabs package doesn't support the full option for getJobs and we don't want to have to make
22 | // an API call for each job to determine whether the job name matches so we will execute this GET
23 | // request manually.
24 | var self = this;
25 | return new Promise(function (resolve, reject) {
26 | var url = 'https://saucelabs.com/rest/v1/' + self._username + '/jobs?full=true';
27 | request(url, function (err, res, body) {
28 | if (err) {
29 | reject(err);
30 | } else {
31 | var jobs = JSON.parse(body);
32 | jobs.forEach(function (job) {
33 | if (job.name === jobName) { // matching job name?
34 | resolve(job);
35 | }
36 | });
37 | }
38 | });
39 | });
40 | };
41 |
42 | Sauce.prototype.updateJob = function (id, data) {
43 | var self = this;
44 | return new Promise(function (resolve, reject) {
45 | self._sauceLabs.updateJob(id, data, function (err, res) {
46 | if (err) {
47 | reject(err);
48 | } else {
49 | resolve(res);
50 | }
51 | });
52 | });
53 | };
54 |
55 | Sauce.prototype.setPassed = function (jobName, build, passed) {
56 | var self = this;
57 | return self.findJob(jobName).then(function (job) {
58 | return self.updateJob(job.id, {
59 | build: build,
60 | passed: passed
61 | });
62 | });
63 | };
64 |
65 | module.exports = Sauce;
66 |
--------------------------------------------------------------------------------
/test/browser/server.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 |
3 | 'use strict';
4 |
5 | var HTTP_PORT = 8001;
6 |
7 | var http_server = require('http-server');
8 | var fs = require('fs');
9 | var indexfile = './test/browser/index.js';
10 | var dotfile = './test/browser/.bundle.js';
11 | var outfile = './test/browser/bundle.js';
12 | var watchify = require('watchify');
13 | var browserify = require('browserify');
14 |
15 | // TODO: make this configurable via an env var
16 | // Watchify appears to occasionally cause "Error: watch ENOSPC" errors in saucelabs so we'll just
17 | // disable it.
18 | var useWatchify = false;
19 |
20 | var b = browserify(indexfile, {
21 | cache: {},
22 | packageCache: {},
23 | fullPaths: true,
24 | debug: true
25 | });
26 |
27 | var filesWritten = false;
28 | var serverStarted = false;
29 | var readyCallback;
30 |
31 | function bundle() {
32 | var wb = (useWatchify ? w.bundle() : b.bundle());
33 | wb.on('error', function (err) {
34 | console.error(String(err));
35 | });
36 | wb.on('end', end);
37 | wb.pipe(fs.createWriteStream(dotfile));
38 |
39 | function end() {
40 | fs.rename(dotfile, outfile, function (err) {
41 | if (err) {
42 | return console.error(err);
43 | }
44 | console.log('Updated:', outfile);
45 | filesWritten = true;
46 | checkReady();
47 | });
48 | }
49 | }
50 |
51 | if (useWatchify) {
52 | var w = watchify(b);
53 | w.on('update', bundle);
54 | }
55 |
56 | bundle();
57 |
58 | function startServers(callback) {
59 | readyCallback = callback;
60 | http_server.createServer().listen(HTTP_PORT);
61 | console.log('Tests: http://127.0.0.1:' + HTTP_PORT + '/test/browser/index.html');
62 | serverStarted = true;
63 | checkReady();
64 | }
65 |
66 | function checkReady() {
67 | if (filesWritten && serverStarted && readyCallback) {
68 | readyCallback();
69 | }
70 | }
71 |
72 | if (require.main === module) {
73 | startServers();
74 | } else {
75 | module.exports.start = startServers;
76 | }
77 |
--------------------------------------------------------------------------------
/test/browser/test.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 |
3 | 'use strict';
4 |
5 | var wd = require('wd');
6 | var sauceConnectLauncher = require('sauce-connect-launcher');
7 | var selenium = require('selenium-standalone');
8 | var querystring = require('querystring');
9 | var SauceResultsUpdater = require('./sauce-results-updater');
10 |
11 | var server = require('./server.js');
12 |
13 | var testTimeout = 30 * 60 * 1000;
14 |
15 | var retries = 0;
16 | var MAX_RETRIES = 10;
17 | var MS_BEFORE_RETRY = 60000;
18 |
19 | var username = process.env.SAUCE_USERNAME;
20 | var accessKey = process.env.SAUCE_ACCESS_KEY;
21 |
22 | var sauceResultsUpdater = new SauceResultsUpdater(username, accessKey);
23 |
24 | // process.env.CLIENT is a colon seperated list of
25 | // (saucelabs|selenium):browserName:browserVerion:platform
26 | var clientStr = process.env.CLIENT || 'selenium:phantomjs';
27 | var tmp = clientStr.split(':');
28 | var client = {
29 | runner: tmp[0] || 'selenium',
30 | browser: tmp[1] || 'phantomjs',
31 | version: tmp[2] || null, // Latest
32 | platform: tmp[3] || null
33 | };
34 |
35 | var testUrl = 'http://127.0.0.1:8001/test/browser/index.html';
36 | var qs = {};
37 |
38 | var sauceClient;
39 | var sauceConnectProcess;
40 | var tunnelId = process.env.TRAVIS_JOB_NUMBER || 'tunnel-' + Date.now();
41 |
42 | var jobName = tunnelId + '-' + clientStr;
43 |
44 | var build = (process.env.TRAVIS_COMMIT ? process.env.TRAVIS_COMMIT : Date.now());
45 |
46 | if (client.runner === 'saucelabs') {
47 | qs.saucelabs = true;
48 | }
49 |
50 | if (process.env.GREP) {
51 | qs.grep = process.env.GREP;
52 | }
53 |
54 | if (process.env.NOINDEXEDDB) {
55 | qs.noindexeddb = process.env.NOINDEXEDDB;
56 | }
57 |
58 | testUrl += '?';
59 | testUrl += querystring.stringify(qs);
60 |
61 | function testError(e) {
62 | console.error(e);
63 | console.error('Doh, tests failed');
64 | sauceClient.quit();
65 | process.exit(3);
66 | }
67 |
68 | function postResult(result) {
69 | var failed = !process.env.PERF && result.failed;
70 | if (client.runner === 'saucelabs') {
71 | sauceResultsUpdater.setPassed(jobName, build, !failed).then(function () {
72 | process.exit(failed ? 1 : 0);
73 | });
74 | } else {
75 | process.exit(failed ? 1 : 0);
76 | }
77 | }
78 |
79 | function testComplete(result) {
80 | sauceClient.quit().then(function () {
81 | if (sauceConnectProcess) {
82 | sauceConnectProcess.close(function () {
83 | postResult(result);
84 | });
85 | } else {
86 | postResult(result);
87 | }
88 | });
89 | }
90 |
91 | function startSelenium(callback) {
92 | // Start selenium
93 | var opts = {
94 | version: '2.45.0'
95 | };
96 | selenium.install(opts, function (err) {
97 | if (err) {
98 | console.error('Failed to install selenium');
99 | process.exit(1);
100 | }
101 | selenium.start(opts, function ( /* err, server */ ) {
102 | sauceClient = wd.promiseChainRemote();
103 | callback();
104 | });
105 | });
106 | }
107 |
108 | function startSauceConnect(callback) {
109 |
110 | var options = {
111 | username: username,
112 | accessKey: accessKey,
113 | tunnelIdentifier: tunnelId
114 | };
115 |
116 | sauceConnectLauncher(options, function (err, _sauceConnectProcess) {
117 | if (err) {
118 | console.error('Failed to connect to saucelabs, err=', err);
119 |
120 | if (++retries > MAX_RETRIES) {
121 | console.log('Max retries reached, exiting');
122 | process.exit(1);
123 | } else {
124 | console.log('Retry', retries, '...');
125 | setTimeout(function () {
126 | startSauceConnect(callback);
127 | }, MS_BEFORE_RETRY);
128 | }
129 |
130 | } else {
131 | sauceConnectProcess = _sauceConnectProcess;
132 | sauceClient = wd.promiseChainRemote('localhost', 4445, username, accessKey);
133 | callback();
134 | }
135 | });
136 | }
137 |
138 | function startTest() {
139 |
140 | console.log('Starting', client);
141 |
142 | var opts = {
143 | browserName: client.browser,
144 | version: client.version,
145 | platform: client.platform,
146 | tunnelTimeout: testTimeout,
147 | name: jobName,
148 | 'max-duration': 60 * 30,
149 | 'command-timeout': 599,
150 | 'idle-timeout': 599,
151 | 'tunnel-identifier': tunnelId
152 | };
153 |
154 | sauceClient.init(opts).get(testUrl, function () {
155 |
156 | /* jshint evil: true */
157 | var interval = setInterval(function () {
158 |
159 | sauceClient.eval('window.results', function (err, results) {
160 |
161 | console.log('=> ', results);
162 |
163 | if (err) {
164 | clearInterval(interval);
165 | testError(err);
166 | } else if (results.completed || results.failures.length) {
167 | clearInterval(interval);
168 | testComplete(results);
169 | }
170 |
171 | });
172 | }, 10 * 1000);
173 | });
174 | }
175 |
176 | server.start(function () {
177 | if (client.runner === 'saucelabs') {
178 | startSauceConnect(startTest);
179 | } else {
180 | startSelenium(startTest);
181 | }
182 | });
183 |
--------------------------------------------------------------------------------
/test/browser/webrunner.js:
--------------------------------------------------------------------------------
1 | /* global mocha */
2 |
3 | (function () {
4 | 'use strict';
5 | var runner = mocha.run();
6 | window.results = {
7 | lastPassed: '',
8 | passed: 0,
9 | failed: 0,
10 | failures: []
11 | };
12 |
13 | runner.on('pass', function (e) {
14 | window.results.lastPassed = e.title;
15 | window.results.passed++;
16 | });
17 |
18 | runner.on('fail', function (e) {
19 | window.results.failed++;
20 | window.results.failures.push({
21 | title: e.title,
22 | message: e.err.message,
23 | stack: e.err.stack
24 | });
25 | });
26 |
27 | runner.on('end', function () {
28 | window.results.completed = true;
29 | window.results.passed++;
30 | });
31 | })();
32 |
--------------------------------------------------------------------------------
/test/config.json:
--------------------------------------------------------------------------------
1 | {
2 |
3 | "dbNamePrefix": "delta_test_",
4 |
5 | "systemDBNamePrefix": "delta_test_sys_",
6 |
7 | "url": {
8 | "scheme": "http",
9 | "host": "localhost",
10 | "port": 8090
11 | }
12 |
13 | }
14 |
--------------------------------------------------------------------------------
/test/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | require('./node');
4 |
--------------------------------------------------------------------------------
/test/node/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var chai = require('chai');
4 | chai.use(require('chai-as-promised'));
5 | chai.should();
6 |
7 | // NOTE: auto-adapter-store uses IndexedDB when available. The IndexedDB adapter is tested at the
8 | // deletadb-orm-nosql layer, but to be extra safe we also test it at this layer as IndexedDB is very
9 | // delicate.
10 | require('../../scripts/auto-adapter-store');
11 |
12 | if (global.deltaDBORMNoSQLNoIDB) { // don't use IndexedDB?
13 | var adapterStore = require('../../scripts/adapter-store'),
14 | MemAdapter = require('deltadb-orm-nosql/scripts/adapters/mem');
15 | adapterStore.newAdapter = function () {
16 | return new MemAdapter();
17 | };
18 | }
19 |
20 | // Set config so that our test server doesn't interfere with any production server. We need to set
21 | // the config first so that all of the following code uses this config.
22 | var config = require('../../scripts/config'),
23 | testConfig = require('../config.json');
24 | for (var i in testConfig) {
25 | config.vals[i] = testConfig[i];
26 | }
27 |
28 | require('../spec');
29 |
--------------------------------------------------------------------------------
/test/spec/adapter.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var Client = require('../../scripts/adapter');
4 |
5 | describe('adapter', function () {
6 |
7 | var client = null,
8 | db1 = null;
9 |
10 | beforeEach(function () {
11 | client = new Client(true);
12 |
13 | db1 = client.db({
14 | db: 'mydb'
15 | });
16 | });
17 |
18 | afterEach(function () {
19 | return db1.destroy();
20 | });
21 |
22 | it('should reuse dbs', function () {
23 | var db2 = client.db({
24 | db: 'mydb'
25 | });
26 | db2.should.eql(db1);
27 | });
28 |
29 | });
30 |
--------------------------------------------------------------------------------
/test/spec/config.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var config = require('../../scripts/config');
4 |
5 | describe('config', function () {
6 |
7 | it('should build url when port is missing', function () {
8 | config.vals.url.port = null;
9 | (config.url() === null).should.eql(false);
10 | });
11 |
12 | });
13 |
--------------------------------------------------------------------------------
/test/spec/db/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | describe('db', function () {
4 |
5 | require('./with-socket');
6 | require('./without-socket');
7 |
8 | });
9 |
--------------------------------------------------------------------------------
/test/spec/db/mock-socket.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var inherits = require('inherits'),
4 | EventEmitter = require('events').EventEmitter,
5 | clientUtils = require('../../../scripts/utils'),
6 | DBMissingError = require('deltadb-common-utils/scripts/errors/db-missing-error');
7 |
8 | var MockSocket = function () {
9 | this._dbs = {};
10 | this._dbs[clientUtils.SYSTEM_DB_NAME] = true; // system should always be present
11 | };
12 |
13 | inherits(MockSocket, EventEmitter);
14 |
15 | MockSocket.prototype.connect = function ( /* url */ ) {
16 | var self = this;
17 | setTimeout(function () { // trigger on next tick to allow time for binding
18 | self.emit('connect');
19 | });
20 | };
21 |
22 | MockSocket.prototype._processInit = function (msg) {
23 | if (this._dbs[msg.db]) { // db exists?
24 | this.emit('init-done');
25 | } else { // db missing
26 | this.emit('delta-error', new DBMissingError(msg.db + ' missing'));
27 | }
28 | };
29 |
30 | MockSocket.prototype._processDBAction = function (change) {
31 | var val = JSON.parse(change.val);
32 |
33 | switch (val.action) {
34 | case clientUtils.ACTION_ADD:
35 |
36 | break;
37 |
38 | case clientUtils.ACTION_REMOVE:
39 |
40 | break;
41 | }
42 | };
43 |
44 | MockSocket.prototype._processAction = function (change) {
45 | switch (change.col) {
46 | case clientUtils.DB_COLLECTION_NAME:
47 | this._processDBAction(change);
48 | break;
49 | }
50 | };
51 |
52 | MockSocket.prototype._processChange = function (change) {
53 | switch (change.name) {
54 | case clientUtils.ATTR_NAME_ACTION:
55 | this._processAction(change);
56 | break;
57 | }
58 | };
59 |
60 | MockSocket.prototype._processChanges = function (msg) {
61 | var self = this;
62 | msg.changes.forEach(function (change) {
63 | self._processChange(change);
64 | change.re = (new Date()).toISOString(); // simulate recording
65 | });
66 |
67 | // Simulate recording
68 | this.emit('changes', msg, true);
69 | };
70 |
71 | MockSocket.prototype.emit = function (event, msg, fromServer) {
72 |
73 | if (!fromServer) { // coming from client?
74 | switch (event) {
75 | case 'init':
76 | this._processInit(msg);
77 | break;
78 |
79 | case 'changes':
80 | this._processChanges(msg);
81 | break;
82 | }
83 | }
84 |
85 | return EventEmitter.prototype.emit.apply(this, arguments);
86 | };
87 |
88 | MockSocket.prototype.on = function ( /* event, callback */ ) {
89 | return EventEmitter.prototype.on.apply(this, arguments);
90 | };
91 |
92 | MockSocket.prototype.disconnect = function () {
93 | // TODO: needed?
94 | this.emit('disconnect');
95 | };
96 |
97 | module.exports = MockSocket;
98 |
--------------------------------------------------------------------------------
/test/spec/db/with-socket.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var DB = require('../../../scripts/db'),
4 | Client = require('../../../scripts/adapter'),
5 | commonUtils = require('deltadb-common-utils'),
6 | MockSocket = require('./mock-socket');
7 |
8 | describe('with-socket', function () {
9 |
10 | var db = null,
11 | client = null;
12 |
13 | afterEach(function () {
14 | if (db) {
15 | return db.destroy();
16 | }
17 | });
18 |
19 | var createClientAndDB = function (opts) {
20 | DB._SocketClass = MockSocket;
21 |
22 | client = new Client();
23 |
24 | var allOpts = {
25 | db: 'mydb'
26 | };
27 |
28 | if (opts) {
29 | allOpts = commonUtils.merge(allOpts, opts);
30 | }
31 |
32 | db = client.db(allOpts);
33 | };
34 |
35 | it('should connect', function () {
36 | createClientAndDB();
37 | });
38 |
39 | });
40 |
--------------------------------------------------------------------------------
/test/spec/db/without-socket.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var DB = require('../../../scripts/db'),
4 | MemAdapter = require('deltadb-orm-nosql/scripts/adapters/mem'),
5 | Client = require('../../../scripts/adapter'),
6 | commonUtils = require('deltadb-common-utils'),
7 | commonTestUtils = require('deltadb-common-utils/scripts/test-utils'),
8 | clientUtils = require('../../../scripts/utils'),
9 | Promise = require('bluebird');
10 |
11 | describe('without-socket', function () {
12 |
13 | var db = null,
14 | client = null;
15 |
16 | afterEach(function () {
17 | if (db) {
18 | return db.destroy(true);
19 | }
20 | });
21 |
22 | var createClientAndDB = function (opts) {
23 | client = new Client(true);
24 |
25 | var allOpts = {
26 | db: 'mydb'
27 | };
28 |
29 | if (opts) {
30 | allOpts = commonUtils.merge(allOpts, opts);
31 | }
32 |
33 | db = client.db(allOpts);
34 | };
35 |
36 | it('should reload properties', function () {
37 | var store = new MemAdapter();
38 | var client = new Client(true);
39 |
40 | var dbStore = store.db({
41 | db: 'mydb'
42 | });
43 |
44 | var propCol = dbStore.col(DB.PROPS_COL_NAME);
45 |
46 | var data = {};
47 | data[dbStore._idName] = DB.PROPS_DOC_ID;
48 | var doc = propCol.doc(data);
49 | return doc.set({
50 | since: null
51 | }).then(function () {
52 | client.db({
53 | db: 'mydb'
54 | });
55 | return null; // prevent runaway promise warning
56 | });
57 | });
58 |
59 | it('should reload db', function () {
60 |
61 | var client = new Client(true);
62 |
63 | // Wait for load after next tick to ensure there is no race condition. The following code was
64 | // failing when the DB store loading was triggered at the adapter layer.
65 | return commonUtils.timeout().then(function () {
66 | db = client.db({
67 | db: 'mydb',
68 | store: new MemAdapter().db('mydb')
69 | });
70 | return commonUtils.once(db, 'load');
71 | });
72 | });
73 |
74 | it('should throw delta errors', function () {
75 | createClientAndDB();
76 |
77 | return commonTestUtils.shouldNonPromiseThrow(function () {
78 | db._onDeltaError(new Error('my err'));
79 | }, new Error('my err'));
80 | });
81 |
82 | it('should find and emit when no changes', function () {
83 | // It is very hard to reliably guarantee the following race condition using e2e testing so we
84 | // test here
85 | var emitted = false;
86 |
87 | createClientAndDB();
88 |
89 | db._connected = true; // fake
90 |
91 | db._ready = commonUtils.resolveFactory(); // fake
92 |
93 | db._localChanges = commonUtils.resolveFactory([]); // fake
94 |
95 | db._emitChanges = function () {
96 | emitted = true;
97 | };
98 |
99 | return db._findAndEmitChanges().then(function () {
100 | emitted.should.eql(false);
101 | });
102 | });
103 |
104 | it('should find and emit when not connected', function () {
105 | // It is very hard to reliably guarantee the following race condition using e2e testing so we
106 | // test here
107 | var emitted = false;
108 |
109 | createClientAndDB();
110 |
111 | db._connected = false; // fake
112 |
113 | db._ready = commonUtils.resolveFactory(); // fake
114 |
115 | db._localChanges = commonUtils.resolveFactory([{
116 | foo: 'bar'
117 | }]); // fake
118 |
119 | db._emitChanges = function () {
120 | emitted = true;
121 | };
122 |
123 | return db._findAndEmitChanges().then(function () {
124 | emitted.should.eql(false);
125 | });
126 | });
127 |
128 | it('should build init msg with filters turned off', function () {
129 | createClientAndDB({
130 | filter: false
131 | });
132 | return commonUtils.once(db, 'load').then(function () {
133 | var msg = db._emitInitMsg();
134 | msg.filter.should.eql(false);
135 | });
136 | });
137 |
138 | it('should limit local changes within collection', function () {
139 |
140 | createClientAndDB();
141 |
142 | var tasks = db.col('tasks');
143 |
144 | var limit = 2,
145 | n = 0,
146 | promises = [];
147 |
148 | // Populate docs
149 | for (var i = 0; i < 10; i++) {
150 | var task = tasks.doc({
151 | thing: 'paint'
152 | });
153 | promises.push(task.save());
154 | }
155 |
156 | return Promise.all(promises).then(function () {
157 | return db._localChanges(null, null, limit, n);
158 | }).then(function (changes) {
159 | // Make sure changes limited
160 | // changes.changes.length.should.eql(limit); // doesn't work in IE 9
161 | (changes.changes.length === limit).should.eql(true);
162 | });
163 | });
164 |
165 | it('should limit local changes across collections', function () {
166 | var promises = [],
167 | limit = 1,
168 | n = 0;
169 |
170 | createClientAndDB();
171 |
172 | var tasks = db.col('tasks');
173 | var users = db.col('users');
174 |
175 | promises.push(tasks.doc({
176 | thing: 'paint'
177 | }).save());
178 |
179 | promises.push(users.doc({
180 | name: 'myuser'
181 | }).save());
182 |
183 | return Promise.all(promises).then(function () {
184 | return db._localChanges(null, null, limit, n);
185 | }).then(function (changes) {
186 | // Make sure changes limited
187 | // changes.changes.length.should.eql(limit); // doesn't work in IE 9
188 | (changes.changes.length === limit).should.eql(true);
189 | });
190 | });
191 |
192 | it('should find and emit changes in batches', function () {
193 | var timesEmitted = 0,
194 | promises = [];
195 |
196 | createClientAndDB();
197 |
198 | db._batchSize = 3;
199 |
200 | var tasks = db.col('tasks');
201 |
202 | db._emitChanges = function () {
203 | timesEmitted++;
204 | };
205 |
206 | // Populate docs
207 | for (var i = 0; i < 10; i++) {
208 | var task = tasks.doc({
209 | thing: 'paint' + i
210 | });
211 | promises.push(task.save());
212 | }
213 |
214 | return Promise.all(promises).then(function () {
215 | return db._findAndEmitAllChangesInBatches();
216 | }).then(function () {
217 | // ceil(10/3) = 4
218 | // timesEmitted.should.eql(4); // doesn't work in IE 9
219 | (timesEmitted === 4).should.eql(true);
220 | });
221 | });
222 |
223 | it('should add role', function () {
224 | createClientAndDB();
225 |
226 | var mockDocs = function (doc) {
227 | var nowStr = (new Date()).toISOString();
228 |
229 | var changes = [{
230 | id: doc.id(),
231 | col: doc._col._name,
232 | name: clientUtils.ATTR_NAME_ROLE,
233 | val: JSON.stringify({
234 | action: clientUtils.ACTION_ADD,
235 | userUUID: 'user-uuid',
236 | roleName: 'my-role'
237 | }),
238 | up: nowStr,
239 | re: nowStr
240 | }];
241 |
242 | db._setChanges(changes);
243 | };
244 |
245 | // Mock recording of docs
246 | db._resolveAfterRoleCreated = function (userUUID, roleName, doc) {
247 | return Promise.all([
248 | DB.prototype._resolveAfterRoleCreated.apply(this, arguments),
249 | mockDocs(doc) // mock docs after listener binds
250 | ]);
251 | };
252 |
253 | // Assume success if there is no error
254 | return db.addRole('user-uuid', 'my-role');
255 | });
256 |
257 | it('should remove role', function () {
258 | createClientAndDB();
259 |
260 | var mockDocs = function (doc) {
261 | var nowStr = (new Date()).toISOString();
262 |
263 | var changes = [{
264 | id: doc.id(),
265 | col: doc._col._name,
266 | name: clientUtils.ATTR_NAME_ROLE,
267 | val: JSON.stringify({
268 | action: clientUtils.ACTION_REMOVE,
269 | userUUID: 'user-uuid',
270 | roleName: 'my-role'
271 | }),
272 | up: nowStr,
273 | re: nowStr
274 | }];
275 |
276 | db._setChanges(changes);
277 | };
278 |
279 | // Mock recording of docs
280 | db._resolveAfterRoleDestroyed = function (userUUID, roleName, doc) {
281 | return Promise.all([
282 | DB.prototype._resolveAfterRoleDestroyed.apply(this, arguments),
283 | mockDocs(doc) // mock docs after listener binds
284 | ]);
285 | };
286 |
287 | // Assume success if there is no error
288 | return db.removeRole('user-uuid', 'my-role');
289 | });
290 |
291 | it('should create database', function () {
292 | createClientAndDB();
293 | // Assume success if there is no error
294 | return db._createDatabase('my-other-db');
295 | });
296 |
297 | it('should destroy database', function () {
298 | createClientAndDB();
299 | // Assume success if there is no error
300 | return db._destroyDatabase('my-other-db');
301 | });
302 | });
303 |
--------------------------------------------------------------------------------
/test/spec/delta-db.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var DeltaDB = require('../../scripts/delta-db'),
4 | MemAdapter = require('deltadb-orm-nosql/scripts/adapters/mem'),
5 | MockSocket = require('./db/mock-socket'),
6 | DB = require('../../scripts/db');
7 |
8 | describe('delta-db', function () {
9 |
10 | it('should create and destroy locally only', function () {
11 | var db = new DeltaDB('mydb');
12 | return db.destroy(true);
13 | });
14 |
15 | it('should uuid', function () {
16 | var uuid = DeltaDB.uuid();
17 | (uuid !== null).should.eql(true);
18 | });
19 |
20 | it('should construct with store', function () {
21 | var adapter = new MemAdapter();
22 | var dbStore = adapter.db('mydb');
23 | var db = new DeltaDB('mydb', null, null, null, dbStore);
24 | return db.destroy(true);
25 | });
26 |
27 | it('should create with url', function () {
28 | DB._SocketClass = MockSocket; // mock socket
29 | var db = new DeltaDB('mydb', 'https://example.com');
30 | return db.destroy(true);
31 | });
32 |
33 | });
34 |
--------------------------------------------------------------------------------
/test/spec/doc.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var Client = require('../../scripts/adapter'),
4 | Doc = require('../../scripts/doc'),
5 | MemAdapter = require('deltadb-orm-nosql/scripts/adapters/mem'),
6 | utils = require('deltadb-common-utils');
7 |
8 | describe('doc', function () {
9 |
10 | var client = null,
11 | db = null,
12 | tasks = null,
13 | task = null;
14 |
15 | beforeEach(function () {
16 | client = new Client(true);
17 |
18 | db = client.db({
19 | db: 'mydb',
20 | store: new MemAdapter().db('mydb')
21 | });
22 |
23 | tasks = db.col('tasks');
24 |
25 | task = tasks.doc();
26 | });
27 |
28 | afterEach(function () {
29 | return db.destroy(true);
30 | });
31 |
32 | var shouldSaveChange = function (data) {
33 | return task.set(data).then(function () {
34 |
35 | // Get the last change as we are using delete to delete the array items so the first index may
36 | // not be 0
37 | var change = task._dat.changes[task._dat.changes.length - 1];
38 |
39 | // Make sure value is being set
40 | if (data.thing === null) {
41 | (change.val === null).should.eql(true);
42 | } else {
43 | change.val.should.eql(data.thing);
44 | }
45 |
46 | // Simulate recording
47 | return task._saveChange({
48 | name: change.name,
49 | val: JSON.stringify(change.val),
50 | up: change.up.toISOString(),
51 | re: change.up.toISOString()
52 | }, false, true);
53 | }).then(function () {
54 | // Make sure change was removed
55 | utils.empty(task._dat.changes).should.eql(true);
56 | });
57 | };
58 |
59 | it('should save change', function () {
60 | return shouldSaveChange({
61 | thing: 'high'
62 | });
63 | });
64 |
65 | it('should save destroy change', function () {
66 | return shouldSaveChange({
67 | thing: 'high'
68 | }).then(function () {
69 | return task.destroy();
70 | }).then(function () {
71 |
72 | // Get the last change as we are using delete to delete the array items so the first index may
73 | // not be 0
74 | var change = task._dat.changes[task._dat.changes.length - 1];
75 |
76 | // Simulate recording of destroy
77 | return task._saveChange({
78 | name: change.name,
79 | up: change.up.toISOString(),
80 | re: change.up.toISOString()
81 | }, false, true);
82 | }).then(function () {
83 | // Make sure change was removed
84 | utils.empty(task._dat.changes).should.eql(true);
85 | });
86 | });
87 |
88 | it('should record when remote change has seq', function () {
89 | var updated = new Date();
90 |
91 | task._dat.changes = [{
92 | name: 'priority',
93 | val: 'high',
94 | up: updated,
95 | seq: 1
96 | }];
97 |
98 | task._record('priority', 'high', updated);
99 | });
100 |
101 | it('should set policy', function () {
102 |
103 | var policy = {
104 | col: {
105 | read: 'somerole'
106 | }
107 | };
108 |
109 | return task.policy(policy).then(function () {
110 | var doc = task.get();
111 | doc[Doc._policyName].should.eql(policy);
112 | });
113 |
114 | });
115 |
116 | it('should not format change', function () {
117 | // Exclude from changes when already sent
118 | var change = {
119 | sent: new Date()
120 | };
121 | var now = change.sent.getTime() - 1;
122 | task._formatChange(0, null, null, change, now);
123 | });
124 |
125 | it('should format false change', function () {
126 | var change = { // fake
127 | val: false,
128 | up: new Date()
129 | };
130 |
131 | var changes = [];
132 |
133 | task._formatChange(0, null, changes, change);
134 |
135 | changes[0].val.should.eql('false');
136 | });
137 |
138 | it('should get existing doc', function () {
139 | // Set task so that id is generated for future lookup
140 | return task.set({
141 | thing: 'sing'
142 | }).then(function () {
143 | var doc = tasks.doc(task.get());
144 | doc.should.eql(task);
145 | });
146 | });
147 |
148 | it('should save boolean change and record', function () {
149 | return shouldSaveChange({
150 | thing: false
151 | });
152 | });
153 |
154 | it('should save null change and record', function () {
155 | return shouldSaveChange({
156 | thing: null
157 | });
158 | });
159 |
160 | it('should load deleted at timestamp from store', function () {
161 | var now = new Date();
162 |
163 | // Fake store
164 | var store = {
165 | updatedAt: now,
166 | destroyedAt: now,
167 | recordedAt: now
168 | };
169 |
170 | task._loadTimestampsFromStore(store);
171 |
172 | // Make sure later timestamps from store
173 | task._dat.updatedAt.should.eql(now);
174 | task._dat.destroyedAt.should.eql(now);
175 | task._dat.recordedAt.should.eql(now);
176 |
177 | });
178 |
179 | it('should convert to iso string when truthy', function () {
180 | task._toISOStringIfTruthy(new Date('2015-11-17T04:11:38.620Z'))
181 | .should.eql('2015-11-17T04:11:38.620Z');
182 | (task._toISOStringIfTruthy(null) === null).should.eql(true);
183 | });
184 |
185 | it('should set even if contains id', function () {
186 | // The id may be present when we work with a copy of the doc's data
187 | return task.set({
188 | $id: task.id(),
189 | thing: 'sing'
190 | });
191 | });
192 |
193 | });
194 |
--------------------------------------------------------------------------------
/test/spec/events.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | // TODO: error event?
4 |
5 | // TODO: split up tests by event
6 |
7 | var commonTestUtils = require('deltadb-common-utils/scripts/test-utils'),
8 | commonUtils = require('deltadb-common-utils'),
9 | testUtils = require('../utils'),
10 | Client = require('../../scripts/adapter'),
11 | Promise = require('bluebird'),
12 | MemAdapter = require('deltadb-orm-nosql/scripts/adapters/mem');
13 |
14 | describe('events', function () {
15 |
16 | var client = null,
17 | db = null,
18 | tasks = null,
19 | task = null,
20 | client2 = null,
21 | db2 = null;
22 |
23 | var COMMON_TEST_UTILS_WAIT_MS = commonTestUtils.WAIT_MS;
24 |
25 | // Testing with IE in Saucelabs can be VERY slow therefore we need to increase the timeouts
26 | if (global.deltaDBSaucelabs && testUtils.IE) { // Saucelabs and IE?
27 | commonTestUtils.WAIT_MS = 60000;
28 | } else {
29 | commonTestUtils.WAIT_MS = commonTestUtils.WAIT_MS;
30 | }
31 |
32 | after(function () {
33 | commonTestUtils.WAIT_MS = COMMON_TEST_UTILS_WAIT_MS;
34 | });
35 |
36 | beforeEach(function () {
37 | client = new Client(true);
38 |
39 | db = client.db({
40 | db: 'mydb',
41 | store: new MemAdapter().db('mydb') // TODO: test with default store?
42 | });
43 |
44 | tasks = db.col('tasks');
45 |
46 | task = tasks.doc({
47 | $id: '1'
48 | });
49 | });
50 |
51 | afterEach(function () {
52 | return Promise.all([db.destroy(true), db2 ? db.destroy(true) : null]);
53 | });
54 |
55 | var Server = function (changes) {
56 | this.queue = function () {};
57 |
58 | this.changes = function () {
59 | return changes;
60 | };
61 | };
62 |
63 | var now = new Date(),
64 | nowStr = now.toISOString(),
65 | before = new Date('2015-01-01'),
66 | beforeStr = before.toISOString(),
67 | later = new Date(now.getTime() + 1),
68 | laterStr = later.toISOString();
69 |
70 | var eventArgsShouldEql = function (args, id, name, value) {
71 | args[0].name.should.eql(name);
72 | args[0].value.should.eql(value);
73 | args[1].id().should.eql(id);
74 | };
75 |
76 | var createLocalShouldEql = function (args) {
77 | eventArgsShouldEql(args, '1', 'priority', 'low');
78 | };
79 |
80 | var createRemoteShouldEql = function (args) {
81 | eventArgsShouldEql(args, '1', 'thing', 'sing');
82 | };
83 |
84 | // -----
85 |
86 | var createLocal = function () {
87 | task._set('priority', 'low', now); // use _set so we can force a timestamp
88 | return task.save(); // doc not registered with collection until save()
89 | };
90 |
91 | var attrShouldCreateLocal = function (emitter) {
92 | return commonTestUtils.shouldDoAndOnce(createLocal, emitter, 'attr:create').then(function (
93 | args) {
94 | createLocalShouldEql(args);
95 | });
96 | };
97 |
98 | it('doc: attr:create local', function () {
99 | attrShouldCreateLocal(task);
100 | });
101 |
102 | it('col: attr:create local', function () {
103 | attrShouldCreateLocal(tasks);
104 | });
105 |
106 | it('db: attr:create local', function () {
107 | attrShouldCreateLocal(db);
108 | });
109 |
110 | it('client: attr:create local', function () {
111 | attrShouldCreateLocal(client);
112 | });
113 |
114 | var createRemote = function () {
115 | var server = new Server([{
116 | id: '1',
117 | col: 'tasks',
118 | name: 'thing',
119 | val: '"sing"',
120 | seq: 0,
121 | up: nowStr,
122 | re: nowStr
123 | }]);
124 | return db.sync(server, true);
125 | };
126 |
127 | var attrShouldCreateRemote = function (emitter) {
128 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
129 | return commonTestUtils.shouldDoAndOnce(createRemote, emitter, 'attr:create');
130 | }).then(function (args) {
131 | createRemoteShouldEql(args);
132 | });
133 | };
134 |
135 | it('doc: attr:create remote', function () {
136 | return attrShouldCreateRemote(task);
137 | });
138 |
139 | it('col: attr:create remote', function () {
140 | return attrShouldCreateRemote(tasks);
141 | });
142 |
143 | it('db: attr:create remote', function () {
144 | return attrShouldCreateRemote(db);
145 | });
146 |
147 | it('client: attr:create remote', function () {
148 | return attrShouldCreateRemote(client);
149 | });
150 |
151 | var createRemoteSame = function () {
152 | var server = new Server([{
153 | id: '1',
154 | col: 'tasks',
155 | name: 'priority',
156 | val: '"low"',
157 | seq: 0,
158 | up: nowStr,
159 | re: nowStr
160 | }]);
161 | return db.sync(server, true);
162 | };
163 |
164 | var attrShouldCreateRemoteSame = function (emitter) {
165 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
166 | return commonTestUtils.shouldDoAndNotOnce(createRemoteSame, emitter, 'attr:create');
167 | });
168 | };
169 |
170 | it('doc: attr:create remote same', function () {
171 | // TODO: does this one test cover the code path for all events?
172 | // TODO: better to just test all cases of Doc._event?? Probably!
173 | return attrShouldCreateRemoteSame(task);
174 | });
175 |
176 | var createRemoteEarlier = function () {
177 | var server = new Server([{
178 | id: '1',
179 | col: 'tasks',
180 | name: 'priority',
181 | val: '"low"',
182 | seq: 0,
183 | up: beforeStr,
184 | re: beforeStr
185 | }]);
186 | return db.sync(server, true);
187 | };
188 |
189 | var attrShouldCreateRemoteEarlier = function (emitter) {
190 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
191 | return commonTestUtils.shouldDoAndNotOnce(createRemoteEarlier, emitter,
192 | 'attr:create');
193 | });
194 | };
195 |
196 | it('doc: attr:create remote earlier', function () {
197 | // TODO: does this one test cover the code path for all events?
198 | // TODO: better to just test all cases of Doc._event?? Probably!
199 | return attrShouldCreateRemoteEarlier(task);
200 | });
201 |
202 | // ------------------------
203 |
204 | var updateLocal = function () {
205 | return testUtils.sleep().then(function () { // sleep so update is after create
206 | task.set({
207 | 'priority': 'high'
208 | }); // use _set so we can force a timestamp
209 | return null; // prevent runaway promise warnings
210 | });
211 | };
212 |
213 | var updateShouldEql = function (args) {
214 | eventArgsShouldEql(args, '1', 'priority', 'high');
215 | };
216 |
217 | var attrShouldUpdateLocal = function (emitter) {
218 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
219 | return commonTestUtils.shouldDoAndOnce(updateLocal, emitter, 'attr:update');
220 | }).then(function (args) {
221 | updateShouldEql(args);
222 | });
223 | };
224 |
225 | it('doc: attr:update local', function () {
226 | return attrShouldUpdateLocal(task);
227 | });
228 |
229 | it('col: attr:update local', function () {
230 | return attrShouldUpdateLocal(tasks);
231 | });
232 |
233 | it('db: attr:update local', function () {
234 | return attrShouldUpdateLocal(db);
235 | });
236 |
237 | it('client: attr:update local', function () {
238 | return attrShouldUpdateLocal(client);
239 | });
240 |
241 | var updateRemote = function () {
242 | var server = new Server([{
243 | id: '1',
244 | col: 'tasks',
245 | name: 'priority',
246 | val: '"high"',
247 | seq: 0,
248 | up: laterStr,
249 | re: laterStr
250 | }]);
251 | return db.sync(server, true);
252 | };
253 |
254 | var attrShouldUpdateRemote = function (emitter) {
255 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
256 | return commonTestUtils.shouldDoAndOnce(updateRemote, emitter, 'attr:update');
257 | }).then(function (args) {
258 | updateShouldEql(args);
259 | });
260 | };
261 |
262 | it('doc: attr:update remote', function () {
263 | return attrShouldUpdateRemote(task);
264 | });
265 |
266 | it('col: attr:update remote', function () {
267 | return attrShouldUpdateRemote(tasks);
268 | });
269 |
270 | it('db: attr:update remote', function () {
271 | return attrShouldUpdateRemote(db);
272 | });
273 |
274 | it('client: attr:update remote', function () {
275 | return attrShouldUpdateRemote(client);
276 | });
277 |
278 | // ------------------------
279 |
280 | var destroyLocal = function () {
281 | return testUtils.sleep().then(function () { // sleep so destroy is after create
282 | task.unset('priority'); // use _set so we can force a timestamp
283 | return null; // prevent runaway promise warnings
284 | });
285 | };
286 |
287 | var attrShouldDestroyLocal = function (emitter) {
288 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
289 | return commonTestUtils.shouldDoAndOnce(destroyLocal, emitter, 'attr:destroy');
290 | }).then(function (args) {
291 | createLocalShouldEql(args);
292 | });
293 | };
294 |
295 | it('doc: attr:destroy local', function () {
296 | return attrShouldDestroyLocal(task);
297 | });
298 |
299 | it('col: attr:destroy local', function () {
300 | return attrShouldDestroyLocal(tasks);
301 | });
302 |
303 | it('db: attr:destroy local', function () {
304 | return attrShouldDestroyLocal(db);
305 | });
306 |
307 | it('client: attr:destroy local', function () {
308 | return attrShouldDestroyLocal(client);
309 | });
310 |
311 | var destroyRemote = function () {
312 | var server = new Server([{
313 | id: '1',
314 | col: 'tasks',
315 | name: 'priority',
316 | seq: 0,
317 | up: laterStr,
318 | re: laterStr
319 | }]);
320 |
321 | return testUtils.sleep().then(function () { // sleep so destroy is after create
322 | return db.sync(server, true);
323 | });
324 | };
325 |
326 | var attrShouldDestroyRemote = function (emitter) {
327 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
328 | return commonTestUtils.shouldDoAndOnce(destroyRemote, emitter, 'attr:destroy');
329 | }).then(function (args) {
330 | createLocalShouldEql(args);
331 | });
332 | };
333 |
334 | it('doc: attr:destroy remote', function () {
335 | return attrShouldDestroyRemote(task);
336 | });
337 |
338 | it('col: attr:destroy remote', function () {
339 | return attrShouldDestroyRemote(tasks);
340 | });
341 |
342 | it('db: attr:destroy remote', function () {
343 | return attrShouldDestroyRemote(db);
344 | });
345 |
346 | it('client: attr:destroy remote', function () {
347 | return attrShouldDestroyRemote(client);
348 | });
349 |
350 | // ------------------------
351 |
352 | var recordRemote = function () {
353 | var server = new Server([{
354 | id: '1',
355 | col: 'tasks',
356 | name: 'priority',
357 | val: '"low"',
358 | seq: 0,
359 | up: nowStr,
360 | re: laterStr
361 | }]);
362 |
363 | return testUtils.sleep().then(function () { // sleep so record is after create
364 | return db.sync(server, true);
365 | });
366 | };
367 |
368 | var attrShouldRecord = function (emitter) {
369 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
370 | return commonTestUtils.shouldDoAndOnce(recordRemote, emitter, 'attr:record');
371 | }).then(function (args) {
372 | createLocalShouldEql(args);
373 | });
374 | };
375 |
376 | it('doc: attr:record', function () {
377 | return attrShouldRecord(task);
378 | });
379 |
380 | it('col: attr:record', function () {
381 | return attrShouldRecord(tasks);
382 | });
383 |
384 | it('db: attr:record', function () {
385 | return attrShouldRecord(db);
386 | });
387 |
388 | it('client: attr:record', function () {
389 | return attrShouldRecord(client);
390 | });
391 |
392 | // ------------------------
393 |
394 | var docCreateShouldEql = function (args) {
395 | args[0].should.eql(task);
396 | };
397 |
398 | var docShouldCreateLocal = function (emitter) {
399 | return commonTestUtils.shouldDoAndOnce(createLocal, emitter, 'doc:create').then(function (
400 | args) {
401 | docCreateShouldEql(args);
402 | });
403 | };
404 |
405 | it('doc: doc:create local', function () {
406 | return docShouldCreateLocal(task);
407 | });
408 |
409 | it('col: doc:create local', function () {
410 | return docShouldCreateLocal(tasks);
411 | });
412 |
413 | it('db: doc:create local', function () {
414 | return docShouldCreateLocal(db);
415 | });
416 |
417 | it('client: doc:create local', function () {
418 | return docShouldCreateLocal(client);
419 | });
420 |
421 | var argsShouldEqlTask = function (args) {
422 | return tasks.get('1').then(function (newTask) {
423 | args[0].should.eql(newTask);
424 | });
425 | };
426 |
427 | var docShouldCreateRemote = function (emitter) {
428 | return commonTestUtils.shouldDoAndOnce(createRemote, emitter, 'doc:create').then(function (
429 | args) {
430 | return argsShouldEqlTask(args);
431 | });
432 | };
433 |
434 | it('doc: doc:create remote already local', function () {
435 | return commonUtils.doAndOnce(createLocal, task, 'doc:create').then(function () {
436 | // Assert doc:create not received as already created
437 | return commonTestUtils.shouldDoAndNotOnce(createRemote, task, 'doc:create');
438 | });
439 | });
440 |
441 | it('col: doc:create remote', function () {
442 | return docShouldCreateRemote(tasks);
443 | });
444 |
445 | it('db: doc:create remote', function () {
446 | return docShouldCreateRemote(db);
447 | });
448 |
449 | it('client: doc:create remote', function () {
450 | return docShouldCreateRemote(client);
451 | });
452 |
453 | // ------------------------
454 |
455 | var docShouldUpdateLocal = function (emitter) {
456 | return commonTestUtils.shouldDoAndOnce(updateLocal, emitter, 'doc:update').then(function (
457 | args) {
458 | args[0].should.eql(task);
459 | });
460 | };
461 |
462 | it('doc: doc:update local', function () {
463 | return docShouldUpdateLocal(task);
464 | });
465 |
466 | it('col: doc:update local', function () {
467 | return docShouldUpdateLocal(tasks);
468 | });
469 |
470 | it('db: doc:update local', function () {
471 | return docShouldUpdateLocal(db);
472 | });
473 |
474 | it('client: doc:update local', function () {
475 | return docShouldUpdateLocal(client);
476 | });
477 |
478 | var docShouldUpdateRemote = function (emitter) {
479 | return commonUtils.doAndOnce(createLocal, emitter, 'doc:create').then(function () {
480 | return commonTestUtils.shouldDoAndOnce(updateRemote, emitter, 'doc:update');
481 | }).then(function (args) {
482 | return argsShouldEqlTask(args);
483 | });
484 | };
485 |
486 | it('doc: doc:update remote', function () {
487 | return docShouldUpdateRemote(task);
488 | });
489 |
490 | it('col: doc:update remote', function () {
491 | return docShouldUpdateRemote(tasks);
492 | });
493 |
494 | it('db: doc:update remote', function () {
495 | return docShouldUpdateRemote(db);
496 | });
497 |
498 | it('client: doc:update remote', function () {
499 | return docShouldUpdateRemote(client);
500 | });
501 |
502 | // ------------------------
503 |
504 | var docDestroyShouldEql = function (args) {
505 | docCreateShouldEql(args);
506 | };
507 |
508 | var destroyDocLocal = function () {
509 | return testUtils.sleep().then(function () { // sleep so destroy is after create
510 | return task.destroy();
511 | });
512 | };
513 |
514 | var docShouldDestroyLocal = function (emitter) {
515 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
516 | return commonTestUtils.shouldDoAndOnce(destroyDocLocal, emitter, 'doc:destroy');
517 | }).then(function (args) {
518 | docDestroyShouldEql(args);
519 | });
520 | };
521 |
522 | it('doc: doc:destroy local', function () {
523 | return docShouldDestroyLocal(task);
524 | });
525 |
526 | it('col: doc:destroy local', function () {
527 | return docShouldDestroyLocal(tasks);
528 | });
529 |
530 | it('db: doc:destroy local', function () {
531 | return docShouldDestroyLocal(db);
532 | });
533 |
534 | it('client: doc:destroy local', function () {
535 | return docShouldDestroyLocal(client);
536 | });
537 |
538 | var destroyDocRemote = function () {
539 | var server = new Server([{
540 | id: '1',
541 | col: 'tasks',
542 | name: null,
543 | seq: 0,
544 | up: laterStr,
545 | re: laterStr
546 | }]);
547 |
548 | return testUtils.sleep().then(function () { // sleep so destroy is after create
549 | return db.sync(server, true);
550 | });
551 | };
552 |
553 | var docShouldDestroyRemote = function (emitter) {
554 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
555 | return commonTestUtils.shouldDoAndOnce(destroyDocRemote, emitter, 'doc:destroy');
556 | }).then(function (args) {
557 | docDestroyShouldEql(args);
558 | });
559 | };
560 |
561 | it('doc: doc:destroy remote', function () {
562 | return docShouldDestroyRemote(task);
563 | });
564 |
565 | it('col: doc:destroy remote', function () {
566 | return docShouldDestroyRemote(tasks);
567 | });
568 |
569 | it('db: doc:destroy remote', function () {
570 | return docShouldDestroyRemote(db);
571 | });
572 |
573 | it('client: doc:destroy remote', function () {
574 | return docShouldDestroyRemote(client);
575 | });
576 |
577 | // ------------------------
578 |
579 | var docShouldRecord = function (emitter) {
580 | return commonUtils.doAndOnce(createLocal, emitter, 'doc:create').then(function () {
581 | return commonTestUtils.shouldDoAndOnce(recordRemote, emitter, 'doc:record');
582 | }).then(function (args) {
583 | docCreateShouldEql(args);
584 | });
585 | };
586 |
587 | it('doc: doc:record', function () {
588 | return docShouldRecord(task);
589 | });
590 |
591 | it('col: doc:record', function () {
592 | return docShouldRecord(tasks);
593 | });
594 |
595 | it('db: doc:record', function () {
596 | return docShouldRecord(db);
597 | });
598 |
599 | it('client: doc:record', function () {
600 | return docShouldRecord(client);
601 | });
602 |
603 | // ------------------------
604 |
605 | var tasks2 = null;
606 |
607 | var colCreateShouldEql = function (args) {
608 | args[0].should.eql(tasks2);
609 | };
610 |
611 | var colCreateLocal = function () {
612 | tasks2 = db.col('tasks2');
613 | return Promise.resolve();
614 | };
615 |
616 | var colShouldCreateLocal = function (emitter) {
617 | return commonTestUtils.shouldDoAndOnce(colCreateLocal, emitter, 'col:create').then(
618 | function (
619 | args) {
620 | colCreateShouldEql(args);
621 | });
622 | };
623 |
624 | // Note: no col:create at col layer as col:create emitted immediately after db.col()
625 |
626 | it('db: col:create local', function () {
627 | return colShouldCreateLocal(db);
628 | });
629 |
630 | it('client: col:create local', function () {
631 | return colShouldCreateLocal(client);
632 | });
633 |
634 | var colCreateRemote = function () {
635 | var server = new Server([{
636 | id: '2',
637 | col: 'tasks2',
638 | name: 'thing',
639 | val: '"sing"',
640 | seq: 0,
641 | up: nowStr,
642 | re: nowStr
643 | }]);
644 | return db.sync(server, true);
645 | };
646 |
647 | var colShouldCreateRemote = function (emitter) {
648 | return commonTestUtils.shouldDoAndOnce(colCreateRemote, emitter, 'col:create').then(
649 | function (
650 | args) {
651 | return args[0].get('2');
652 | }).then(function (doc) {
653 | var obj = doc.get();
654 | obj.thing.should.eql('sing');
655 | });
656 | };
657 |
658 | it('db: col:create remote', function () {
659 | return colShouldCreateRemote(db);
660 | });
661 |
662 | it('client: col:create remote', function () {
663 | return colShouldCreateRemote(client);
664 | });
665 |
666 | // ------------------------
667 |
668 | var colShouldUpdateLocal = function (emitter) {
669 | return commonTestUtils.shouldDoAndOnce(updateLocal, emitter, 'col:update').then(function (
670 | args) {
671 | return args[0].get('1');
672 | }).then(function (doc) {
673 | var obj = doc.get();
674 | obj.priority.should.eql('high');
675 | });
676 | };
677 |
678 | it('col: col:update local', function () {
679 | return colShouldUpdateLocal(tasks);
680 | });
681 |
682 | it('db: col:update local', function () {
683 | return colShouldUpdateLocal(db);
684 | });
685 |
686 | it('client: col:update local', function () {
687 | return colShouldUpdateLocal(client);
688 | });
689 |
690 | var colShouldUpdateRemote = function (emitter) {
691 | // We cannot first listen to col:create as the col was created with db.col()
692 | return commonUtils.doAndOnce(createLocal, emitter, 'doc:create').then(function () {
693 | return commonTestUtils.shouldDoAndOnce(updateRemote, emitter, 'col:update');
694 | }).then(function (args) {
695 | return args[0].get('1');
696 | }).then(function (doc) {
697 | var obj = doc.get();
698 | obj.priority.should.eql('high');
699 | });
700 | };
701 |
702 | it('col: col:update remote', function () {
703 | return colShouldUpdateRemote(tasks);
704 | });
705 |
706 | it('db: col:update remote', function () {
707 | return colShouldUpdateRemote(db);
708 | });
709 |
710 | it('client: col:update remote', function () {
711 | return colShouldUpdateRemote(client);
712 | });
713 |
714 | // ------------------------
715 |
716 | var destroyColLocal = function () {
717 | return testUtils.sleep().then(function () { // sleep so destroy is after create
718 | return tasks.destroy();
719 | });
720 | };
721 |
722 | var colShouldDestroyLocal = function (emitter) {
723 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
724 | return commonTestUtils.shouldDoAndOnce(destroyColLocal, emitter, 'col:destroy');
725 | }).then(function (args) {
726 | return args[0].get('1');
727 | }).then(function (doc) {
728 | var obj = doc.get();
729 | obj.priority.should.eql('low');
730 | });
731 | };
732 |
733 | it('col: col:destroy local', function () {
734 | return colShouldDestroyLocal(tasks);
735 | });
736 |
737 | it('db: col:destroy local', function () {
738 | return colShouldDestroyLocal(db);
739 | });
740 |
741 | it('client: col:destroy local', function () {
742 | return colShouldDestroyLocal(client);
743 | });
744 |
745 | // TODO: create construct for passing col destroy via delta? e.g. { name: '$col', value: null } so
746 | // that we can emit col:destroy when receive this delta?
747 |
748 | // ------------------------
749 |
750 | var colShouldRecord = function (emitter) {
751 | return commonUtils.doAndOnce(createLocal, emitter, 'doc:create').then(function () {
752 | return commonTestUtils.shouldDoAndOnce(recordRemote, emitter, 'col:record');
753 | }).then(function (args) {
754 | return args[0].get('1');
755 | }).then(function (doc) {
756 | var obj = doc.get();
757 | obj.priority.should.eql('low');
758 | });
759 | };
760 |
761 | it('col: col:record', function () {
762 | return colShouldRecord(tasks);
763 | });
764 |
765 | it('db: col:record', function () {
766 | return colShouldRecord(db);
767 | });
768 |
769 | it('client: col:record', function () {
770 | return colShouldRecord(client);
771 | });
772 |
773 | // ------------------------
774 |
775 | var dbCreateLocal = function () {
776 | db2 = client2.db({
777 | db: 'myotherdb',
778 | store: new MemAdapter().db('mydb') // TODO: test with default store?
779 | });
780 | return Promise.resolve();
781 | };
782 |
783 | var dbShouldCreateLocal = function () {
784 | client2 = new Client(true);
785 | return commonTestUtils.shouldDoAndOnce(dbCreateLocal, client2, 'db:create').then(function (
786 | args) {
787 | args[0].should.eql(db2);
788 | });
789 | };
790 |
791 | it('client: db:create local', function () {
792 | return dbShouldCreateLocal();
793 | });
794 |
795 | // TODO: how can the client detect that a database has been created remotely? Currently, syncing
796 | // is done per database and instead we would require a notification at the layer above.
797 |
798 | // ------------------------
799 |
800 | // Note: we don't support db:update as there is no database rename function and no other way to
801 | // update a database.
802 |
803 | // ------------------------
804 |
805 | // var dbDestroyLocal = function () {
806 | // return client2.connect({
807 | // db: 'myotherdb'
808 | // }).then(function (_db2) {
809 | // db2 = _db2;
810 | // }).then(function () {
811 | // return db2.destroy();
812 | // });
813 | // };
814 |
815 | // var dbShouldDestroyLocal = function () {
816 | // return commonTestUtils.shouldDoAndOnce(dbDestroyLocal, client2, 'db:destroy').then(function (
817 | // args) {
818 | // args[0].should.eql(db2);
819 | // });
820 | // };
821 |
822 | // TODO: need to first implement db.destroy()
823 | // it('client: db:destroy local', function () {
824 | // return dbShouldDestroyLocal();
825 | // });
826 |
827 | // TODO: how can the client detect that a database has been destroyed remotely? Currently, syncing
828 | // is done per database and instead we would require a notification at the layer above.
829 |
830 | // ------------------------
831 |
832 | var dbShouldRecord = function (emitter) {
833 | return commonUtils.doAndOnce(createLocal, emitter, 'attr:create').then(function () {
834 | return commonTestUtils.shouldDoAndOnce(recordRemote, emitter, 'db:record');
835 | }).then(function (args) {
836 | args[0].should.eql(db);
837 | });
838 | };
839 |
840 | it('db: db:record', function () {
841 | return dbShouldRecord(db);
842 | });
843 |
844 | it('client: db:record', function () {
845 | return dbShouldRecord(client);
846 | });
847 |
848 | });
849 |
--------------------------------------------------------------------------------
/test/spec/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var utils = require('../utils');
4 |
5 | describe('spec', function () {
6 |
7 | this.timeout(utils.TIMEOUT);
8 |
9 | require('./adapter');
10 | require('./client');
11 | require('./config');
12 | require('./db');
13 | require('./delta-db');
14 | require('./doc');
15 | require('./events');
16 | require('./multiple');
17 | require('./persist');
18 | require('./sender');
19 | require('./socket');
20 | require('./utils');
21 |
22 | });
23 |
--------------------------------------------------------------------------------
/test/spec/multiple.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var commonTestUtils = require('deltadb-common-utils/scripts/test-utils'),
4 | Client = require('../../scripts/adapter'),
5 | Promise = require('bluebird'),
6 | MemAdapter = require('deltadb-orm-nosql/scripts/adapters/mem');
7 |
8 | describe('multiple', function () {
9 |
10 | var client1 = null,
11 | client2 = null,
12 | db1 = null,
13 | db2 = null,
14 | col1 = null,
15 | col2 = null,
16 | doc1 = null,
17 | doc2 = null;
18 |
19 | beforeEach(function () {
20 | client1 = new Client(true); // local only so no connection to server
21 | client2 = new Client(true); // local only so no connection to server
22 |
23 | db1 = client1.db({
24 | db: 'mydb',
25 | store: new MemAdapter().db('mydb')
26 | });
27 | db2 = client2.db({
28 | db: 'mydb',
29 | store: new MemAdapter().db('mydb')
30 | });
31 | col1 = db1.col('mycol');
32 | col2 = db2.col('mycol');
33 | doc1 = col1.doc();
34 | doc2 = col2.doc();
35 | });
36 |
37 | afterEach(function () {
38 | return Promise.all([db1.destroy(true), db2.destroy(true)]);
39 | });
40 |
41 | // Note: don't need afterEach as everything created in mem and therefore doesn't need to be purged
42 |
43 | it('should have unique event emitters', function () {
44 |
45 | // Note: the following test was failing with as Doc defined an attribute called "_events" which
46 | // was also in use by EventEmitter. TODO: to prevent this in the future, should Doc contain
47 | // EventEmitter and just provide access functions?
48 |
49 | var promiseFactory = function () {
50 | doc1.emit('test-event');
51 | return Promise.resolve();
52 | };
53 |
54 | return commonTestUtils.shouldDoAndNotOnce(promiseFactory, doc2, 'test-event');
55 | });
56 |
57 | });
58 |
--------------------------------------------------------------------------------
/test/spec/persist.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var commonUtils = require('deltadb-common-utils'),
4 | Client = require('../../scripts/adapter'),
5 | testUtils = require('../utils');
6 |
7 | describe('persist', function () {
8 |
9 | var client = null,
10 | db = null,
11 | tasks = null,
12 | propsReady = null,
13 | db2 = null;
14 |
15 | beforeEach(function () {
16 | client = new Client(true);
17 | db = client.db({
18 | db: 'mydb'
19 | });
20 | propsReady = commonUtils.once(db, 'load');
21 | tasks = db.col('tasks');
22 | });
23 |
24 | afterEach(function () {
25 | // In these tests db and db2 reference the same underlying DB so we do not need to destroy db2.
26 | // Otherwise, the destroy would block.
27 | return db.destroy(true);
28 | });
29 |
30 | it('should restore from store', function () {
31 |
32 | var client2 = null,
33 | found = false,
34 | task = tasks.doc(),
35 | dbLoaded = commonUtils.once(db, 'load');
36 |
37 | var nowStr = (new Date().toISOString());
38 |
39 | return task.set({
40 | thing: 'sing',
41 | priority: 'high'
42 | }).then(function () {
43 | // Wait until all the data has been loaded from the store
44 | return dbLoaded;
45 | }).then(function () {
46 | // Fake update of since
47 | return db._props.set({
48 | since: nowStr
49 | });
50 | }).then(function () {
51 | // Simulate a reload from store, e.g. when an app restarts, by destroying the DB, but keeping
52 | // the local store and then reloading the store
53 | return db.destroy(true, true);
54 | }).then(function () {
55 | client2 = new Client(true);
56 | db2 = client2.db({
57 | db: 'mydb'
58 | });
59 |
60 | // Wait until all the docs have been loaded from the store
61 | return commonUtils.once(db2, 'load');
62 | }).then(function () {
63 | // Verify restoration of since
64 | var props = db2._props.get();
65 | props.since.should.eql(nowStr);
66 |
67 | // Verify task was loaded
68 | db2.all(function (tasks) {
69 | // Assuming only col is tasks
70 | tasks.find(null, function (task2) {
71 | // Check that all data, e.g. changes, latest, etc... was reloaded, not just the values
72 | task2._dat.should.eql(task._dat);
73 | found = true;
74 | }, true); // include destroyed docs
75 | });
76 |
77 | found.should.eql(true);
78 | return null; // prevent runaway promise warning
79 | });
80 | });
81 |
82 | it('should handle race conditions', function () {
83 | // Make sure there are no race conditions with loading, e.g.
84 | // planner = client.db('planner');
85 | // tasks = planner.col('tasks');
86 | // write = tasks.doc({ thing: 'write' });
87 | // What if thing is already in the store and loads after we have the handles above?
88 |
89 | var task = tasks.doc({
90 | thing: 'sing',
91 | priority: 'high',
92 | notes: 'some notes'
93 | }),
94 | client2 = null,
95 | tasks2 = null,
96 | task2 = null;
97 |
98 | var setUpClient2 = function () {
99 | client2 = new Client(true);
100 | db2 = client2.db({
101 | db: 'mydb'
102 | });
103 | tasks2 = db2.col('tasks');
104 | task2 = tasks2.doc({
105 | $id: task.id(),
106 | thing: 'write',
107 | type: 'personal'
108 | });
109 | task2.unset('notes');
110 | };
111 |
112 | // Populate underlying store
113 | return task.save().then(function () {
114 | // Sleep so that timestamps aren't the same and the 2nd set of changes come later
115 | return testUtils.sleep();
116 | }).then(function () {
117 | // Simulate reload using a second client
118 | setUpClient2();
119 | return commonUtils.once(db2, 'load');
120 | }).then(function () {
121 | // Make sure that we take the latest changes
122 | task2.get().should.eql({
123 | $id: task.id(),
124 | thing: 'write',
125 | type: 'personal',
126 | priority: 'high'
127 | });
128 | });
129 |
130 | });
131 |
132 | });
133 |
--------------------------------------------------------------------------------
/test/spec/sender.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var Sender = require('../../scripts/sender'),
4 | Promise = require('bluebird');
5 |
6 | describe('sender', function () {
7 |
8 | it('should launch retry sender', function () {
9 | var db = { // fake
10 | _retryAfterMSecs: 10
11 | };
12 |
13 | var sends = 0,
14 | expectedSends = 2;
15 |
16 | var sender = new Sender(db);
17 |
18 | // The test will timeout if something goes wrong
19 | return new Promise(function (resolve) {
20 | sender.send = function () { // fake
21 | if (++sends === expectedSends) {
22 | resolve();
23 | }
24 | };
25 | });
26 |
27 | });
28 |
29 | });
30 |
--------------------------------------------------------------------------------
/test/spec/socket.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var Socket = require('../../scripts/socket');
4 |
5 | describe('socket', function () {
6 |
7 | var socket = new Socket();
8 |
9 | var mockSocket = {
10 | emit: function () {},
11 | on: function () {},
12 | disconnect: function () {}
13 | };
14 |
15 | var mockIO = function () {
16 | socket._io = {
17 | connect: function () {
18 | return mockSocket;
19 | }
20 | };
21 | };
22 |
23 | mockIO();
24 |
25 | it('should connect', function () {
26 | socket.connect();
27 | });
28 |
29 | it('should emit', function () {
30 | socket.emit();
31 | });
32 |
33 | it('should on', function () {
34 | socket.on();
35 | });
36 |
37 | it('should disconnect', function () {
38 | socket.disconnect();
39 | });
40 |
41 | });
42 |
--------------------------------------------------------------------------------
/test/spec/utils.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var clientUtils = require('../../scripts/utils'),
4 | commonUtils = require('deltadb-common-utils'),
5 | commonTestUtils = require('deltadb-common-utils/scripts/test-utils');
6 |
7 | describe('utils', function () {
8 |
9 | var shouldGenUser = function (status) {
10 | return clientUtils.genUser('user-uuid', 'username', 'secret', status).then(function (user) {
11 | user.uuid.should.eql('user-uuid');
12 | user.username.should.eql('username');
13 |
14 | if (typeof status === 'undefined') {
15 | user.status.should.eql('enabled');
16 | } else {
17 | user.status.should.eql(status);
18 | }
19 |
20 | (user.salt === null).should.eql(false);
21 | (user.password === null).should.eql(false);
22 | });
23 | };
24 |
25 | it('should gen user without status', function () {
26 | return shouldGenUser();
27 | });
28 |
29 | it('should gen user with status', function () {
30 | return shouldGenUser(true);
31 | });
32 |
33 | it('should convert to doc uuid', function () {
34 | var docUUID = clientUtils.toDocUUID('user-uuid');
35 | docUUID.should.eql(clientUtils.UUID_PRE + 'user-uuid');
36 | });
37 |
38 | it('should sleep', function () {
39 | var before = new Date();
40 | return commonUtils.timeout(1000).then(function () {
41 | var after = new Date();
42 | var elapsed = after.getTime() - before.getTime();
43 | (elapsed >= 1000 && elapsed < 1500).should.eql(true); // allow for 500 ms window
44 | });
45 | });
46 |
47 | it('should throw when db name is invalid', function () {
48 | return commonTestUtils.shouldNonPromiseThrow(function () {
49 | clientUtils.escapeDBName('my^#invalid$ db%name!');
50 | }, new Error());
51 | });
52 |
53 | });
54 |
--------------------------------------------------------------------------------
/test/utils.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var commonUtils = require('deltadb-common-utils');
4 |
5 | var Utils = function () {};
6 |
7 | Utils.prototype.IE = global.window && (navigator.appName === 'Microsoft Internet Explorer' ||
8 | 'ActiveXObject' in window);
9 |
10 | // Testing with IE in Saucelabs can be VERY slow therefore we need to increase the timeouts
11 | if (global.deltaDBSaucelabs && Utils.prototype.IE) { // Saucelabs and IE?
12 | Utils.prototype.TIMEOUT = 120000;
13 | } else {
14 | Utils.prototype.TIMEOUT = 30000;
15 | }
16 |
17 | Utils.prototype.sleep = function (sleepMs) {
18 | // Ensure a different timestamp will be generated after this function resolves.
19 | // Occasionally, using timeout(1) will not guarantee a different timestamp, e.g.:
20 | // 1. (new Date()).getTime()
21 | // 2. timeout(1)
22 | // 3. (new Date()).getTime()
23 | // It is not clear as to what causes this but the solution is to sleep longer. This function is
24 | // also used to delay between DB writes to create predictable patterns. In this case it may be
25 | // that the DB adapter processes queries out of sequence.
26 | return commonUtils.timeout(sleepMs ? sleepMs : 10);
27 | };
28 |
29 | Utils.prototype.allShouldEql = function (collection, expected) {
30 | // Index data as order is guaranteed
31 |
32 | var allDocs = {};
33 |
34 | var allExpDocs = {};
35 | expected.forEach(function (exp) {
36 | allExpDocs[exp.$id] = exp;
37 | });
38 |
39 | return collection.all(function (item) {
40 | allDocs[item.id()] = item.get();
41 | }).then(function () {
42 | allDocs.should.eql(allExpDocs);
43 | });
44 | };
45 |
46 | module.exports = new Utils();
47 |
--------------------------------------------------------------------------------
deltadb [](https://travis-ci.org/delta-db/deltadb) [](https://coveralls.io/github/delta-db/deltadb?branch=master) [](https://david-dm.org/delta-db/deltadb)
2 | ===
3 | [](https://saucelabs.com/u/deltadb-user)
4 |
5 | DeltaDB is an offline-first database designed to talk directly to clients and works great offline and online.
6 |
7 |
8 | ** Update: Suspending Development of DeltaDB **
9 | ---
10 |
11 | I have decided to suspend development of DeltaDB for the following reasons:
12 | * Recent enhancements to both PouchDB and CouchDB have made [PouchDB initial replication much faster](https://medium.com/@redgeoff/is-pouchdb-fast-enough-for-my-app-5e36d28a831f#.o7zmldh1t)
13 | * After more analysis of the last-write-wins resolution policy, I am left feeling that the last-write-wins resolution policy is mostly good for real-time systems that are always online. In DeltaDB, this last-write-wins policy results in a [Reasonable Ordering](https://github.com/delta-db/deltadb-server/blob/master/NOTES.md#reasonable-ordering). Moreover, the last-write-wins policy is nice when starting a new project as it is automatic, but other conflict resolution policies that force the user to manually resolve the conflict, like CouchDB’s revision protocol, have become more of the standard in the offline-first world.
14 | * Building a DB that scales and is distributed over many nodes, takes a lot of work. I considered some of the necessary details when initially designing DeltaDB, but have only scratched the surface of what needs to be done. There are other DBs, like CouchDB 2.0, that have nearly solved these problems and CouchDB has been in development since 2005.
15 |
16 |
17 | Live Demos
18 | ---
19 |
20 | * [todomvc-angular](http://delta-db.github.io/deltadb/examples/todomvc-angular) - a todo app. For fun, open it in 2 different browser windows and watch the todos change in the 2nd window when you change the todos in the 1st window.
21 |
22 | * [hello](http://codepen.io/redgeoff/pen/vLKYzN?editors=100) - a simple hello world example with code
23 |
24 |
25 | [Getting Started With DeltaDB](https://medium.com/@redgeoff/getting-started-with-deltadb-137359111282#.tciuz7o6b)
26 | ---
27 |
28 | Check out the [Getting Started With DeltaDB](https://medium.com/@redgeoff/getting-started-with-deltadb-137359111282#.tciuz7o6b) tutorial
29 |
30 |
31 | Main Principles
32 | ---
33 |
34 | * Written in JavaScript
35 | * Framework agnostic
36 | * Works the same whether the client is offline or online
37 | * NoSQL database that works in your browser and automatically syncs with the database cluster
38 | * Stores all data as a series of deltas, which allows for smooth collaborative experiences even in frequently offline scenarios.
39 | * Uses a simple last-write-wins conflict resolution policy and is eventually consistent
40 | * Uses a homegrown ORM to speak to underlying SQL databases. (Support for underlying NoSQL databases will be added)
41 | * Is fast. Clients push their deltas on to the server's queue. The server processes the queue separately and partitions the data so that clients can retrieve all recent changes very quickly.
42 | * Implements a granular authentication system that protects databases, collections, docs and attributes
43 | * Is incredibly scalable. Deltas can be segmented by UUID and the cost to add new nodes has a negligible impact on the cluster as handshaking between servers can be done as frequently as desired.
44 | * Highly available. Clients can switch to talk to any node, even if that node hasn't received the latest deltas from another node.
45 | * Fault tolerant by using the concept of a quorum of servers for recording changes
46 | * Data is auto-restored when a client modifies data that was previously deleted
47 | * Uses timestamps to update records so that transactions and their overhead can be avoided
48 | * Thread-safe so that adding more cores will speed up DB reads and writes
49 |
50 |
51 | Why?
52 | ---
53 |
54 | Because it doesn't exist and true support for offline environments needs to be engineered from the ground up
55 | - PouchDB relies on CouchDB and CouchDB is slow to replicate when there are many revisions and it is not optimized for offline setups like db-per-user
56 | - Firebase doesn't work offline and is not open source
57 | - Meteor doesn't work offline
58 | - See [Inspiration](https://github.com/delta-db/deltadb-server/blob/master/INSPIRATION.md) for more info
59 |
60 |
61 | [Installation](https://github.com/delta-db/deltadb-server/blob/master/INSTALL.md)
62 | ---
63 |
64 |
65 | [Examples](EXAMPLES.md)
66 | ---
67 |
68 |
69 | [API](https://github.com/delta-db/deltadb/wiki)
70 | ---
71 |
72 |
73 | [Roadmap](https://github.com/delta-db/deltadb-server/wiki/DeltaDB-Roadmap)
74 | ---
75 |
76 |
77 | [Contributing](CONTRIBUTING.md)
78 | ---
79 |
80 |
81 | [Notes](https://github.com/delta-db/deltadb-server/blob/master/NOTES.md)
82 | ---
83 |
84 |
85 | [Issues](https://github.com/delta-db/deltadb-server/blob/master/ISSUES.md)
86 | ---
87 |
88 |
89 | [Ideas](https://github.com/delta-db/deltadb-server/blob/master/IDEAS.md)
90 | ---
91 |
--------------------------------------------------------------------------------
/beautify.json:
--------------------------------------------------------------------------------
1 | {
2 | "indent_size": 2,
3 | "jslint_happy": true,
4 | "wrap_line_length": 100,
5 | "end_with_newline": true
6 | }
7 |
--------------------------------------------------------------------------------
/bin/publish.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | # Make sure deps are up to date
4 | # rm -r node_modules
5 | # npm install
6 |
7 | # get current version
8 | VERSION=$(node --eval "console.log(require('./package.json').version);")
9 |
10 | # Increment the version in master
11 | git add -A
12 | git commit -m "$VERSION"
13 | git push origin master
14 |
15 | # Build
16 | git checkout -b build
17 |
18 | npm run build
19 |
20 | # Publish npm release
21 | npm publish
22 |
23 | # Create git tag, which is also the Bower/Github release
24 | git add dist -f
25 | # git add bower.json component.json package.json lib/version-browser.js
26 | git rm -r bin scripts test
27 |
28 | git commit -m "build $VERSION"
29 |
30 | # Tag and push
31 | git tag $VERSION
32 | # TODO: can the following line be changed to git push origin master --tags $VERSION ??
33 | git push --tags https://github.com/delta-db/deltadb.git $VERSION
34 |
35 | # Cleanup
36 | git checkout master
37 | git branch -D build
38 |
--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "deltadb",
3 | "version": "0.0.11",
4 | "description": "DeltaDB offline-first database",
5 | "main": "dist/deltadb.min.js",
6 | "homepage": "https://github.com/delta-db/deltadb",
7 | "authors": [
8 | "Geoffrey Cox"
9 | ],
10 | "keywords": [
11 | "deltadb",
12 | "offline-first",
13 | "database",
14 | "javascript",
15 | "js"
16 | ],
17 | "license": "MIT",
18 | "ignore": [
19 | "**/.*",
20 | "node_modules",
21 | "bower_components",
22 | "test",
23 | "npm-debug.log"
24 | ],
25 | "devDependencies": {},
26 | "appPath": "app",
27 | "dependencies": {}
28 | }
29 |
--------------------------------------------------------------------------------
/examples/hello/index-local.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
9 |
10 |
11 |
12 |
13 |