/* * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * */ /* jshint jasmine: true */ /* global WebKitBlobBuilder */ exports.defineAutoTests = function () { var isBrowser = (cordova.platformId === "browser"); // Use feature detection to determine current browser instead of checking user-agent var isChrome = isBrowser && window.webkitRequestFileSystem && window.webkitResolveLocalFileSystemURL; var isIE = isBrowser && (window.msIndexedDB); var isIndexedDBShim = isBrowser && !isChrome; // Firefox and IE for example var isWindows = (cordova.platformId === "windows" || cordova.platformId === "windows8"); var MEDIUM_TIMEOUT = 15000; describe('File API', function () { // Adding a Jasmine helper matcher, to report errors when comparing to FileError better. var fileErrorMap = { 1 : 'NOT_FOUND_ERR', 2 : 'SECURITY_ERR', 3 : 'ABORT_ERR', 4 : 'NOT_READABLE_ERR', 5 : 'ENCODING_ERR', 6 : 'NO_MODIFICATION_ALLOWED_ERR', 7 : 'INVALID_STATE_ERR', 8 : 'SYNTAX_ERR', 9 : 'INVALID_MODIFICATION_ERR', 10 : 'QUOTA_EXCEEDED_ERR', 11 : 'TYPE_MISMATCH_ERR', 12 : 'PATH_EXISTS_ERR' }, root, temp_root, persistent_root; beforeEach(function (done) { // Custom Matchers jasmine.Expectation.addMatchers({ toBeFileError : function () { return { compare : function (error, code) { var pass = error.code === code; return { pass : pass, message : 'Expected FileError with code ' + fileErrorMap[error.code] + ' (' + error.code + ') to be ' + fileErrorMap[code] + '(' + code + ')' }; } }; }, toCanonicallyMatch : function () { return { compare : function (currentPath, path) { var a = path.split("/").join("").split("\\").join(""), b = currentPath.split("/").join("").split("\\").join(""), pass = a === b; return { pass : pass, message : 'Expected paths to match : ' + path + ' should be ' + currentPath }; } }; }, toFailWithMessage : function () { return { compare : function (error, message) { var pass = false; return { pass : pass, message : message }; } }; }, toBeDataUrl: function () { return { compare : function (url) { var pass = false; // "data:application/octet-stream;base64," var header = url.substr(0, url.indexOf(',')); var headerParts = header.split(/[:;]/); if (headerParts.length === 3 && headerParts[0] === 'data' && headerParts[2] === 'base64') { pass = true; } var message = 'Expected ' + url + ' to be a valid data url. ' + header + ' is not valid header for data uris'; return { pass : pass, message : message }; } }; } }); //Define global variables var onError = function (e) { console.log('[ERROR] Problem setting up root filesystem for test running! Error to follow.'); console.log(JSON.stringify(e)); }; window.requestFileSystem(LocalFileSystem.PERSISTENT, 0, function (fileSystem) { root = fileSystem.root; // set in file.tests.js persistent_root = root; window.requestFileSystem(LocalFileSystem.TEMPORARY, 0, function (fileSystem) { temp_root = fileSystem.root; // set in file.tests.js done(); }, onError); }, onError); }); // HELPER FUNCTIONS // deletes specified file or directory var deleteEntry = function (name, success, error) { // deletes entry, if it exists // entry.remove success callback is required: http://www.w3.org/TR/2011/WD-file-system-api-20110419/#the-entry-interface success = success || function() {}; error = error || failed.bind(null, success, 'deleteEntry failed.'); window.resolveLocalFileSystemURL(root.toURL() + '/' + name, function (entry) { if (entry.isDirectory === true) { entry.removeRecursively(success, error); } else { entry.remove(success, error); } }, success); }; // deletes file, if it exists, then invokes callback var deleteFile = function (fileName, callback) { // entry.remove success callback is required: http://www.w3.org/TR/2011/WD-file-system-api-20110419/#the-entry-interface callback = callback || function() {}; root.getFile(fileName, null, // remove file system entry function (entry) { entry.remove(callback, function () { console.log('[ERROR] deleteFile cleanup method invoked fail callback.'); }); }, // doesn't exist callback); }; // deletes and re-creates the specified file var createFile = function (fileName, success, error) { deleteEntry(fileName, function () { root.getFile(fileName, { create : true }, success, error); }, error); }; // deletes and re-creates the specified directory var createDirectory = function (dirName, success, error) { deleteEntry(dirName, function () { root.getDirectory(dirName, { create : true }, success, error); }, error); }; function failed(done, msg, error) { var info = typeof msg == 'undefined' ? 'Unexpected error callback' : msg; var codeMsg = (error && error.code) ? (': ' + fileErrorMap[error.code]) : ''; expect(true).toFailWithMessage(info + '\n' + JSON.stringify(error) + codeMsg); done(); } var succeed = function (done, msg) { var info = typeof msg == 'undefined' ? 'Unexpected success callback' : msg; expect(true).toFailWithMessage(info); done(); }; var joinURL = function (base, extension) { if (base.charAt(base.length - 1) !== '/' && extension.charAt(0) !== '/') { return base + '/' + extension; } if (base.charAt(base.length - 1) === '/' && extension.charAt(0) === '/') { return base + extension.substring(1); } return base + extension; }; describe('FileError object', function () { it("file.spec.1 should define FileError constants", function () { expect(FileError.NOT_FOUND_ERR).toBe(1); expect(FileError.SECURITY_ERR).toBe(2); expect(FileError.ABORT_ERR).toBe(3); expect(FileError.NOT_READABLE_ERR).toBe(4); expect(FileError.ENCODING_ERR).toBe(5); expect(FileError.NO_MODIFICATION_ALLOWED_ERR).toBe(6); expect(FileError.INVALID_STATE_ERR).toBe(7); expect(FileError.SYNTAX_ERR).toBe(8); expect(FileError.INVALID_MODIFICATION_ERR).toBe(9); expect(FileError.QUOTA_EXCEEDED_ERR).toBe(10); expect(FileError.TYPE_MISMATCH_ERR).toBe(11); expect(FileError.PATH_EXISTS_ERR).toBe(12); }); }); describe('LocalFileSystem', function () { it("file.spec.2 should define LocalFileSystem constants", function () { expect(LocalFileSystem.TEMPORARY).toBe(0); expect(LocalFileSystem.PERSISTENT).toBe(1); }); describe('window.requestFileSystem', function () { it("file.spec.3 should be defined", function () { expect(window.requestFileSystem).toBeDefined(); }); it("file.spec.4 should be able to retrieve a PERSISTENT file system", function (done) { var win = function (fileSystem) { expect(fileSystem).toBeDefined(); expect(fileSystem.name).toBeDefined(); if (isChrome) { expect(fileSystem.name).toContain("Persistent"); } else { expect(fileSystem.name).toBe("persistent"); } expect(fileSystem.root).toBeDefined(); expect(fileSystem.root.filesystem).toBeDefined(); // Shouldn't use cdvfile by default. expect(fileSystem.root.toURL()).not.toMatch(/^cdvfile:/); // All DirectoryEntry URLs should always have a trailing slash. expect(fileSystem.root.toURL()).toMatch(/\/$/); done(); }; // Request a little bit of space on the filesystem, unless we're running in a browser where that could cause a prompt. var spaceRequired = isBrowser ? 0 : 1024; // retrieve PERSISTENT file system window.requestFileSystem(LocalFileSystem.PERSISTENT, spaceRequired, win, failed.bind(null, done, 'window.requestFileSystem - Error retrieving PERSISTENT file system')); }); it("file.spec.5 should be able to retrieve a TEMPORARY file system", function (done) { var win = function (fileSystem) { expect(fileSystem).toBeDefined(); if (isChrome) { expect(fileSystem.name).toContain("Temporary"); } else { expect(fileSystem.name).toBe("temporary"); } expect(fileSystem.root).toBeDefined(); expect(fileSystem.root.filesystem).toBeDefined(); expect(fileSystem.root.filesystem).toBe(fileSystem); done(); }; //retrieve TEMPORARY file system window.requestFileSystem(LocalFileSystem.TEMPORARY, 0, win, failed.bind(null, done, 'window.requestFileSystem - Error retrieving TEMPORARY file system')); }); it("file.spec.6 should error if you request a file system that is too large", function (done) { if (isBrowser) { /*window.requestFileSystem TEMPORARY and PERSISTENT filesystem quota is not limited in Chrome. Firefox filesystem size is not limited but every 50MB request user permission. IE10 allows up to 10mb of combined AppCache and IndexedDB used in implementation of filesystem without prompting, once you hit that level you will be asked if you want to allow it to be increased up to a max of 250mb per site. So `size` parameter for `requestFileSystem` function does not affect on filesystem in Firefox and IE.*/ pending(); } var fail = function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.QUOTA_EXCEEDED_ERR); done(); }; //win = createWin('window.requestFileSystem'); // Request the file system window.requestFileSystem(LocalFileSystem.TEMPORARY, 1000000000000000, failed.bind(null, done, 'window.requestFileSystem - Error retrieving TEMPORARY file system'), fail); }); it("file.spec.7 should error out if you request a file system that does not exist", function (done) { var fail = function (error) { expect(error).toBeDefined(); if (isChrome) { /*INVALID_MODIFICATION_ERR (code: 9) is thrown instead of SYNTAX_ERR(code: 8) on requesting of a non-existant filesystem.*/ expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); } else { expect(error).toBeFileError(FileError.SYNTAX_ERR); } done(); }; // Request the file system window.requestFileSystem(-1, 0, succeed.bind(null, done, 'window.requestFileSystem'), fail); }); }); describe('window.resolveLocalFileSystemURL', function () { it("file.spec.8 should be defined", function () { expect(window.resolveLocalFileSystemURL).toBeDefined(); }); it("file.spec.9 should resolve a valid file name", function (done) { var fileName = 'file.spec.9'; var win = function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.isFile).toBe(true); expect(fileEntry.isDirectory).toBe(false); expect(fileEntry.name).toCanonicallyMatch(fileName); expect(fileEntry.toURL()).not.toMatch(/^cdvfile:/, 'should not use cdvfile URL'); expect(fileEntry.toURL()).not.toMatch(/\/$/, 'URL should not end with a slash'); // Clean-up deleteEntry(fileName, done); }; createFile(fileName, function (entry) { window.resolveLocalFileSystemURL(entry.toURL(), win, failed.bind(null, done, 'window.resolveLocalFileSystemURL - Error resolving file URL: ' + entry.toURL())); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName), failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.9.1 should resolve a file even with a terminating slash", function (done) { var fileName = 'file.spec.9.1'; var win = function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.isFile).toBe(true); expect(fileEntry.isDirectory).toBe(false); expect(fileEntry.name).toCanonicallyMatch(fileName); expect(fileEntry.toURL()).not.toMatch(/^cdvfile:/, 'should not use cdvfile URL'); expect(fileEntry.toURL()).not.toMatch(/\/$/, 'URL should not end with a slash'); // Clean-up deleteEntry(fileName, done); }; createFile(fileName, function (entry) { var entryURL = entry.toURL() + '/'; window.resolveLocalFileSystemURL(entryURL, win, failed.bind(null, done, 'window.resolveLocalFileSystemURL - Error resolving file URL: ' + entryURL)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName), failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.9.5 should resolve a directory", function (done) { var fileName = 'file.spec.9.5'; var win = function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.isFile).toBe(false); expect(fileEntry.isDirectory).toBe(true); expect(fileEntry.name).toCanonicallyMatch(fileName); expect(fileEntry.toURL()).not.toMatch(/^cdvfile:/, 'should not use cdvfile URL'); expect(fileEntry.toURL()).toMatch(/\/$/, 'URL end with a slash'); // cleanup deleteEntry(fileName, done); }; function gotDirectory(entry) { // lookup file system entry window.resolveLocalFileSystemURL(entry.toURL(), win, failed.bind(null, done, 'window.resolveLocalFileSystemURL - Error resolving directory URL: ' + entry.toURL())); } createDirectory(fileName, gotDirectory, failed.bind(null, done, 'createDirectory - Error creating directory: ' + fileName), failed.bind(null, done, 'createDirectory - Error creating directory: ' + fileName)); }); it("file.spec.9.6 should resolve a directory even without a terminating slash", function (done) { var fileName = 'file.spec.9.6'; var win = function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.isFile).toBe(false); expect(fileEntry.isDirectory).toBe(true); expect(fileEntry.name).toCanonicallyMatch(fileName); expect(fileEntry.toURL()).not.toMatch(/^cdvfile:/, 'should not use cdvfile URL'); expect(fileEntry.toURL()).toMatch(/\/$/, 'URL end with a slash'); // cleanup deleteEntry(fileName, done); }; function gotDirectory(entry) { // lookup file system entry var entryURL = entry.toURL(); entryURL = entryURL.substring(0, entryURL.length - 1); window.resolveLocalFileSystemURL(entryURL, win, failed.bind(null, done, 'window.resolveLocalFileSystemURL - Error resolving directory URL: ' + entryURL)); } createDirectory(fileName, gotDirectory, failed.bind(null, done, 'createDirectory - Error creating directory: ' + fileName), failed.bind(null, done, 'createDirectory - Error creating directory: ' + fileName)); }); it("file.spec.10 resolve valid file name with parameters", function (done) { var fileName = "resolve.file.uri.params", win = function (fileEntry) { expect(fileEntry).toBeDefined(); if (fileEntry.toURL().toLowerCase().substring(0, 10) === "cdvfile://") { expect(fileEntry.fullPath).toBe("/" + fileName + "?1234567890"); } expect(fileEntry.name).toBe(fileName); // cleanup deleteEntry(fileName, done); }; // create a new file entry createFile(fileName, function (entry) { window.resolveLocalFileSystemURL(entry.toURL() + "?1234567890", win, failed.bind(null, done, 'window.resolveLocalFileSystemURL - Error resolving file URI: ' + entry.toURL())); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.11 should error (NOT_FOUND_ERR) when resolving (non-existent) invalid file name", function (done) { var fileName = cordova.platformId === 'windowsphone' ? root.toURL() + "/" + "this.is.not.a.valid.file.txt" : joinURL(root.toURL(), "this.is.not.a.valid.file.txt"), fail = function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); done(); }; // lookup file system entry window.resolveLocalFileSystemURL(fileName, succeed.bind(null, done, 'window.resolveLocalFileSystemURL - Error unexpected callback resolving file URI: ' + fileName), fail); }); it("file.spec.12 should error (ENCODING_ERR) when resolving invalid URI with leading /", function (done) { var fileName = "/this.is.not.a.valid.url", fail = function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.ENCODING_ERR); done(); }; // lookup file system entry window.resolveLocalFileSystemURL(fileName, succeed.bind(null, done, 'window.resolveLocalFileSystemURL - Error unexpected callback resolving file URI: ' + fileName), fail); }); }); }); //LocalFileSystem describe('Metadata interface', function () { it("file.spec.13 should exist and have the right properties", function () { var metadata = new Metadata(); expect(metadata).toBeDefined(); expect(metadata.modificationTime).toBeDefined(); }); }); describe('Flags interface', function () { it("file.spec.14 should exist and have the right properties", function () { var flags = new Flags(false, true); expect(flags).toBeDefined(); expect(flags.create).toBeDefined(); expect(flags.create).toBe(false); expect(flags.exclusive).toBeDefined(); expect(flags.exclusive).toBe(true); }); }); describe('FileSystem interface', function () { it("file.spec.15 should have a root that is a DirectoryEntry", function (done) { var win = function (entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(false); expect(entry.isDirectory).toBe(true); expect(entry.name).toBeDefined(); expect(entry.fullPath).toBeDefined(); expect(entry.getMetadata).toBeDefined(); expect(entry.moveTo).toBeDefined(); expect(entry.copyTo).toBeDefined(); expect(entry.toURL).toBeDefined(); expect(entry.remove).toBeDefined(); expect(entry.getParent).toBeDefined(); expect(entry.createReader).toBeDefined(); expect(entry.getFile).toBeDefined(); expect(entry.getDirectory).toBeDefined(); expect(entry.removeRecursively).toBeDefined(); done(); }; window.resolveLocalFileSystemURL(root.toURL(), win, failed.bind(null, done, 'window.resolveLocalFileSystemURL - Error resolving file URI: ' + root.toURL())); }); }); describe('DirectoryEntry', function () { it("file.spec.16 getFile: get Entry for file that does not exist", function (done) { var fileName = "de.no.file", fail = function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); done(); }; // create:false, exclusive:false, file does not exist root.getFile(fileName, { create : false }, succeed.bind(null, done, 'root.getFile - Error unexpected callback, file should not exists: ' + fileName), fail); }); it("file.spec.17 getFile: create new file", function (done) { var fileName = "de.create.file", filePath = joinURL(root.fullPath, fileName), win = function (entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toCanonicallyMatch(fileName); expect(entry.fullPath).toCanonicallyMatch(filePath); // cleanup deleteEntry(entry.name, done); }; // create:true, exclusive:false, file does not exist root.getFile(fileName, { create : true }, win, succeed.bind(null, done, 'root.getFile - Error unexpected callback, file should not exists: ' + fileName)); }); it("file.spec.18 getFile: create new file (exclusive)", function (done) { var fileName = "de.create.exclusive.file", filePath = joinURL(root.fullPath, fileName), win = function (entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toBe(fileName); expect(entry.fullPath).toCanonicallyMatch(filePath); // cleanup deleteEntry(entry.name, done); }; // create:true, exclusive:true, file does not exist root.getFile(fileName, { create : true, exclusive : true }, win, failed.bind(null, done, 'root.getFile - Error creating file: ' + fileName)); }); it("file.spec.19 getFile: create file that already exists", function (done) { var fileName = "de.create.existing.file", filePath = joinURL(root.fullPath, fileName); function win(entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toCanonicallyMatch(fileName); expect(entry.fullPath).toCanonicallyMatch(filePath); // cleanup deleteEntry(entry.name, done); } function getFile(file) { // create:true, exclusive:false, file exists root.getFile(fileName, { create : true }, win, failed.bind(null, done, 'root.getFile - Error creating file: ' + fileName)); } // create file to kick off it root.getFile(fileName, { create : true }, getFile, failed.bind(null, done, 'root.getFile - Error on initial creating file: ' + fileName)); }); it("file.spec.20 getFile: create file that already exists (exclusive)", function (done) { var fileName = "de.create.exclusive.existing.file", existingFile; function fail(error) { expect(error).toBeDefined(); if (isChrome) { /*INVALID_MODIFICATION_ERR (code: 9) is thrown instead of PATH_EXISTS_ERR(code: 12) on trying to exclusively create a file, which already exists in Chrome.*/ expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); } else { expect(error).toBeFileError(FileError.PATH_EXISTS_ERR); } // cleanup deleteEntry(existingFile.name, done); } function getFile(file) { existingFile = file; // create:true, exclusive:true, file exists root.getFile(fileName, { create : true, exclusive : true }, succeed.bind(null, done, 'root.getFile - getFile function - Error unexpected callback, file should exists: ' + fileName), fail); } // create file to kick off it root.getFile(fileName, { create : true }, getFile, failed.bind(null, done, 'root.getFile - Error creating file: ' + fileName)); }); it("file.spec.21 DirectoryEntry.getFile: get Entry for existing file", function (done) { var fileName = "de.get.file", filePath = joinURL(root.fullPath, fileName), win = function (entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toCanonicallyMatch(fileName); expect(entry.fullPath).toCanonicallyMatch(filePath); expect(entry.filesystem).toBeDefined(); expect(entry.filesystem).toBe(root.filesystem); //clean up deleteEntry(entry.name, done); }, getFile = function (file) { // create:false, exclusive:false, file exists root.getFile(fileName, { create : false }, win, failed.bind(null, done, 'root.getFile - Error getting file entry: ' + fileName)); }; // create file to kick off it root.getFile(fileName, { create : true }, getFile, failed.bind(null, done, 'root.getFile - Error creating file: ' + fileName)); }); it("file.spec.22 DirectoryEntry.getFile: get FileEntry for invalid path", function (done) { if (isBrowser) { /*The plugin does not follow to ["8.3 Naming restrictions"] (http://www.w3.org/TR/2011/WD-file-system-api-20110419/#naming-restrictions).*/ pending(); } var fileName = "de:invalid:path", fail = function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.ENCODING_ERR); done(); }; // create:false, exclusive:false, invalid path root.getFile(fileName, { create : false }, succeed.bind(null, done, 'root.getFile - Error unexpected callback, file should not exists: ' + fileName), fail); }); it("file.spec.23 DirectoryEntry.getDirectory: get Entry for directory that does not exist", function (done) { var dirName = "de.no.dir", fail = function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); done(); }; // create:false, exclusive:false, directory does not exist root.getDirectory(dirName, { create : false }, succeed.bind(null, done, 'root.getDirectory - Error unexpected callback, directory should not exists: ' + dirName), fail); }); it("file.spec.24 DirectoryEntry.getDirectory: create new dir with space then resolveLocalFileSystemURL", function (done) { var dirName = "de create dir"; function win(directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.name).toCanonicallyMatch(dirName); expect(directory.fullPath).toCanonicallyMatch(joinURL(root.fullPath, dirName)); // cleanup deleteEntry(directory.name, done); } function getDir(dirEntry) { expect(dirEntry.filesystem).toBeDefined(); expect(dirEntry.filesystem).toBe(root.filesystem); var dirURI = dirEntry.toURL(); // now encode URI and try to resolve window.resolveLocalFileSystemURL(dirURI, win, failed.bind(null, done, 'window.resolveLocalFileSystemURL - getDir function - Error resolving directory: ' + dirURI)); } // create:true, exclusive:false, directory does not exist root.getDirectory(dirName, { create : true }, getDir, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); // This test is excluded, and should probably be removed. Filesystem // should always be properly encoded URLs, and *not* raw paths, and it // doesn't make sense to double-encode the URLs and expect that to be // handled by the implementation. // If a particular platform uses paths internally rather than URLs, // then that platform should careful to pass them correctly to its // backend. xit("file.spec.25 DirectoryEntry.getDirectory: create new dir with space resolveLocalFileSystemURL with encoded URI", function (done) { var dirName = "de create dir2", dirPath = joinURL(root.fullPath, dirName); function win(directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.name).toCanonicallyMatch(dirName); expect(directory.fullPath).toCanonicallyMatch(dirPath); // cleanup deleteEntry(directory.name, done); } function getDir(dirEntry) { var dirURI = dirEntry.toURL(); // now encode URI and try to resolve window.resolveLocalFileSystemURL(encodeURI(dirURI), win, failed.bind(null, done, 'window.resolveLocalFileSystemURL - getDir function - Error resolving directory: ' + dirURI)); } // create:true, exclusive:false, directory does not exist root.getDirectory(dirName, { create : true }, getDir, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); it("file.spec.26 DirectoryEntry.getDirectory: create new directory", function (done) { var dirName = "de.create.dir", dirPath = joinURL(root.fullPath, dirName), win = function (directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.name).toCanonicallyMatch(dirName); expect(directory.fullPath).toCanonicallyMatch(dirPath); expect(directory.filesystem).toBeDefined(); expect(directory.filesystem).toBe(root.filesystem); // cleanup deleteEntry(directory.name, done); }; // create:true, exclusive:false, directory does not exist root.getDirectory(dirName, { create : true }, win, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); it("file.spec.27 DirectoryEntry.getDirectory: create new directory (exclusive)", function (done) { var dirName = "de.create.exclusive.dir", dirPath = joinURL(root.fullPath, dirName), win = function (directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.name).toCanonicallyMatch(dirName); expect(directory.fullPath).toCanonicallyMatch(dirPath); expect(directory.filesystem).toBeDefined(); expect(directory.filesystem).toBe(root.filesystem); // cleanup deleteEntry(directory.name, done); }; // create:true, exclusive:true, directory does not exist root.getDirectory(dirName, { create : true, exclusive : true }, win, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); it("file.spec.28 DirectoryEntry.getDirectory: create directory that already exists", function (done) { var dirName = "de.create.existing.dir", dirPath = joinURL(root.fullPath, dirName), win = function (directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.name).toCanonicallyMatch(dirName); expect(directory.fullPath).toCanonicallyMatch(dirPath); // cleanup deleteEntry(directory.name, done); }; // create directory to kick off it root.getDirectory(dirName, { create : true }, function () { root.getDirectory(dirName, { create : true }, win, failed.bind(null, done, 'root.getDirectory - Error creating existent second directory : ' + dirName)); }, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); it("file.spec.29 DirectoryEntry.getDirectory: create directory that already exists (exclusive)", function (done) { var dirName = "de.create.exclusive.existing.dir", existingDir, fail = function (error) { expect(error).toBeDefined(); if (isChrome) { /*INVALID_MODIFICATION_ERR (code: 9) is thrown instead of PATH_EXISTS_ERR(code: 12) on trying to exclusively create a file or directory, which already exists (Chrome).*/ expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); } else { expect(error).toBeFileError(FileError.PATH_EXISTS_ERR); } // cleanup deleteEntry(existingDir.name, done); }; // create directory to kick off it root.getDirectory(dirName, { create : true }, function (directory) { existingDir = directory; // create:true, exclusive:true, directory exists root.getDirectory(dirName, { create : true, exclusive : true }, failed.bind(null, done, 'root.getDirectory - Unexpected success callback, second directory should not be created : ' + dirName), fail); }, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); it("file.spec.30 DirectoryEntry.getDirectory: get Entry for existing directory", function (done) { var dirName = "de.get.dir", dirPath = joinURL(root.fullPath, dirName), win = function (directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.name).toCanonicallyMatch(dirName); expect(directory.fullPath).toCanonicallyMatch(dirPath); // cleanup deleteEntry(directory.name, done); }; // create directory to kick it off root.getDirectory(dirName, { create : true }, function () { root.getDirectory(dirName, { create : false }, win, failed.bind(null, done, 'root.getDirectory - Error getting directory entry : ' + dirName)); }, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); it("file.spec.31 DirectoryEntry.getDirectory: get DirectoryEntry for invalid path", function (done) { if (isBrowser) { /*The plugin does not follow to ["8.3 Naming restrictions"] (http://www.w3.org/TR/2011/WD-file-system-api-20110419/#naming-restrictions).*/ pending(); } var dirName = "de:invalid:path", fail = function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.ENCODING_ERR); done(); }; // create:false, exclusive:false, invalid path root.getDirectory(dirName, { create : false }, succeed.bind(null, done, 'root.getDirectory - Unexpected success callback, directory should not exists: ' + dirName), fail); }); it("file.spec.32 DirectoryEntry.getDirectory: get DirectoryEntry for existing file", function (done) { var fileName = "de.existing.file", existingFile, fail = function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.TYPE_MISMATCH_ERR); // cleanup deleteEntry(existingFile.name, done); }; // create file to kick off it root.getFile(fileName, { create : true }, function (file) { existingFile = file; root.getDirectory(fileName, { create : false }, succeed.bind(null, done, 'root.getDirectory - Unexpected success callback, directory should not exists: ' + fileName), fail); }, failed.bind(null, done, 'root.getFile - Error creating file : ' + fileName)); }); it("file.spec.33 DirectoryEntry.getFile: get FileEntry for existing directory", function (done) { var dirName = "de.existing.dir", existingDir, fail = function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.TYPE_MISMATCH_ERR); // cleanup deleteEntry(existingDir.name, done); }; // create directory to kick off it root.getDirectory(dirName, { create : true }, function (directory) { existingDir = directory; root.getFile(dirName, { create : false }, succeed.bind(null, done, 'root.getFile - Unexpected success callback, file should not exists: ' + dirName), fail); }, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); it("file.spec.34 DirectoryEntry.removeRecursively on directory", function (done) { var dirName = "de.removeRecursively", subDirName = "dir", dirExists = function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); done(); }; // create a new directory entry to kick off it root.getDirectory(dirName, { create : true }, function (entry) { entry.getDirectory(subDirName, { create : true }, function (dir) { entry.removeRecursively(function () { root.getDirectory(dirName, { create : false }, succeed.bind(null, done, 'root.getDirectory - Unexpected success callback, directory should not exists: ' + dirName), dirExists); }, failed.bind(null, done, 'entry.removeRecursively - Error removing directory recursively : ' + dirName)); }, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + subDirName)); }, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); it("file.spec.35 createReader: create reader on existing directory", function () { // create reader for root directory var reader = root.createReader(); expect(reader).toBeDefined(); expect(typeof reader.readEntries).toBe('function'); }); it("file.spec.36 removeRecursively on root file system", function (done) { var remove = function (error) { expect(error).toBeDefined(); if (isChrome) { /*INVALID_MODIFICATION_ERR (code: 9) is thrown instead of NO_MODIFICATION_ALLOWED_ERR(code: 6) on trying to call removeRecursively on the root file system (Chrome).*/ expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); } else { expect(error).toBeFileError(FileError.NO_MODIFICATION_ALLOWED_ERR); } done(); }; // remove root file system root.removeRecursively(succeed.bind(null, done, 'root.removeRecursively - Unexpected success callback, root cannot be removed'), remove); }); }); describe('DirectoryReader interface', function () { describe("readEntries", function () { it("file.spec.37 should read contents of existing directory", function (done) { var reader, win = function (entries) { expect(entries).toBeDefined(); expect(entries instanceof Array).toBe(true); done(); }; // create reader for root directory reader = root.createReader(); // read entries reader.readEntries(win, failed.bind(null, done, 'reader.readEntries - Error reading entries')); }); it("file.spec.37.1 should read contents of existing directory", function (done) { var dirName = 'readEntries.dir', fileName = 'readeEntries.file'; root.getDirectory(dirName, { create : true }, function (directory) { directory.getFile(fileName, { create : true }, function (fileEntry) { var reader = directory.createReader(); reader.readEntries(function (entries) { expect(entries).toBeDefined(); expect(entries instanceof Array).toBe(true); expect(entries.length).toBe(1); expect(entries[0].fullPath).toCanonicallyMatch(fileEntry.fullPath); expect(entries[0].filesystem).not.toBe(null); if (isChrome) { // Slicing '[object {type}]' -> '{type}' expect(entries[0].filesystem.toString().slice(8, -1)).toEqual("DOMFileSystem"); } else { expect(entries[0].filesystem instanceof FileSystem).toBe(true); } // cleanup deleteEntry(directory.name, done); }, failed.bind(null, done, 'reader.readEntries - Error reading entries from directory: ' + dirName)); }, failed.bind(null, done, 'directory.getFile - Error creating file : ' + fileName)); }, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); it("file.spec.109 should return an empty entry list on the second call", function (done) { var reader, fileName = 'test109.txt'; // Add a file to ensure the root directory is non-empty and then read the contents of the directory. root.getFile(fileName, { create : true }, function (entry) { reader = root.createReader(); //First read reader.readEntries(function (entries) { expect(entries).toBeDefined(); expect(entries instanceof Array).toBe(true); expect(entries.length).not.toBe(0); //Second read reader.readEntries(function (entries_) { expect(entries_).toBeDefined(); expect(entries_ instanceof Array).toBe(true); expect(entries_.length).toBe(0); //Clean up deleteEntry(entry.name, done); }, failed.bind(null, done, 'reader.readEntries - Error during SECOND reading of entries from [root] directory')); }, failed.bind(null, done, 'reader.readEntries - Error during FIRST reading of entries from [root] directory')); }, failed.bind(null, done, 'root.getFile - Error creating file : ' + fileName)); }); }); it("file.spec.38 should read contents of directory that has been removed", function (done) { var dirName = "de.createReader.notfound"; // create a new directory entry to kick off it root.getDirectory(dirName, { create : true }, function (directory) { directory.removeRecursively(function () { var reader = directory.createReader(); reader.readEntries(succeed.bind(null, done, 'reader.readEntries - Unexpected success callback, it should not read entries from deleted dir: ' + dirName), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); root.getDirectory(dirName, { create : false }, succeed.bind(null, done, 'root.getDirectory - Unexpected success callback, it should not get deleted directory: ' + dirName), function (err) { expect(err).toBeDefined(); expect(err).toBeFileError(FileError.NOT_FOUND_ERR); done(); }); }); }, failed.bind(null, done, 'directory.removeRecursively - Error removing directory recursively : ' + dirName)); }, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); }); //DirectoryReader interface describe('File', function () { it("file.spec.39 constructor should be defined", function () { expect(File).toBeDefined(); expect(typeof File).toBe('function'); }); it("file.spec.40 should be define File attributes", function () { var file = new File(); expect(file.name).toBeDefined(); expect(file.type).toBeDefined(); expect(file.lastModifiedDate).toBeDefined(); expect(file.size).toBeDefined(); }); }); //File describe('FileEntry', function () { it("file.spec.41 should be define FileEntry methods", function (done) { var fileName = "fe.methods", testFileEntry = function (fileEntry) { expect(fileEntry).toBeDefined(); expect(typeof fileEntry.createWriter).toBe('function'); expect(typeof fileEntry.file).toBe('function'); // cleanup deleteEntry(fileEntry.name, done); }; // create a new file entry to kick off it root.getFile(fileName, { create : true }, testFileEntry, failed.bind(null, done, 'root.getFile - Error creating file : ' + fileName)); }); it("file.spec.42 createWriter should return a FileWriter object", function (done) { var fileName = "fe.createWriter", testFile, testWriter = function (writer) { expect(writer).toBeDefined(); if (isChrome) { // Slicing '[object {type}]' -> '{type}' expect(writer.toString().slice(8, -1)).toEqual("FileWriter"); } else { expect(writer instanceof FileWriter).toBe(true); } // cleanup deleteEntry(testFile.name, done); }; // create a new file entry to kick off it root.getFile(fileName, { create : true }, function (fileEntry) { testFile = fileEntry; fileEntry.createWriter(testWriter, failed.bind(null, done, 'fileEntry.createWriter - Error creating Writer from entry')); }, failed.bind(null, done, 'root.getFile - Error creating file : ' + fileName)); }); it("file.spec.43 file should return a File object", function (done) { var fileName = "fe.file", newFile, testFile = function (file) { expect(file).toBeDefined(); if (isChrome) { // Slicing '[object {type}]' -> '{type}' expect(file.toString().slice(8, -1)).toEqual("File"); } else { expect(file instanceof File).toBe(true); } // cleanup deleteEntry(newFile.name, done); }; // create a new file entry to kick off it root.getFile(fileName, { create : true }, function (fileEntry) { newFile = fileEntry; fileEntry.file(testFile, failed.bind(null, done, 'fileEntry.file - Error reading file using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'root.getFile - Error creating file : ' + fileName)); }); it("file.spec.44 file: on File that has been removed", function (done) { var fileName = "fe.no.file"; // create a new file entry to kick off it root.getFile(fileName, { create : true }, function (fileEntry) { fileEntry.remove(function () { fileEntry.file(succeed.bind(null, done, 'fileEntry.file - Unexpected success callback, file it should not be created from removed entry'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); done(); }); }, failed.bind(null, done, 'fileEntry.remove - Error removing entry : ' + fileName)); }, failed.bind(null, done, 'root.getFile - Error creating file : ' + fileName)); }); }); //FileEntry describe('Entry', function () { it("file.spec.45 Entry object", function (done) { var fileName = "entry", fullPath = joinURL(root.fullPath, fileName), winEntry = function (entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toCanonicallyMatch(fileName); expect(entry.fullPath).toCanonicallyMatch(fullPath); expect(typeof entry.getMetadata).toBe('function'); expect(typeof entry.setMetadata).toBe('function'); expect(typeof entry.moveTo).toBe('function'); expect(typeof entry.copyTo).toBe('function'); expect(typeof entry.toURL).toBe('function'); expect(typeof entry.remove).toBe('function'); expect(typeof entry.getParent).toBe('function'); expect(typeof entry.createWriter).toBe('function'); expect(typeof entry.file).toBe('function'); // Clean up deleteEntry(fileName, done); }; // create a new file entry createFile(fileName, winEntry, failed.bind(null, done, 'createFile - Error creating file : ' + fileName)); }); it("file.spec.46 Entry.getMetadata on file", function (done) { var fileName = "entry.metadata.file"; // create a new file entry createFile(fileName, function (entry) { entry.getMetadata(function (metadata) { expect(metadata).toBeDefined(); expect(metadata.modificationTime instanceof Date).toBe(true); expect(typeof metadata.size).toBe("number"); // cleanup deleteEntry(fileName, done); }, failed.bind(null, done, 'entry.getMetadata - Error getting metadata from entry : ' + fileName)); }, failed.bind(null, done, 'createFile - Error creating file : ' + fileName)); }); it("file.spec.47 Entry.getMetadata on directory", function (done) { if (isIndexedDBShim) { /* Does not support metadata for directories (Firefox, IE) */ pending(); } var dirName = "entry.metadata.dir"; // create a new directory entry createDirectory(dirName, function (entry) { entry.getMetadata(function (metadata) { expect(metadata).toBeDefined(); expect(metadata.modificationTime instanceof Date).toBe(true); expect(typeof metadata.size).toBe("number"); expect(metadata.size).toBe(0); // cleanup deleteEntry(dirName, done); }, failed.bind(null, done, 'entry.getMetadata - Error getting metadata from entry : ' + dirName)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + dirName)); }); it("file.spec.48 Entry.getParent on file in root file system", function (done) { var fileName = "entry.parent.file", rootPath = root.fullPath; // create a new file entry createFile(fileName, function (entry) { entry.getParent(function (parent) { expect(parent).toBeDefined(); expect(parent.fullPath).toCanonicallyMatch(rootPath); // cleanup deleteEntry(fileName, done); }, failed.bind(null, done, 'entry.getParent - Error getting parent directory of file : ' + fileName)); }, failed.bind(null, done, 'createFile - Error creating file : ' + fileName)); }); it("file.spec.49 Entry.getParent on directory in root file system", function (done) { var dirName = "entry.parent.dir", rootPath = root.fullPath; // create a new directory entry createDirectory(dirName, function (entry) { entry.getParent(function (parent) { expect(parent).toBeDefined(); expect(parent.fullPath).toCanonicallyMatch(rootPath); // cleanup deleteEntry(dirName, done); }, failed.bind(null, done, 'entry.getParent - Error getting parent directory of directory : ' + dirName)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + dirName)); }); it("file.spec.50 Entry.getParent on root file system", function (done) { var rootPath = root.fullPath, winParent = function (parent) { expect(parent).toBeDefined(); expect(parent.fullPath).toCanonicallyMatch(rootPath); done(); }; // create a new directory entry root.getParent(winParent, failed.bind(null, done, 'root.getParent - Error getting parent directory of root')); }); it("file.spec.51 Entry.toURL on file", function (done) { var fileName = "entry.uri.file", rootPath = root.fullPath, winURI = function (entry) { var uri = entry.toURL(); expect(uri).toBeDefined(); expect(uri.indexOf(rootPath)).not.toBe(-1); // cleanup deleteEntry(fileName, done); }; // create a new file entry createFile(fileName, winURI, failed.bind(null, done, 'createFile - Error creating file : ' + fileName)); }); it("file.spec.52 Entry.toURL on directory", function (done) { var dirName_1 = "num 1", dirName_2 = "num 2", rootPath = root.fullPath; createDirectory(dirName_1, function (entry) { entry.getDirectory(dirName_2, { create : true }, function (entryFile) { var uri = entryFile.toURL(); expect(uri).toBeDefined(); expect(uri).toContain('/num%201/num%202/'); expect(uri.indexOf(rootPath)).not.toBe(-1); // cleanup deleteEntry(dirName_1, done); }, failed.bind(null, done, 'entry.getDirectory - Error creating directory : ' + dirName_2)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + dirName_1)); }); it("file.spec.53 Entry.remove on file", function (done) { var fileName = "entr .rm.file"; // create a new file entry createFile(fileName, function (entry) { expect(entry).toBeDefined(); entry.remove(function () { root.getFile(fileName, null, succeed.bind(null, done, 'root.getFile - Unexpected success callback, it should not get deleted file : ' + fileName), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); // cleanup deleteEntry(fileName, done); }); }, failed.bind(null, done, 'entry.remove - Error removing entry : ' + fileName)); }, failed.bind(null, done, 'createFile - Error creating file : ' + fileName)); }); it("file.spec.53.1 Entry.remove on filename with #s", function (done) { var fileName = "entry.#rm#.file"; // create a new file entry createFile(fileName, function (entry) { expect(entry).toBeDefined(); entry.remove(function () { root.getFile(fileName, null, succeed.bind(null, done, 'root.getFile - Unexpected success callback, it should not get deleted file : ' + fileName), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); // cleanup deleteEntry(fileName, done); }); }, failed.bind(null, done, 'entry.remove - Error removing entry : ' + fileName)); }, failed.bind(null, done, 'createFile - Error creating file : ' + fileName)); }); it("file.spec.54 remove on empty directory", function (done) { var dirName = "entry.rm.dir"; // create a new directory entry createDirectory(dirName, function (entry) { expect(entry).toBeDefined(); entry.remove(function () { root.getDirectory(dirName, null, succeed.bind(null, done, 'root.getDirectory - Unexpected success callback, it should not get deleted directory : ' + dirName), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); // cleanup deleteEntry(dirName, done); }); }, failed.bind(null, done, 'entry.remove - Error removing entry : ' + dirName)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + dirName)); }); it("file.spec.55 remove on non-empty directory", function (done) { if (isIndexedDBShim) { /* Both Entry.remove and directoryEntry.removeRecursively don't fail when removing non-empty directories - directories being removed are cleaned along with contents instead (Firefox, IE)*/ pending(); } var dirName = "ent y.rm.dir.not.empty", fileName = "re ove.txt", fullPath = joinURL(root.fullPath, dirName); // create a new directory entry createDirectory(dirName, function (entry) { entry.getFile(fileName, { create : true }, function (fileEntry) { entry.remove(succeed.bind(null, done, 'entry.remove - Unexpected success callback, it should not remove a directory that contains files : ' + dirName), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); root.getDirectory(dirName, null, function (entry) { expect(entry).toBeDefined(); expect(entry.fullPath).toCanonicallyMatch(fullPath); // cleanup deleteEntry(dirName, done); }, failed.bind(null, done, 'root.getDirectory - Error getting directory : ' + dirName)); }); }, failed.bind(null, done, 'entry.getFile - Error creating file : ' + fileName + ' inside of ' + dirName)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + dirName)); }); it("file.spec.56 remove on root file system", function (done) { // remove entry that doesn't exist root.remove(succeed.bind(null, done, 'entry.remove - Unexpected success callback, it should not remove entry that it does not exists'), function (error) { expect(error).toBeDefined(); if (isChrome) { /*INVALID_MODIFICATION_ERR (code: 9) is thrown instead of NO_MODIFICATION_ALLOWED_ERR(code: 6) on trying to call removeRecursively on the root file system.*/ expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); } else { expect(error).toBeFileError(FileError.NO_MODIFICATION_ALLOWED_ERR); } done(); }); }); it("file.spec.57 copyTo: file", function (done) { var file1 = "entry copy.file1", file2 = "entry copy.file2", fullPath = joinURL(root.fullPath, file2); // create a new file entry to kick off it deleteEntry(file2, function () { createFile(file1, function (fileEntry) { // copy file1 to file2 fileEntry.copyTo(root, file2, function (entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.fullPath).toCanonicallyMatch(fullPath); expect(entry.name).toCanonicallyMatch(file2); root.getFile(file2, { create : false }, function (entry2) { expect(entry2).toBeDefined(); expect(entry2.isFile).toBe(true); expect(entry2.isDirectory).toBe(false); expect(entry2.fullPath).toCanonicallyMatch(fullPath); expect(entry2.name).toCanonicallyMatch(file2); // cleanup deleteEntry(file1, function () { deleteEntry(file2, done); }); }, failed.bind(null, done, 'root.getFile - Error getting copied file : ' + file2)); }, failed.bind(null, done, 'fileEntry.copyTo - Error copying file : ' + file2)); }, failed.bind(null, done, 'createFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'deleteEntry - Error removing file : ' + file2)); }); it("file.spec.58 copyTo: file onto itself", function (done) { var file1 = "entry.copy.fos.file1"; // create a new file entry to kick off it createFile(file1, function (entry) { // copy file1 onto itself entry.copyTo(root, null, succeed.bind(null, done, 'entry.copyTo - Unexpected success callback, it should not copy a null file'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); // cleanup deleteEntry(file1, done); }); }, failed.bind(null, done, 'createFile - Error creating file : ' + file1)); }); it("file.spec.59 copyTo: directory", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var file1 = "file1", srcDir = "entry.copy.srcDir", dstDir = "entry.copy.dstDir", dstPath = joinURL(root.fullPath, dstDir), filePath = joinURL(dstPath, file1); // create a new directory entry to kick off it deleteEntry(dstDir, function () { createDirectory(srcDir, function (directory) { // create a file within new directory directory.getFile(file1, { create : true }, function () { directory.copyTo(root, dstDir, function (directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.fullPath).toCanonicallyMatch(dstPath); expect(directory.name).toCanonicallyMatch(dstDir); root.getDirectory(dstDir, { create : false }, function (dirEntry) { expect(dirEntry).toBeDefined(); expect(dirEntry.isFile).toBe(false); expect(dirEntry.isDirectory).toBe(true); expect(dirEntry.fullPath).toCanonicallyMatch(dstPath); expect(dirEntry.name).toCanonicallyMatch(dstDir); dirEntry.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.isFile).toBe(true); expect(fileEntry.isDirectory).toBe(false); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); expect(fileEntry.name).toCanonicallyMatch(file1); // cleanup deleteEntry(srcDir, function () { deleteEntry(dstDir, done); }); }, failed.bind(null, done, 'dirEntry.getFile - Error getting file : ' + file1)); }, failed.bind(null, done, 'root.getDirectory - Error getting copied directory : ' + dstDir)); }, failed.bind(null, done, 'directory.copyTo - Error copying directory : ' + srcDir + ' to :' + dstDir)); }, failed.bind(null, done, 'directory.getFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }, failed.bind(null, done, 'deleteEntry - Error removing directory : ' + dstDir)); }); it("file.spec.60 copyTo: directory to backup at same root directory", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var file1 = "file1", srcDir = "entry.copy srcDirSame", dstDir = "entry.copy srcDirSame-backup", dstPath = joinURL(root.fullPath, dstDir), filePath = joinURL(dstPath, file1); // create a new directory entry to kick off it deleteEntry(dstDir, function () { createDirectory(srcDir, function (directory) { directory.getFile(file1, { create : true }, function () { directory.copyTo(root, dstDir, function (directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.fullPath).toCanonicallyMatch(dstPath); expect(directory.name).toCanonicallyMatch(dstDir); root.getDirectory(dstDir, { create : false }, function (dirEntry) { expect(dirEntry).toBeDefined(); expect(dirEntry.isFile).toBe(false); expect(dirEntry.isDirectory).toBe(true); expect(dirEntry.fullPath).toCanonicallyMatch(dstPath); expect(dirEntry.name).toCanonicallyMatch(dstDir); dirEntry.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.isFile).toBe(true); expect(fileEntry.isDirectory).toBe(false); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); expect(fileEntry.name).toCanonicallyMatch(file1); // cleanup deleteEntry(srcDir, function () { deleteEntry(dstDir, done); }); }, failed.bind(null, done, 'dirEntry.getFile - Error getting file : ' + file1)); }, failed.bind(null, done, 'root.getDirectory - Error getting copied directory : ' + dstDir)); }, failed.bind(null, done, 'directory.copyTo - Error copying directory : ' + srcDir + ' to :' + dstDir)); }, failed.bind(null, done, 'directory.getFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }, failed.bind(null, done, 'deleteEntry - Error removing directory : ' + dstDir)); }); it("file.spec.61 copyTo: directory onto itself", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var file1 = "file1", srcDir = "entry.copy.dos.srcDir", srcPath = joinURL(root.fullPath, srcDir), filePath = joinURL(srcPath, file1); // create a new directory entry to kick off it createDirectory(srcDir, function (directory) { // create a file within new directory directory.getFile(file1, { create : true }, function (fileEntry) { // copy srcDir onto itself directory.copyTo(root, null, succeed.bind(null, done, 'directory.copyTo - Unexpected success callback, it should not copy file: ' + srcDir + ' to a null destination'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); root.getDirectory(srcDir, { create : false }, function (dirEntry) { expect(dirEntry).toBeDefined(); expect(dirEntry.fullPath).toCanonicallyMatch(srcPath); dirEntry.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); // cleanup deleteEntry(srcDir, done); }, failed.bind(null, done, 'dirEntry.getFile - Error getting file : ' + file1)); }, failed.bind(null, done, 'root.getDirectory - Error getting directory : ' + srcDir)); }); }, failed.bind(null, done, 'directory.getFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }); it("file.spec.62 copyTo: directory into itself", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var srcDir = "entry.copy.dis.srcDir", dstDir = "entry.copy.dis.dstDir", srcPath = joinURL(root.fullPath, srcDir); // create a new directory entry to kick off it createDirectory(srcDir, function (directory) { // copy source directory into itself directory.copyTo(directory, dstDir, succeed.bind(null, done, 'directory.copyTo - Unexpected success callback, it should not copy a directory ' + srcDir + ' into itself'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); root.getDirectory(srcDir, { create : false }, function (dirEntry) { // returning confirms existence so just check fullPath entry expect(dirEntry).toBeDefined(); expect(dirEntry.fullPath).toCanonicallyMatch(srcPath); // cleanup deleteEntry(srcDir, done); }, failed.bind(null, done, 'root.getDirectory - Error getting directory : ' + srcDir)); }); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }); it("file.spec.63 copyTo: directory that does not exist", function (done) { var file1 = "entry.copy.dnf.file1", dirName = 'dir-foo'; createFile(file1, function (fileEntry) { createDirectory(dirName, function (dirEntry) { dirEntry.remove(function () { fileEntry.copyTo(dirEntry, null, succeed.bind(null, done, 'fileEntry.copyTo - Unexpected success callback, it should not copy a file ' + file1 + ' into a removed directory'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); done(); }); }, failed.bind(null, done, 'dirEntry.remove - Error removing directory : ' + dirName)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + dirName)); }, failed.bind(null, done, 'createFile - Error creating file : ' + file1)); }); it("file.spec.64 copyTo: invalid target name", function (done) { if (isBrowser) { /*The plugin does not follow ["8.3 Naming restrictions"] (http://www.w3.org/TR/2011/WD-file-system-api-20110419/#naming-restrictions*/ pending(); } var file1 = "entry.copy.itn.file1", file2 = "bad:file:name"; // create a new file entry createFile(file1, function (entry) { // copy file1 to file2 entry.copyTo(root, file2, succeed.bind(null, done, 'entry.copyTo - Unexpected success callback, it should not copy a file ' + file1 + ' to an invalid file name: ' + file2), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.ENCODING_ERR); // cleanup deleteEntry(file1, done); }); }, failed.bind(null, done, 'createFile - Error creating file : ' + file1)); }); it("file.spec.65 moveTo: file to same parent", function (done) { var file1 = "entry.move.fsp.file1", file2 = "entry.move.fsp.file2", dstPath = joinURL(root.fullPath, file2); // create a new file entry to kick off it createFile(file1, function (entry) { // move file1 to file2 entry.moveTo(root, file2, function (entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.fullPath).toCanonicallyMatch(dstPath); expect(entry.name).toCanonicallyMatch(file2); root.getFile(file2, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(dstPath); root.getFile(file1, { create : false }, succeed.bind(null, done, 'root.getFile - Unexpected success callback, it should not get invalid or moved file: ' + file1), function (error) { //expect(navigator.fileMgr.testFileExists(srcPath) === false, "original file should not exist."); expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); // cleanup deleteEntry(file1, function () { deleteEntry(file2, done); }); }); }, failed.bind(null, done, 'root.getFile - Error getting file : ' + file2)); }, failed.bind(null, done, 'entry.moveTo - Error moving file : ' + file1 + ' to root as: ' + file2)); }, failed.bind(null, done, 'createFile - Error creating file : ' + file1)); }); it("file.spec.66 moveTo: file to new parent", function (done) { var file1 = "entry.move.fnp.file1", dir = "entry.move.fnp.dir", dstPath = joinURL(joinURL(root.fullPath, dir), file1); // ensure destination directory is cleaned up first deleteEntry(dir, function () { // create a new file entry to kick off it createFile(file1, function (entry) { // create a parent directory to move file to root.getDirectory(dir, { create : true }, function (directory) { // move file1 to new directory // move the file entry.moveTo(directory, null, function (entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.fullPath).toCanonicallyMatch(dstPath); expect(entry.name).toCanonicallyMatch(file1); // test the moved file exists directory.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(dstPath); root.getFile(file1, { create : false }, succeed.bind(null, done, 'root.getFile - Unexpected success callback, it should not get invalid or moved file: ' + file1), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); // cleanup deleteEntry(file1, function () { deleteEntry(dir, done); }); }); }, failed.bind(null, done, 'directory.getFile - Error getting file : ' + file1 + ' from: ' + dir)); }, failed.bind(null, done, 'entry.moveTo - Error moving file : ' + file1 + ' to: ' + dir + ' with the same name')); }, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dir)); }, failed.bind(null, done, 'createFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'deleteEntry - Error removing directory : ' + dir)); }); it("file.spec.67 moveTo: directory to same parent", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var file1 = "file1", srcDir = "entry.move.dsp.srcDir", dstDir = "entry.move.dsp.dstDir", dstPath = joinURL(root.fullPath, dstDir), filePath = joinURL(dstPath, file1); // ensure destination directory is cleaned up before it deleteEntry(dstDir, function () { // create a new directory entry to kick off it createDirectory(srcDir, function (directory) { // create a file within directory directory.getFile(file1, { create : true }, function () { // move srcDir to dstDir directory.moveTo(root, dstDir, function (directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.fullPath).toCanonicallyMatch(dstPath); expect(directory.name).toCanonicallyMatch(dstDir); // test that moved file exists in destination dir directory.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); // check that the moved file no longer exists in original dir root.getFile(file1, { create : false }, succeed.bind(null, done, 'directory.getFile - Unexpected success callback, it should not get invalid or moved file: ' + file1), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); // cleanup deleteEntry(srcDir, function() { deleteEntry(dstDir, done); }); }); }, failed.bind(null, done, 'directory.getFile - Error getting file : ' + file1 + ' from: ' + srcDir)); }, failed.bind(null, done, 'entry.moveTo - Error moving directory : ' + srcDir + ' to root as: ' + dstDir)); }, failed.bind(null, done, 'directory.getFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }, failed.bind(null, done, 'deleteEntry - Error removing directory : ' + dstDir)); }); it("file.spec.68 moveTo: directory to same parent with same name", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var file1 = "file1", srcDir = "entry.move.dsp.srcDir", dstDir = "entry.move.dsp.srcDir-backup", dstPath = joinURL(root.fullPath, dstDir), filePath = joinURL(dstPath, file1); // ensure destination directory is cleaned up before it deleteEntry(dstDir, function () { // create a new directory entry to kick off it createDirectory(srcDir, function (directory) { // create a file within directory directory.getFile(file1, { create : true }, function () { // move srcDir to dstDir directory.moveTo(root, dstDir, function (directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.fullPath).toCanonicallyMatch(dstPath); expect(directory.name).toCanonicallyMatch(dstDir); // check that moved file exists in destination dir directory.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); // check that the moved file no longer exists in original dir root.getFile(file1, { create : false }, succeed.bind(null, done, 'directory.getFile - Unexpected success callback, it should not get invalid or moved file: ' + file1), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); // cleanup deleteEntry(srcDir, function() { deleteEntry(dstDir, done); }); }); }, failed.bind(null, done, 'directory.getFile - Error getting file : ' + file1 + ' from: ' + srcDir)); }, failed.bind(null, done, 'entry.moveTo - Error moving directory : ' + srcDir + ' to root as: ' + dstDir)); }, failed.bind(null, done, 'directory.getFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }, failed.bind(null, done, 'deleteEntry - Error removing directory : ' + dstDir)); }); it("file.spec.69 moveTo: directory to new parent", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var file1 = "file1", srcDir = "entry.move.dnp.srcDir", dstDir = "entry.move.dnp.dstDir", dstPath = joinURL(root.fullPath, dstDir), filePath = joinURL(dstPath, file1); // ensure destination directory is cleaned up before it deleteEntry(dstDir, function () { // create a new directory entry to kick off it createDirectory(srcDir, function (directory) { // create a file within directory directory.getFile(file1, { create : true }, function () { // move srcDir to dstDir directory.moveTo(root, dstDir, function (dirEntry) { expect(dirEntry).toBeDefined(); expect(dirEntry.isFile).toBe(false); expect(dirEntry.isDirectory).toBe(true); expect(dirEntry.fullPath).toCanonicallyMatch(dstPath); expect(dirEntry.name).toCanonicallyMatch(dstDir); // test that moved file exists in destination dir dirEntry.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); // test that the moved file no longer exists in original dir root.getFile(file1, { create : false }, succeed.bind(null, done, 'root.getFile - Unexpected success callback, it should not get invalid or moved file: ' + file1), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); // cleanup deleteEntry(srcDir, function() { deleteEntry(dstDir, done); }); }); }, failed.bind(null, done, 'directory.getFile - Error getting file : ' + file1 + ' from: ' + dstDir)); }, failed.bind(null, done, 'directory.moveTo - Error moving directory : ' + srcDir + ' to root as: ' + dstDir)); }, failed.bind(null, done, 'directory.getFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }, failed.bind(null, done, 'deleteEntry - Error removing directory : ' + dstDir)); }); it("file.spec.70 moveTo: directory onto itself", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var file1 = "file1", srcDir = "entry.move.dos.srcDir", srcPath = joinURL(root.fullPath, srcDir), filePath = joinURL(srcPath, file1); // create a new directory entry to kick off it createDirectory(srcDir, function (directory) { // create a file within new directory directory.getFile(file1, { create : true }, function () { // move srcDir onto itself directory.moveTo(root, null, succeed.bind(null, done, 'directory.moveTo - Unexpected success callback, it should not move directory to invalid path'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); // test that original dir still exists root.getDirectory(srcDir, { create : false }, function (dirEntry) { // returning confirms existence so just check fullPath entry expect(dirEntry).toBeDefined(); expect(dirEntry.fullPath).toCanonicallyMatch(srcPath); dirEntry.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); // cleanup deleteEntry(srcDir, done); }, failed.bind(null, done, 'dirEntry.getFile - Error getting file : ' + file1 + ' from: ' + srcDir)); }, failed.bind(null, done, 'root.getDirectory - Error getting directory : ' + srcDir)); }); }, failed.bind(null, done, 'directory.getFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }); it("file.spec.71 moveTo: directory into itself", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var srcDir = "entry.move.dis.srcDir", dstDir = "entry.move.dis.dstDir", srcPath = joinURL(root.fullPath, srcDir); // create a new directory entry to kick off it createDirectory(srcDir, function (directory) { // move source directory into itself directory.moveTo(directory, dstDir, succeed.bind(null, done, 'directory.moveTo - Unexpected success callback, it should not move a directory into itself: ' + srcDir), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); // make sure original directory still exists root.getDirectory(srcDir, { create : false }, function (entry) { expect(entry).toBeDefined(); expect(entry.fullPath).toCanonicallyMatch(srcPath); // cleanup deleteEntry(srcDir, done); }, failed.bind(null, done, 'root.getDirectory - Error getting directory, making sure that original directory still exists: ' + srcDir)); }); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }); it("file.spec.130 moveTo: directory into similar directory", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var srcDir = "entry.move.dis.srcDir", dstDir = "entry.move.dis.srcDir-backup"; // create a new directory entry to kick off it createDirectory(srcDir, function (srcDirEntry) { deleteEntry(dstDir, function () { createDirectory(dstDir, function (dstDirEntry) { // move source directory into itself srcDirEntry.moveTo(dstDirEntry, 'file', function (newDirEntry) { expect(newDirEntry).toBeDefined(); deleteEntry(dstDir, done); }, failed.bind(null, done, 'directory.moveTo - Error moving a directory into a similarly-named directory: ' + srcDir)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + dstDir)); }, failed.bind(null, done, 'deleteEntry - Error deleting directory : ' + dstDir)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }); it("file.spec.72 moveTo: file onto itself", function (done) { var file1 = "entry.move.fos.file1", filePath = joinURL(root.fullPath, file1); // create a new file entry to kick off it createFile(file1, function (entry) { // move file1 onto itself entry.moveTo(root, null, succeed.bind(null, done, 'entry.moveTo - Unexpected success callback, it should not move a file: ' + file1 + ' into the same parent'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); //test that original file still exists root.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); // cleanup deleteEntry(file1, done); }, failed.bind(null, done, 'root.getFile - Error getting file, making sure that original file still exists: ' + file1)); }); }, failed.bind(null, done, 'createFile - Error creating file : ' + file1)); }); it("file.spec.73 moveTo: file onto existing directory", function (done) { var file1 = "entry.move.fod.file1", dstDir = "entry.move.fod.dstDir", subDir = "subDir", dirPath = joinURL(joinURL(root.fullPath, dstDir), subDir), filePath = joinURL(root.fullPath, file1); // ensure destination directory is cleaned up before it deleteEntry(dstDir, function () { // create a new file entry to kick off it createFile(file1, function (entry) { // create top level directory root.getDirectory(dstDir, { create : true }, function (directory) { // create sub-directory directory.getDirectory(subDir, { create : true }, function (subDirectory) { // move file1 onto sub-directory entry.moveTo(directory, subDir, succeed.bind(null, done, 'entry.moveTo - Unexpected success callback, it should not move a file: ' + file1 + ' into directory: ' + dstDir + '\n' + subDir + ' directory already exists'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); // check that original dir still exists directory.getDirectory(subDir, { create : false }, function (dirEntry) { expect(dirEntry).toBeDefined(); expect(dirEntry.fullPath).toCanonicallyMatch(dirPath); // check that original file still exists root.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); // cleanup deleteEntry(file1, function () { deleteEntry(dstDir, done); }); }, failed.bind(null, done, 'root.getFile - Error getting file, making sure that original file still exists: ' + file1)); }, failed.bind(null, done, 'directory.getDirectory - Error getting directory, making sure that original directory still exists: ' + subDir)); }); }, failed.bind(null, done, 'directory.getDirectory - Error creating directory : ' + subDir)); }, failed.bind(null, done, 'root.getDirectory - Error creating directory : ' + dstDir)); }, failed.bind(null, done, 'createFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'deleteEntry - Error removing directory : ' + dstDir)); }); it("file.spec.74 moveTo: directory onto existing file", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var file1 = "entry.move.dof.file1", srcDir = "entry.move.dof.srcDir", dirPath = joinURL(root.fullPath, srcDir), filePath = joinURL(root.fullPath, file1); // create a new directory entry to kick off it createDirectory(srcDir, function (entry) { // create file root.getFile(file1, { create : true }, function (fileEntry) { // move directory onto file entry.moveTo(root, file1, succeed.bind(null, done, 'entry.moveTo - Unexpected success callback, it should not move : \n' + srcDir + ' into root directory renamed as ' + file1 + '\n' + file1 + ' file already exists'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); // test that original directory exists root.getDirectory(srcDir, { create : false }, function (dirEntry) { // returning confirms existence so just check fullPath entry expect(dirEntry).toBeDefined(); expect(dirEntry.fullPath).toCanonicallyMatch(dirPath); // test that original file exists root.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); // cleanup deleteEntry(file1, function () { deleteEntry(srcDir, done); }); }, failed.bind(null, done, 'root.getFile - Error getting file, making sure that original file still exists: ' + file1)); }, failed.bind(null, done, 'directory.getDirectory - Error getting directory, making sure that original directory still exists: ' + srcDir)); }); }, failed.bind(null, done, 'root.getFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }); it("file.spec.75 copyTo: directory onto existing file", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var file1 = "entry.copy.dof.file1", srcDir = "entry.copy.dof.srcDir", dirPath = joinURL(root.fullPath, srcDir), filePath = joinURL(root.fullPath, file1); // create a new directory entry to kick off it createDirectory(srcDir, function (entry) { // create file root.getFile(file1, { create : true }, function () { // copy directory onto file entry.copyTo(root, file1, succeed.bind(null, done, 'entry.copyTo - Unexpected success callback, it should not copy : \n' + srcDir + ' into root directory renamed as ' + file1 + '\n' + file1 + ' file already exists'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); //check that original dir still exists root.getDirectory(srcDir, { create : false }, function (dirEntry) { // returning confirms existence so just check fullPath entry expect(dirEntry).toBeDefined(); expect(dirEntry.fullPath).toCanonicallyMatch(dirPath); // test that original file still exists root.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); // cleanup deleteEntry(file1, function () { deleteEntry(srcDir, done); }); }, failed.bind(null, done, 'root.getFile - Error getting file, making sure that original file still exists: ' + file1)); }, failed.bind(null, done, 'root.getDirectory - Error getting directory, making sure that original directory still exists: ' + srcDir)); }); }, failed.bind(null, done, 'root.getFile - Error creating file : ' + file1)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }); it("file.spec.76 moveTo: directory onto directory that is not empty", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var srcDir = "entry.move.dod.srcDir", dstDir = "entry.move.dod.dstDir", subDir = "subDir", srcPath = joinURL(root.fullPath, srcDir), dstPath = joinURL(joinURL(root.fullPath, dstDir), subDir); // ensure destination directory is cleaned up before it deleteEntry(dstDir, function () { // create a new file entry to kick off it createDirectory(srcDir, function (entry) { // create top level directory root.getDirectory(dstDir, { create : true }, function (directory) { // create sub-directory directory.getDirectory(subDir, { create : true }, function () { // move srcDir onto dstDir (not empty) entry.moveTo(root, dstDir, succeed.bind(null, done, 'entry.moveTo - Unexpected success callback, it should not copy : \n' + srcDir + ' into root directory renamed as ' + dstDir + '\n' + dstDir + ' directory already exists'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); // making sure destination directory still exists directory.getDirectory(subDir, { create : false }, function (dirEntry) { // returning confirms existence so just check fullPath entry expect(dirEntry).toBeDefined(); expect(dirEntry.fullPath).toCanonicallyMatch(dstPath); // making sure source directory exists root.getDirectory(srcDir, { create : false }, function (srcEntry) { expect(srcEntry).toBeDefined(); expect(srcEntry.fullPath).toCanonicallyMatch(srcPath); // cleanup deleteEntry(srcDir, function () { deleteEntry(dstDir, done); }); }, failed.bind(null, done, 'root.getDirectory - Error getting directory, making sure that original directory still exists: ' + srcDir)); }, failed.bind(null, done, 'directory.getDirectory - Error getting directory, making sure that original directory still exists: ' + subDir)); }); }, failed.bind(null, done, 'directory.getDirectory - Error creating directory : ' + subDir)); }, failed.bind(null, done, 'directory.getDirectory - Error creating directory : ' + subDir)); }, failed.bind(null, done, 'createDirectory - Error creating directory : ' + srcDir)); }, failed.bind(null, done, 'deleteEntry - Error removing directory : ' + dstDir)); }); it("file.spec.77 moveTo: file replace existing file", function (done) { var file1 = "entry.move.frf.file1", file2 = "entry.move.frf.file2", file2Path = joinURL(root.fullPath, file2); // create a new directory entry to kick off it createFile(file1, function (entry) { // create file root.getFile(file2, { create : true }, function () { // replace file2 with file1 entry.moveTo(root, file2, function (entry2) { expect(entry2).toBeDefined(); expect(entry2.isFile).toBe(true); expect(entry2.isDirectory).toBe(false); expect(entry2.fullPath).toCanonicallyMatch(file2Path); expect(entry2.name).toCanonicallyMatch(file2); // old file should not exists root.getFile(file1, { create : false }, succeed.bind(null, done, 'root.getFile - Unexpected success callback, file: ' + file1 + ' should not exists'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); // test that new file exists root.getFile(file2, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(file2Path); // cleanup deleteEntry(file1, function () { deleteEntry(file2, done); }); }, failed.bind(null, done, 'root.getFile - Error getting moved file: ' + file2)); }); }, failed.bind(null, done, 'entry.moveTo - Error moving file : ' + file1 + ' to root as: ' + file2)); }, failed.bind(null, done, 'root.getFile - Error creating file: ' + file2)); }, failed.bind(null, done, 'createFile - Error creating file: ' + file1)); }); it("file.spec.78 moveTo: directory replace empty directory", function (done) { if (isIndexedDBShim) { /* `copyTo` and `moveTo` functions do not support directories (Firefox, IE) */ pending(); } var file1 = "file1", srcDir = "entry.move.drd.srcDir", dstDir = "entry.move.drd.dstDir", dstPath = joinURL(root.fullPath, dstDir), filePath = dstPath + '/' + file1; // ensure destination directory is cleaned up before it deleteEntry(dstDir, function () { // create a new directory entry to kick off it createDirectory(srcDir, function (directory) { // create a file within source directory directory.getFile(file1, { create : true }, function () { // create destination directory root.getDirectory(dstDir, { create : true }, function () { // move srcDir to dstDir directory.moveTo(root, dstDir, function (dirEntry) { expect(dirEntry).toBeDefined(); expect(dirEntry.isFile).toBe(false); expect(dirEntry.isDirectory).toBe(true); expect(dirEntry.fullPath).toCanonicallyMatch(dstPath); expect(dirEntry.name).toCanonicallyMatch(dstDir); // check that old directory contents have been moved dirEntry.getFile(file1, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.fullPath).toCanonicallyMatch(filePath); // check that old directory no longer exists root.getDirectory(srcDir, { create : false }, succeed.bind(null, done, 'root.getDirectory - Unexpected success callback, directory: ' + srcDir + ' should not exists'), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); // cleanup deleteEntry(srcDir, function () { deleteEntry(dstDir, done); }); }); }, failed.bind(null, done, 'dirEntry.getFile - Error getting moved file: ' + file1)); }, failed.bind(null, done, 'entry.moveTo - Error moving directory : ' + srcDir + ' to root as: ' + dstDir)); }, failed.bind(null, done, 'root.getDirectory - Error creating directory: ' + dstDir)); }, failed.bind(null, done, 'root.getFile - Error creating file: ' + file1)); }, failed.bind(null, done, 'createDirectory - Error creating directory: ' + srcDir)); }, failed.bind(null, done, 'deleteEntry - Error removing directory : ' + dstDir)); }); it("file.spec.79 moveTo: directory that does not exist", function (done) { var file1 = "entry.move.dnf.file1", dstDir = "entry.move.dnf.dstDir", dstPath = joinURL(root.fullPath, dstDir); // create a new file entry to kick off it createFile(file1, function (entry) { // move file to directory that does not exist var directory = new DirectoryEntry(); directory.filesystem = root.filesystem; directory.fullPath = dstPath; entry.moveTo(directory, null, succeed.bind(null, done, 'entry.moveTo - Unexpected success callback, parent directory: ' + dstPath + ' should not exists'), function (error) { expect(error).toBeDefined(); if (isChrome) { /*INVALID_MODIFICATION_ERR (code: 9) is thrown instead of NOT_FOUND_ERR(code: 1) on trying to moveTo directory that does not exist.*/ expect(error).toBeFileError(FileError.INVALID_MODIFICATION_ERR); } else { expect(error).toBeFileError(FileError.NOT_FOUND_ERR); } // cleanup deleteEntry(file1, done); }); }, failed.bind(null, done, 'createFile - Error creating file: ' + file1)); }); it("file.spec.80 moveTo: invalid target name", function (done) { if (isBrowser) { /*The plugin does not follow ["8.3 Naming restrictions"] (http://www.w3.org/TR/2011/WD-file-system-api-20110419/#naming-restrictions*/ pending(); } var file1 = "entry.move.itn.file1", file2 = "bad:file:name"; // create a new file entry to kick off it createFile(file1, function (entry) { // move file1 to file2 entry.moveTo(root, file2, succeed.bind(null, done, 'entry.moveTo - Unexpected success callback, : ' + file1 + ' to root as: ' + file2), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.ENCODING_ERR); // cleanup deleteEntry(file1, done); }); }, failed.bind(null, done, 'createFile - Error creating file: ' + file1)); }); }); //Entry describe('FileReader', function () { it("file.spec.81 should have correct methods", function () { var reader = new FileReader(); expect(reader).toBeDefined(); expect(typeof reader.readAsBinaryString).toBe('function'); expect(typeof reader.readAsDataURL).toBe('function'); expect(typeof reader.readAsText).toBe('function'); expect(typeof reader.readAsArrayBuffer).toBe('function'); expect(typeof reader.abort).toBe('function'); expect(reader.result).toBe(null); }); }); //FileReader describe('Read method', function () { it("file.spec.82 should error out on non-existent file", function (done) { var fileName = cordova.platformId === 'windowsphone' ? root.toURL() + "/" + "somefile.txt" : "somefile.txt", verifier = function (evt) { expect(evt).toBeDefined(); expect(evt.target.error).toBeFileError(FileError.NOT_FOUND_ERR); done(); }; root.getFile(fileName, { create : true }, function (entry) { entry.file(function (file) { deleteEntry(fileName, function () { //Create FileReader var reader = new FileReader(); reader.onerror = verifier; reader.onload = succeed.bind(null, done, 'reader.onload - Unexpected success callback, file: ' + fileName + ' it should not exists'); reader.readAsText(file); }, failed.bind(null, done, 'deleteEntry - Error removing file: ' + fileName)); }, failed.bind(null, done, 'entry.file - Error reading file: ' + fileName)); }, failed.bind(null, done, 'root.getFile - Error creating file: ' + fileName)); }); it("file.spec.83 should be able to read native blob objects", function (done) { // Skip test if blobs are not supported (e.g.: Android 2.3). if (typeof window.Blob == 'undefined' || typeof window.Uint8Array == 'undefined') { expect(true).toFailWithMessage('Platform does not supported this feature'); done(); } var contents = 'asdf'; var uint8Array = new Uint8Array(contents.length); for (var i = 0; i < contents.length; ++i) { uint8Array[i] = contents.charCodeAt(i); } var Builder = window.BlobBuilder || window.WebKitBlobBuilder; var blob; if (Builder) { var builder = new Builder(); builder.append(uint8Array.buffer); builder.append(contents); blob = builder.getBlob("text/plain"); } else { try { // iOS 6 does not support Views, so pass in the buffer. blob = new Blob([uint8Array.buffer, contents]); } catch (e) { // Skip the test if we can't create a blob (e.g.: iOS 5). if (e instanceof TypeError) { expect(true).toFailWithMessage('Platform does not supported this feature'); done(); } throw e; } } var verifier = function (evt) { expect(evt).toBeDefined(); expect(evt.target.result).toBe('asdfasdf'); done(); }; var reader = new FileReader(); reader.onloadend = verifier; reader.readAsText(blob); }); function writeDummyFile(writeBinary, callback, done, fileContents) { var fileName = "dummy.txt", fileEntry = null, // use default string if file data is not provided fileData = fileContents !== undefined ? fileContents : '\u20AC\xEB - There is an exception to every rule. Except this one.', fileDataAsBinaryString = fileContents !== undefined ? fileContents : '\xe2\x82\xac\xc3\xab - There is an exception to every rule. Except this one.'; function createWriter(fe) { fileEntry = fe; fileEntry.createWriter(writeFile, failed.bind(null, done, 'fileEntry.createWriter - Error reading file: ' + fileName)); } // writes file and reads it back in function writeFile(writer) { writer.onwriteend = function () { fileEntry.file(function (f) { callback(fileEntry, f, fileData, fileDataAsBinaryString); }, failed.bind(null, done, 'writer.onwriteend - Error writing data on file: ' + fileName)); }; writer.write(fileData); } fileData += writeBinary ? 'bin:\x01\x00' : ''; fileDataAsBinaryString += writeBinary ? 'bin:\x01\x00' : ''; // create a file, write to it, and read it in again createFile(fileName, createWriter, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); } function runReaderTest(funcName, writeBinary, done, progressFunc, verifierFunc, sliceStart, sliceEnd, fileContents) { writeDummyFile(writeBinary, function (fileEntry, file, fileData, fileDataAsBinaryString) { var verifier = function (evt) { expect(evt).toBeDefined(); verifierFunc(evt, fileData, fileDataAsBinaryString); }; var reader = new FileReader(); reader.onprogress = progressFunc; reader.onload = verifier; reader.onerror = failed.bind(null, done, 'reader.onerror - Error reading file: ' + file + ' using function: ' + funcName); if (sliceEnd !== undefined) { // 'type' is specified so that is will be preserved in the resulting file: // http://www.w3.org/TR/FileAPI/#slice-method-algo -> "6.4.1. The slice method" -> 4. A), 6. c) file = file.slice(sliceStart, sliceEnd, file.type); } else if (sliceStart !== undefined) { file = file.slice(sliceStart, file.size, file.type); } reader[funcName](file); }, done, fileContents); } function arrayBufferEqualsString(ab, str) { var buf = new Uint8Array(ab); var match = buf.length == str.length; for (var i = 0; match && i < buf.length; i++) { match = buf[i] == str.charCodeAt(i); } return match; } it("file.spec.84 should read file properly, readAsText", function (done) { runReaderTest('readAsText', false, done, null, function (evt, fileData, fileDataAsBinaryString) { expect(evt.target.result).toBe(fileData); done(); }); }); it("file.spec.84.1 should read JSON file properly, readAsText", function (done) { var testObject = {key1: "value1", key2: 2}; runReaderTest('readAsText', false, done, null, function (evt, fileData, fileDataAsBinaryString) { expect(evt.target.result).toEqual(JSON.stringify(testObject)); done(); }, undefined, undefined, JSON.stringify(testObject)); }); it("file.spec.85 should read file properly, Data URI", function (done) { runReaderTest('readAsDataURL', true, done, null, function (evt, fileData, fileDataAsBinaryString) { /* `readAsDataURL` function is supported, but the mediatype in Chrome depends on entry name extension, mediatype in IE is always empty (which is the same as `text-plain` according the specification), the mediatype in Firefox is always `application/octet-stream`. For example, if the content is `abcdefg` then Firefox returns `data:application/octet-stream;base64,YWJjZGVmZw==`, IE returns `data:;base64,YWJjZGVmZw==`, Chrome returns `data:;base64,YWJjZGVmZw==`. */ expect(evt.target.result).toBeDataUrl(); //The atob function it is completely ignored during mobilespec execution, besides the returned object: evt //it is encoded and the atob function is aimed to decode a string. Even with btoa (encode) the function it gets stucked //because of the Unicode characters that contains the fileData object. //Issue reported at JIRA with all the details: CB-7095 //expect(evt.target.result.slice(23)).toBe(atob(fileData)); done(); }); }); it("file.spec.86 should read file properly, readAsBinaryString", function (done) { if (isIE) { /*`readAsBinaryString` function is not supported by IE and has not the stub.*/ pending(); } runReaderTest('readAsBinaryString', true, done, null, function (evt, fileData, fileDataAsBinaryString) { expect(evt.target.result).toBe(fileDataAsBinaryString); done(); }); }); it("file.spec.87 should read file properly, readAsArrayBuffer", function (done) { // Skip test if ArrayBuffers are not supported (e.g.: Android 2.3). if (typeof window.ArrayBuffer == 'undefined') { expect(true).toFailWithMessage('Platform does not supported this feature'); done(); } runReaderTest('readAsArrayBuffer', true, done, null, function (evt, fileData, fileDataAsBinaryString) { expect(arrayBufferEqualsString(evt.target.result, fileDataAsBinaryString)).toBe(true); done(); }); }); it("file.spec.88 should read sliced file: readAsText", function (done) { runReaderTest('readAsText', false, done, null, function (evt, fileData, fileDataAsBinaryString) { expect(evt.target.result).toBe(fileDataAsBinaryString.slice(10, 40)); done(); }, 10, 40); }); it("file.spec.89 should read sliced file: slice past eof", function (done) { runReaderTest('readAsText', false, done, null, function (evt, fileData, fileDataAsBinaryString) { expect(evt.target.result).toBe(fileData.slice(-5, 9999)); done(); }, -5, 9999); }); it("file.spec.90 should read sliced file: slice to eof", function (done) { runReaderTest('readAsText', false, done, null, function (evt, fileData, fileDataAsBinaryString) { expect(evt.target.result).toBe(fileData.slice(-5)); done(); }, -5); }); it("file.spec.91 should read empty slice", function (done) { runReaderTest('readAsText', false, done, null, function (evt, fileData, fileDataAsBinaryString) { expect(evt.target.result).toBe(''); done(); }, 0, 0); }); it("file.spec.92 should read sliced file properly, readAsDataURL", function (done) { runReaderTest('readAsDataURL', true, done, null, function (evt, fileData, fileDataAsBinaryString) { /* `readAsDataURL` function is supported, but the mediatype in Chrome depends on entry name extension, mediatype in IE is always empty (which is the same as `text-plain` according the specification), the mediatype in Firefox is always `application/octet-stream`. For example, if the content is `abcdefg` then Firefox returns `data:application/octet-stream;base64,YWJjZGVmZw==`, IE returns `data:;base64,YWJjZGVmZw==`, Chrome returns `data:;base64,YWJjZGVmZw==`. */ expect(evt.target.result).toBeDataUrl(); //The atob function it is completely ignored during mobilespec execution, besides the returned object: evt //it is encoded and the atob function is aimed to decode a string. Even with btoa (encode) the function it gets stucked //because of the Unicode characters that contains the fileData object. //Issue reported at JIRA with all the details: CB-7095 //expect(evt.target.result.slice(23)).toBe(atob(fileDataAsBinaryString.slice(10, -3))); done(); }, 10, -3); }); it("file.spec.93 should read sliced file properly, readAsBinaryString", function (done) { if (isIE) { /*`readAsBinaryString` function is not supported by IE and has not the stub.*/ pending(); } runReaderTest('readAsBinaryString', true, done, null, function (evt, fileData, fileDataAsBinaryString) { expect(evt.target.result).toBe(fileDataAsBinaryString.slice(-10, -5)); done(); }, -10, -5); }); it("file.spec.94 should read sliced file properly, readAsArrayBuffer", function (done) { // Skip test if ArrayBuffers are not supported (e.g.: Android 2.3). if (typeof window.ArrayBuffer == 'undefined') { expect(true).toFailWithMessage('Platform does not supported this feature'); done(); } runReaderTest('readAsArrayBuffer', true, done, null, function (evt, fileData, fileDataAsBinaryString) { expect(arrayBufferEqualsString(evt.target.result, fileDataAsBinaryString.slice(0, -1))).toBe(true); done(); }, 0, -1); }); it("file.spec.94.5 should read large file in multiple chunks, readAsArrayBuffer", function (done) { // Skip test if ArrayBuffers are not supported (e.g.: Android 2.3). if (typeof window.ArrayBuffer == 'undefined') { expect(true).toFailWithMessage('Platform does not supported this feature'); done(); } var largeText = ""; for (var i = 0; i < 1000; i++) { largeText += "Test " + i + "\n"; } // Set the chunk size so that the read will take 5 chunks FileReader.READ_CHUNK_SIZE = Math.floor(largeText.length / 4) + 1; var chunkCount = 0; var lastProgressValue = -1; var progressFunc = function (evt) { expect(evt.loaded).toBeDefined(); expect(evt.total).toBeDefined(); expect(evt.total >= largeText.length).toBe(true); expect(evt.total <= largeText.length + 5).toBe(true); expect(evt.loaded > lastProgressValue).toBe(true); expect(evt.loaded <= evt.total).toBe(true); lastProgressValue = evt.loaded; chunkCount++; }; runReaderTest( 'readAsArrayBuffer', true, done, progressFunc, function (evt, fileData, fileDataAsBinaryString) { expect(arrayBufferEqualsString(evt.target.result, fileDataAsBinaryString.slice(0, -1))).toBe(true); expect(lastProgressValue >= largeText.length).toBe(true); expect(lastProgressValue <= largeText.length + 5).toBe(true); expect(chunkCount).toBe(5); done(); }, 0, -1, largeText); }); }); //Read method describe('FileWriter', function () { it("file.spec.95 should have correct methods", function (done) { // retrieve a FileWriter object var fileName = "writer.methods"; // FileWriter root.getFile(fileName, { create : true }, function (fileEntry) { fileEntry.createWriter(function (writer) { expect(writer).toBeDefined(); expect(typeof writer.write).toBe('function'); expect(typeof writer.seek).toBe('function'); expect(typeof writer.truncate).toBe('function'); expect(typeof writer.abort).toBe('function'); // cleanup deleteFile(fileName, done); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'root.getFile - Error creating file: ' + fileName)); }); it("file.spec.96 should be able to write and append to file, createWriter", function (done) { var fileName = "writer.append.createWriter", // file content content = "There is an exception to every rule.", // for checkin file length exception = " Except this one.", length = content.length; // create file, then write and append to it createFile(fileName, function (fileEntry) { // writes initial file content fileEntry.createWriter(function (writer) { //Verifiers declaration function verifier(evt) { expect(writer.length).toBe(length); expect(writer.position).toBe(length); // Append some more data writer.onwriteend = secondVerifier; length += exception.length; writer.seek(writer.length); writer.write(exception); } function secondVerifier(evt) { expect(writer.length).toBe(length); expect(writer.position).toBe(length); var reader = new FileReader(); reader.onloadend = thirdVerifier; reader.onerror = failed.bind(null, done, 'reader.onerror - Error reading file: ' + fileName); fileEntry.file(function(f){reader.readAsText(f);}); } function thirdVerifier(evt) { expect(evt.target.result).toBe(content+exception); // cleanup deleteFile(fileName, done); } //Write process writer.onwriteend = verifier; writer.write(content); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.97 should be able to write and append to file, File object", function (done) { var fileName = "writer.append.File", // file content content = "There is an exception to every rule.", // for checkin file length exception = " Except this one.", length = content.length; root.getFile(fileName, { create : true }, function (fileEntry) { fileEntry.createWriter(function (writer) { //Verifiers declaration function verifier() { expect(writer.length).toBe(length); expect(writer.position).toBe(length); // Append some more data writer.onwriteend = secondVerifier; length += exception.length; writer.seek(writer.length); writer.write(exception); } function secondVerifier() { expect(writer.length).toBe(length); expect(writer.position).toBe(length); var reader = new FileReader(); reader.onloadend = thirdVerifier; reader.onerror = failed.bind(null, done, 'reader.onerror - Error reading file: ' + fileName); fileEntry.file(function(f){reader.readAsText(f);}); } function thirdVerifier(evt) { expect(evt.target.result).toBe(content+exception); // cleanup deleteFile(fileName, done); } //Write process writer.onwriteend = verifier; writer.write(content); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'root.getFile - Error creating file: ' + fileName)); }); it("file.spec.98 should be able to seek to the middle of the file and write more data than file.length", function (done) { var fileName = "writer.seek.write", // file content content = "This is our sentence.", // for checking file length exception = "newer sentence.", length = content.length; // create file, then write and append to it createFile(fileName, function (fileEntry) { fileEntry.createWriter(function (writer) { //Verifiers declaration function verifier(evt) { expect(writer.length).toBe(length); expect(writer.position).toBe(length); // Append some more data writer.onwriteend = secondVerifier; length = 12 + exception.length; writer.seek(12); writer.write(exception); } function secondVerifier(evt) { expect(writer.length).toBe(length); expect(writer.position).toBe(length); var reader = new FileReader(); reader.onloadend = thirdVerifier; reader.onerror = failed.bind(null, done, 'reader.onerror - Error reading file: ' + fileName); fileEntry.file(function(f){reader.readAsText(f);}); } function thirdVerifier(evt) { expect(evt.target.result).toBe(content.substr(0,12)+exception); // cleanup deleteFile(fileName, done); } //Write process writer.onwriteend = verifier; writer.write(content); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.99 should be able to seek to the middle of the file and write less data than file.length", function (done) { if (isChrome) { /* Chrome (re)writes as follows: "This is our sentence." -> "This is new.sentence.", i.e. the length is not being changed from content.length and writer length will be equal 21 */ pending(); } var fileName = "writer.seek.write2", // file content content = "This is our sentence.", // for checking file length exception = "new.", length = content.length; // create file, then write and append to it createFile(fileName, function (fileEntry) { fileEntry.createWriter(function (writer) { // Verifiers declaration function verifier(evt) { expect(writer.length).toBe(length); expect(writer.position).toBe(length); // Append some more data writer.onwriteend = secondVerifier; length = 8 + exception.length; writer.seek(8); writer.write(exception); } function secondVerifier(evt) { expect(writer.length).toBe(length); expect(writer.position).toBe(length); var reader = new FileReader(); reader.onloadend = thirdVerifier; reader.onerror = failed.bind(null, done, 'reader.onerror - Error reading file: ' + fileName); fileEntry.file(function(f){reader.readAsText(f);}); } function thirdVerifier(evt) { expect(evt.target.result).toBe(content.substr(0,8)+exception); // cleanup deleteFile(fileName, done); } //Write process writer.onwriteend = verifier; writer.write(content); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.100 should be able to write XML data", function (done) { var fileName = "writer.xml", // file content content = '\n\nData\n\n', // for testing file length length = content.length; // creates file, then write XML data createFile(fileName, function (fileEntry) { fileEntry.createWriter(function (writer) { //Verifier content var verifier = function (evt) { expect(writer.length).toBe(length); expect(writer.position).toBe(length); // cleanup deleteFile(fileName, done); }; //Write process writer.onwriteend = verifier; writer.write(content); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.101 should be able to write JSON data", function (done) { var fileName = "writer.json", // file content content = '{ "name": "Guy Incognito", "email": "here@there.com" }', // for testing file length length = content.length; // creates file, then write JSON content createFile(fileName, function (fileEntry) { fileEntry.createWriter(function (writer) { //Verifier declaration var verifier = function (evt) { expect(writer.length).toBe(length); expect(writer.position).toBe(length); // cleanup deleteFile(fileName, done); }; //Write process writer.onwriteend = verifier; writer.write(content); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.102 should be able to seek", function (done) { var fileName = "writer.seek", // file content content = "There is an exception to every rule. Except this one.", // for testing file length length = content.length; // creates file, then write JSON content createFile(fileName, function (fileEntry) { // writes file content and tests writer.seek fileEntry.createWriter(function (writer) { //Verifier declaration var verifier = function () { expect(writer.position).toBe(length); writer.seek(-5); expect(writer.position).toBe(length - 5); writer.seek(length + 100); expect(writer.position).toBe(length); writer.seek(10); expect(writer.position).toBe(10); // cleanup deleteFile(fileName, done); }; //Write process writer.onwriteend = verifier; writer.seek(-100); expect(writer.position).toBe(0); writer.write(content); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.103 should be able to truncate", function (done) { if (isIndexedDBShim) { /* `abort` and `truncate` functions are not supported (Firefox, IE) */ pending(); } var fileName = "writer.truncate", content = "There is an exception to every rule. Except this one."; // creates file, writes to it, then truncates it createFile(fileName, function (fileEntry) { fileEntry.createWriter(function (writer) { // Verifier declaration var verifier = function () { expect(writer.length).toBe(36); expect(writer.position).toBe(36); // cleanup deleteFile(fileName, done); }; //Write process writer.onwriteend = function () { //Truncate process after write writer.onwriteend = verifier; writer.truncate(36); }; writer.write(content); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.104 should be able to write binary data from an ArrayBuffer", function (done) { // Skip test if ArrayBuffers are not supported (e.g.: Android 2.3). if (typeof window.ArrayBuffer == 'undefined') { expect(true).toFailWithMessage('Platform does not supported this feature'); done(); return; } var fileName = "bufferwriter.bin", // file content data = new ArrayBuffer(32), dataView = new Int8Array(data), // for verifying file length length = 32; for (var i = 0; i < dataView.length; i++) { dataView[i] = i; } // creates file, then write content createFile(fileName, function (fileEntry) { // writes file content fileEntry.createWriter(function (writer) { //Verifier declaration var verifier = function () { expect(writer.length).toBe(length); expect(writer.position).toBe(length); // cleanup deleteFile(fileName, done); }; //Write process writer.onwriteend = verifier; writer.write(data); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.105 should be able to write binary data from a Blob", function (done) { // Skip test if Blobs are not supported (e.g.: Android 2.3). if ((typeof window.Blob == 'undefined' && typeof window.WebKitBlobBuilder == 'undefined') || typeof window.ArrayBuffer == 'undefined') { expect(true).toFailWithMessage('Platform does not supported this feature'); done(); return; } var fileName = "blobwriter.bin", // file content data = new ArrayBuffer(32), dataView = new Int8Array(data), blob, // for verifying file length length = 32; for (var i = 0; i < dataView.length; i++) { dataView[i] = i; } try { // Mobile Safari: Use Blob constructor blob = new Blob([data], { "type" : "application/octet-stream" }); } catch (e) { if (window.WebKitBlobBuilder) { // Android Browser: Use deprecated BlobBuilder var builder = new WebKitBlobBuilder(); builder.append(data); blob = builder.getBlob('application/octet-stream'); } else { // We have no way defined to create a Blob, so fail fail(); } } if (typeof blob !== 'undefined') { // creates file, then write content createFile(fileName, function (fileEntry) { fileEntry.createWriter(function (writer) { //Verifier declaration var verifier = function () { expect(writer.length).toBe(length); expect(writer.position).toBe(length); // cleanup deleteFile(fileName, done); }; //Write process writer.onwriteend = verifier; writer.write(blob); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); } }); it("file.spec.106 should be able to write a File to a FileWriter", function (done) { var dummyFileName = 'dummy.txt', outputFileName = 'verify.txt', dummyFileText = 'This text should be written to two files', verifier = function (outputFileWriter) { expect(outputFileWriter.length).toBe(dummyFileText.length); expect(outputFileWriter.position).toBe(dummyFileText.length); deleteFile(outputFileName, done); }, writeFile = function (fileName, fileData, win) { var theWriter, write_file = function (fileEntry) { // writes file content to new file fileEntry.createWriter(function (writer) { theWriter = writer; writer.onwriteend = function (ev) { if (typeof fileData.length !== "undefined") { expect(theWriter.length).toBe(fileData.length); expect(theWriter.position).toBe(fileData.length); } win(theWriter); }; writer.onerror = failed.bind(null, done, 'writer.onerror - Error writing content on file: ' + fileName); writer.write(fileData); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }; createFile(fileName, write_file, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }, openFile = function (fileName, callback) { root.getFile(fileName, { create : false }, function (fileEntry) { fileEntry.file(callback, failed.bind(null, done, 'fileEntry.file - Error reading file using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'root.getFile - Error getting file: ' + fileName)); }; writeFile(dummyFileName, dummyFileText, function (dummyFileWriter) { openFile(dummyFileName, function (file) { writeFile(outputFileName, file, verifier); }); }); }); it("file.spec.107 should be able to write a sliced File to a FileWriter", function (done) { var dummyFileName = 'dummy2.txt', outputFileName = 'verify2.txt', dummyFileText = 'This text should be written to two files', verifier = function (outputFileWriter) { expect(outputFileWriter.length).toBe(10); expect(outputFileWriter.position).toBe(10); deleteFile(outputFileName, done); }, writeFile = function (fileName, fileData, win) { var theWriter, write_file = function (fileEntry) { // writes file content to new file fileEntry.createWriter(function (writer) { theWriter = writer; writer.onwriteend = function (ev) { if (typeof fileData.length !== "undefined") { expect(theWriter.length).toBe(fileData.length); expect(theWriter.position).toBe(fileData.length); } win(theWriter); }; writer.onerror = failed.bind(null, done, 'writer.onerror - Error writing content on file: ' + fileName); writer.write(fileData); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }; createFile(fileName, write_file, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }, openFile = function (fileName, callback) { root.getFile(fileName, { create : false }, function (fileEntry) { fileEntry.file(callback, failed.bind(null, done, 'fileEntry.file - Error reading file using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'root.getFile - Error getting file: ' + fileName)); }; writeFile(dummyFileName, dummyFileText, function (dummyFileWriter) { openFile(dummyFileName, function (file) { writeFile(outputFileName, file.slice(10, 20), verifier); }); }); }); it("file.spec.108 should be able to write binary data from a File", function (done) { // Skip test if Blobs are not supported (e.g.: Android 2.3). if (typeof window.Blob == 'undefined' && typeof window.WebKitBlobBuilder == 'undefined') { expect(true).toFailWithMessage('Platform does not supported this feature'); done(); } var dummyFileName = "blobwriter.bin", outputFileName = 'verify.bin', // file content data = new ArrayBuffer(32), dataView = new Int8Array(data), blob, // for verifying file length length = 32, verifier = function (outputFileWriter) { expect(outputFileWriter.length).toBe(length); expect(outputFileWriter.position).toBe(length); // cleanup deleteFile(outputFileName); done(); }, writeFile = function (fileName, fileData, win) { var theWriter, write_file = function (fileEntry) { // writes file content to new file fileEntry.createWriter(function (writer) { theWriter = writer; writer.onwriteend = function (ev) { if (typeof fileData.length !== "undefined") { expect(theWriter.length).toBe(fileData.length); expect(theWriter.position).toBe(fileData.length); } win(theWriter); }; writer.onerror = failed.bind(null, done, 'writer.onerror - Error writing content on file: ' + fileName); writer.write(fileData); }, failed.bind(null, done, 'fileEntry.createWriter - Error creating writer using fileEntry: ' + fileEntry.name)); }; createFile(fileName, write_file, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }, openFile = function (fileName, callback) { root.getFile(fileName, { create : false }, function (fileEntry) { fileEntry.file(callback, failed.bind(null, done, 'fileEntry.file - Error reading file using fileEntry: ' + fileEntry.name)); }, failed.bind(null, done, 'root.getFile - Error getting file: ' + fileName)); }; for (var i = 0; i < dataView.length; i++) { dataView[i] = i; } try { // Mobile Safari: Use Blob constructor blob = new Blob([data], { "type" : "application/octet-stream" }); } catch (e) { if (window.WebKitBlobBuilder) { // Android Browser: Use deprecated BlobBuilder var builder = new WebKitBlobBuilder(); builder.append(data); blob = builder.getBlob('application/octet-stream'); } else { // We have no way defined to create a Blob, so fail fail(); } } if (typeof blob !== 'undefined') { // creates file, then write content writeFile(dummyFileName, blob, function (dummyFileWriter) { openFile(dummyFileName, function (file) { writeFile(outputFileName, file, verifier); }); }); } }); }); //FileWritter describe('Backwards compatibility', function () { /* These specs exist to test that the File plugin can still recognize file:/// * URLs, and can resolve them to FileEntry and DirectoryEntry objects. * They rely on an undocumented interface to File which provides absolute file * paths, which are not used internally anymore. * If that interface is not present, then these tests will silently succeed. */ it("file.spec.109 should be able to resolve a file:/// URL", function (done) { var localFilename = 'file.txt'; var originalEntry; root.getFile(localFilename, { create : true }, function (entry) { originalEntry = entry; /* This is an undocumented interface to File which exists only for testing * backwards compatibilty. By obtaining the raw filesystem path of the download * location, we can pass that to ft.download() to make sure that previously-stored * paths are still valid. */ cordova.exec(function (localPath) { window.resolveLocalFileSystemURL("file://" + encodeURI(localPath), function (fileEntry) { expect(fileEntry.toURL()).toEqual(originalEntry.toURL()); // cleanup deleteFile(localFilename); done(); }, failed.bind(null, done, 'window.resolveLocalFileSystemURL - Error resolving URI: file://' + encodeURI(localPath))); }, done, 'File', '_getLocalFilesystemPath', [entry.toURL()]); }, failed.bind(null, done, 'root.getFile - Error creating file: ' + localFilename)); }); }); //Backwards Compatibility describe('Parent References', function () { /* These specs verify that paths with parent references i("..") in them * work correctly, and do not cause the application to crash. */ it("file.spec.110 should not throw exception resolving parent refefences", function (done) { /* This is a direct copy of file.spec.9, with the filename changed, * as reported in CB-5721. */ var fileName = "resolve.file.uri"; var dirName = "resolve.dir.uri"; // create a new file entry createDirectory(dirName, function () { createFile(dirName+"/../" + fileName, function (entry) { // lookup file system entry window.resolveLocalFileSystemURL(entry.toURL(), function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.name).toCanonicallyMatch(fileName); // cleanup deleteEntry(fileName, done); }, failed.bind(null, done, 'window.resolveLocalFileSystemURL - Error resolving URI: ' + entry.toURL())); }, failed.bind(null, done, 'createFile - Error creating file: ../' + fileName)); }, failed.bind(null, done, 'createDirectory - Error creating directory: ' + dirName)); }); it("file.spec.111 should not traverse above above the root directory", function (done) { var fileName = "traverse.file.uri"; // create a new file entry createFile(fileName, function (entry) { // lookup file system entry root.getFile('../' + fileName, { create : false }, function (fileEntry) { // Note: we expect this to still resolve, as the correct behaviour is to ignore the ../, not to fail out. expect(fileEntry).toBeDefined(); expect(fileEntry.name).toBe(fileName); expect(fileEntry.fullPath).toCanonicallyMatch(root.fullPath +'/' + fileName); // cleanup deleteEntry(fileName, done); }, failed.bind(null, done, 'root.getFile - Error getting file: ../' + fileName)); }, failed.bind(null, done, 'createFile - Error creating file: ../' + fileName)); }); it("file.spec.112 should traverse above above the current directory", function (done) { var fileName = "traverse2.file.uri", dirName = "traverse2.subdir"; // create a new directory and a file entry createFile(fileName, function () { createDirectory(dirName, function (entry) { // lookup file system entry entry.getFile('../' + fileName, { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.name).toBe(fileName); expect(fileEntry.fullPath).toCanonicallyMatch('/' + fileName); // cleanup deleteEntry(fileName, function () { deleteEntry(dirName, done); }); }, failed.bind(null, done, 'entry.getFile - Error getting file: ' + fileName + ' recently created above: ' + dirName)); }, failed.bind(null, done, 'createDirectory - Error creating directory: ' + dirName)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.113 getFile: get Entry should error for missing file above root directory", function (done) { var fileName = "../missing.file"; // create:false, exclusive:false, file does not exist root.getFile(fileName, { create : false }, succeed.bind(null, done, 'root.getFile - Unexpected success callback, it should not locate nonexistent file: ' + fileName), function (error) { expect(error).toBeDefined(); expect(error).toBeFileError(FileError.NOT_FOUND_ERR); done(); }); }); }); //Parent References describe('toNativeURL interface', function () { /* These specs verify that FileEntries have a toNativeURL method * which appears to be sane. */ var pathExpect = cordova.platformId === 'windowsphone' ? "//nativ" : "file://"; if (isChrome) { pathExpect = 'filesystem:file://'; } it("file.spec.114 fileEntry should have a toNativeURL method", function (done) { var fileName = "native.file.uri"; if (isWindows) { var rootPath = root.fullPath; pathExpect = rootPath.substr(0, rootPath.indexOf(":")); } // create a new file entry createFile(fileName, function (entry) { expect(entry.toNativeURL).toBeDefined(); expect(entry.name).toCanonicallyMatch(fileName); expect(typeof entry.toNativeURL).toBe('function'); var nativeURL = entry.toNativeURL(); expect(typeof nativeURL).toBe("string"); expect(nativeURL.substring(0, pathExpect.length)).toEqual(pathExpect); expect(nativeURL.substring(nativeURL.length - fileName.length)).toEqual(fileName); // cleanup deleteEntry(fileName, done); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.115 DirectoryReader should return entries with toNativeURL method", function (done) { var dirName = 'nativeEntries.dir', fileName = 'nativeEntries.file', directory, checkEntries = function (entries) { expect(entries).toBeDefined(); expect(entries instanceof Array).toBe(true); expect(entries.length).toBe(1); expect(entries[0].toNativeURL).toBeDefined(); expect(typeof entries[0].toNativeURL).toBe('function'); var nativeURL = entries[0].toNativeURL(); expect(typeof nativeURL).toBe("string"); expect(nativeURL.substring(0, pathExpect.length)).toEqual(pathExpect); expect(nativeURL.substring(nativeURL.length - fileName.length)).toEqual(fileName); // cleanup directory.removeRecursively(null, null); done(); }; // create a new file entry root.getDirectory(dirName, { create : true }, function (dir) { directory = dir; directory.getFile(fileName, { create : true }, function (fileEntry) { var reader = directory.createReader(); reader.readEntries(checkEntries, failed.bind(null, done, 'reader.readEntries - Error reading entries from directory: ' + dirName)); }, failed.bind(null, done, 'directory.getFile - Error creating file: ' + fileName)); }, failed.bind(null, done, 'root.getDirectory - Error creating directory: ' + dirName)); }); it("file.spec.116 resolveLocalFileSystemURL should return entries with toNativeURL method", function (done) { var fileName = "native.resolve.uri"; // create a new file entry createFile(fileName, function (entry) { resolveLocalFileSystemURL(entry.toURL(), function (entry) { expect(entry.toNativeURL).toBeDefined(); expect(entry.name).toCanonicallyMatch(fileName); expect(typeof entry.toNativeURL).toBe('function'); var nativeURL = entry.toNativeURL(); expect(typeof nativeURL).toBe("string"); expect(nativeURL.substring(0, pathExpect.length)).toEqual(pathExpect); expect(nativeURL.substring(nativeURL.length - fileName.length)).toEqual(fileName); // cleanup deleteEntry(fileName, done); }, failed.bind(null, done, 'resolveLocalFileSystemURL - Error resolving file URL: ' + entry.toURL())); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); }); //toNativeURL interface describe('resolveLocalFileSystemURL on file://', function () { /* These specs verify that window.resolveLocalFileSystemURL works correctly on file:// URLs */ it("file.spec.117 should not resolve native URLs outside of FS roots", function (done) { // lookup file system entry window.resolveLocalFileSystemURL("file:///this.is.an.invalid.url", succeed.bind(null, done, 'window.resolveLocalFileSystemURL - Unexpected success callback, it should not resolve invalid URL: file:///this.is.an.invalid.url'), function (error) { expect(error).toBeDefined(); done(); }); }); it("file.spec.118 should not resolve native URLs outside of FS roots", function (done) { // lookup file system entry window.resolveLocalFileSystemURL("file://localhost/this.is.an.invalid.url", succeed.bind(null, done, 'window.resolveLocalFileSystemURL - Unexpected success callback, it should not resolve invalid URL: file://localhost/this.is.an.invalid.url'), function (error) { expect(error).toBeDefined(); done(); }); }); it("file.spec.119 should not resolve invalid native URLs", function (done) { // lookup file system entry window.resolveLocalFileSystemURL("file://localhost", succeed.bind(null, done, 'window.resolveLocalFileSystemURL - Unexpected success callback, it should not resolve invalid URL: file://localhost'), function (error) { expect(error).toBeDefined(); done(); }); }); it("file.spec.120 should not resolve invalid native URLs with query strings", function (done) { // lookup file system entry window.resolveLocalFileSystemURL("file://localhost?test/test", succeed.bind(null, done, 'window.resolveLocalFileSystemURL - Unexpected success callback, it should not resolve invalid URL: file://localhost?test/test'), function (error) { expect(error).toBeDefined(); done(); }); }); it("file.spec.121 should resolve native URLs returned by API", function (done) { var fileName = "native.resolve.uri1"; // create a new file entry createFile(fileName, function (entry) { resolveLocalFileSystemURL(entry.toNativeURL(), function (fileEntry) { expect(fileEntry.fullPath).toCanonicallyMatch(root.fullPath + "/" + fileName); // cleanup deleteEntry(fileName, done); }, failed.bind(null, done, 'resolveLocalFileSystemURL - Error resolving file URL: ' + entry.toNativeURL())); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.122 should resolve native URLs returned by API with localhost", function (done) { var fileName = "native.resolve.uri2"; // create a new file entry createFile(fileName, function (entry) { var url = entry.toNativeURL(); url = url.replace("///", "//localhost/"); resolveLocalFileSystemURL(url, function (fileEntry) { expect(fileEntry.fullPath).toCanonicallyMatch(root.fullPath + "/" + fileName); // cleanup deleteEntry(fileName, done); }, failed.bind(null, done, 'resolveLocalFileSystemURL - Error resolving file URL: ' + url)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.123 should resolve native URLs returned by API with query string", function (done) { var fileName = "native.resolve.uri3"; // create a new file entry createFile(fileName, function (entry) { var url = entry.toNativeURL(); url = url + "?test/test"; resolveLocalFileSystemURL(url, function (fileEntry) { expect(fileEntry.fullPath).toCanonicallyMatch(root.fullPath + "/" + fileName); // cleanup deleteEntry(fileName, done); }, failed.bind(null, done, 'resolveLocalFileSystemURL - Error resolving file URL: ' + url)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); it("file.spec.124 should resolve native URLs returned by API with localhost and query string", function (done) { var fileName = "native.resolve.uri4"; // create a new file entry createFile(fileName, function (entry) { var url = entry.toNativeURL(); url = url.replace("///", "//localhost/") + "?test/test"; resolveLocalFileSystemURL(url, function (fileEntry) { expect(fileEntry.fullPath).toCanonicallyMatch(root.fullPath + "/" + fileName); // cleanup deleteEntry(fileName, done); }, failed.bind(null, done, 'resolveLocalFileSystemURL - Error resolving file URL: ' + url)); }, failed.bind(null, done, 'createFile - Error creating file: ' + fileName)); }); }); //resolveLocalFileSystemURL on file:// describe('cross-file-system copy and move', function () { /* These specs verify that Entry.copyTo and Entry.moveTo work correctly * when crossing filesystem boundaries. */ it("file.spec.125 copyTo: temporary -> persistent", function (done) { var file1 = "entry.copy.file1a", file2 = "entry.copy.file2a", sourceEntry, fullPath = joinURL(root.fullPath, file2), validateFile = function (entry) { // a bit redundant since copy returned this entry already expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toCanonicallyMatch(file2); expect(entry.fullPath).toCanonicallyMatch(fullPath); expect(entry.filesystem).toBeDefined(); if (isChrome) { expect(entry.filesystem.name).toContain("Persistent"); } else { expect(entry.filesystem.name).toEqual("persistent"); } // cleanup deleteEntry(entry.name); deleteEntry(sourceEntry.name, done); }, createSourceAndTransfer = function () { temp_root.getFile(file1, { create : true }, function (entry) { expect(entry.filesystem).toBeDefined(); if (isChrome) { expect(entry.filesystem.name).toContain("Temporary"); } else { expect(entry.filesystem.name).toEqual("temporary"); } sourceEntry = entry; // Save for later cleanup entry.copyTo(persistent_root, file2, validateFile, failed.bind(null, done, 'entry.copyTo - Error copying file: ' + file1 + ' to PERSISTENT root as: ' + file2)); }, failed.bind(null, done, 'temp_root.getFile - Error creating file: ' + file1 + 'at TEMPORAL root')); }; // Delete any existing file to start things off persistent_root.getFile(file2, {}, function (entry) { entry.remove(createSourceAndTransfer, failed.bind(null, done, 'entry.remove - Error removing file: ' + file2)); }, createSourceAndTransfer); }); it("file.spec.126 copyTo: persistent -> temporary", function (done) { var file1 = "entry.copy.file1b", file2 = "entry.copy.file2b", sourceEntry, fullPath = joinURL(temp_root.fullPath, file2), validateFile = function (entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toCanonicallyMatch(file2); expect(entry.fullPath).toCanonicallyMatch(fullPath); if (isChrome) { expect(entry.filesystem.name).toContain("Temporary"); } else { expect(entry.filesystem.name).toEqual("temporary"); } // cleanup deleteEntry(entry.name); deleteEntry(sourceEntry.name, done); }, createSourceAndTransfer = function () { persistent_root.getFile(file1, { create : true }, function (entry) { expect(entry).toBeDefined(); expect(entry.filesystem).toBeDefined(); if (isChrome) { expect(entry.filesystem.name).toContain("Persistent"); } else { expect(entry.filesystem.name).toEqual("persistent"); } sourceEntry = entry; // Save for later cleanup entry.copyTo(temp_root, file2, validateFile, failed.bind(null, done, 'entry.copyTo - Error copying file: ' + file1 + ' to TEMPORAL root as: ' + file2)); }, failed.bind(null, done, 'persistent_root.getFile - Error creating file: ' + file1 + 'at PERSISTENT root')); }; // Delete any existing file to start things off temp_root.getFile(file2, {}, function (entry) { entry.remove(createSourceAndTransfer, failed.bind(null, done, 'entry.remove - Error removing file: ' + file2)); }, createSourceAndTransfer); }); it("file.spec.127 moveTo: temporary -> persistent", function (done) { var file1 = "entry.copy.file1a", file2 = "entry.copy.file2a", sourceEntry, fullPath = joinURL(root.fullPath, file2), validateFile = function (entry) { // a bit redundant since copy returned this entry already expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toCanonicallyMatch(file2); expect(entry.fullPath).toCanonicallyMatch(fullPath); expect(entry.filesystem).toBeDefined(); if (isChrome) { expect(entry.filesystem.name).toContain("Persistent"); } else { expect(entry.filesystem.name).toEqual("persistent"); } // cleanup deleteEntry(entry.name); deleteEntry(sourceEntry.name, done); }, createSourceAndTransfer = function () { temp_root.getFile(file1, { create : true }, function (entry) { expect(entry.filesystem).toBeDefined(); if (isChrome) { expect(entry.filesystem.name).toContain("Temporary"); } else { expect(entry.filesystem.name).toEqual("temporary"); } sourceEntry = entry; // Save for later cleanup entry.moveTo(persistent_root, file2, validateFile, failed.bind(null, done, 'entry.moveTo - Error moving file: ' + file1 + ' to PERSISTENT root as: ' + file2)); }, failed.bind(null, done, 'temp_root.getFile - Error creating file: ' + file1 + 'at TEMPORAL root')); }; // Delete any existing file to start things off persistent_root.getFile(file2, {}, function (entry) { entry.remove(createSourceAndTransfer, failed.bind(null, done, 'entry.remove - Error removing file: ' + file2)); }, createSourceAndTransfer); }); it("file.spec.128 moveTo: persistent -> temporary", function (done) { var file1 = "entry.copy.file1b", file2 = "entry.copy.file2b", sourceEntry, fullPath = joinURL(temp_root.fullPath, file2), validateFile = function (entry) { expect(entry).toBeDefined(); expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toCanonicallyMatch(file2); expect(entry.fullPath).toCanonicallyMatch(fullPath); if(isChrome) { expect(entry.filesystem.name).toContain("Temporary"); } else { expect(entry.filesystem.name).toEqual("temporary"); } // cleanup deleteEntry(entry.name); deleteEntry(sourceEntry.name, done); }, createSourceAndTransfer = function () { persistent_root.getFile(file1, { create : true }, function (entry) { expect(entry).toBeDefined(); expect(entry.filesystem).toBeDefined(); if (isChrome) { expect(entry.filesystem.name).toContain("Persistent"); } else { expect(entry.filesystem.name).toEqual("persistent"); } sourceEntry = entry; // Save for later cleanup entry.moveTo(temp_root, file2, validateFile, failed.bind(null, done, 'entry.moveTo - Error moving file: ' + file1 + ' to TEMPORAL root as: ' + file2)); }, failed.bind(null, done, 'persistent_root.getFile - Error creating file: ' + file1 + 'at PERSISTENT root')); }; // Delete any existing file to start things off temp_root.getFile(file2, {}, function (entry) { entry.remove(createSourceAndTransfer, failed.bind(null, done, 'entry.remove - Error removing file: ' + file2)); }, createSourceAndTransfer); }); it("file.spec.129 cordova.file.*Directory are set", function () { var expectedPaths = ['applicationDirectory', 'applicationStorageDirectory', 'dataDirectory', 'cacheDirectory']; if (cordova.platformId == 'android' || cordova.platformId == 'amazon-fireos') { if (cordova.file.externalApplicationStorageDirectory !== null) { // https://issues.apache.org/jira/browse/CB-10411 // If external storage can't be mounted, the cordova.file.external* properties are null. expectedPaths.push('externalApplicationStorageDirectory', 'externalRootDirectory', 'externalCacheDirectory', 'externalDataDirectory'); } } else if (cordova.platformId == 'blackberry10') { expectedPaths.push('externalRootDirectory', 'sharedDirectory'); } else if (cordova.platformId == 'ios') { expectedPaths.push('syncedDataDirectory', 'documentsDirectory', 'tempDirectory'); } else if (cordova.platformId == 'osx') { expectedPaths.push('documentsDirectory', 'tempDirectory', 'rootDirectory'); } else { console.log('Skipping test due on unsupported platform.'); return; } for (var i = 0; i < expectedPaths.length; ++i) { expect(typeof cordova.file[expectedPaths[i]]).toBe('string'); expect(cordova.file[expectedPaths[i]]).toMatch(/\/$/, 'Path should end with a slash'); } }); }); //cross-file-system copy and move describe('IndexedDB-based impl', function () { it("file.spec.131 Nested file or nested directory should be removed when removing a parent directory", function (done) { var parentDirName = 'deletedDir131', nestedDirName = 'nestedDir131', nestedFileName = 'nestedFile131.txt'; createDirectory(parentDirName, function (parent) { parent.getDirectory(nestedDirName, { create: true}, function () { parent.getFile(nestedFileName, { create: true}, function () { parent.removeRecursively(function() { root.getDirectory(parentDirName,{ create: false}, failed.bind(this, done, 'root.getDirectory - unexpected success callback : ' + parentDirName), function(){ parent.getFile(nestedFileName,{ create: false}, failed.bind(this, done, 'getFile - unexpected success callback : ' + nestedFileName), function(){ parent.getDirectory(nestedDirName, { create: false}, failed.bind(this, done, 'getDirectory - unexpected success callback : ' + nestedDirName), done); }); }); }, failed.bind(this, done, 'removeRecursively - Error removing directory : ' + parentDirName)); }, failed.bind(this, done, 'getFile - Error creating file : ' + nestedFileName)); },failed.bind(this, done, 'getDirectory - Error creating directory : ' + nestedDirName)); }, failed.bind(this, done, 'root.getDirectory - Error creating directory : ' + parentDirName)); }); it("file.spec.132 Entry should be created succesfully when using relative paths if its parent directory exists", function (done) { /* Directory entries have to be created successively. For example, the call `fs.root.getDirectory('dir1/dir2', {create:true}, successCallback, errorCallback)` will fail if dir1 did not exist. */ var parentName = 'parentName132'; var nestedName = 'nestedName132'; var path = parentName + '/' + nestedName; var win = function(directory){ expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.name).toCanonicallyMatch(nestedName); expect(directory.fullPath).toCanonicallyMatch('/' + path + '/'); deleteEntry(directory.name); deleteEntry(parentName, done); }; createDirectory(parentName, function() { root.getDirectory(parentName + '/' + nestedName, {create:true}, win, failed.bind(this, done, 'root.getDirectory - Error getting directory : ' + path)); }, failed.bind(this, done, 'root.getDirectory - Error getting directory : ' + parentName)); }); it("file.spec.133 A file being removed should not affect another file with name being a prefix of the removed file name.", function (done) { // Names include special symbols so that we check the IndexedDB range used var deletedFileName = 'deletedFile.0', secondFileName = 'deletedFile.0.1'; var win = function(fileEntry){ expect(fileEntry).toBeDefined(); expect(fileEntry.isFile).toBe(true); expect(fileEntry.isDirectory).toBe(false); expect(fileEntry.name).toCanonicallyMatch(secondFileName); deleteEntry(fileEntry.name, done); }; createFile(deletedFileName, function (deletedFile) { createFile(secondFileName, function () { deletedFile.remove(function() { root.getFile(deletedFileName, {create: false}, failed.bind(this, done, 'getFile - unexpected success callback getting deleted file : ' + deletedFileName), function(){ root.getFile(secondFileName, {create: false}, win, failed.bind(this, done, 'getFile - Error getting file after deleting deletedFile : ' + secondFileName)); }); }, failed.bind(this, done, 'remove - Error removing file : ' + deletedFileName)); }, failed.bind(this, done, 'getFile - Error creating file : ' + secondFileName)); }, failed.bind(this, done, 'getFile - Error creating file : ' + deletedFileName)); }); it("file.spec.134 A directory being removed should not affect another directory with name being a prefix of the removed directory name.", function (done) { // Names include special symbols so that we check the IndexedDB range used var deletedDirName = 'deletedDir.0', secondDirName = 'deletedDir.0.1'; var win = function(directory){ expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.name).toCanonicallyMatch(secondDirName); deleteEntry(directory.name, done); }; createDirectory(deletedDirName, function (deletedDir) { createDirectory(secondDirName, function () { deletedDir.remove(function() { root.getDirectory(deletedDirName, {create: false}, failed.bind(this, done, 'getDirectory - unexpected success callback getting deleted directory : ' + deletedDirName), function() { root.getDirectory(secondDirName, {create: false}, win, failed.bind(this, done, 'getDirectory - Error getting directory after deleting deletedDirectory : ' + secondDirName)); }); }, failed.bind(this, done, 'remove - Error removing directory : ' + deletedDirName)); }, failed.bind(this, done, 'root.getDirectory - Error creating directory : ' + secondDirName)); }, failed.bind(this, done, 'root.getDirectory - Error creating directory : ' + deletedDirName)); }); it("file.spec.135 Deletion of a child directory should not affect the parent directory.", function (done) { var parentName = 'parentName135'; var childName = 'childName135'; var win = function(directory){ expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.name).toCanonicallyMatch(parentName); deleteEntry(directory.name, done); }; createDirectory(parentName, function(parent){ parent.getDirectory(childName, {create: true}, function(child){ child.removeRecursively(function(){ root.getDirectory(parentName, {create: false}, win, failed.bind(this, done, 'root.getDirectory - Error getting parent directory : ' + parentName)); }, failed.bind(this, done, 'getDirectory - Error removing directory : ' + childName)); }, failed.bind(this, done, 'getDirectory - Error creating directory : ' + childName)); }, failed.bind(this, done, 'root.getDirectory - Error creating directory : ' + parentName)); }); it("file.spec.136 Paths should support Unicode symbols.", function (done) { var dirName = '文件插件'; var win = function(directory){ expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.name).toCanonicallyMatch(dirName); deleteEntry(directory.name, done); }; createDirectory(dirName, function(){ root.getDirectory(dirName, {create: false}, win, failed.bind(this, done, 'root.getDirectory - Error getting directory : ' + dirName)); }, failed.bind(this, done, 'root.getDirectory - Error creating directory : ' + dirName)); }); }); // Content and Asset URLs if (cordova.platformId == 'android') { describe('content: URLs', function() { function testContentCopy(src, done) { var file2 = "entry.copy.file2b", fullPath = joinURL(temp_root.fullPath, file2), validateFile = function (entry) { expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toCanonicallyMatch(file2); expect(entry.fullPath).toCanonicallyMatch(fullPath); expect(entry.filesystem.name).toEqual("temporary"); // cleanup deleteEntry(entry.name, done); }, transfer = function () { resolveLocalFileSystemURL(src, function(entry) { expect(entry).toBeDefined(); expect(entry.filesystem.name).toEqual("content"); entry.copyTo(temp_root, file2, validateFile, failed.bind(null, done, 'entry.copyTo - Error copying file: ' + entry.toURL() + ' to TEMPORAL root as: ' + file2)); }, failed.bind(null, done, 'resolveLocalFileSystemURL failed for content provider')); }; // Delete any existing file to start things off temp_root.getFile(file2, {}, function (entry) { entry.remove(transfer, failed.bind(null, done, 'entry.remove - Error removing file: ' + file2)); }, transfer); } it("file.spec.138 copyTo: content", function(done) { testContentCopy('content://org.apache.cordova.file.testprovider/www/index.html', done); }); it("file.spec.139 copyTo: content /w space and query", function(done) { testContentCopy('content://org.apache.cordova.file.testprovider/?name=foo%20bar&realPath=%2Fwww%2Findex.html', done); }); it("file.spec.140 delete: content should fail", function(done) { resolveLocalFileSystemURL('content://org.apache.cordova.file.testprovider/www/index.html', function(entry) { entry.remove(failed.bind(null, done, 'expected delete to fail'), done); }, failed.bind(null, done, 'resolveLocalFileSystemURL failed for content provider')); }); }); // these tests ensure that you can read and copy from android_asset folder // for details see https://issues.apache.org/jira/browse/CB-6428 // and https://mail-archives.apache.org/mod_mbox/cordova-dev/201508.mbox/%3C782154441.8406572.1440182722528.JavaMail.yahoo%40mail.yahoo.com%3E describe('asset: URLs', function() { it("file.spec.141 filePaths.applicationStorage", function() { expect(cordova.file.applicationDirectory).toEqual('file:///android_asset/'); }, MEDIUM_TIMEOUT); it("file.spec.142 assets should be enumerable", function(done) { resolveLocalFileSystemURL('file:///android_asset/www/fixtures/asset-test', function(entry) { var reader = entry.createReader(); reader.readEntries(function (entries) { expect(entries.length).not.toBe(0); done(); }, failed.bind(null, done, 'reader.readEntries - Error during reading of entries from assets directory')); }, failed.bind(null, done, 'resolveLocalFileSystemURL failed for assets')); }, MEDIUM_TIMEOUT); it("file.spec.145 asset subdirectories should be obtainable", function(done) { resolveLocalFileSystemURL('file:///android_asset/www/fixtures', function(entry) { entry.getDirectory('asset-test', { create: false }, function (subDir) { expect(subDir).toBeDefined(); expect(subDir.isFile).toBe(false); expect(subDir.isDirectory).toBe(true); expect(subDir.name).toCanonicallyMatch('asset-test'); done(); }, failed.bind(null, done, 'entry.getDirectory - Error getting asset subdirectory')); }, failed.bind(null, done, 'resolveLocalFileSystemURL failed for assets')); }, MEDIUM_TIMEOUT); it("file.spec.146 asset files should be readable", function(done) { resolveLocalFileSystemURL('file:///android_asset/www/fixtures/asset-test/asset-test.txt', function(entry) { expect(entry.isFile).toBe(true); entry.file(function (file) { expect(file).toBeDefined(); var reader = new FileReader(); reader.onerror = failed.bind(null, done, 'reader.readAsText - Error reading asset text file'); reader.onloadend = function () { expect(this.result).toBeDefined(); expect(this.result.length).not.toBe(0); done(); }; reader.readAsText(file); }, failed.bind(null, done, 'entry.file - Error reading asset file')); }, failed.bind(null, done, 'resolveLocalFileSystemURL failed for assets')); }, MEDIUM_TIMEOUT); it("file.spec.143 copyTo: asset -> temporary", function(done) { var file2 = "entry.copy.file2b", fullPath = joinURL(temp_root.fullPath, file2), validateFile = function (entry) { expect(entry.isFile).toBe(true); expect(entry.isDirectory).toBe(false); expect(entry.name).toCanonicallyMatch(file2); expect(entry.fullPath).toCanonicallyMatch(fullPath); expect(entry.filesystem.name).toEqual("temporary"); // cleanup deleteEntry(entry.name, done); }, transfer = function () { resolveLocalFileSystemURL('file:///android_asset/www/index.html', function(entry) { expect(entry.filesystem.name).toEqual('assets'); entry.copyTo(temp_root, file2, validateFile, failed.bind(null, done, 'entry.copyTo - Error copying file: ' + entry.toURL() + ' to TEMPORAL root as: ' + file2)); }, failed.bind(null, done, 'resolveLocalFileSystemURL failed for assets')); }; // Delete any existing file to start things off temp_root.getFile(file2, {}, function (entry) { entry.remove(transfer, failed.bind(null, done, 'entry.remove - Error removing file: ' + file2)); }, transfer); }, MEDIUM_TIMEOUT); }); it("file.spec.144 copyTo: asset directory", function (done) { var srcUrl = 'file:///android_asset/www/fixtures/asset-test'; var dstDir = "entry.copy.dstDir"; var dstPath = joinURL(root.fullPath, dstDir); // create a new directory entry to kick off it deleteEntry(dstDir, function () { resolveLocalFileSystemURL(srcUrl, function(directory) { directory.copyTo(root, dstDir, function (directory) { expect(directory).toBeDefined(); expect(directory.isFile).toBe(false); expect(directory.isDirectory).toBe(true); expect(directory.fullPath).toCanonicallyMatch(dstPath); expect(directory.name).toCanonicallyMatch(dstDir); root.getDirectory(dstDir, { create : false }, function (dirEntry) { expect(dirEntry).toBeDefined(); expect(dirEntry.isFile).toBe(false); expect(dirEntry.isDirectory).toBe(true); expect(dirEntry.fullPath).toCanonicallyMatch(dstPath); expect(dirEntry.name).toCanonicallyMatch(dstDir); dirEntry.getFile('asset-test.txt', { create : false }, function (fileEntry) { expect(fileEntry).toBeDefined(); expect(fileEntry.isFile).toBe(true); // cleanup deleteEntry(dstDir, done); }, failed.bind(null, done, 'dirEntry.getFile - Error getting subfile')); }, failed.bind(null, done, 'root.getDirectory - Error getting copied directory')); }, failed.bind(null, done, 'directory.copyTo - Error copying directory')); }, failed.bind(null, done, 'resolving src dir')); }, failed.bind(null, done, 'deleteEntry - Error removing directory : ' + dstDir)); }, MEDIUM_TIMEOUT); } }); }; //****************************************************************************************** //***************************************Manual Tests*************************************** //****************************************************************************************** exports.defineManualTests = function (contentEl, createActionButton) { function resolveFs(fsname) { var fsURL = "cdvfile://localhost/" + fsname + "/"; logMessage("Resolving URL: " + fsURL); resolveLocalFileSystemURL(fsURL, function (entry) { logMessage("Success", 'green'); logMessage(entry.toURL(), 'blue'); logMessage(entry.toInternalURL(), 'blue'); logMessage("Resolving URL: " + entry.toURL()); resolveLocalFileSystemURL(entry.toURL(), function (entry2) { logMessage("Success", 'green'); logMessage(entry2.toURL(), 'blue'); logMessage(entry2.toInternalURL(), 'blue'); }, logError("resolveLocalFileSystemURL")); }, logError("resolveLocalFileSystemURL")); } function testPrivateURL() { requestFileSystem(LocalFileSystem.TEMPORARY, 0, function (fileSystem) { logMessage("Temporary root is at " + fileSystem.root.toNativeURL()); fileSystem.root.getFile("testfile", { create : true }, function (entry) { logMessage("Temporary file is at " + entry.toNativeURL()); if (entry.toNativeURL().substring(0, 12) == "file:///var/") { logMessage("File starts with /var/, trying /private/var"); var newURL = "file://localhost/private/var/" + entry.toNativeURL().substring(12) + "?and=another_thing"; //var newURL = entry.toNativeURL(); logMessage(newURL, 'blue'); resolveLocalFileSystemURL(newURL, function (newEntry) { logMessage("Successfully resolved.", 'green'); logMessage(newEntry.toURL(), 'blue'); logMessage(newEntry.toNativeURL(), 'blue'); }, logError("resolveLocalFileSystemURL")); } }, logError("getFile")); }, logError("requestFileSystem")); } function clearLog() { var log = document.getElementById("info"); log.innerHTML = ""; } function logMessage(message, color) { var log = document.getElementById("info"); var logLine = document.createElement('div'); if (color) { logLine.style.color = color; } logLine.innerHTML = message; log.appendChild(logLine); } function logError(serviceName) { return function (err) { logMessage("ERROR: " + serviceName + " " + JSON.stringify(err), "red"); }; } var fsRoots = { "ios" : "library,library-nosync,documents,documents-nosync,cache,bundle,root,private", "osx" : "library,library-nosync,documents,documents-nosync,cache,bundle,root,private", "android" : "files,files-external,documents,sdcard,cache,cache-external,root", "amazon-fireos" : "files,files-external,documents,sdcard,cache,cache-external,root", "windows": "temporary,persistent" }; //Add title and align to content var div = document.createElement('h2'); div.appendChild(document.createTextNode('File Systems')); div.setAttribute("align", "center"); contentEl.appendChild(div); div = document.createElement('h3'); div.appendChild(document.createTextNode('Results are displayed in yellow status box below with expected results noted under that')); div.setAttribute("align", "center"); contentEl.appendChild(div); div = document.createElement('div'); div.setAttribute("id", "button"); div.setAttribute("align", "center"); contentEl.appendChild(div); if (fsRoots.hasOwnProperty(cordova.platformId)) { (fsRoots[cordova.platformId].split(',')).forEach(function (fs) { if (cordova.platformId === 'ios' && fs === 'private') { createActionButton("Test private URL (iOS)", function () { clearLog(); testPrivateURL(); }, 'button'); } else { createActionButton(fs, function () { clearLog(); resolveFs(fs); }, 'button'); } }); } div = document.createElement('div'); div.setAttribute("id", "info"); div.setAttribute("align", "center"); contentEl.appendChild(div); div = document.createElement('h3'); div.appendChild(document.createTextNode('For each test above, file or directory should be successfully found. ' + 'Status box should say Resolving URL was Success. The first URL resolved is the internal URL. ' + 'The second URL resolved is the absolute URL. Blue URLs must match.')); contentEl.appendChild(div); div = document.createElement('h3'); div.appendChild(document.createTextNode('For Test private URL (iOS), the private URL (first blue URL in status box) ' + 'should be successfully resolved. Status box should say Successfully resolved. Both blue URLs below ' + 'that should match.')); contentEl.appendChild(div); };