test(staging): add util and staging tests

Adds tests to staging and util areas of the codebase

Author: jimthedev

common/util.js

@@ -42,21 +42,42 @@ function getParsedPackageJsonFromPath(path) {
  * Test if the passed argument is an array
  */
 function isArray(arr) {
-  return arr.constructor === Array;
+    if(typeof arr === "undefined")
+  {
+    return false;
+  } else if (arr === null) {
+    return false;
+  } else {
+    return arr.constructor === Array;
+  }
 }
 
 /**
  * Test if the passed argument is a function 
  */
 function isFunction(functionToCheck) {
- var getType = {};
- return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
+  if(typeof functionToCheck === "undefined")
+  {
+    return false;
+  } else if (functionToCheck === null) {
+    return false;
+  } else {
+    var getType = {};
+    return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]'; 
+  }
 }
 
 /**
  * Test if the passed argument is a string
  */
 function isString(str) {
-  return Object.prototype.toString.call(str) == '[object String]';
+  if(typeof str === "undefined")
+  {
+    return false;
+  } else if (str === null) {
+    return false;
+  } else {
+    return Object.prototype.toString.call(str) == '[object String]';
+  }
 }
 

src/git/commit.js

@@ -20,6 +20,10 @@ function commit(sh, repoPath, message, options, done) {
 
     // Write progress to the screen
     .on('data',function(data) {
+      
+      // Ignore this for code coverage since it is only there 
+      // to make our testing suite pretty
+      /* istanbul ignore if  */
       if(!options.quiet) {
         if(isString(data))
         {

test/tests/commit-missing-adapter.js

@@ -1,2 +1,4 @@
+import './commit';
 import './init';
-import './commit';
+import './staging';
+import './util';

test/tests/index.js

@@ -0,0 +1,80 @@
+import {expect} from 'chai';
+import path from 'path';
+import fs from 'fs';
+
+
+// Bootstrap our tester
+import {bootstrap} from '../tester';
+
+// Get our source files
+import {init as gitInit, addPath as gitAdd, log} from '../../src/git';
+import {init as commitizenInit, staging} from '../../src/commitizen';
+
+// Destructure some things for cleaner tests
+let { config, sh, repo, clean, util, files } = bootstrap();
+let { writeFilesToPath } = files;
+
+before(function() {
+  // Creates the temp path
+  clean.before(sh, config.paths.tmp);
+});
+
+beforeEach(function() {
+  this.timeout(config.maxTimeout); // this could take a while
+  repo.createEndUser(sh, config.paths.endUserRepo);
+});
+
+describe('commit', function() {
+  
+  it('should determine if a repo is clean', function(done) {
+    
+    this.timeout(config.maxTimeout); // this could take a while
+    
+    // SETUP
+    
+    // Describe a repo and some files to add and commit
+    let repoConfig = {
+      path: config.paths.endUserRepo,
+      files: {
+        dummyfile: {
+            contents: `duck-duck-goose`,
+            filename: `mydummyfile.txt`,
+        },
+        gitignore: {
+          contents: `node_modules/`,
+          filename: `.gitignore`
+        }
+      }
+    };
+    
+    gitInit(sh, repoConfig.path);
+    
+    staging.isClean(repoConfig.path, function(stagingIsClean) {
+      
+      expect(stagingIsClean).to.be.true;
+      
+      writeFilesToPath(repoConfig.files, repoConfig.path);
+      
+      gitAdd(sh, repoConfig.path);
+      
+      staging.isClean(repoConfig.path, function(afterWriteStagingIsClean) {
+        expect(afterWriteStagingIsClean).to.be.false;
+        done();
+      });
+      
+    });
+
+  });
+
+});
+
+afterEach(function() {
+  // All this should do is archive the tmp path to the artifacts
+  clean.afterEach(sh, config.paths.tmp, config.preserve);
+}); 
+
+after(function() {
+  // Once everything is done, the artifacts should be cleaned up based on 
+  // the preserve setting in the config
+  clean.after(sh, config.paths.tmp, config.preserve);
+}); 

test/tests/staging.js

@@ -0,0 +1,70 @@
+import {expect} from 'chai';
+import {isArray, isFunction, isString} from '../../common/util';
+
+describe('common util', function() {
+  
+  it('isArray determines if array is passed', function() {
+    
+    // Truthies
+    expect(isArray([])).to.be.true;
+    expect(isArray([1, 2, 3])).to.be.true;
+    expect(isArray([1, , 3])).to.be.true;
+    expect(isArray(new Array())).to.be.true;
+    
+    // Falsies
+    expect(isArray(undefined)).to.be.false;
+    expect(isArray(null)).to.be.false;
+    expect(isArray(49)).to.be.false;
+    expect(isArray(function(){})).to.be.false;
+    expect(isArray({})).to.be.false;
+    expect(isArray("asdf")).to.be.false;
+    expect(isArray(true)).to.be.false;
+    expect(isArray(false)).to.be.false;
+    expect(isArray(Symbol())).to.be.false;
+    
+  });
+  
+  it('isFunction determines if a function is passed', function() {
+
+    // Truthies
+    expect(isFunction(function(){})).to.be.true;
+    expect(isFunction(new Function())).to.be.true;
+
+    // Falsies
+    expect(isFunction(undefined)).to.be.false;
+    expect(isFunction(null)).to.be.false;
+    expect(isFunction(49)).to.be.false;
+    expect(isFunction([])).to.be.false;
+    expect(isFunction({})).to.be.false;
+    expect(isFunction("asdf")).to.be.false;
+    expect(isFunction(true)).to.be.false;
+    expect(isFunction(false)).to.be.false;
+    expect(isFunction(Symbol())).to.be.false;
+    
+  });
+  
+  it('isString determines if string is passed', function() {
+    
+    // Truthies
+    expect(isString('a single quoted string')).to.be.true;
+    expect(isString("a double quoted string")).to.be.true;
+    expect(isString(`
+      a multi
+      line
+      string`
+    )).to.be.true;
+    expect(isString(new String())).to.be.true;
+
+    // Falsies
+    expect(isString(function(){})).to.be.false;
+    expect(isString(undefined)).to.be.false;
+    expect(isString(null)).to.be.false;
+    expect(isString(49)).to.be.false;
+    expect(isString([])).to.be.false;
+    expect(isString({})).to.be.false;
+    expect(isString(true)).to.be.false;
+    expect(isString(false)).to.be.false;
+    expect(isString(Symbol())).to.be.false;
+    
+  });  
+});