TypeError: Cannot read property '_default' of undefined
        at node_modules/bardjs/dist/bard.js:560:37

  var value = configKeys.indexOf(key) > -1 ?
                config[key] : config._default;

preprocessors: {
        '../Templates/**/*.html' : ['ng-html2js']
    },

    ngHtml2JsPreprocessor: {
        // setting this option will create only a single module that contains templates
        // from all the files, so you can load them all with  angular.mock.module('foo')

        stripPrefix: "Templates/",
        prependPrefix: "/",
        moduleName: 'templatesCached'
    },

bard.appModule('templatesCached');
bard.appModule('ha.module.core');

Error: [$injector:modulerr] Failed to instantiate module function fakeRouteProvider($provide) due to:
TypeError: sinon.stub is not a function
    at new <anonymous> 

FAILED TESTS:
  LookupTestController
    ✖ "before each" hook for "should say hello"
      PhantomJS 1.9.8 (Linux 0.0.0)
    TypeError: 'undefined' is not a function (evaluating 'bard.appModule('lookup-test')')
        at /var/www/query_tool/web/bundles/test/js/specs/lookup.controller.spec.js:17

module.exports = function(config) {
  config.set({

    // base path that will be used to resolve all patterns (eg. files, exclude)
    basePath: '',


    // frameworks to use
    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
    frameworks: ['mocha','chai-as-promised','chai','sinon', 'sinon-chai'],

    files: [

      // add test polyfills (Promise)
      'web/bundles/test/js/Promise.js',
      'web/bundles/test/js/function.bind.polyfill.js',

      // module dependencies and angular mocks library
      'node_modules/angular/angular.js',
      'node_modules/angular-mocks/angular-mocks.js',
      'node_modules/angular-ui-select/select.js',
      'node_modules/bardjs/dist/bard.min.js',

      // add each js file which will be tested
      'web/bundles/test/js/myController.js',

      // testing lookup interface
      'web/bundles/test/js/ng-lodash.js',

      // loads all module dependencies (controller, filter, service, factory)
      'web/bundles/test/js/lookup.*.js',

      // reference spec directory (all specs will be run)
      'web/bundles/test/js/specs/**/*.spec.js'
    ],


    // list of files to exclude
    exclude: [
    ],


    // preprocess matching files before serving them to the browser
    // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
    preprocessors: {
    },


    // test results reporter to use
    // possible values: 'dots', 'progress'
    // available reporters: https://npmjs.org/browse/keyword/karma-reporter
    reporters: ['progress', 'mocha-clean'],


    // web server port
    port: 9876,


    // enable / disable colors in the output (reporters and logs)
    colors: true,


    // level of logging
    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
    logLevel: config.LOG_INFO,


    // enable / disable watching file and executing tests whenever any file changes
    autoWatch: true,


    // start these browsers
    // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
    browsers: ['PhantomJS'],


    // Continuous Integration mode
    // if true, Karma captures browsers, runs the tests and exits
    singleRun: false,

    // Concurrency level
    // how many browser should be started simultaneous
    concurrency: Infinity
  })
}

angular.module('app.core')
   .factory('PeopleService', PeopleService)

  function PeopleService($http, $q, $filter) {

    var endpoint;
    var service = {
      customers: {
        value: null
      },
      getAllCustomers: getAllCustomers,
    };

    return service;

    function getCustomers(endpoint_) {
      endpoint = endpoint_;
      service.customers.value = [];

      return handleFetch($http.get(endpoint));
    }

    function handleFetch(promise) {
      return promise.then(function (resp) {
        service.customers.value = service.customers.value.concat(resp.data.data);
      });
    }

    function getAllCustomers() {
      return $q.all([
        getCustomers('/api/customers'),
      ]).then(function(responses) {
        return responses[0];
      });
    }
  }

angular.module('app.people')
    .controller('peopleCtrl', peopleCtrl);

function peopleCtrl($scope, PeopleService) {
    $scope.customers = PeopleService.customers;

    getCustomers();

    function getCustomers() {
      return PeopleService.getAllCustomers().then(function () {
        return PeopleService.customers.value;
      });
    }
}

describe('People Service', function () {
    var controller;
    var customers = mockData.getMockCustomers(); // my fake customers array

    beforeEach(function() {
      bard.appModule('app');
      bard.inject('$controller', '$q', '$rootScope', 'PeopleService');

      var ps = {
        getAllCustomers: function() {
          return $q.when(customers);
        }
      };

      controller = $controller('peopleCtrl', {
        $scope: $rootScope,
        PeopleService: ps
      });
    });

    it('should return an array of 5 customers', function() {
      $rootScope.$apply();
      expect($rootScope.customers).to.have.length(5);
    });
});

beforeEach(function() {
        bard.appModule('myModule');
        bard.inject(this, '$controller', '$log', '$q', '$rootScope');
    });

beforeEach(function() {
    bard.appModule('app');
    bard.inject(this, '$controller', '$httpBackend', '$log', '$q', '$rootScope', 'dataservice', 'peopleService');
  });

 "before each" hook for "should pass"
      PhantomJS 1.9.8 (Mac OS X 0.0.0)
    Error: [$injector:modulerr] Failed to instantiate module ng due to:
    TypeError: 'null' is not an object (evaluating 'this')

bard.inject('$controller', '$q', '$rootScope', 'serviceName');

bard.mockService(serviceName, {
    method: $q.when({})
});

'undefined' is not an object (evaluating 'service[key] = sinon.spy(function() {
    return value;
})')

"devDependencies": {
    "angular-mocks": "~1.4.0",
    "bardjs": "~0.1.3",
    "sinon": "~1.14.1"
}

karma start karma.conf.js

frameworks: ['mocha', 'chai', 'sinon', 'chai-sinon'],

files: [
  ...

  '../../node_modules/sinon/lib/sinon.js',
  '../../node_modules/bardjs/dist/bard.js',

  ...
],

angular
    .module('app.upload',['angularFileUpload'])
    .controller('UploadController', UploadController);

UploadController.$inject = ['logger','FileUploader','$scope'];
/* @ngInject */
function UploadController(logger, FileUploader, scope) {
    var vm = this;
    vm.title = 'Upload';

    var uploader  = scope.uploader = new FileUploader({
        url: '/upload'
    });

    activate();

    function activate() {
        logger.info('Activated Upload View');
    }

    // FILTERS

    uploader.filters.push({
        name: 'customFilter',
        fn: function(item /*{File|FileLikeObject}*/, options) {
            return this.queue.length < 10;
        }
    });

    // CALLBACKS

    uploader.onWhenAddingFileFailed = function(item /*{File|FileLikeObject}*/, filter, options) {
        console.info('onWhenAddingFileFailed', item, filter, options);
    };
    uploader.onAfterAddingFile = function(fileItem) {
        console.info('onAfterAddingFile', fileItem);
    };
    uploader.onAfterAddingAll = function(addedFileItems) {
        console.info('onAfterAddingAll', addedFileItems);
    };
    uploader.onBeforeUploadItem = function(item) {
        console.info('onBeforeUploadItem', item);
    };
    uploader.onProgressItem = function(fileItem, progress) {
        console.info('onProgressItem', fileItem, progress);
    };
    uploader.onProgressAll = function(progress) {
        console.info('onProgressAll', progress);
    };
    uploader.onSuccessItem = function(fileItem, response, status, headers) {
        console.info('onSuccessItem', fileItem, response, status, headers);
    };
    uploader.onErrorItem = function(fileItem, response, status, headers) {
        console.info('onErrorItem', fileItem, response, status, headers);
    };
    uploader.onCancelItem = function(fileItem, response, status, headers) {
        console.info('onCancelItem', fileItem, response, status, headers);
    };
    uploader.onCompleteItem = function(fileItem, response, status, headers) {
        console.info('onCompleteItem', fileItem, response, status, headers);
    };
    uploader.onCompleteAll = function() {
        console.info('onCompleteAll');
    };

    console.info('uploader', uploader);

}

beforeEach(function() {
    bard.appModule('app.upload');
    bard.inject('$controller', '$log', '$rootScope');
});

beforeEach(function () {
    controller = $controller('UploadController');
    $rootScope.$apply();
});

bard.verifyNoOutstandingHttpRequests();

describe('Upload controller', function() {

    it('should be created successfully', function () {

        expect(controller).to.be.defined;
    });

    describe('after activate', function() {
        it('should have title of Upload', function() {
            expect(controller.title).to.equal('Upload');
        });

        it('should have logged "Activated"', function() {
            expect($log.info.logs).to.match(/Activated/);
        });
    });
});

beforeEach(function () {
    bard.appModule('mmApp.core');
    bard.inject(this, '$q',
                'userProgressService',
                'surveyDataService',
                'userInputService',
                '$state');
    bard.mockService($state);
});

bard.mockService($state, {
    go : sinon.stub()
});

PhantomJS 1.9.8 (Mac OS X) Template Controller "before each" hook FAILED
    TypeError: 'undefined' is not a function (evaluating 'getCtxFromArgs.bind(this)')
        at bardInject (/Users/lodnert/projects/myapp/app/bower_components/bardjs/dist/bard.js:277)
        at /Users/lodnert/projects/myapp/test/spec/app/registry/template.controller.js:8
PhantomJS 1.9.8 (Mac OS X): Executed 1 of 1 (1 FAILED) ERROR (0.002 secs / 0 secs)

describe('Controller: Auth', function () {
  var controller;
  beforeEach(function() {

      bard.appModule('myapp.auth');
      bard.inject('$controller', '$rootScope');

  });



  it('should be created successfully', function () {
    expect('hello').toBeDefined();
  });

});

// current: {},  // fake before each test as needed
// state:  {}  // fake before each test as needed
// more? You'll know when it fails :-)
_faked: 'this is the faked $state service'

var isFirstCall = true;
function myReplacementFunc(){
    if(isFirstCall){
        isFirstCall = false;
        return {test:"value"};
    }else{
        return undefined;
    }
}
mockService(MyService, {
    get: myReplacementFunc
}

expect(MyService.get).toHaveBeenCalledOnce();

Expected spy "function myReplacementFunc() {
        if (isFirstCall ) {
            isFirstCall = false;
            return { test: "value" };
        } else {
            return undefined;
        }
    }" to have been called twice. "function myReplacementFunc() {
        if (isFirstCall ) {
            isFirstCall = false;
            return { test: "value" };
        } else {
            return undefined;
        }
    }" was called 0 times.

sinon.stub(MyService, 'get', myReplacementFunc);

service[key] = value;

sinon.stub(service, key, value);

describe('Customer Controller', function () {
    var controller;
    var customers = mockData.getMockCustomers(); // fake customers (5 customers)

    beforeEach(function() {
      bard.appModule('app');
      bard.inject('$controller', '$q', '$rootScope');

      var cs = {
        getCustomers: function() {
          return $q.when(customers);
        }
      };

      controller = $controller('scoreListCtrl', {
        CustomerService: cs
      });
    });

    it('should return 5 customers', function() {
      $rootScope.$apply();
      expect(controller.customers).to.have.length(5);
    });
});

function customersCtrl(dataservice) {
  var vm = this;
  vm.customers = [];

  fetchCustomers();

  function fetchCustomers() {
    return dataservice.getCustomers()
    .then(function(data) {
      vm.customers = data.data;
      return vm.customers ;
    });
  }
}

$ bower install bardjs
$ ...
$ cd bower_components/bardjs/dist
$ ls

Unable to find a suitable version for angular, please choose one:
1) angular#~1.3.8 which resolved to 1.3.16 and is required by bardjs#0.1.3
2) angular#1.3.16 which resolved to 1.3.16 and is required by angular-mocks#1.3.16
3) angular#>=1.3.0 which resolved to 1.4.0 and is required by angular-bootstrap#0.13.0, angular-toastr#1.4.1
4) angular#~1.4.0 which resolved to 1.4.0 and is required by manage-my-money-client
5) angular#>= 1.0.8 which resolved to 1.4.0 and is required by angular-ui-router#0.2.15
6) angular#1.4.0 which resolved to 1.4.0 and is required by angular-animate#1.4.0

 class MyService {

        doAThing(){
            return 'bad';
        }

    }

////

        bard.appModule('app');

        bard.inject(this, 'MyService');
        bard.mockService(MyService, {
            _default: false
        });

    it('returns the proper values', ()=> {
        expect(MyService.doAThing()).toBe(false);
    })

  function MyService() {
        var returnBad = function () {
            return 'bad';
        };
        this.doAThing = returnBad;
    }

////

        bard.appModule('app');

        bard.inject(this, 'MyService');
        bard.mockService(MyService, {
            _default: false
        });

    it('returns the proper values', ()=> {
        expect(MyService.doAThing()).toBe(false);
    })

(function () {

    'use strict';

    angular
        .module('test', [])
        .controller("TestCtrl", testController);

    testController.$inject = ["$scope"];

    function testController($scope) {

        console.log("TestCtrl Constructor");

        var vm = this;
        vm.activate = activate;
        vm.activate();

        function activate() {
            console.log("TestCtrl activate");

            angular.extend($scope, {
                mapBounds: [0, 0]
            });

        }
    }

})();

describe("TestController Test 2", function () {

    var controller;
    var scope;

    beforeEach(function () {
        bard.appModule('test');
        bard.inject('$controller', '$log', '$q', '$rootScope', function ($rootScope) {
            scope = $rootScope.$new();
            return { $scope: scope };
        });
    });

    beforeEach(function () {
        controller = $controller('TestCtrl');
    });

    describe('Test 2', function () {
        it('should be created successfully', function () {
            expect(false).to.be.true;
            expect(controller).to.be.defined;
        });

    });

});

Error: [$injector:unpr] http://errors.angularjs.org/1.4.8/$injector/unpr?
p0=$scopeProvider <- $scope <- TestCtrl
        at Error (native)

beforeEach(function() {
                bard.appModule('testingApp');
                bard.inject('Api', '$rootScope', '$q', '$httpBackend'); //first include Api

                testData = [
                    "post1", "post2", "post3"
                ];

        //second mock the Api
                bard.mockService(Api, {
                    getPosts: $q.when(testData)
                });

                //third inject the PostService which has Api as a dependency
                bard.inject('PostService');

                $httpBackend.whenGET(/\.*./).respond({anything: 123});
            });

function PostService(Api) {

        var svc = this;

        svc.posts = null;

        ////////////////////////// Init

        init();

        function init() {
            Api.getPosts()
                .then(function(result) {
                    svc.posts = result;
                })
        }
    }

function Api($http) {

        var svc = this;
        var root = 'http://jsonplaceholder.typicode.com';

        // Functions

        svc.getPosts = getPosts;

        ////////////////////////// Implementation

        function getPosts() {
            return $http({
                method: 'GET',
                url: root + '/posts'
            })
        }
    }

it('should initially set the posts to null', function() {
                expect(PostService.posts).toBeNull();
            });

            it('should resolve a promise correctly', function() {
                $rootScope.$apply();
                expect(PostService.posts).toEqual(testData);
            });

var mockApi, $rootScope, PostService, testData, $httpBackend;

            beforeEach(function() {
                mockApi = {};

                testData = {
                    "data": [1, 2, 3]
                };

                module('testingApp', function($provide) {
                    $provide.value('Api', mockApi);
                });

                inject(function($q) {
                    mockApi.getPosts = function() {
                        return $q.when(testData);
                    }
                });

            });

            beforeEach(inject(function(_$rootScope_, _PostService_, _$httpBackend_) {
                $rootScope = _$rootScope_;
                PostService = _PostService_;
                $httpBackend = _$httpBackend_;

                $httpBackend.whenGET(/http\.*/).respond({anything: 123});
            }));

var testData;

            beforeEach(function() {
                bard.appModule('testingApp');
                bard.inject('PostService', 'Api', '$rootScope', '$q', '$httpBackend');

                testData = [
                    "post1", "post2", "post3"
                ];

                bard.mockService(Api, {
                    getPosts: $q.when(testData) // also tried with function() { $q.when(testData) }) - no success
                });

                $httpBackend.whenGET(/\.*./).respond({anything: 123});
            });

Error: [$injector:modulerr] Failed to instantiate module function fakeRouteProvider($provide) due to:
    TypeError: 'undefined' is not a function (evaluating 'sinon.stub()')
        at /Users/bbohling/Projects/itdz/itdz-ui/app/bower_components/bardjs/dist/bard.js:377

describe('itdz', function() {
    var controller;
    var page = mockPage.getPage();

    beforeEach(function() {
        bard.appModule('itdz');
        bard.inject('$controller', '$q', '$rootScope', 'pageService');
    });

    beforeEach(function() {
        sinon.stub(pageService, 'slug').returns($q.when(page));
        controller = $controller('Content');
        $rootScope.$apply();
    });

    bard.verifyNoOutstandingHttpRequests();

    describe('Content controller', function() {
        it('should be created successfully', function () {
            expect(controller).to.be.defined;
        });

        describe('after activate', function() {
            it('should have called pageService.slug 1 time', function () {
                expect(pageService.slug).to.have.been.calledOnce;
            });

        });
    });
});