bastion 0.1.0

data/test/incubator/format/unlimited-filter.filter.test.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2014 Red Hat, Inc.
+ *
+ * This software is licensed to you under the GNU General Public
+ * License as published by the Free Software Foundation; either version
+ * 2 of the License (GPLv2) or (at your option) any later version.
+ * There is NO WARRANTY for this software, express or implied,
+ * including the implied warranties of MERCHANTABILITY,
+ * NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+ * have received a copy of GPLv2 along with this software; if not, see
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ */
+describe('Filter:unlimitedFilter', function() {
+    var unlimitedFilter;
+
+    beforeEach(module('alchemy.format'));
+
+    beforeEach(module(function($provide) {
+        $provide.value('translate',  function(a) {return a});
+    }));
+
+    beforeEach(inject(function($filter) {
+        unlimitedFilter = $filter('unlimitedFilter');
+    }));
+
+    it("ensures correctly transforms limit", function() {
+        expect(unlimitedFilter(3, true)).toBe('Unlimited');
+        expect(unlimitedFilter(2)).toBe('2');
+    });
+
+});

data/test/incubator/nutupane-table.directive.test.js

@@ -0,0 +1,69 @@
+/**
+ * Copyright 2014 Red Hat, Inc.
+ *
+ * This software is licensed to you under the GNU General Public
+ * License as published by the Free Software Foundation; either version
+ * 2 of the License (GPLv2) or (at your option) any later version.
+ * There is NO WARRANTY for this software, express or implied,
+ * including the implied warranties of MERCHANTABILITY,
+ * NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+ * have received a copy of GPLv2 along with this software; if not, see
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ */
+
+
+describe('Directive: nutupaneTable', function() {
+    var scope,
+        compile,
+        tableElement;
+
+    beforeEach(module('alchemy'));
+
+    beforeEach(inject(function(_$compile_, _$rootScope_) {
+        compile = _$compile_;
+        scope = _$rootScope_;
+    }));
+
+    beforeEach(function() {
+        tableElement = angular.element(
+            '<div nutupane-table>' +
+              '<table>' +
+                '<thead>' +
+                  '<tr><th>Column 1</th></tr>' +
+                '</thead>' +
+                '<tbody>' +
+                  '<tr>' +
+                    '<td>Row 1</td>' +
+                 '</tr>' +
+                '</tbody>' +
+              '</table>' +
+            '</div>');
+
+        compile(tableElement)(scope);
+        scope.$digest();
+        scope.$broadcast("$stateChangeSuccess", {}, {}, {}, {});
+    });
+
+    it("should create a new table element with just the thead", function() {
+        var theads = tableElement.find('thead'),
+            tbodys = tableElement.find('tbody');
+
+        expect(theads.length).toEqual(2);
+        expect(tbodys.length).toEqual(1);
+    });
+
+    it("should hide the original table's thead", function() {
+        var originalTableHead = angular.element(tableElement.find('thead')[1]);
+
+        expect(originalTableHead.css('display')).toBe('none');
+    });
+
+    it("should remove the duplicate row select from the cloned table if present", function() {
+        var rowSelectTable = tableElement.clone();
+        rowSelectTable.find('thead').prepend("<tr><th class='row-select'></th></tr>");
+        compile(rowSelectTable)(scope);
+        scope.$digest();
+        scope.$broadcast("$stateChangeSuccess", {}, {}, {}, {});
+        expect(rowSelectTable.find('.row-select').length).toBe(1);
+    });
+});

data/test/incubator/nutupane.factory.test.js

@@ -0,0 +1,307 @@
+/**
+ * Copyright 2014 Red Hat, Inc.
+ *
+ * This software is licensed to you under the GNU General Public
+ * License as published by the Free Software Foundation; either version
+ * 2 of the License (GPLv2) or (at your option) any later version.
+ * There is NO WARRANTY for this software, express or implied,
+ * including the implied warranties of MERCHANTABILITY,
+ * NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+ * have received a copy of GPLv2 along with this software; if not, see
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ */
+
+describe('Factory: Nutupane', function() {
+    var $timeout,
+        $location,
+        Resource,
+        expectedResult,
+        Nutupane;
+
+    beforeEach(module('Bastion.widgets'));
+
+    beforeEach(module(function() {
+        expectedResult = [{id: 2, value: "value2"}, {id:3, value: "value3"}];
+        Resource = {
+            queryPaged: function(params, callback) {
+                var result = {results: expectedResult};
+                if (callback) {
+                    callback(result);
+                }
+                return result;
+            },
+            customAction: function() {},
+            total: 10,
+            subtotal: 8,
+            offset: 5,
+            sort: {
+                by: "description",
+                order: "ASC"
+            }
+        };
+    }));
+
+    beforeEach(inject(function(_$location_, _$timeout_, _Nutupane_) {
+        $location = _$location_;
+        $timeout = _$timeout_;
+        Nutupane = _Nutupane_;
+    }));
+
+    describe("adds additional functionality to the Nutupane table by", function() {
+        var nutupane;
+
+        beforeEach(function() {
+            nutupane = new Nutupane(Resource);
+            nutupane.table.working = false;
+            nutupane.table.selectAll = function() {};
+            nutupane.table.getSelected = function() {};
+            nutupane.table.disableSelectAll = function () { };
+            nutupane.table.enableSelectAll = function () { };
+            nutupane.table.allSelected = function () { return true; };
+            nutupane.table.rows = [{id: 0, value: "value0"}, {id:1, value: "value1"}];
+            nutupane.table.resource = Resource;
+        });
+
+        it("providing a method to fetch records for the table", function() {
+            var expected = nutupane.table.rows.concat(expectedResult);
+
+            spyOn(Resource, 'queryPaged').andCallThrough();
+            nutupane.query();
+
+            expect(Resource.queryPaged).toHaveBeenCalled();
+            expect(nutupane.table.rows.length).toBe(4);
+            angular.forEach(nutupane.table.rows, function(value, index) {
+                expect(value).toBe(expected[index]);
+            });
+        });
+
+        it("providing a method to refresh the table", function() {
+            spyOn(Resource, 'queryPaged').andCallThrough();
+            nutupane.refresh();
+
+            expect(Resource.queryPaged).toHaveBeenCalled();
+            expect(nutupane.table.rows).toBe(expectedResult);
+        });
+
+        it("providing a method to perform a search", function() {
+            spyOn(Resource, 'queryPaged');
+            nutupane.table.closeItem = function() {};
+
+            nutupane.table.search();
+
+            expect(Resource.queryPaged).toHaveBeenCalled();
+        });
+
+        it("refusing to perform a search if the table is currently fetching", function() {
+            spyOn(Resource, 'queryPaged');
+            nutupane.table.closeItem = function() {};
+            nutupane.table.working = true;
+
+            nutupane.table.search();
+
+            expect(Resource.queryPaged).not.toHaveBeenCalled();
+        });
+
+        it("setting the search parameter in the URL when performing a search", function() {
+            spyOn(Resource, 'queryPaged');
+            nutupane.table.closeItem = function() {};
+            nutupane.table.working = true;
+
+            nutupane.table.search("Find Me");
+
+            expect($location.search().search).toEqual("Find Me");
+        });
+
+        it("enforcing the user of this factory to define a closeItem function", function() {
+            expect(nutupane.table.closeItem).toThrow();
+        });
+
+        it("updates a single occurrence of a row within the list of rows.", function() {
+            var newRow = {id:0, value:"new value", anotherValue: "value"};
+            nutupane.query();
+            nutupane.table.replaceRow(newRow);
+            expect(nutupane.table.rows[0]).toBe(newRow);
+        });
+
+        it("removes a single occurrence of a row within the list of rows.", function() {
+            var row = {id:0, value: "value2"};
+            nutupane.removeRow(row.id);
+            expect(nutupane.table.rows.length).toBe(1);
+            expect(nutupane.table.rows).not.toContain(row);
+        });
+
+        it("decrements num selected if removed row is selected.", function() {
+               var row = nutupane.table.rows[0];
+               row.selected = true;
+               nutupane.table.numSelected = 1;
+
+               nutupane.removeRow(row.id);
+               expect(nutupane.table.rows.length).toBe(1);
+               expect(nutupane.table.rows).not.toContain(row);
+               expect(nutupane.table.numSelected).toBe(0);
+        });
+
+        it("providing a method that fetches more data", function() {
+            nutupane.table.rows = [];
+            spyOn(Resource, 'queryPaged');
+
+            nutupane.table.nextPage();
+
+            expect(Resource.queryPaged).toHaveBeenCalled();
+        });
+
+        it("refusing to fetch more data if the table is currently working", function() {
+            spyOn(Resource, 'queryPaged');
+            nutupane.table.working = true;
+            nutupane.table.nextPage();
+
+            expect(Resource.queryPaged).not.toHaveBeenCalled();
+        });
+
+        it("refusing to fetch more data if the subtotal of records equals the number of rows", function() {
+            spyOn(Resource, 'queryPaged');
+            nutupane.table.rows = new Array(8);
+            nutupane.table.nextPage();
+
+            expect(Resource.queryPaged).not.toHaveBeenCalled();
+        });
+
+        it("provides a way to add an individual row", function() {
+            nutupane.table.rows = new Array(8);
+            nutupane.table.addRow('');
+
+            expect(nutupane.table.rows.length).toBe(9);
+        });
+
+        it("provides a way to enable select all results", function(){
+           nutupane.enableSelectAllResults();
+           expect(nutupane.table.selectAllResultsEnabled).toBe(true);
+        });
+
+        it("provides a way to select all results", function() {
+            nutupane.enableSelectAllResults();
+            spyOn(nutupane.table, 'selectAll');
+            spyOn(nutupane.table, 'disableSelectAll');
+
+            nutupane.table.selectAllResults(true);
+
+            expect(nutupane.table.selectAll).toHaveBeenCalledWith(true);
+            expect(nutupane.table.disableSelectAll).toHaveBeenCalled();
+            expect(nutupane.table.allResultsSelected).toBe(true);
+            expect(nutupane.table.numSelected).toBe(nutupane.table.resource.subtotal);
+        });
+
+        it("provides a way to de-select all results", function(){
+            nutupane.enableSelectAllResults();
+            nutupane.table.numSelected = 0;
+            spyOn(nutupane.table, 'selectAll');
+            spyOn(nutupane.table, 'enableSelectAll');
+            nutupane.table.selectAllResults(false);
+
+            expect(nutupane.table.selectAll).toHaveBeenCalledWith(false);
+            expect(nutupane.table.enableSelectAll).toHaveBeenCalled();
+            expect(nutupane.table.allResultsSelected).toBe(false);
+            expect(nutupane.table.numSelected).toBe(0);
+        });
+
+        it("provides a way to get deselected items", function(){
+            var deselected;
+            nutupane.enableSelectAllResults();
+            nutupane.table.rows = expectedResult;
+            angular.forEach(nutupane.table.rows, function(item, itemIndex) {
+                item.selected = true;
+            });
+            nutupane.table.rows[0].selected = false
+            deselected = nutupane.getDeselected();
+
+            expect(deselected.length).toBe(1);
+            expect(deselected[0]).toBe(nutupane.table.rows[0]);
+        });
+
+        it("provides a way to retrieve selected result items", function(){
+            var results;
+            nutupane.enableSelectAllResults();
+            nutupane.table.selectAllResults(true);
+            nutupane.table.searchTerm = "FOO"
+
+            angular.forEach(nutupane.table.rows, function(item, itemIndex) {
+                item.selected = true;
+            });
+            nutupane.table.rows[0].selected = false;
+            results = nutupane.getAllSelectedResults('id');
+            expect(results.excluded.ids[0]).toBe(nutupane.table.rows[0]['id']);
+            expect(results.included.search).toBe("FOO");
+        });
+
+        describe("provides a way to sort the table", function() {
+            it ("defaults the sort to ascending if the previous sort does not match the new sort.", function() {
+                var expectedParams = {sort_by: 'name', sort_order: 'ASC', search: '', page: 1};
+                nutupane.table.resource.sort = {};
+
+                spyOn(Resource, 'queryPaged');
+                nutupane.table.sortBy({id: "name"});
+
+                expect(Resource.queryPaged).toHaveBeenCalledWith(expectedParams, jasmine.any(Function));
+            });
+
+            it("toggles the sort order if already sorting by that column", function() {
+                var expectedParams = {sort_by: 'name', sort_order: 'DESC', search: '', page: 1};
+                nutupane.table.resource.sort = {
+                    by: 'name',
+                    order: 'ASC'
+                };
+
+                spyOn(Resource, 'queryPaged');
+                nutupane.table.sortBy({id: "name"});
+
+                expect(Resource.queryPaged).toHaveBeenCalledWith(expectedParams, jasmine.any(Function));
+            });
+
+            it("sets the column sort order and marks it as active.", function() {
+                var column = {id: "name"}
+                nutupane.table.resource.sort = {};
+                nutupane.table.sortBy(column);
+                expect(column.sortOrder).toBe("ASC");
+                expect(column.active).toBe(true);
+            });
+
+            it("refreshes the table by calling query()", function() {
+                spyOn(nutupane, "query");
+                nutupane.table.sortBy({id: "name"});
+                expect(nutupane.query).toHaveBeenCalled();
+            });
+        });
+    });
+
+    describe("Nutupane should", function() {
+        beforeEach(function() {
+            nutupane = new Nutupane(Resource, {}, 'customAction');
+            nutupane.table.working = false;
+            nutupane.table.closeItem = function () {};
+            nutupane.table.allSelected = function () {};
+            nutupane.table.selectAll = function () {};
+        });
+
+        it("provide a method to fetch records for the table via a custom action", function() {
+            spyOn(Resource, 'customAction');
+            nutupane.query();
+
+            expect(Resource.customAction).toHaveBeenCalled();
+        });
+
+        it("naming the URL search field based off the action", function() {
+            spyOn(Resource, 'customAction');
+            nutupane.table.search('*');
+
+            expect($location.search()['customActionSearch']).toBe('*');
+        });
+
+        it("provide a method to add params", function () {
+            nutupane.addParam('test', 'ABC');
+
+            expect(nutupane.getParams()['test']).toBe('ABC');
+        });
+    });
+
+});
+

data/test/menu/menu-expander.service.test.js

@@ -0,0 +1,74 @@
+/**
+ * Copyright 2014 Red Hat, Inc.
+ *
+ * This software is licensed to you under the GNU General Public
+ * License as published by the Free Software Foundation; either version
+ * 2 of the License (GPLv2) or (at your option) any later version.
+ * There is NO WARRANTY for this software, express or implied,
+ * including the implied warranties of MERCHANTABILITY,
+ * NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+ * have received a copy of GPLv2 along with this software; if not, see
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ **/
+
+describe('Service: MenuExpander', function() {
+    var menuExpander;
+
+    beforeEach(module('Bastion.menu'));
+
+    beforeEach(inject(function(MenuExpander) {
+        menuExpander = MenuExpander;
+    }));
+
+    describe('sets menu items', function() {
+        it('by adding a menu if the menu does not exist', function() {
+            var menu = [{'url': 'http://google.com', 'label': 'google'}];
+
+            menuExpander.setMenu('system', menu);
+
+            expect(menuExpander.getMenu('system')).toBe(menu);
+        });
+
+        it('by adding to the menu if it already exists', function() {
+            var menu1 = [{'url': 'http://google.com', 'label': 'google'}],
+                menu2 = [{'url': 'http://redhat.com', 'label': 'redhat'}];
+
+            menuExpander.setMenu('system', menu1);
+            menuExpander.setMenu('system', menu2);
+
+            expect(menuExpander.getMenu('system').length).toBe(2);
+            expect(menuExpander.getMenu('system')[0]).toBe(menu1[0]);
+            expect(menuExpander.getMenu('system')[1]).toBe(menu2[0]);
+        });
+
+        it('by not adding duplicate menu items', function() {
+            var menu1 = [{'url': 'http://google.com', 'label': 'google'}],
+                menu2 = [{'url': 'http://google.com', 'label': 'google'}];
+
+            menuExpander.setMenu('system', menu1);
+            menuExpander.setMenu('system', menu2);
+
+            expect(menuExpander.getMenu('system').length).toBe(1);
+            expect(menuExpander.getMenu('system')[0]).toBe(menu1[0]);
+        });
+    });
+
+    describe("gets menu items", function() {
+        it('by returning an empty array if the menu does not exist.', function() {
+            expect($.isArray(menuExpander.getMenu('system'))).toBe(true);
+            expect(menuExpander.getMenu('system').length).toBe(0);
+        });
+
+        it('by returning the menu if it exists.', function() {
+            var menu = [{'url': 'http://google.com', 'label': 'google'}];
+
+            expect(menuExpander.getMenu('system').length).toBe(0);
+
+            menuExpander.setMenu('system', menu);
+
+            expect(menuExpander.getMenu('system').length).toBe(1);
+            expect(menuExpander.getMenu('system')).toBe(menu);
+        });
+    });
+});
+