fs-utilities/test/fsTest.js

utility module for interacting with the file system e.g. asynchronously retreiving list of folders

var assert = require('assert');
var path = require('path');

var testObject = require('../src/fs.js');


var NOT_EXISTING_FILE = "notExistingFile.txt";
var NOT_EXISTING_PATH = "./not/existing/path";


describe('utilities.fs', function(){
    describe('checkIfIsDirectorySync', function(){
        it('should return true', function(){
            assert.equal( true, testObject.checkIfIsDirectorySync( __dirname ) );
        });

        it('should return false', function(){
            assert.equal( false, testObject.checkIfIsDirectorySync( __filename ) );
        });

        it('should throw exception', function(){
            assert.throws( function(){
                testObject.checkIfIsDirectorySync( NOT_EXISTING_FILE );
            });
        });
    });


    describe('checkIfIsDirectory', function(){
        it('should return true', function( done ){
            testObject.checkIfIsDirectory( __dirname, function( err, folder ){
                assert.strictEqual( err, null );
                assert.strictEqual( folder, __dirname );
                done();
            });
        });

        it('should return false', function( done ){
            testObject.checkIfIsDirectory( __filename, function( err, folder ){
                assert.notStrictEqual( err, null );
                assert.notStrictEqual( folder, __filename );
                done();
            });
        });

        it('should return with error', function(){

            testObject.checkIfIsDirectory( NOT_EXISTING_FILE, function( err, folder ){
                assert.notStrictEqual( err, null );
                assert.notStrictEqual( folder, NOT_EXISTING_FILE );
                done();
            });
        });
    });


    describe('getSubfoders', function(){
        it("should find 'testdata'", function( done ){
            var expectedFolders = [ path.join(__dirname, 'testdata') ];

            testObject.getSubfoders( __dirname, function( err, folders ){
                assert.equal( err, null );
                assert.deepEqual( folders, expectedFolders );
                done();
            });
        });

        it("should return with error", function( done ){
            testObject.getSubfoders( __filename, function( err, folders ){
                assert.notEqual( err, null );
                assert.strictEqual( folders, undefined );
                done();
            });
        });
    });


    describe('getSubfodersSync', function(){
        it("should find 'testdata'", function(){
            var expectedFolders = [ path.join(__dirname, 'testdata') ];
            var folders = testObject.getSubfodersSync( __dirname );
            assert.deepEqual( folders, expectedFolders );
        });

        it("should throw exception", function(){
            assert.throws( function(){
                testObject.getSubfodersSync( __filename );
            });
        });
    });


    describe('traverseAllSubFolders', function(){
        it("should find 'testdata', 'testfolder1' and 'testfolder2'", function( done ){
            var expectedFolders = [ path.join( __dirname, 'testdata' ),
                                    path.join( __dirname, 'testdata/testfolder1' ),
                                    path.join( __dirname, 'testdata/testfolder2' ) ];
            var foundFolders = [];

            testObject.traverseAllSubFolders( __dirname, function( folder ){
                foundFolders.push( folder );
            }, [], function( err ){
                assert.equal( err, null );
                assert.deepEqual( foundFolders, expectedFolders );
                done();
            });
        });

        it("should find 'testdata' and 'testfolder1'", function( done ){
            var expectedFolders = [ path.join( __dirname, 'testdata' ),
                                    path.join( __dirname, 'testdata/testfolder1' ) ];
            var foundFolders = [];

            testObject.traverseAllSubFolders( __dirname, function( folder ){
                foundFolders.push( folder );
            }, ['testfolder2'], function( err ){
                assert.equal( err, null );
                assert.deepEqual( foundFolders, expectedFolders );
                done();
            });
        });

        it("should return with error", function( done ){
            var foundFolders = [];

            testObject.traverseAllSubFolders( __filename, function( folder ){
                foundFolders.push( folder );
            }, [], function( err ){
                assert.notEqual( err, null );
                assert.deepEqual( foundFolders, [] );
                done();
            });
        });
    });


    describe('traverseAllSubFoldersSync', function(){
        it("should find 'testdata', 'testfolder1' and 'testfolder2'", function(){
            var expectedFolders = [ path.join( __dirname, 'testdata' ),
                                    path.join( __dirname, 'testdata/testfolder1' ),
                                    path.join( __dirname, 'testdata/testfolder2' ) ];
            var foundFolders = [];

            testObject.traverseAllSubFoldersSync( __dirname, function( folder ){
                foundFolders.push( folder );
            });

            assert.deepEqual( foundFolders, expectedFolders );
        });

        it("should find 'testdata' and 'testfolder1'", function(){
            var expectedFolders = [ path.join( __dirname, 'testdata' ),
                                    path.join( __dirname, 'testdata/testfolder1' ) ];
            var foundFolders = [];

            testObject.traverseAllSubFoldersSync( __dirname, function( folder ){
                foundFolders.push( folder );
            }, ['testfolder2']);

            assert.deepEqual( foundFolders, expectedFolders );
        });
    });

});