cronapp-cordova-plugin-contentsync 4.4.0-RC7

package/tests/tests.js

@@ -0,0 +1,255 @@
+exports.defineAutoTests = function() {
+
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 30000;
+
+    describe('cronapp-cordova-plugin-contentsync', function() {
+
+        it("should exist", function() {
+            expect(window.ContentSync).toBeDefined();
+            expect(typeof window.ContentSync.sync == 'function').toBe(true);
+            expect(typeof window.ContentSync.download == 'function').toBe(true);
+            expect(typeof window.ContentSync.unzip == 'function').toBe(true);
+        });
+
+        function syncArchive(url, done) {
+            
+            var progressEvent = null;
+            var sync = ContentSync.sync({ src: url, id: 'myapps/myapp', type: 'replace', copyCordovaAssets: false, headers: false });
+
+
+            sync.on('progress', function(progress) {
+                //console.log("in progress callback " + Object.getOwnPropertyNames(progress));
+                //console.log("onProgress :: " + progress.progress + " status = " + progress.status);
+                if(!progressEvent) {
+                    progressEvent = progress;
+                }
+            });
+
+            sync.on('complete', function(data) {
+                //console.log("progress = " + progressEvent);
+                expect(progressEvent).toBeDefined("Progress should have been received");
+
+                //console.log("progressEvent.status = " + progressEvent.status);
+                expect(progressEvent.status).toBeDefined("Progress event should have a status prop");
+
+                expect(progressEvent.progress).toBeDefined("Progress event should have a progress prop");
+                //console.log("progressEvent.progress = " + progressEvent.progress);
+
+                //console.log("data = " + data);
+                expect(data).toBeDefined("On complete, data is not null");
+                done();
+            });
+
+            sync.on('error', function (e) {
+                expect(progressEvent).toBeDefined("Progress should have been received");
+                expect(e).toBe(null, "Error callback was called :: " + JSON.stringify(e));
+                //console.log("got error back :: " + e);
+                done();
+            });
+
+        }
+
+        it("can sync archive without www folder at root", function(done){
+            var url = "http://localhost:4321/www1.zip";
+            syncArchive(url, done);
+        }, 60000); // wait a full 60 secs
+        
+        it("can sync archive with www folder at root", function(done){
+            var url = "http://localhost:4321/www2.zip";
+            syncArchive(url, done);
+        }, 60000); // wait a full 60 secs
+
+        it('reports error on 404', function(done){
+            var sync = ContentSync.sync({
+                src: 'https://www.google.com/error/not/found.zip',
+                id: 'test' + (new Date().getTime()), // ensure that repeated tests work
+                type: 'replace',
+                copyCordovaAssets: false
+            });
+            sync.on('complete', function() {
+                fail('404 page should not complete');
+                done();
+            });
+
+            sync.on('error', function(e) {
+                expect(e).toBeDefined('error should be reported');
+                done();
+            });
+        }, 60000); // wait a full 60 secs for slow Android emulator
+
+        it('tests copyCordovaAssets works without copyRootApp', function(done) {
+            var appId = 'copyCordovaAssets' + (new Date().getTime());
+            var sync = ContentSync.sync({
+                id: appId,
+                copyCordovaAssets: true,
+                type: 'local'
+            });
+
+            sync.on('complete', function(data) {
+                // cordova.js should be available in the synced directory
+                testFileExists(appId + '/cordova.js', function success() {
+                    done();
+                }, function fail() {
+                    fail('cordova.js should exist in the synced directory.');
+                });
+            });
+        });
+
+        /**
+         * Helper function that tests if the file at the given path exists
+         */
+        function testFileExists(path, success, fail) {
+            var filePath;
+            if (path.indexOf('file://') === 0) {
+                // test via system url
+                filePath = path;
+            } else {
+                // test via cordova.file.dataDirectory location
+                filePath = cordova.file.dataDirectory + '/' + path;
+            }
+            window.resolveLocalFileSystemURL(filePath, function(fileEntry) {
+                expect(fileEntry).toBeDefined();
+                success();
+            }, function(e){
+                fail(path + ' should exist in local copy. Error code ' + e.code);
+            });
+        }
+
+        /**
+         * Helper function that syncs and test if the local copy has the `/index.html`
+         */
+        function syncAndTest(appId, useLocalPath, success, fail) {
+            var sync = ContentSync.sync({
+                id: appId,
+                type: 'local',
+                copyRootApp: true
+            });
+            sync.on('complete', function (data) {
+                if (useLocalPath && cordova.platformId !== 'windows') {
+                    testFileExists('file://' + data.localPath + '/index.html', success, fail);
+                } else {
+                    testFileExists(appId + '/index.html', success, fail);
+                }
+            });
+            sync.on('error', function (e) {
+                fail();
+            });
+        }
+
+        /**
+         * Tests if the local copy is at the correct place and can be accessed via file plugin.
+         */
+        it('local copy is accessible via file plugin', function(done) {
+            var appId = 'test' + (new Date()).getTime(); // create new id every time
+            syncAndTest(appId, false, done, function(e){
+                fail(e);
+                done();
+            })
+        }, 60000); // wait a full 60 secs for slow Android emulator
+
+        it('create local copy with www prefix', function(done) {
+            var appId = 'www/local/test' + (new Date()).getTime(); // create new id every time
+            syncAndTest(appId, true, done, function(e){
+                fail(e);
+                done();
+            })
+        }, 60000); // wait a full 60 secs for slow Android emulator
+
+        it('create local copy with www suffix', function(done) {
+            var appId = 'local/test' + (new Date()).getTime() + '/www'; // create new id every time
+            syncAndTest(appId, true, done, function(e){
+                fail(e);
+                done();
+            })
+        }, 60000); // wait a full 60 secs for slow Android emulator
+
+        /**
+         * Test for invalid server name
+         */
+        it('error on invalid server name', function(done) {
+            var sync = ContentSync.sync({
+                src: 'http://servername',
+                id: 'test' + (new Date().getTime()), // ensure that repeated tests work
+                type: 'replace',
+                copyCordovaAssets: false
+            });
+            sync.on('complete', function() {
+                fail('invalid server name should not complete');
+                done();
+            });
+
+            sync.on('error', function(e) {
+                expect(e).toBeDefined('error should be reported');
+                done();
+            });
+        });
+
+    });
+
+
+    if(cordova.platformId == 'windows') {
+        describe('CronApp/cronapp-cordova-plugin-contentsync windows tests', function() {
+            it("Has linked C# code", function(done){
+                //
+                expect(ZipWinProj).toBeDefined("ZipWinProj should exist");
+                expect(ZipWinProj.PGZipInflate)
+                    .toBeDefined("ZipWinProj.PGZipInflate should exist");
+                expect(ZipWinProj.PGZipInflate.inflateAsync)
+                    .toBeDefined("ZipWinProj.PGZipInflate.inflateAsync should exist");
+                done();
+            });
+
+        });
+    }
+
+    if (cordova.platformId === 'osx') {
+        it("syncing the same id concurrently should fail", function(done) {
+
+            var url = "https://github.com/timkim/zipTest/archive/master.zip";
+            var sync1 = ContentSync.sync({
+                src: url,
+                id: 'myapps/myapp',
+                type: 'replace',
+                copyCordovaAssets: false,
+                headers: false
+            });
+            var sync2 = ContentSync.sync({
+                src: url,
+                id: 'myapps/myapp',
+                type: 'replace',
+                copyCordovaAssets: false,
+                headers: false
+            });
+
+            var numFinished = 0;
+
+            sync1.on('complete', function(data) {
+                expect(data).toBeDefined("On complete, data is not null");
+                if (++numFinished == 2) {
+                    done();
+                }
+            });
+            sync1.on('error', function(e) {
+                fail(e);
+                done();
+            });
+
+            sync2.on('complete', function(data) {
+                fail('syncing concurrently the same id should fail.');
+                done();
+            });
+            sync2.on('error', function(e) {
+                expect(e).toEqual(5);
+                if (++numFinished == 2) {
+                    done();
+                }
+            });
+
+        }, 60000); // wait a full 60 secs
+    }
+
+};
+
+exports.defineManualTests = function() {
+
+};

package/www/index.js

@@ -0,0 +1,285 @@
+/* global cordova:false */
+
+/*!
+ * Module dependencies.
+ */
+
+var exec = cordova.require('cordova/exec');
+
+/**
+ * ContentSync constructor.
+ *
+ * @param {Object} options to initiate a new content synchronization.
+ *   @param {String} src is a URL to the content sync end-point.
+ *   @param {String} id is used as a unique identifier for the sync operation
+ *   @param {Object} type defines the sync strategy applied to the content.
+ *     @param {String} replace completely removes existing content then copies new content.
+ *     @param {String} merge   does not modify existing content, but adds new content.
+ *   @param {Object} headers are used to set the headers for when we send a request to the src URL
+ *  @param {Boolean} validateSrc whether to validate src url with a HEAD request before download (ios only, default true).
+ * @return {ContentSync} instance that can be monitored and cancelled.
+ */
+
+var ContentSync = function(options) {
+    this._handlers = {
+        'progress': [],
+        'cancel': [],
+        'error': [],
+        'complete': []
+    };
+
+    // require options parameter
+    if (typeof options === 'undefined') {
+        throw new Error('The options argument is required.');
+    }
+
+    // require options.src parameter
+    if (typeof options.src === 'undefined' && options.type !== "local") {
+        throw new Error('The options.src argument is required for merge replace types.');
+    }
+
+    // require options.id parameter
+    if (typeof options.id === 'undefined') {
+        throw new Error('The options.id argument is required.');
+    }
+
+    // define synchronization strategy
+    //
+    //     replace: This is the normal behavior. Existing content is replaced
+    //              completely by the imported content, i.e. is overridden or
+    //              deleted accordingly.
+    //     merge:   Existing content is not modified, i.e. only new content is
+    //              added and none is deleted or modified.
+    //     local:   Existing content is not modified, i.e. only new content is
+    //              added and none is deleted or modified.
+    //
+    if (typeof options.type === 'undefined') {
+        options.type = 'replace';
+    }
+
+    if (typeof options.headers === 'undefined') {
+        options.headers = null;
+    }
+
+    if (typeof options.copyCordovaAssets === 'undefined') {
+        options.copyCordovaAssets = false;
+    }
+
+    if (typeof options.copyRootApp === 'undefined') {
+        options.copyRootApp = false;
+    }
+
+    if (typeof options.timeout === 'undefined') {
+        options.timeout = 15.0;
+    }
+
+    if (typeof options.trustHost === 'undefined') {
+        options.trustHost = false;
+    }
+
+    if (typeof options.manifest === 'undefined') {
+        options.manifest = "";
+    }
+
+    if (typeof options.validateSrc === 'undefined') {
+        options.validateSrc = true;
+    }
+
+    // store the options to this object instance
+    this.options = options;
+
+    // triggered on update and completion
+    var that = this;
+    var success = function(result) {
+        if (result && typeof result.progress !== 'undefined') {
+            that.emit('progress', result);
+        } else if (result && typeof result.localPath !== 'undefined') {
+            that.emit('complete', result);
+        }
+    };
+
+    // triggered on error
+    var fail = function(msg) {
+        var e = (typeof msg === 'string') ? new Error(msg) : msg;
+        that.emit('error', e);
+    };
+
+    // wait at least one process tick to allow event subscriptions
+    setTimeout(function() {
+        exec(success, fail, 'Sync', 'sync', [options.src, options.id, options.type, options.headers, options.copyCordovaAssets, options.copyRootApp, options.timeout, options.trustHost, options.manifest, options.validateSrc]);
+    }, 10);
+};
+
+/**
+ * Cancel the Content Sync
+ *
+ * After successfully canceling the content sync process, the `cancel` event
+ * will be emitted.
+ */
+
+ContentSync.prototype.cancel = function() {
+    var that = this;
+    var onCancel = function() {
+        that.emit('cancel');
+    };
+    setTimeout(function() {
+        exec(onCancel, onCancel, 'Sync', 'cancel', [ that.options.id ]);
+    }, 10);
+};
+
+/**
+ * Listen for an event.
+ *
+ * The following events are supported:
+ *
+ *   - progress
+ *   - cancel
+ *   - error
+ *   - completion
+ *
+ * @param {String} eventName to subscribe to.
+ * @param {Function} callback triggered on the event.
+ */
+
+ContentSync.prototype.on = function(eventName, callback) {
+    if (this._handlers.hasOwnProperty(eventName)) {
+        this._handlers[eventName].push(callback);
+    }
+};
+
+/**
+ * Emit an event.
+ *
+ * This is intended for internal use only.
+ *
+ * @param {String} eventName is the event to trigger.
+ * @param {*} all arguments are passed to the event listeners.
+ *
+ * @return {Boolean} is true when the event is triggered otherwise false.
+ */
+
+ContentSync.prototype.emit = function() {
+    var args = Array.prototype.slice.call(arguments);
+    var eventName = args.shift();
+
+    if (!this._handlers.hasOwnProperty(eventName)) {
+        return false;
+    }
+
+    for (var i = 0, length = this._handlers[eventName].length; i < length; i++) {
+        this._handlers[eventName][i].apply(undefined,args);
+    }
+
+    return true;
+};
+
+/*!
+ * Content Sync Plugin.
+ */
+
+module.exports = {
+    /**
+     * Synchronize the content.
+     *
+     * This method will instantiate a new copy of the ContentSync object
+     * and start synchronizing.
+     *
+     * @param {Object} options
+     * @return {ContentSync} instance
+     */
+
+    sync: function(options) {
+        return new ContentSync(options);
+    },
+
+    /**
+     * Unzip
+     *
+     * This call is to replicate Zip::unzip plugin
+     *
+     */
+
+    unzip: function(fileUrl, dirUrl, callback, progressCallback) {
+        var win = function(result) {
+            if (result && result.progress) {
+                if (progressCallback) {
+                    progressCallback(result);
+                }
+            } else if (callback) {
+                callback(0);
+            }
+        };
+        var fail = function(result) {
+            if (callback) {
+                callback(-1);
+            }
+        };
+        exec(win, fail, 'Zip', 'unzip', [fileUrl, dirUrl]);
+    },
+
+    /**
+     * Download
+     *
+     * This call is to replicate nothing but might be used instead of FileTransfer
+     *
+     */
+
+    download: function(url, headers, cb) {
+        var callback = (typeof headers == "function" ? headers : cb);
+        exec(callback, callback, 'Sync', 'download', [url, null, headers]);
+    },
+    
+    /**
+     * loadUrl
+     *
+     * This method allows loading file:// urls when using WKWebViews on iOS. 
+     *
+     */
+
+    loadUrl: function(url, cb) {
+        if(!url) {
+            throw new Error('URL is required.');
+        }
+        exec(cb, cb, 'Sync', 'loadUrl', [url]);
+    },
+
+
+    /**
+     * ContentSync Object.
+     *
+     * Expose the ContentSync object for direct use
+     * and testing. Typically, you should use the
+     * .sync helper method.
+     */
+
+    ContentSync: ContentSync,
+
+    /**
+     * PROGRESS_STATE enumeration.
+     *
+     * Maps to the `progress` event's `status` object.
+     * The plugin user can customize the enumeration's mapped string
+     * to a value that's appropriate for their app.
+     */
+
+    PROGRESS_STATE: {
+        0: 'STOPPED',
+        1: 'DOWNLOADING',
+        2: 'EXTRACTING',
+        3: 'COMPLETE'
+    },
+
+    /**
+     * ERROR_STATE enumeration.
+     *
+     * Maps to the `error` event's `status` object.
+     * The plugin user can customize the enumeration's mapped string
+     * to a value that's appropriate for their app.
+     */
+
+    ERROR_STATE: {
+        1: 'INVALID_URL_ERR',
+        2: 'CONNECTION_ERR',
+        3: 'UNZIP_ERR'
+    }
+};