blackberry10/node_modules/plugman/spec/platforms/common.spec.js

/*
 *
 *
 * Licensed 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 common = require('../../src/platforms/common')
  , path = require('path')
  , fs = require('fs')
  , osenv = require('osenv')
  , shell = require('shelljs')
  , test_dir = path.join(osenv.tmpdir(), 'test_plugman') 
  , project_dir = path.join(test_dir, 'project')
  , src = path.join(project_dir, 'src')
  , dest = path.join(project_dir, 'dest')
  , java_dir = path.join(src, 'one', 'two', 'three')
  , java_file = path.join(java_dir, 'test.java');

describe('common platform handler', function() {
    describe('resolveSrcPath', function() {
        it('should throw if path cannot be resolved', function(){  
            expect(function(){common.resolveSrcPath(test_dir, 'I_dont_exist')}).toThrow();
        });
        
        it('should not throw if path exists', function(){
            shell.mkdir('-p', test_dir);
            var target = path.join(test_dir, 'somefile');
            fs.writeFileSync(target, '80085', 'utf-8');
            expect(function(){common.resolveSrcPath(test_dir, 'somefile')}).not.toThrow();
            shell.rm('-rf', test_dir);
        });
    });

    describe('resolveTargetPath', function() {
        it('should throw if path exists', function(){
            shell.mkdir('-p', test_dir);
            expect(function(){common.resolveTargetPath(test_dir)}).toThrow();
            shell.rm('-rf', test_dir);
        });
        
        it('should not throw if path cannot be resolved', function(){
            expect(function(){common.resolveTargetPath(test_dir, 'somefile')}).not.toThrow();
        });
    });

    describe('copyFile', function() {    
        it('should throw if source path cannot be resolved', function(){
            expect(function(){common.copyFile(test_dir, src, project_dir, dest)}).toThrow();
        });
        
        it('should throw if target path exists', function(){
            shell.mkdir('-p', dest);
            expect(function(){common.copyFile(test_dir, src, project_dir, dest)}).toThrow();
            shell.rm('-rf', dest);
        });
        
        it('should call mkdir -p on target path', function(){
            shell.mkdir('-p', java_dir);
            fs.writeFileSync(java_file, 'contents', 'utf-8');
            
            var s = spyOn(shell, 'mkdir').andCallThrough();
            var resolvedDest = common.resolveTargetPath(project_dir, dest);
            
            common.copyFile(test_dir, java_file, project_dir, dest);
            
            expect(s).toHaveBeenCalled();
            expect(s).toHaveBeenCalledWith('-p', path.dirname(resolvedDest));
            shell.rm('-rf', project_dir);            
        });
            
        it('should call cp source/dest paths', function(){
            shell.mkdir('-p', java_dir);
            fs.writeFileSync(java_file, 'contents', 'utf-8');
            
            var s = spyOn(shell, 'cp').andCallThrough();
            var resolvedDest = common.resolveTargetPath(project_dir, dest);
            
            common.copyFile(test_dir, java_file, project_dir, dest);
            
            expect(s).toHaveBeenCalled();
            expect(s).toHaveBeenCalledWith(java_file, resolvedDest);

            shell.rm('-rf', project_dir);         
        });

    });

    describe('deleteJava', function() {
        it('should call fs.unlinkSync on the provided paths', function(){
            shell.mkdir('-p', java_dir);
            fs.writeFileSync(java_file, 'contents', 'utf-8');
            
            var s = spyOn(fs, 'unlinkSync').andCallThrough();
            common.deleteJava(project_dir, java_file); 
            expect(s).toHaveBeenCalled();
            expect(s).toHaveBeenCalledWith(path.resolve(project_dir, java_file));
            
            shell.rm('-rf', java_dir);
        });
        
        it('should delete empty directories after removing source code in a java src path heirarchy', function(){
            shell.mkdir('-p', java_dir);
            fs.writeFileSync(java_file, 'contents', 'utf-8');
            
            common.deleteJava(project_dir, java_file); 
            expect(fs.existsSync(java_file)).not.toBe(true);
            expect(fs.existsSync(java_dir)).not.toBe(true);
            expect(fs.existsSync(path.join(src,'one'))).not.toBe(true);
            
            shell.rm('-rf', java_dir);
        });
        
        it('should never delete the top-level src directory, even if all plugins added were removed', function(){
            shell.mkdir('-p', java_dir);
            fs.writeFileSync(java_file, 'contents', 'utf-8');
            
            common.deleteJava(project_dir, java_file); 
            expect(fs.existsSync(src)).toBe(true);
            
            shell.rm('-rf', java_dir);
        });
    });
});