| /** |
| 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. |
| */ |
| |
| var path = require('path'); |
| var rewire = require('rewire'); |
| var FileUpdater = rewire('../src/FileUpdater'); |
| |
| // Normally these are internal to the module; these lines use rewire to expose them for testing. |
| FileUpdater.mapDirectory = FileUpdater.__get__('mapDirectory'); |
| FileUpdater.mergePathMaps = FileUpdater.__get__('mergePathMaps'); |
| FileUpdater.updatePathWithStats = FileUpdater.__get__('updatePathWithStats'); |
| |
| // Intercept calls to the internal updatePathWithStats function, |
| // so calling methods can be tested in isolation. |
| FileUpdater.updatePathWithStatsCalls = []; |
| FileUpdater.updatePathWithStatsResult = true; |
| FileUpdater.__set__('updatePathWithStats', function () { |
| FileUpdater.updatePathWithStatsCalls.push(arguments); |
| return FileUpdater.updatePathWithStatsResult; |
| }); |
| |
| // Create mock fs.Stats to simulate file or directory attributes. |
| function mockFileStats (modified) { |
| return { |
| isFile: function () { return true; }, |
| isDirectory: function () { return false; }, |
| ctime: modified, |
| mtime: modified |
| }; |
| } |
| function mockDirStats () { |
| return { |
| isFile: function () { return false; }, |
| isDirectory: function () { return true; }, |
| ctime: null, |
| mtime: null |
| }; |
| } |
| |
| // Create a mock to replace the fs-extra module used by the FileUpdater, |
| // so the tests don't have to actually touch the filesystem. |
| var mockFs = { |
| mkdirPaths: [], |
| cpPaths: [], |
| rmPaths: [], |
| dirMap: {}, |
| statMap: {}, |
| |
| reset: function () { |
| this.mkdirPaths = []; |
| this.cpPaths = []; |
| this.rmPaths = []; |
| this.dirMap = {}; |
| this.statMap = {}; |
| }, |
| |
| existsSync: function (fileOrDirPath) { |
| return typeof (this.statMap[fileOrDirPath]) !== 'undefined'; |
| }, |
| |
| readdirSync: function (dirPath) { |
| var result = this.dirMap[dirPath]; |
| if (!result) throw new Error('Directory path not found: ' + dirPath); |
| return result; |
| }, |
| |
| statSync: function (fileOrDirPath) { |
| var result = this.statMap[fileOrDirPath]; |
| if (!result) throw new Error('File or directory path not found: ' + fileOrDirPath); |
| return result; |
| }, |
| |
| ensureDirSync: function (path) { |
| this.mkdirPaths.push(path); |
| }, |
| |
| copySync: function (sourcePath, targetPath) { |
| this.cpPaths.push([sourcePath, targetPath]); |
| }, |
| |
| removeSync: function (path) { |
| this.rmPaths.push(path); |
| } |
| }; |
| FileUpdater.__set__('fs', mockFs); |
| |
| // Define some constants used in the test cases. |
| var testRootDir = 'testRootDir'; |
| var testSourceDir = 'testSourceDir'; |
| var testSourceDir2 = 'testSourceDir2'; |
| var testSourceDir3 = 'testSourceDir3'; |
| var testTargetDir = 'testTargetDir'; |
| var testSourceFile = 'testSourceFile'; |
| var testSourceFile2 = 'testSourceFile2'; |
| var testTargetFile = 'testTargetFile'; |
| var testTargetFile2 = 'testTargetFile2'; |
| var testSubDir = 'testSubDir'; |
| var now = new Date(); |
| var oneHourAgo = new Date(now.getTime() - 1 * 60 * 60 * 1000); |
| var testDirStats = mockDirStats(); |
| var testFileStats = mockFileStats(now); |
| var testFileStats2 = mockFileStats(now); |
| var testFileStats3 = mockFileStats(now); |
| var nullLogger = function () {}; |
| |
| describe('FileUpdater class', function () { |
| |
| beforeEach(function () { |
| FileUpdater.updatePathWithStatsCalls = []; |
| FileUpdater.updatePathWithStatsResult = true; |
| mockFs.reset(); |
| }); |
| |
| describe('updatePathWithStats method', function () { |
| it('Test 001 : should do nothing when a directory exists at source and target', function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceDir, mockDirStats(), testTargetDir, mockDirStats(), |
| null, nullLogger); |
| expect(updated).toBe(false); |
| expect(mockFs.mkdirPaths.length).toBe(0); |
| expect(mockFs.rmPaths.length).toBe(0); |
| }); |
| it('Test 002 : should create a directory that exists at source and not at target', function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceDir, mockDirStats(), testTargetDir, null, |
| null, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.mkdirPaths.length).toBe(1); |
| expect(mockFs.rmPaths.length).toBe(0); |
| expect(mockFs.mkdirPaths[0]).toBe(testTargetDir); |
| }); |
| it('Test 003 : should remove a directory that exists at target and not at source', function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceDir, null, testTargetDir, mockDirStats(), |
| null, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.mkdirPaths.length).toBe(0); |
| expect(mockFs.rmPaths.length).toBe(1); |
| expect(mockFs.rmPaths[0]).toBe(testTargetDir); |
| }); |
| |
| it('Test 004 : should copy when a file exists at source and target and times are the same', |
| function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceFile, mockFileStats(now), testTargetFile, mockFileStats(now), |
| null, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.cpPaths.length).toBe(1); |
| expect(mockFs.rmPaths.length).toBe(0); |
| expect(mockFs.cpPaths[0]).toEqual([testSourceFile, testTargetFile]); |
| }); |
| it('Test 005 : should copy when a file exists at source and target and target is older', |
| function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceFile, mockFileStats(now), testTargetFile, mockFileStats(oneHourAgo), |
| null, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.cpPaths.length).toBe(1); |
| expect(mockFs.rmPaths.length).toBe(0); |
| expect(mockFs.cpPaths[0]).toEqual([testSourceFile, testTargetFile]); |
| }); |
| it('Test 006 : should do nothing when a file exists at source and target and target is newer', |
| function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceFile, mockFileStats(oneHourAgo), testTargetFile, mockFileStats(now), |
| null, nullLogger); |
| expect(updated).toBe(false); |
| expect(mockFs.cpPaths.length).toBe(0); |
| expect(mockFs.rmPaths.length).toBe(0); |
| }); |
| it('Test 007 : should copy when a file exists at source and target and forcing update', function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceFile, mockFileStats(now), testTargetFile, mockFileStats(now), |
| { all: true }, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.cpPaths.length).toBe(1); |
| expect(mockFs.rmPaths.length).toBe(0); |
| expect(mockFs.cpPaths[0]).toEqual([testSourceFile, testTargetFile]); |
| }); |
| it('Test 008 : should copy when a file exists at source and target and target is newer ' + |
| 'and forcing update', function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceFile, mockFileStats(oneHourAgo), testTargetFile, mockFileStats(now), |
| { all: true }, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.cpPaths.length).toBe(1); |
| expect(mockFs.rmPaths.length).toBe(0); |
| expect(mockFs.cpPaths[0]).toEqual([testSourceFile, testTargetFile]); |
| }); |
| it('Test 009 : should copy when a file exists at source and target and source is newer', function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceFile, mockFileStats(now), testTargetFile, mockFileStats(oneHourAgo), |
| null, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.cpPaths.length).toBe(1); |
| expect(mockFs.rmPaths.length).toBe(0); |
| expect(mockFs.cpPaths[0]).toEqual([testSourceFile, testTargetFile]); |
| }); |
| it('Test 010 : should copy when a file exists at source and not at target', function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceFile, mockFileStats(now), testTargetFile, null, |
| null, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.cpPaths.length).toBe(1); |
| expect(mockFs.rmPaths.length).toBe(0); |
| expect(mockFs.cpPaths[0]).toEqual([testSourceFile, testTargetFile]); |
| }); |
| it('Test 011 : should remove when a file exists at target and not at source', function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceFile, null, testTargetFile, mockFileStats(now), |
| null, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.cpPaths.length).toBe(0); |
| expect(mockFs.rmPaths.length).toBe(1); |
| expect(mockFs.rmPaths[0]).toBe(testTargetFile); |
| }); |
| |
| it('Test 012 : should remove and mkdir when source is a directory and target is a file', function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceDir, mockDirStats(), testTargetDir, mockFileStats(now), |
| null, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.cpPaths.length).toBe(0); |
| expect(mockFs.rmPaths.length).toBe(1); |
| expect(mockFs.mkdirPaths.length).toBe(1); |
| expect(mockFs.rmPaths[0]).toBe(testTargetDir); |
| expect(mockFs.mkdirPaths[0]).toBe(testTargetDir); |
| }); |
| it('Test 013 : should remove and copy when source is a file and target is a directory', function () { |
| var updated = FileUpdater.updatePathWithStats( |
| testSourceFile, mockFileStats(now), testTargetFile, mockDirStats(), |
| null, nullLogger); |
| expect(updated).toBe(true); |
| expect(mockFs.rmPaths.length).toBe(1); |
| expect(mockFs.cpPaths.length).toBe(1); |
| expect(mockFs.mkdirPaths.length).toBe(0); |
| expect(mockFs.rmPaths[0]).toBe(testTargetFile); |
| expect(mockFs.cpPaths[0]).toEqual([testSourceFile, testTargetFile]); |
| }); |
| |
| it('Test 014 : should join the paths when a rootDir is specified', function () { |
| FileUpdater.updatePathWithStats( |
| testSourceFile, mockFileStats(now), testTargetFile, null, |
| { rootDir: testRootDir }, nullLogger); |
| expect(mockFs.cpPaths.length).toBe(1); |
| expect(mockFs.rmPaths.length).toBe(0); |
| expect(mockFs.cpPaths[0]).toEqual( |
| [path.join(testRootDir, testSourceFile), path.join(testRootDir, testTargetFile)]); |
| }); |
| |
| it('Test 015 : should log dir creation', function () { |
| var loggedSource = 0; |
| var loggedTarget = 0; |
| var loggedRoot = 0; |
| FileUpdater.updatePathWithStats( |
| testSourceDir, mockDirStats(now), testTargetDir, null, { rootDir: testRootDir }, |
| function (message) { |
| loggedSource += new RegExp(testSourceDir).test(message) ? 1 : 0; |
| loggedTarget += new RegExp(testTargetDir).test(message) ? 1 : 0; |
| loggedRoot += new RegExp(testRootDir).test(message) ? 1 : 0; |
| }); |
| expect(loggedSource).toBe(0); |
| expect(loggedTarget).toBe(1); |
| expect(loggedRoot).toBe(0); |
| }); |
| it('Test 016 : should log dir removal', function () { |
| var loggedSource = 0; |
| var loggedTarget = 0; |
| var loggedRoot = 0; |
| FileUpdater.updatePathWithStats( |
| testSourceDir, null, testTargetDir, mockDirStats(now), { rootDir: testRootDir }, |
| function (message) { |
| loggedSource += new RegExp(testSourceDir).test(message) ? 1 : 0; |
| loggedTarget += new RegExp(testTargetDir).test(message) ? 1 : 0; |
| loggedRoot += new RegExp(testRootDir).test(message) ? 1 : 0; |
| }); |
| expect(loggedSource).toBe(0); |
| expect(loggedTarget).toBe(1); |
| expect(loggedRoot).toBe(0); |
| }); |
| it('Test 017 : should log file copy', function () { |
| var loggedSource = 0; |
| var loggedTarget = 0; |
| var loggedRoot = 0; |
| FileUpdater.updatePathWithStats( |
| testSourceFile, mockFileStats(now), testTargetFile, null, { rootDir: testRootDir }, |
| function (message) { |
| loggedSource += new RegExp(testSourceFile).test(message) ? 1 : 0; |
| loggedTarget += new RegExp(testTargetFile).test(message) ? 1 : 0; |
| loggedRoot += new RegExp(testRootDir).test(message) ? 1 : 0; |
| }); |
| expect(loggedSource).toBe(1); |
| expect(loggedTarget).toBe(1); |
| expect(loggedRoot).toBe(0); |
| }); |
| it('Test 018: should log file removal', function () { |
| var loggedSource = 0; |
| var loggedTarget = 0; |
| var loggedRoot = 0; |
| var messages = []; |
| FileUpdater.updatePathWithStats( |
| testSourceFile, null, testTargetFile, mockFileStats(now), { rootDir: testRootDir }, |
| function (message) { |
| loggedSource += new RegExp(testSourceFile).test(message) ? 1 : 0; |
| loggedTarget += new RegExp(testTargetFile).test(message) ? 1 : 0; |
| loggedRoot += new RegExp(testRootDir).test(message) ? 1 : 0; |
| }); |
| expect(messages).toEqual([]); |
| expect(loggedSource).toBe(0); |
| expect(loggedTarget).toBe(1); |
| expect(loggedRoot).toBe(0); |
| }); |
| }); |
| |
| describe('mapDirectory method', function () { |
| it('Test 019 : should map an empty directory', function () { |
| mockFs.statMap[path.join(testRootDir, testSourceDir)] = testDirStats; |
| mockFs.dirMap[path.join(testRootDir, testSourceDir)] = []; |
| var dirMap = FileUpdater.mapDirectory(testRootDir, testSourceDir, ['**'], []); |
| expect(Object.keys(dirMap)).toEqual(['']); |
| expect(dirMap[''].subDir).toBe(testSourceDir); |
| expect(dirMap[''].stats).toBe(testDirStats); |
| }); |
| it('Test 020 : should map a directory with a file', function () { |
| mockFs.statMap[path.join(testRootDir, testSourceDir)] = testDirStats; |
| mockFs.dirMap[path.join(testRootDir, testSourceDir)] = [testSourceFile]; |
| mockFs.statMap[path.join(testRootDir, testSourceDir, testSourceFile)] = testFileStats; |
| var dirMap = FileUpdater.mapDirectory(testRootDir, testSourceDir, ['**'], []); |
| expect(Object.keys(dirMap).sort()).toEqual(['', testSourceFile]); |
| expect(dirMap[''].subDir).toBe(testSourceDir); |
| expect(dirMap[''].stats).toBe(testDirStats); |
| expect(dirMap[testSourceFile].subDir).toBe(testSourceDir); |
| expect(dirMap[testSourceFile].stats).toBe(testFileStats); |
| }); |
| it('Test 021 : should map a directory with a subdirectory', function () { |
| mockFs.statMap[testSourceDir] = testDirStats; |
| mockFs.dirMap[testSourceDir] = [testSubDir]; |
| mockFs.statMap[path.join(testSourceDir, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(testSourceDir, testSubDir)] = []; |
| var dirMap = FileUpdater.mapDirectory('', testSourceDir, ['**'], []); |
| expect(Object.keys(dirMap).sort()).toEqual(['', testSubDir]); |
| expect(dirMap[''].subDir).toBe(testSourceDir); |
| expect(dirMap[''].stats).toBe(testDirStats); |
| expect(dirMap[testSubDir].subDir).toBe(testSourceDir); |
| expect(dirMap[testSubDir].stats).toBe(testDirStats); |
| }); |
| it('Test 022 : should map a directory with a file in a nested subdirectory', function () { |
| mockFs.statMap[testSourceDir] = testDirStats; |
| mockFs.dirMap[testSourceDir] = [testSubDir]; |
| mockFs.statMap[path.join(testSourceDir, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(testSourceDir, testSubDir)] = [testSubDir]; |
| mockFs.statMap[path.join(testSourceDir, testSubDir, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(testSourceDir, testSubDir, testSubDir)] = [testSourceFile]; |
| mockFs.statMap[path.join(testSourceDir, testSubDir, testSubDir, testSourceFile)] = |
| testFileStats; |
| var dirMap = FileUpdater.mapDirectory('', testSourceDir, ['**'], []); |
| expect(Object.keys(dirMap).sort()).toEqual([ |
| '', |
| testSubDir, |
| path.join(testSubDir, testSubDir), |
| path.join(testSubDir, testSubDir, testSourceFile)]); |
| expect(dirMap[''].subDir).toBe(testSourceDir); |
| expect(dirMap[''].stats).toBe(testDirStats); |
| expect(dirMap[testSubDir].subDir).toBe(testSourceDir); |
| expect(dirMap[testSubDir].stats).toBe(testDirStats); |
| expect(dirMap[path.join(testSubDir, testSubDir)].subDir).toBe(testSourceDir); |
| expect(dirMap[path.join(testSubDir, testSubDir)].stats).toBe(testDirStats); |
| expect(dirMap[path.join(testSubDir, testSubDir, testSourceFile)].subDir).toBe( |
| testSourceDir); |
| expect(dirMap[path.join(testSubDir, testSubDir, testSourceFile)].stats).toBe( |
| testFileStats); |
| }); |
| |
| it('Test 023 : should include files that match include globs', function () { |
| mockFs.statMap[testSourceDir] = testDirStats; |
| mockFs.dirMap[testSourceDir] = [testSourceFile, testSourceFile2]; |
| mockFs.statMap[path.join(testSourceDir, testSourceFile)] = testFileStats; |
| mockFs.statMap[path.join(testSourceDir, testSourceFile2)] = testFileStats; |
| var dirMap = FileUpdater.mapDirectory('', testSourceDir, [testSourceFile], []); |
| expect(Object.keys(dirMap).sort()).toEqual(['', testSourceFile]); |
| expect(dirMap[''].subDir).toBe(testSourceDir); |
| expect(dirMap[''].stats).toBe(testDirStats); |
| expect(dirMap[testSourceFile].subDir).toBe(testSourceDir); |
| expect(dirMap[testSourceFile].stats).toBe(testFileStats); |
| }); |
| it('Test 024 : should include files in a subdirectory that match include globs', function () { |
| mockFs.statMap[testSourceDir] = testDirStats; |
| mockFs.dirMap[testSourceDir] = [testSubDir]; |
| mockFs.statMap[path.join(testSourceDir, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(testSourceDir, testSubDir)] = |
| [testSourceFile, testSourceFile2]; |
| mockFs.statMap[path.join(testSourceDir, testSubDir, testSourceFile)] = testFileStats; |
| mockFs.statMap[path.join(testSourceDir, testSubDir, testSourceFile2)] = testFileStats; |
| var dirMap = FileUpdater.mapDirectory('', testSourceDir, ['**/' + testSourceFile], []); |
| expect(Object.keys(dirMap).sort()).toEqual([ |
| '', |
| testSubDir, |
| path.join(testSubDir, testSourceFile)]); |
| expect(dirMap[''].subDir).toBe(testSourceDir); |
| expect(dirMap[''].stats).toBe(testDirStats); |
| expect(dirMap[path.join(testSubDir, testSourceFile)].subDir).toBe(testSourceDir); |
| expect(dirMap[path.join(testSubDir, testSourceFile)].stats).toBe(testFileStats); |
| }); |
| it('Test 025 : should exclude paths that match exclude globs', function () { |
| mockFs.statMap[testSourceDir] = testDirStats; |
| mockFs.dirMap[testSourceDir] = [testSourceFile, testSourceFile2]; |
| mockFs.statMap[path.join(testSourceDir, testSourceFile)] = testFileStats; |
| mockFs.statMap[path.join(testSourceDir, testSourceFile2)] = testFileStats; |
| var dirMap = FileUpdater.mapDirectory('', testSourceDir, ['**'], [testSourceFile2]); |
| expect(Object.keys(dirMap).sort()).toEqual(['', testSourceFile]); |
| expect(dirMap[''].subDir).toBe(testSourceDir); |
| expect(dirMap[''].stats).toBe(testDirStats); |
| expect(dirMap[testSourceFile].subDir).toBe(testSourceDir); |
| expect(dirMap[testSourceFile].stats).toBe(testFileStats); |
| }); |
| it('Test 026 : should exclude paths that match both exclude and include globs', function () { |
| mockFs.statMap[testSourceDir] = testDirStats; |
| mockFs.dirMap[testSourceDir] = [testSubDir]; |
| mockFs.statMap[path.join(testSourceDir, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(testSourceDir, testSubDir)] = |
| [testSourceFile, testSourceFile2]; |
| mockFs.statMap[path.join(testSourceDir, testSubDir, testSourceFile)] = testFileStats; |
| mockFs.statMap[path.join(testSourceDir, testSubDir, testSourceFile2)] = testFileStats; |
| var dirMap = FileUpdater.mapDirectory( |
| '', testSourceDir, ['**/' + testSourceFile], [testSubDir]); |
| expect(Object.keys(dirMap).sort()).toEqual(['']); |
| expect(dirMap[''].subDir).toBe(testSourceDir); |
| expect(dirMap[''].stats).toBe(testDirStats); |
| }); |
| }); |
| |
| describe('mergePathMaps method', function () { |
| var testTargetFileStats = mockFileStats(oneHourAgo); |
| var testSourceFileStats = mockFileStats(now); |
| var testSourceFileStats2 = mockFileStats(now); |
| var testSourceFileStats3 = mockFileStats(now); |
| it('Test 027 : should prepend the target directory on target paths', function () { |
| var mergedPathMap = FileUpdater.mergePathMaps( |
| [{ |
| '': { subDir: testSourceDir, stats: testDirStats }, |
| testTargetFile: { subDir: testSourceDir, stats: testSourceFileStats } |
| }], |
| { |
| '': { subDir: testTargetDir, stats: testDirStats }, |
| testTargetFile: { subDir: testTargetDir, stats: testTargetFileStats } |
| }, |
| testTargetDir); |
| expect(Object.keys(mergedPathMap).sort()).toEqual(['', testTargetFile]); |
| expect(mergedPathMap[''].targetPath).toBe(testTargetDir); |
| expect(mergedPathMap[''].targetStats).toBe(testDirStats); |
| expect(mergedPathMap[''].sourcePath).toBe(testSourceDir); |
| expect(mergedPathMap[''].sourceStats).toBe(testDirStats); |
| expect(mergedPathMap[testTargetFile].targetPath).toBe( |
| path.join(testTargetDir, testTargetFile)); |
| expect(mergedPathMap[testTargetFile].targetStats).toBe(testTargetFileStats); |
| expect(mergedPathMap[testTargetFile].sourcePath).toBe( |
| path.join(testSourceDir, testTargetFile)); |
| expect(mergedPathMap[testTargetFile].sourceStats).toBe(testSourceFileStats); |
| }); |
| it('Test 028 : should handle missing source files', function () { |
| var mergedPathMap = FileUpdater.mergePathMaps( |
| [{}], |
| { |
| testTargetFile: { subDir: testTargetDir, stats: testTargetFileStats } |
| }, |
| testTargetDir); |
| expect(Object.keys(mergedPathMap).sort()).toEqual([testTargetFile]); |
| expect(mergedPathMap[testTargetFile].targetPath).toBe( |
| path.join(testTargetDir, testTargetFile)); |
| expect(mergedPathMap[testTargetFile].targetStats).toBe(testTargetFileStats); |
| expect(mergedPathMap[testTargetFile].sourcePath).toBeNull(); |
| expect(mergedPathMap[testTargetFile].sourceStats).toBeNull(); |
| }); |
| it('Tets 029 : should handle missing target files', function () { |
| var mergedPathMap = FileUpdater.mergePathMaps( |
| [{ |
| testTargetFile: { subDir: testSourceDir, stats: testSourceFileStats } |
| }], |
| {}, |
| testTargetDir); |
| expect(Object.keys(mergedPathMap).sort()).toEqual([testTargetFile]); |
| expect(mergedPathMap[testTargetFile].targetPath).toBe( |
| path.join(testTargetDir, testTargetFile)); |
| expect(mergedPathMap[testTargetFile].targetStats).toBeNull(); |
| expect(mergedPathMap[testTargetFile].sourcePath).toBe( |
| path.join(testSourceDir, testTargetFile)); |
| expect(mergedPathMap[testTargetFile].sourceStats).toBe(testSourceFileStats); |
| }); |
| it('Test 030 : should merge three source maps', function () { |
| var mergedPathMap = FileUpdater.mergePathMaps( |
| [ |
| { |
| '': { subDir: testSourceDir, stats: testDirStats }, |
| testTargetFile: { subDir: testSourceDir, stats: testSourceFileStats } |
| }, |
| { |
| '': { subDir: testSourceDir2, stats: testDirStats }, |
| testTargetFile: { subDir: testSourceDir2, stats: testSourceFileStats2 }, |
| testTargetFile2: { subDir: testSourceDir2, stats: testSourceFileStats2 } |
| }, |
| { |
| '': { subDir: testSourceDir3, stats: testDirStats }, |
| testTargetFile2: { subDir: testSourceDir3, stats: testSourceFileStats3 } |
| } |
| ], |
| { |
| '': { subDir: testTargetDir, stats: testDirStats }, |
| testTargetFile: { subDir: testTargetDir, stats: testTargetFileStats } |
| }, |
| testTargetDir); |
| expect(Object.keys(mergedPathMap).sort()).toEqual( |
| ['', testTargetFile, testTargetFile2]); |
| expect(mergedPathMap[''].targetPath).toBe(testTargetDir); |
| expect(mergedPathMap[''].targetStats).toBe(testDirStats); |
| expect(mergedPathMap[''].sourcePath).toBe(testSourceDir3); |
| expect(mergedPathMap[''].sourceStats).toBe(testDirStats); |
| expect(mergedPathMap[testTargetFile].targetPath).toBe( |
| path.join(testTargetDir, testTargetFile)); |
| expect(mergedPathMap[testTargetFile].targetStats).toBe(testTargetFileStats); |
| expect(mergedPathMap[testTargetFile].sourcePath).toBe( |
| path.join(testSourceDir2, testTargetFile)); |
| expect(mergedPathMap[testTargetFile].sourceStats).toBe(testSourceFileStats2); |
| expect(mergedPathMap[testTargetFile2].targetPath).toBe( |
| path.join(testTargetDir, testTargetFile2)); |
| expect(mergedPathMap[testTargetFile2].targetStats).toBeNull(); |
| expect(mergedPathMap[testTargetFile2].sourcePath).toBe( |
| path.join(testSourceDir3, testTargetFile2)); |
| expect(mergedPathMap[testTargetFile2].sourceStats).toBe(testSourceFileStats3); |
| }); |
| }); |
| |
| describe('updatePath method', function () { |
| it('Test 031 : should update a path', function () { |
| mockFs.statMap[testRootDir] = testDirStats; |
| mockFs.statMap[path.join(testRootDir, testTargetFile)] = testFileStats; |
| mockFs.statMap[path.join(testRootDir, testSourceFile)] = testFileStats2; |
| var updated = FileUpdater.updatePath( |
| testSourceFile, testTargetFile, { rootDir: testRootDir, all: true }); |
| expect(updated).toBe(true); |
| expect(FileUpdater.updatePathWithStatsCalls.length).toBe(1); |
| expect(FileUpdater.updatePathWithStatsCalls[0][0]).toBe(testSourceFile); |
| expect(FileUpdater.updatePathWithStatsCalls[0][1]).toEqual(testFileStats2); |
| expect(FileUpdater.updatePathWithStatsCalls[0][2]).toBe(testTargetFile); |
| expect(FileUpdater.updatePathWithStatsCalls[0][3]).toEqual(testFileStats); |
| expect(FileUpdater.updatePathWithStatsCalls[0][4]).toEqual( |
| { rootDir: testRootDir, all: true }); |
| }); |
| it('Test 032 : should update a path without a separate root directory', function () { |
| mockFs.statMap[testTargetFile] = testFileStats; |
| mockFs.statMap[testSourceFile] = testFileStats2; |
| FileUpdater.updatePathWithStatsResult = false; |
| var updated = FileUpdater.updatePath(testSourceFile, testTargetFile); |
| expect(updated).toBe(false); |
| expect(FileUpdater.updatePathWithStatsCalls.length).toBe(1); |
| expect(FileUpdater.updatePathWithStatsCalls[0][0]).toBe(testSourceFile); |
| expect(FileUpdater.updatePathWithStatsCalls[0][1]).toEqual(testFileStats2); |
| expect(FileUpdater.updatePathWithStatsCalls[0][2]).toBe(testTargetFile); |
| expect(FileUpdater.updatePathWithStatsCalls[0][3]).toEqual(testFileStats); |
| expect(FileUpdater.updatePathWithStatsCalls[0][4]).toBeUndefined(); |
| }); |
| it('Test 033 : should update a path when the source doesn\'t exist', function () { |
| mockFs.statMap[testTargetFile] = testFileStats; |
| var updated = FileUpdater.updatePath(null, testTargetFile); |
| expect(updated).toBe(true); |
| expect(FileUpdater.updatePathWithStatsCalls.length).toBe(1); |
| expect(FileUpdater.updatePathWithStatsCalls[0][0]).toBeNull(); |
| expect(FileUpdater.updatePathWithStatsCalls[0][1]).toBeNull(); |
| expect(FileUpdater.updatePathWithStatsCalls[0][2]).toBe(testTargetFile); |
| expect(FileUpdater.updatePathWithStatsCalls[0][3]).toEqual(testFileStats); |
| expect(FileUpdater.updatePathWithStatsCalls[0][4]).toBeUndefined(); |
| }); |
| it('Test 034 : should update a path when the target doesn\'t exist', function () { |
| mockFs.statMap[testSourceFile] = testFileStats2; |
| var updated = FileUpdater.updatePath(testSourceFile, testTargetFile); |
| expect(updated).toBe(true); |
| expect(FileUpdater.updatePathWithStatsCalls.length).toBe(1); |
| expect(FileUpdater.updatePathWithStatsCalls[0][0]).toBe(testSourceFile); |
| expect(FileUpdater.updatePathWithStatsCalls[0][1]).toEqual(testFileStats2); |
| expect(FileUpdater.updatePathWithStatsCalls[0][2]).toBe(testTargetFile); |
| expect(FileUpdater.updatePathWithStatsCalls[0][3]).toBeNull(); |
| expect(FileUpdater.updatePathWithStatsCalls[0][4]).toBeUndefined(); |
| }); |
| it('Test 035 : should create the target\'s parent directory if it doesn\'t exist', |
| function () { |
| mockFs.statMap[path.join(testRootDir, testSourceFile)] = testFileStats2; |
| var updated = FileUpdater.updatePath( |
| testSourceFile, testTargetFile, { rootDir: testRootDir }); |
| expect(updated).toBe(true); |
| expect(FileUpdater.updatePathWithStatsCalls.length).toBe(1); |
| expect(FileUpdater.updatePathWithStatsCalls[0][0]).toBe(testSourceFile); |
| expect(FileUpdater.updatePathWithStatsCalls[0][1]).toEqual(testFileStats2); |
| expect(FileUpdater.updatePathWithStatsCalls[0][2]).toBe(testTargetFile); |
| expect(FileUpdater.updatePathWithStatsCalls[0][3]).toBeNull(); |
| expect(FileUpdater.updatePathWithStatsCalls[0][4]).toEqual({ rootDir: testRootDir }); |
| expect(mockFs.mkdirPaths.length).toBe(1); |
| expect(mockFs.mkdirPaths[0]).toBe(testRootDir); |
| }); |
| }); |
| |
| describe('mergeAndUpdateDir method', function () { |
| it('Test 036 : should update files from merged source directories', function () { |
| mockFs.statMap[testTargetDir] = testDirStats; |
| mockFs.dirMap[testTargetDir] = [testSubDir]; |
| mockFs.statMap[path.join(testTargetDir, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(testTargetDir, testSubDir)] = [testSourceFile]; |
| mockFs.statMap[path.join(testTargetDir, testSubDir, testSourceFile)] = |
| testFileStats; |
| |
| mockFs.statMap[testSourceDir] = testDirStats; |
| mockFs.dirMap[testSourceDir] = [testSubDir]; |
| mockFs.statMap[path.join(testSourceDir, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(testSourceDir, testSubDir)] = [testSourceFile]; |
| mockFs.statMap[path.join(testSourceDir, testSubDir, testSourceFile)] = |
| testFileStats2; |
| |
| mockFs.statMap[testSourceDir2] = testDirStats; |
| mockFs.dirMap[testSourceDir2] = [testSubDir]; |
| mockFs.statMap[path.join(testSourceDir2, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(testSourceDir2, testSubDir)] = [testSourceFile2]; |
| mockFs.statMap[path.join(testSourceDir2, testSubDir, testSourceFile2)] = |
| testFileStats3; |
| |
| var updated = FileUpdater.mergeAndUpdateDir( |
| [testSourceDir, testSourceDir2], testTargetDir); |
| expect(updated).toBe(true); |
| expect(FileUpdater.updatePathWithStatsCalls.length).toBe(4); |
| |
| function validateUpdatePathWithStatsCall ( |
| index, subPath, sourceDir, sourceStats, targetDir, targetStats) { |
| var args = FileUpdater.updatePathWithStatsCalls[index]; |
| expect(args[0]).toBe(path.join(sourceDir, subPath)); |
| expect(args[1]).toEqual(sourceStats); |
| expect(args[2]).toBe(path.join(targetDir, subPath)); |
| expect(args[3]).toEqual(targetStats); |
| expect(args[4]).toBeUndefined(); |
| } |
| |
| // Update the root directory. |
| validateUpdatePathWithStatsCall( |
| 0, |
| '', |
| testSourceDir2, |
| testDirStats, |
| testTargetDir, |
| testDirStats); |
| // Update the subdirectory. |
| validateUpdatePathWithStatsCall( |
| 1, |
| testSubDir, |
| testSourceDir2, |
| testDirStats, |
| testTargetDir, |
| testDirStats); |
| // Update the first file, from the first source. |
| validateUpdatePathWithStatsCall( |
| 2, |
| path.join(testSubDir, testSourceFile), |
| testSourceDir, |
| testFileStats2, |
| testTargetDir, |
| testFileStats); |
| // Update the second file, from the second source. |
| validateUpdatePathWithStatsCall( |
| 3, |
| path.join(testSubDir, testSourceFile2), |
| testSourceDir2, |
| testFileStats3, |
| testTargetDir, |
| null); |
| }); |
| |
| it('Test 037 : should update files from merged source directories - with a rootDir', function () { |
| var rootDir = path.join('Users', 'me'); |
| mockFs.statMap[rootDir] = testDirStats; |
| mockFs.dirMap[rootDir] = [testSourceDir, testSourceDir2, testTargetDir]; |
| |
| mockFs.statMap[path.join(rootDir, testTargetDir)] = testDirStats; |
| mockFs.dirMap[path.join(rootDir, testTargetDir)] = [testSubDir]; |
| mockFs.statMap[path.join(rootDir, testTargetDir, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(rootDir, testTargetDir, testSubDir)] = [testSourceFile]; |
| mockFs.statMap[path.join(rootDir, testTargetDir, testSubDir, testSourceFile)] = |
| testFileStats; |
| |
| mockFs.statMap[path.join(rootDir, testSourceDir)] = testDirStats; |
| mockFs.dirMap[path.join(rootDir, testSourceDir)] = [testSubDir]; |
| mockFs.statMap[path.join(rootDir, testSourceDir, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(rootDir, testSourceDir, testSubDir)] = [testSourceFile]; |
| mockFs.statMap[path.join(rootDir, testSourceDir, testSubDir, testSourceFile)] = |
| testFileStats2; |
| |
| mockFs.statMap[path.join(rootDir, testSourceDir2)] = testDirStats; |
| mockFs.dirMap[path.join(rootDir, testSourceDir2)] = [testSubDir]; |
| mockFs.statMap[path.join(rootDir, testSourceDir2, testSubDir)] = testDirStats; |
| mockFs.dirMap[path.join(rootDir, testSourceDir2, testSubDir)] = [testSourceFile2]; |
| mockFs.statMap[path.join(rootDir, testSourceDir2, testSubDir, testSourceFile2)] = |
| testFileStats3; |
| |
| var updated = FileUpdater.mergeAndUpdateDir( |
| [testSourceDir, testSourceDir2], testTargetDir, { rootDir: rootDir }); |
| expect(updated).toBe(true); |
| expect(FileUpdater.updatePathWithStatsCalls.length).toBe(4); |
| |
| function validateUpdatePathWithStatsCall ( |
| index, subPath, sourceDir, sourceStats, targetDir, targetStats) { |
| var args = FileUpdater.updatePathWithStatsCalls[index]; |
| expect(args[0]).toBe(path.join(sourceDir, subPath)); |
| expect(args[1]).toEqual(sourceStats); |
| expect(args[2]).toBe(path.join(targetDir, subPath)); |
| expect(args[3]).toEqual(targetStats); |
| expect(args[4]).toBeDefined(); // rootDir is defined |
| } |
| |
| // Update the root directory. |
| validateUpdatePathWithStatsCall( |
| 0, |
| '', |
| testSourceDir2, |
| testDirStats, |
| testTargetDir, |
| testDirStats); |
| // Update the subdirectory. |
| validateUpdatePathWithStatsCall( |
| 1, |
| testSubDir, |
| testSourceDir2, |
| testDirStats, |
| testTargetDir, |
| testDirStats); |
| // Update the first file, from the first source. |
| validateUpdatePathWithStatsCall( |
| 2, |
| path.join(testSubDir, testSourceFile), |
| testSourceDir, |
| testFileStats2, |
| testTargetDir, |
| testFileStats); |
| // Update the second file, from the second source. |
| validateUpdatePathWithStatsCall( |
| 3, |
| path.join(testSubDir, testSourceFile2), |
| testSourceDir2, |
| testFileStats3, |
| testTargetDir, |
| null); |
| }); |
| |
| }); |
| }); |
