bastion 0.1.0

data/test/incubator/alch-container-scroll.directive.test.js

@@ -0,0 +1,68 @@
+/**
+ * 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: alchContainerScroll', function() {
+    var scope,
+        compile,
+        window,
+        tableElement;
+
+    beforeEach(module('alchemy'));
+
+    beforeEach(inject(function(_$compile_, _$rootScope_, _$window_) {
+        compile = _$compile_;
+        scope = _$rootScope_;
+        window = _$window_;
+    }));
+
+    beforeEach(function() {
+        tableElement = angular.element(
+            '<div alch-container-scroll control-width="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();
+    });
+
+    it("should adjust the table width on window resize", function() {
+        var table = tableElement.find('table'),
+            tableWidth = table.width(),
+            windowElement = angular.element(window);
+
+        windowElement.width('300px');
+        windowElement.trigger('resize');
+
+        expect(table.width()).toEqual(windowElement.width());
+    });
+
+    it("should adjust the table height on window resize", function() {
+        var table = tableElement.find('table'),
+            windowElement = angular.element(window);
+
+        windowElement.height('100px');
+        windowElement.trigger('resize');
+
+        expect(tableElement.height()).toEqual(windowElement.height() - tableElement.offset().top);
+    });
+});

data/test/incubator/alch-dropdown.directive.test.js

@@ -0,0 +1,113 @@
+/**
+ * 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: alchDropdown', function() {
+    var scope,
+        compile,
+        testItems,
+        element,
+        elementScope;
+
+    beforeEach(module(
+        'alchemy',
+        'incubator/views/alch-dropdown.html',
+        'incubator/views/alch-flyout.html'
+    ));
+
+    beforeEach(inject(function(_$compile_, _$rootScope_) {
+        compile = _$compile_;
+        scope = _$rootScope_;
+    }));
+
+    beforeEach(function() {
+        testItems = [
+            {url: 'http://redhat.com', display: 'Red Hat'},
+            {url: 'http://google.com', display: 'Google'},
+            {display: 'Projects', type: 'flyout', items: [
+                {url: 'http://katello.org', display: 'Katello'},
+                {url: 'http://theforeman.org', display: 'Foreman'}
+            ]}
+        ];
+        scope.items = testItems;
+
+        element = angular.element('<ul alch-dropdown="items"></ul>');
+        compile(element)(scope);
+        scope.$digest();
+
+        elementScope = element.isolateScope();
+    });
+
+    it("should display a .dropdown <ul>", function() {
+        expect(element.is('ul')).toBe(true);
+        expect(element.hasClass('dropdown')).toBe(true);
+    });
+
+    it("should display a .dropdown-item <li> for each top level menu item", function() {
+        expect(element.find('.dropdown-item').length).toBe(3);
+    });
+
+    it("should display an <li> element for each item (including flyout children).", function() {
+        expect(element.find('li').length).toBe(5);
+    });
+
+    describe("should respond to mouse events", function() {
+        var target;
+
+        beforeEach(function() {
+            target = angular.element(element.find('li')[1]);
+            spyOn(elementScope, 'setHover').andCallThrough();
+        });
+
+        it("by setting the item to active on mouse in", function() {
+            target.mouseenter();
+
+            expect(elementScope.setHover).toHaveBeenCalledWith(testItems[1], true);
+            expect(testItems[1].active).toBe(true);
+        });
+
+        it("by setting the item to inactive on mouse out", function() {
+            target.mouseleave();
+
+            expect(elementScope.setHover).toHaveBeenCalledWith(testItems[1], false);
+            expect(testItems[1].active).toBe(false);
+        });
+    });
+
+    describe("should handle mouse events for child flyouts", function() {
+        var target;
+
+        beforeEach(function() {
+            target = angular.element(element.find('li')[2]);
+            spyOn(elementScope, 'setHover').andCallThrough();
+        });
+
+        it("by setting the item to active on mouse in", function() {
+            target.mouseenter();
+
+            expect(elementScope.setHover).toHaveBeenCalledWith(testItems[2], true);
+            expect(testItems[2].active).toBe(true);
+        });
+
+        it("by setting the item to inactive on mouse out", function() {
+            target.mouseenter();
+            target.mouseleave();
+
+            expect(elementScope.setHover).toHaveBeenCalledWith(testItems[2], false);
+        });
+    });
+
+    it("provides a way to tell if the direction is right", function() {
+        expect(elementScope.isRight('right')).toBe(true);
+        expect(elementScope.isRight('left')).toBe(false);
+    });
+});

data/test/incubator/alch-edit.directive.test.js

@@ -0,0 +1,320 @@
+/**
+ * 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: alchEdit', function() {
+    var scope,
+        compile,
+        testItem;
+
+    beforeEach(module('alchemy',
+        'alchemy.format',
+        'incubator/views/alch-edit.html',
+        'incubator/views/alch-edit-text.html',
+        'incubator/views/alch-edit-textarea.html',
+        'incubator/views/alch-edit-select.html',
+        'incubator/views/alch-edit-add-item.html',
+        'incubator/views/alch-edit-checkbox.html',
+        'incubator/views/alch-edit-add-remove-cancel.html',
+        'incubator/views/alch-edit-multiselect.html',
+        'incubator/views/alch-edit-save-cancel.html'));
+
+    beforeEach(module(function($provide) {
+        testItem = {
+            name: 'Test Name',
+            taco: 'carnitas',
+            add: function () {},
+            save: function() {},
+            revert: function() {},
+            delete: function() {}
+        };
+
+        translate = function() {
+            this.$get = function() {
+                return function() {};
+            };
+
+            return this;
+        };
+
+        $provide.provider('translate', translate);
+        $provide.provider('translateFilter', translate);
+    }));
+
+    beforeEach(inject(function(_$compile_, _$rootScope_) {
+        compile = _$compile_;
+        scope = _$rootScope_;
+    }));
+
+    describe('alchEdit controller', function() {
+        var element,
+            editController;
+
+        beforeEach(inject(function($controller) {
+            editController = $controller('AlchEditController', {$scope: scope});
+        }));
+
+    });
+
+    describe('alchEdit directive', function() {
+        var editableElement;
+
+        beforeEach(function() {
+            editableElement = angular.element(
+                '<span alch-edit-text="item.name" on-save="item.save()" on-delete="item.delete()" ' +
+                    'on-cancel="item.revert()"></span>');
+
+            scope.item = testItem;
+
+            compile(editableElement)(scope);
+            scope.$digest();
+        });
+
+        it("should show the attribute passed in to the directive", function() {
+            var element = editableElement.find('.editable-value');
+
+            expect(element.text()).toBe(testItem.name);
+        });
+
+        it("should hide the editable value display on click", function() {
+            var element = editableElement.find('.editable');
+
+            expect(element.hasClass('ng-hide')).toBe(false);
+            element.trigger('click');
+
+            expect(element.hasClass('ng-hide')).toBe(true);
+        });
+
+        it("should call the method set to on-save when clicking save button", function() {
+            var element = editableElement.find('[ng-click="save()"]');
+            spyOn(testItem, 'save');
+
+            element.trigger('click');
+
+            expect(testItem.save).toHaveBeenCalled();
+        });
+
+        it("should call the method set to on-delete when clicking delete button", function() {
+            var element = editableElement.find('.icon-remove');
+            spyOn(testItem, 'delete');
+
+            element.trigger('click');
+
+            expect(testItem.delete).toHaveBeenCalled();
+        });
+
+        it("should call the method set to on-cancel when clicking cancel button", function() {
+            var element = editableElement.find('[ng-click="cancel()"]');
+            spyOn(testItem, 'revert');
+
+            element.trigger('click');
+
+            expect(testItem.revert).toHaveBeenCalled();
+        });
+
+        describe("formats displayed values", function() {
+            var $filter, elementScope;
+            beforeEach(inject(function(_$filter_) {
+                $filter = _$filter_;
+                elementScope = editableElement.isolateScope();
+            }));
+
+            it("by executing the provided filter on the model", function() {
+                elementScope.formatter = 'uppercase';
+
+                elementScope.model = 'new name';
+                elementScope.$digest();
+                expect(elementScope.displayValue).toBe('NEW NAME');
+            });
+
+            it("by defaulting to model value if no filter is provided", function() {
+                expect(elementScope.displayValue).toBe(elementScope.model);
+            });
+        });
+    });
+
+    describe('alchEditText directive', function() {
+        var editableElement;
+
+        beforeEach(function() {
+            editableElement = angular.element(
+                '<span alch-edit-text="item.name"></span>');
+
+            scope.item = testItem;
+
+            compile(editableElement)(scope);
+            scope.$digest();
+        });
+
+        it("should display an input box on editable click", function() {
+            var element = editableElement.find('.editable'),
+                input = editableElement.find('input');
+            element.trigger('click');
+
+            expect(input.css('display')).not.toBe('none');
+        });
+
+    });
+
+    describe('alchEditCheckbox directive', function() {
+        var editableElement;
+
+        beforeEach(function() {
+            editableElement = angular.element(
+                '<span alch-edit-checkbox="item.name"></span>');
+
+            scope.item = testItem;
+
+            compile(editableElement)(scope);
+            scope.$digest();
+        });
+
+        it("should display an checkbox on editable click", function() {
+            var element = editableElement.find('.editable'),
+                input = editableElement.find('input[type=checkbox]');
+            element.trigger('click');
+
+            expect(input.css('display')).not.toBe('none');
+        });
+
+    });
+
+    describe('alchEditTextarea directive', function() {
+        var editableElement;
+
+        beforeEach(function() {
+            editableElement = angular.element(
+                '<span alch-edit-textarea="item.name"></span>');
+
+            scope.item = testItem;
+            scope.tacoOptions = ['baja shrimp', 'barbacoa', 'carnitas', 'spicy tinga chicken'];
+
+            compile(editableElement)(scope);
+            scope.$digest();
+        });
+
+        it("should display a textarea on editable click", function() {
+            var element = editableElement.find('.editable'),
+                input = editableElement.find('textarea');
+            element.trigger('click');
+
+            expect(input.css('display')).not.toBe('none');
+        });
+
+    });
+
+    describe('alchEditSelect directive', function() {
+        var editableElement;
+
+        beforeEach(function() {
+            scope.tacoOptions = [{id: 1, name: 'Carnitas'}, {id: 2, name: 'Tilapia'}];
+
+            editableElement = angular.element(
+                '<span alch-edit-select="item.taco" options="tacoOptions" ></span>'
+            );
+
+            scope.item = testItem;
+
+            compile(editableElement)(scope);
+            scope.$digest();
+        });
+
+        it("should display a select on editable click", function() {
+            var element = editableElement.find('.editable'),
+                input = editableElement.find('select');
+            element.trigger('click');
+
+            expect(input.css('display')).not.toBe('none');
+        });
+
+        it("should create options", function() {
+            var element = editableElement.find('.editable'),
+                input = editableElement.find('select');
+            expect(input.find('option').length).not.toBe(2);
+        });
+
+    });
+
+    describe('alchEditMultiselect directive', function() {
+        var editableElement,
+            directiveScope,
+            multiSelectController;
+
+        beforeEach(function() {
+            editableElement = angular.element(
+                '<span alch-edit-multiselect="tacos" options="tacoOptions"></span>');
+
+            scope.tacos = [{id: 2, name: 'barbacoa'}, {id: 3, name: 'carnitas'}];
+            scope.tacoOptions = [{id: 1, name: 'baja shrimp'}, {id: 2, name: 'barbacoa'},
+                {id: 3, name: 'carnitas'}, {id: 4, name: 'spicy tinga chicken'}];
+
+            compile(editableElement)(scope);
+            scope.$digest();
+            directiveScope = editableElement.isolateScope();
+        });
+
+        beforeEach(inject(function($controller) {
+            multiSelectController = $controller('AlchEditMultiselectController', {$scope: directiveScope});
+        }));
+
+        it("should display a multi select on editable click", function() {
+            var element = editableElement.find('.editable'),
+                input = editableElement.find('div');
+            element.trigger('click');
+            expect(input.css('display')).not.toBe('none');
+        });
+
+        it("automatically selects the previously selected items.", function() {
+            directiveScope.edit();
+            directiveScope.$digest();
+
+            expect(directiveScope.options[0].selected).toBe(false);
+            expect(directiveScope.options[1].selected).toBe(true);
+            expect(directiveScope.options[2].selected).toBe(true);
+            expect(directiveScope.options[3].selected).toBe(false);
+        });
+
+        it("allows a way to toggle options", function() {
+            directiveScope.toggleOption(scope.tacoOptions[0]);
+            expect(scope.tacoOptions[0].selected).toBe(true);
+
+            directiveScope.toggleOption(scope.tacoOptions[0]);
+            expect(scope.tacoOptions[0].selected).toBe(false);
+        });
+
+    });
+
+    describe('alchEditAddItem directive', function() {
+        var editableElement;
+
+        beforeEach(function() {
+            editableElement = angular.element(
+                '<span alch-edit-add-item="item.name" on-add="item.add()"></span>');
+
+            scope.item = testItem;
+
+            compile(editableElement)(scope);
+            scope.$digest();
+        });
+
+        it("should call the method set to on-save when clicking save button", function() {
+            var element = editableElement.find('button');
+            spyOn(testItem, 'add');
+
+            element.trigger('click');
+
+            expect(testItem.add).toHaveBeenCalled();
+        });
+    });
+
+});