puppet-herald 0.1.1 → 0.2.0

data/spec/unit/puppet-herald/client_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'webmock/rspec'
+require 'puppet-herald/client'
+
+describe PuppetHerald::Client, '.process' do
+  let(:payload) { { :zz => 65, :yh => 12 } }
+  let(:expected) { payload.to_yaml }
+  before :each do
+    stub_request(:post, "#{address}/api/v1/reports").with(:body => expected).
+      to_return(:body => "{id: 1}", :status => 201)
+  end
+  subject { client.process payload }
+  context 'on defaults' do
+    let(:address) { 'localhost:11303' }
+    let(:client) { PuppetHerald::Client.new }
+    it { expect(subject).to be_truthy }
+  end
+  context 'on other host:port' do
+    let(:address) { 'master.secure.vm:8082' }
+    let(:client) { PuppetHerald::Client.new('master.secure.vm', 8082) }
+    it { expect(subject).to be_truthy }
+  end
+end

data/spec/unit/puppet-herald/database_spec.rb

@@ -1,34 +1,33 @@
 require 'spec_helper'
 require 'puppet-herald'
-require 'puppet-herald/database'
 
 describe PuppetHerald::Database, '.spec' do
   let(:tempdir) { Dir.tmpdir }
   let(:echo) { false }
-  subject { PuppetHerald::Database::spec echo }
+  subject { PuppetHerald::database::spec echo }
   context 'with invalid dbconn' do
     before :each do
-      PuppetHerald::Database::dbconn = "#{tempdir}/non-existing.db"
+      PuppetHerald::database::dbconn = "#{tempdir}/non-existing.db"
     end
     it { expect { subject }.to raise_error(RuntimeError, /Invalid database connection string given/) }
   end
   context 'using sqlite' do
     context 'with non existing database' do
       before :each do
-        PuppetHerald::Database::dbconn = 'sqlite:///non-existing/non-existing.db'
+        PuppetHerald::database::dbconn = 'sqlite:///non-existing/non-existing.db'
       end
       it { expect { subject }.to raise_error(Errno::ENOENT, /No such file or directory/) }
     end
     context 'with creatable database file' do
       before :each do
-        PuppetHerald::Database::dbconn = "sqlite://#{tempdir}/non-existing.db"
+        PuppetHerald::database::dbconn = "sqlite://#{tempdir}/non-existing.db"
       end
       its(:class) { should be Hash }
       its(:size) { should eq 2 }
       context 'while echoing!!' do
         let(:echo) { true }
         before :each do
-          PuppetHerald::Database::logger.level = Logger::FATAL
+          PuppetHerald::database::logger.level = Logger::FATAL
         end
         its(:class) { should be Hash }
         its(:size) { should eq 2 }
@@ -37,17 +36,17 @@ describe PuppetHerald::Database, '.spec' do
   end
   context 'using postgres' do
     before :each do
-      PuppetHerald::Database::dbconn = "postgres://abc@localhost:6543/adb"
+      PuppetHerald::database::dbconn = "postgres://abc@localhost:6543/adb"
     end
     context 'with non existing passfile' do
       before :each do
-        PuppetHerald::Database::passfile = "/non-existing/passfile"
+        PuppetHerald::database::passfile = "/non-existing/passfile"
       end
       it { expect { subject }.to raise_error(Errno::ENOENT, /No such file or directory/) }
     end
     context 'with existing passfile' do
       before :each do
-        PuppetHerald::Database::passfile = __FILE__
+        PuppetHerald::database::passfile = __FILE__
       end
       its(:class) { should be Hash }
       its(:size) { should eq 7 }

data/spec/unit/puppet-herald/javascript_spec.rb

@@ -3,16 +3,14 @@ require 'puppet-herald'
 require 'puppet-herald/javascript'
 
 describe PuppetHerald::Javascript, '.files' do
+  subject { PuppetHerald::Javascript.new }
   context 'running in dev environment' do
     before :each do
-      expect(PuppetHerald).to receive(:is_in_dev?).twice.and_return true
+      expect(PuppetHerald).to receive(:in_dev?).twice.and_return true
       expect(Dir).to receive(:glob).twice.and_return(['aaa.js', 'a/bbb.js', 'ccc_test.js'])
-      PuppetHerald::Javascript::files
+      subject.files
     end
-    after :each do
-      PuppetHerald::Javascript::class_variable_set '@@files', nil
-    end
-    let(:files) { PuppetHerald::Javascript::files }
+    let(:files) { subject.files }
     it { files.size.should eq 2 }
     it { files.should include 'aaa.js' }
     it { files.should_not include 'ccc_test.js' }
@@ -20,14 +18,11 @@ describe PuppetHerald::Javascript, '.files' do
 
   context 'running in prod environment' do
     before :each do
-      expect(PuppetHerald).to receive(:is_in_dev?).twice.and_return false
+      expect(PuppetHerald).to receive(:in_dev?).twice.and_return false
       expect(Dir).to receive(:glob).once.and_return(['aaa.js', 'a/bbb.js', 'ccc_test.js'])
-      PuppetHerald::Javascript::files
-    end
-    after :each do
-      PuppetHerald::Javascript::class_variable_set '@@files', nil
+      subject.files
     end
-    let(:files) { PuppetHerald::Javascript::files }
+    let(:files) { subject.files }
     it { files.size.should eq 2 }
     it { files.should include 'aaa.js' }
     it { files.should_not include 'ccc_test.js' }
@@ -35,7 +30,7 @@ describe PuppetHerald::Javascript, '.files' do
 end
 
 describe PuppetHerald::Javascript, '.uglify' do
-  subject { PuppetHerald::Javascript::uglify 'myapp.js.map' }
+  subject { PuppetHerald::Javascript.new.uglify 'myapp.js.map' }
 
   it { subject.size.should eq 2 }
   it { subject['js'].should_not be_empty }

data/spec/unit/puppet-herald_spec.rb

@@ -37,8 +37,8 @@ describe PuppetHerald do
     describe '.environment' do
       it { subject::environment.should eq(:production) }
     end
-    describe '.is_in_prod?' do
-      it { subject.should be_is_in_prod }
+    describe '.in_prod?' do
+      it { subject.should be_in_prod }
     end
   end
 
@@ -49,8 +49,8 @@ describe PuppetHerald do
     describe '.environment' do
       it { subject::environment.should eq(:dev) }
     end
-    describe '.is_in_prod?' do
-      it { subject.should be_is_in_dev }
+    describe '.in_prod?' do
+      it { subject.should be_in_dev }
     end
   end
 end

data/test/javascript/karma.conf.js

@@ -1,13 +1,51 @@
 module.exports = function(config) {
   config.set({
+
+    basePath: '../..',
+
+    singleRun: true,
+
     frameworks: ['jasmine'],
 
+    reporters: ['story', 'coverage'],
+
+    preprocessors: {
+      // source files, that you wanna generate coverage for
+      // do not include tests or libraries
+      // (these files will be instrumented by Istanbul)
+      'lib/puppet-herald/public/**/*.js': ['coverage'],
+      'lib/puppet-herald/public/**/*.html': ['ng-html2js']
+    },
+
+    // optionally, configure the reporter
+    coverageReporter: {
+      dir : 'coverage/javascript',
+      reporters: [
+        // reporters not supporting the `file` property
+        { type: 'html', subdir: 'report-html' },
+        // reporters supporting the `file` property, use `subdir` to directly
+        // output them in the `dir` directory
+        { type: 'cobertura', subdir: '.', file: 'cobertura.txt' },
+        { type: 'text', subdir: '.', file: 'text.txt' },
+        { type: 'text-summary', subdir: '.', file: 'text-summary.txt' },
+      ]
+    },
+
+    ngHtml2JsPreprocessor: {
+      // strip this from the file path
+      stripPrefix: 'lib/puppet-herald/public/',
+    },
+
     files: [
-      '../../node_modules/angular/angular.js',
-      '../../node_modules/angular-loader/angular-loader.js',
-      '../../node_modules/angular-mocks/angular-mocks.js',
-      '../../node_modules/angular-route/angular-route.js',
-      '../../lib/puppet-herald/public/**/*_test.js'
+      'node_modules/angular/angular.js',
+      'node_modules/angular-loader/angular-loader.js',
+      'node_modules/angular-mocks/angular-mocks.js',
+      'node_modules/angular-route/angular-route.js',
+      'node_modules/moment/moment.js',
+      'node_modules/angular-moment/angular-moment.js',
+      'lib/puppet-herald/public/**/*.js',
+      'lib/puppet-herald/public/**/*.html',
+      'test/javascript/src/**/*.js'
     ]
   });
 };

data/test/javascript/src/app_test.js

@@ -0,0 +1,90 @@
+'use strict';
+
+describe('herald module', function() {
+  beforeEach(module('herald'));
+
+  describe('AppController', function() {
+    var controller, scope, Page;
+    beforeEach(inject(function(_$controller_, _Page_) {
+      var $controller = _$controller_;
+      scope = {};
+      controller = $controller('AppController', { $scope: scope });
+      Page = _Page_;
+    }));
+
+    it('should have a `null` as page set by default', function() {
+      expect(controller.page).toEqual(null);
+    });
+
+    it('should have a ("Nodes", null) as page set, if Page.title("Nodes") was called before', function() {
+      Page.title('Nodes');
+      expect(controller.page).toEqual("Nodes");
+      expect(controller.target).toEqual(undefined);
+    });
+
+    it('should have a ("Report", 1234567) as page set, if Page.title("Report", 1234567) was called before', function() {
+      Page.title('Report', 1234567);
+      expect(controller.page).toEqual("Report");
+      expect(controller.target).toEqual(1234567);
+    });
+
+    it('should have a ("Node", "master") as page set, if Page.title("Node", "master", " - ") was called before', function() {
+      Page.title('Node', "master", ' - ');
+      expect(controller.page).toEqual("Node");
+      expect(controller.target).toEqual('master');
+    });
+
+  });
+
+  describe('routes mapping', function() {
+
+    var $route, $location, $rootScope, navigateTo;
+    beforeEach(module('nodes/nodes.html'));
+    beforeEach(module('node/node.html'));
+    beforeEach(module('report/report.html'));
+    beforeEach(inject(function(_$route_, _$location_, _$rootScope_) {
+      $route = _$route_;
+      $location = _$location_;
+      $rootScope = _$rootScope_;
+      navigateTo = function(address) {
+        expect($route.current).toBeUndefined();
+        $location.path(address);
+        $rootScope.$digest();
+      };
+    }));
+
+    it('should map NodesController for unknown address', function() {
+      expect($route.routes[null].redirectTo).toEqual('/nodes');
+    });
+    it('should map NodesController if given "/nodes"', function() {
+      expect($route.routes['/nodes'].controller).toBe('NodesController');
+    });
+
+    it('should navigate to "/nodes" if given "/" a address', function() {
+      navigateTo('/');
+      expect($route.current.controller).toBe('NodesController');
+      expect($route.current.originalPath).toBe('/nodes');
+    });
+
+    it('should navigate to "/nodes" if given "/non-existing-link-0" a address', function() {
+      navigateTo('/non-existing-link-0');
+      expect($route.current.controller).toBe('NodesController');
+      expect($route.current.originalPath).toBe('/nodes');
+    });
+
+    it('should navigate to "/node/1" if given "/node/1" a address', function() {
+      navigateTo('/node/1');
+      expect($route.current.controller).toBe('NodeController');
+      expect($route.current.originalPath).toBe('/node/:nodeId');
+      expect($route.current.pathParams.nodeId).toBe('1');
+    });
+
+    it('should navigate to "/report/1" if given "/report/1" a address', function() {
+      navigateTo('/report/1');
+      expect($route.current.controller).toBe('ReportController');
+      expect($route.current.originalPath).toBe('/report/:reportId');
+      expect($route.current.pathParams.reportId).toBe('1');
+    });
+
+  });
+});

data/test/javascript/src/components/artifact/artifact-directive_test.js

@@ -0,0 +1,36 @@
+'use strict';
+
+describe('herald.artifact module', function() {
+  beforeEach(module('herald.artifact'));
+
+  describe('app-version directive', function() {
+
+    var $controller, $compile, $rootScope;
+    // Store references to $rootScope and $compile
+    // so they are available to all tests in this describe block
+    beforeEach(inject(function(_$compile_, _$controller_, _$rootScope_){
+      // The injector unwraps the underscores (_) from around the parameter names when matching
+      $compile = _$compile_;
+      $controller = _$controller_;
+      $rootScope = _$rootScope_;
+    }));
+
+    it('should print current version', function() {
+
+      inject(function($compile, $rootScope, $injector) {
+        // Set up the mock http service responses
+        var $httpBackend = $injector.get('$httpBackend');
+        // backend definition common for all tests
+        var authRequestHandler = $httpBackend.when('GET', '/version.json')
+                              .respond({version: 'TEST_VER'});
+        $httpBackend.expectGET('/version.json');
+
+        var element = $compile('<div><span app-version></span></div>')($rootScope);
+        expect(element.text()).toEqual('{{ artifact.version }}');
+        // fire all the watches, so the scope expression {{ artifact.version }} will be evaluated
+        $rootScope.$digest();
+        expect(element.text()).toEqual('0.0.0');
+      });
+    });
+  });
+});

data/test/javascript/src/components/artifact/artifact_test.js

@@ -0,0 +1,64 @@
+'use strict';
+
+describe('herald.artifact module', function() {
+  beforeEach(module('herald.artifact'));
+
+  describe('ArtifactController', function() {
+
+    var $httpBackend, $rootScope, createController, authRequestHandler;
+
+    var mockValues = {
+      version: 'TEST_VER',
+      homepage: 'http://example.org/herald',
+      summary: 'herald',
+      package: 'herald',
+      license: 'Apache 2.0',
+      name:    'Puppet Herald'
+    };
+
+    beforeEach(inject(function($injector) {
+
+      // Set up the mock http service responses
+      $httpBackend = $injector.get('$httpBackend');
+      // backend definition common for all tests
+      authRequestHandler = $httpBackend.when('GET', '/version.json')
+                              .respond(mockValues);
+
+      // Get hold of a scope (i.e. the root scope)
+      $rootScope = $injector.get('$rootScope');
+      // The $controller service is used to create instances of controllers
+      var $controller = $injector.get('$controller');
+
+      createController = function() {
+        $httpBackend.expectGET('/version.json');
+        var controller = $controller('ArtifactController', {'$scope' : $rootScope });
+        $httpBackend.flush();
+        return controller;
+      };
+    }));
+
+    afterEach(function() {
+      $httpBackend.verifyNoOutstandingExpectation();
+      $httpBackend.verifyNoOutstandingRequest();
+    });
+
+    it('should fetch version of artifact', function() { 
+      expect(createController().version).toBe(mockValues.version);
+    });
+    it('should fetch homepage of artifact', function() { 
+      expect(createController().homepage).toBe(mockValues.homepage);
+    });
+    it('should fetch package of artifact', function() { 
+      expect(createController().package).toBe(mockValues.package);
+    });
+    it('should fetch summary of artifact', function() { 
+      expect(createController().summary).toBe(mockValues.summary);
+    });
+    it('should fetch license of artifact', function() { 
+      expect(createController().license).toBe(mockValues.license);
+    });
+    it('should fetch name of artifact', function() { 
+      expect(createController().name).toBe(mockValues.name);
+    });
+  });
+});

data/test/javascript/src/components/directives/status-button_test.js

@@ -0,0 +1,159 @@
+'use strict';
+
+describe('herald.directives module', function() {
+  beforeEach(module('herald.directives'));
+
+  describe('herald.directives.status-button module', function() {
+
+    beforeEach(module('herald.directives.status-button'));
+
+    describe('StatusButtonController', function() {
+      var controller, scope, location;
+      
+      beforeEach(inject(function($injector) {
+        var $controller = $injector.get('$controller');
+        var $rootScope = $injector.get('$rootScope');
+        location = $injector.get('$location');
+        $rootScope.$on('$locationChangeStart', function(event, args) {
+          event.preventDefault();
+        })
+        var $scope = {};
+        scope = $scope;
+        controller = $controller('StatusButtonController', { $scope: $scope });
+      }));
+
+      it('should navigate to "/node/112" after issuing navigate() function', function() {
+        spyOn(location, 'path').and.returnValue(null);
+        expect(scope.navigate('/node/:id', 112)).toBe(undefined);
+        expect(location.path).toHaveBeenCalledWith('/node/112');
+      });
+
+    });
+
+    describe('colorizeStatus filter', function() {
+
+      var colorizeStatus;
+
+      beforeEach(inject(function($injector) {
+        var $filter = $injector.get('$filter');
+        colorizeStatus = $filter('colorizeStatus');
+      }));
+
+      it('should returns "default" when given null', function() {
+        expect(colorizeStatus(null)).toEqual('default');
+      });
+      it('should returns "default" when given undefined', function() {
+        expect(colorizeStatus(undefined)).toEqual('default');
+      });
+      it('should returns "default" when given undefined', function() {
+        expect(colorizeStatus('unknown')).toEqual('default');
+      });
+      it('should returns "success" when given "unchanged"', function() {
+        expect(colorizeStatus('unchanged')).toEqual('success');
+      });
+      it('should returns "info" when given "changed"', function() {
+        expect(colorizeStatus('changed')).toEqual('info');
+      });
+      it('should returns "danger" when given "failed"', function() {
+        expect(colorizeStatus('failed')).toEqual('danger');
+      });
+      it('should returns "warning" when given "pending"', function() {
+        expect(colorizeStatus('pending')).toEqual('warning');
+      });
+    });
+
+    describe('iconizeStatus filter', function() {
+
+      var iconizeStatus;
+
+      beforeEach(inject(function($injector) {
+        var $filter = $injector.get('$filter');
+        iconizeStatus = $filter('iconizeStatus');
+      }));
+
+      it('should returns "sign" when given null', function() {
+        expect(iconizeStatus(null)).toEqual('sign');
+      });
+      it('should returns "sign" when given undefined', function() {
+        expect(iconizeStatus(undefined)).toEqual('sign');
+      });
+      it('should returns "sign" when given undefined', function() {
+        expect(iconizeStatus('unknown')).toEqual('sign');
+      });
+      it('should returns "ok" when given "unchanged"', function() {
+        expect(iconizeStatus('unchanged')).toEqual('ok');
+      });
+      it('should returns "pencil" when given "changed"', function() {
+        expect(iconizeStatus('changed')).toEqual('pencil');
+      });
+      it('should returns "remove" when given "failed"', function() {
+        expect(iconizeStatus('failed')).toEqual('remove');
+      });
+      it('should returns "asterisk" when given "pending"', function() {
+        expect(iconizeStatus('pending')).toEqual('asterisk');
+      });
+    });
+
+    describe('ngStatusButton directive', function() {
+
+      var elm, scope, button;
+      beforeEach(module('components/directives/status-button.html'));
+      beforeEach(inject(function($rootScope, $compile){
+        var tpl = '<ng-status-button status="node.status" id="node.id" route="\'/node/:id\'"></ng-status-button>';
+        elm = angular.element(tpl);
+        scope = $rootScope;
+        $compile(elm)(scope);
+        scope.$digest();
+        button = elm.find('button');
+      }));
+
+      describe('with scope without any values', function() {
+
+        it('should embed a one element of type "button"', function() {
+          expect(button.length).toBe(1);
+        });
+        it('should embed an element with class "btn-default"', function() {
+          expect(button.hasClass('btn-default')).toBe(true);
+        });
+        it('should embed an element with class "glyphicon-sign"', function() {
+          expect(button.hasClass('glyphicon-sign')).toBe(true);
+        });
+        it('should embed a button with text " "', function() {
+          expect(button.text()).toEqual(' ');
+        });
+
+      });
+
+      describe('with values { status: "unchanged", id: 16 } given', function() {
+
+        beforeEach(function() {
+          scope.$apply(function() {
+            scope.node = {
+              status: "unchanged",
+              id: 16
+            };
+          });
+        });
+
+        it('should embed a one element of type "button"', function() {
+          expect(button.length).toBe(1);
+        });
+        it('should embed an element with class "btn-success"', function() {
+          expect(button.hasClass('btn-success')).toBe(true);
+        });
+        it('should embed an element with class "glyphicon-ok"', function() {
+          expect(button.hasClass('glyphicon-ok')).toBe(true);
+        });
+        it('should embed a button with text " UNCHANGED"', function() {
+          expect(button.text()).toEqual(' UNCHANGED');
+        });
+        it('should embed a button with onclick == "navigate(route, id)"', function() {
+          expect(button.attr('ng-click')).toEqual("navigate(route, id)");
+        });
+
+      });
+
+    });
+  });
+
+});