robeaux 0.2.0 → 0.3.0

data/partials/widget_editor.html

@@ -0,0 +1,68 @@
+<div class="row">
+  <div class="widgets">
+    <div class="sidebar">
+      <h2>Widgets</h2>
+
+      <div class="new-widget">
+        <input type="text" ng-model="name" placeholder="new widget name">
+        <button ng-click="add(name)" class="btn btn-device">add</button>
+      </div>
+
+      <div class="list">
+        <div class="widget"
+             ng-repeat="widget in widgets.list"
+             ng-click="edit(widget)"
+             ng-class="{selected: (editing === widget)}">
+          {{widget.name}}
+          <span class="close" ng-if="widget.custom" ng-click="widgets.remove(widget.name)">&#x2716;</span>
+        </div>
+      </div>
+    </div>
+
+
+    <div class="editor">
+      <div class="attrs">
+        <label>
+          <strong>Attrs:</strong>
+          <small>Attributes to be defined when instantiating the widget. They will be available in the script as <code>attrs</code>.</small>
+        </label>
+
+        <div class="attrs-list">
+          <span ng-repeat="attr in editing.attrs" ng-click="removeAttr($index)">
+            {{ attr }}
+            {{ $last ? '' : ', ' }}
+          </span>
+        </div>
+
+        <div class="new-attr">
+          <input type="text" ng-disabled="!editing" ng-model="newAttr">
+          <button ng-disabled="!editing" ng-click="addAttr()" class="btn btn-device">Add Attribute</button>
+        </div>
+      </div>
+
+      <div class="field">
+        <label>
+          <strong>Template:</strong>
+          <small>The code you put here will be used as a template for an Angular directive.</small>
+        </label>
+
+        <textarea id="template" ng-disabled="!editing" ng-model="editing.template" ng-blur="widgets.save()" placeholder="write your template here">
+        </textarea>
+      </div>
+
+      <div class="field">
+        <label>
+          <strong>Script:</strong>
+          <small>The code you put here will be used as a <code>link</code> function for an Angular directive.</small>
+        </label>
+        <textarea ng-disabled="!editing" ng-model="editing.script" ng-blur="widgets.save()" placeholder="write your javascript here">
+        </textarea>
+      </div>
+    </div>
+
+    <div class="footer">
+      <button class="btn btn-save" ng-click="widgets.save()">save</button>
+      <button class="btn btn-reset" ng-click="widgets.reset()">reset</button>
+    </div>
+  </div>
+</div>

data/robeaux.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = "robeaux"
-  s.version     = "0.2.0"
+  s.version     = "0.3.0"
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Ron Evans", "Adrian Zankich", "Ari Lerner", "Mario Ricalde", "Daniel Fischer", "Andrew Stewart"]
   s.email       = ["artoo@hybridgroup.com"]

data/test/controllers/device_commands_ctrl.js

@@ -0,0 +1,129 @@
+describe("Testing Controllers", function() {
+    describe('Controller DeviceCommandsCtrl:', function() {
+
+        beforeEach(module('robeaux'));
+        
+        var $scope, $rootScope, $httpBackend, $timeout, testController;
+        
+        beforeEach(inject(function($injector) {
+            $timeout = $injector.get('$timeout');
+            $httpBackend = $injector.get('$httpBackend');
+            $rootScope = $injector.get('$rootScope');
+            $scope = $rootScope.$new();
+
+            var $controller = $injector.get('$controller');
+
+            testController = function() {
+                return $controller('DeviceCommandsCtrl', {
+                    '$scope': $scope
+                });
+            };
+            var controller = testController();
+
+            jasmine.getJSONFixtures().fixturesPath='base/test/support';
+
+            var data = loadJSONFixtures('myDevice.json')['myDevice.json'];
+
+            $scope.device = data[0];
+            $scope.device.results = [];
+            $scope.device.params = [{ name: '', value: '', type: 'string' }];
+        }));
+
+        afterEach(function() {
+            $httpBackend.verifyNoOutstandingExpectation();
+            $httpBackend.verifyNoOutstandingRequest();
+        });
+
+        describe('command:', function() {
+            it('should be an empty string', function (){
+                expect($scope.command).toBe("");
+            });
+        });
+
+        describe('command types:', function() {
+            it('should be an array of string, boolean and number', function (){
+                var command_types = [ 'string', 'boolean', 'number' ];
+                expect($scope.types).toEqual(command_types);
+            });
+        });
+
+        describe('isDisabled:', function() {
+            it('should return true if command is empty', function (){
+                expect($scope.isDisabled()).toBe(true);
+            });
+
+            it('should return false if command exist', function (){
+                $scope.command = 'test_command'
+                expect($scope.isDisabled()).toBe(false);
+            });
+        });
+
+        describe('addParam:', function() {
+            it('should add params if last', function (){
+                expect($scope.device.params.length).toBe(1)
+                $scope.addParam($scope.device);
+                expect($scope.device.params.length).toBe(2)
+            });
+
+            it('should not add params if not last', function (){
+                expect($scope.device.params.length).toBe(1)
+                $scope.addParam();
+                expect($scope.device.params.length).toBe(1)
+            });
+        });
+
+        describe('removeParam:', function() {
+            it('should remove param if there is more than one', function (){
+                $scope.device.params = [
+                  { name: '', value: '', type: 'string' },
+                  { name: '', value: '', type: 'string' }
+                ];
+
+                expect($scope.device.params.length).toBe(2)
+                $scope.removeParam($scope.device);
+                expect($scope.device.params.length).toBe(1)
+            });
+
+            it('should not remove param if there just one', function (){
+                $scope.device.params = [
+                  { name: '', value: '', type: 'string' }
+                ];
+
+                expect($scope.device.params.length).toBe(1)
+                $scope.removeParam($scope.device);
+                expect($scope.device.params.length).toBe(1)
+            });
+
+            it('should remove the correct param passed to the function', function (){
+                $scope.device.params = [
+                  { name: 'param1', value: 'value1', type: 'string' },
+                  { name: 'param2', value: 'value2', type: 'string' }
+                ];
+
+                var param_to_remove = { name: 'param1', value: 'value1', type: 'string' };
+                var param_to_keep = { name: 'param2', value: 'value2', type: 'string' };
+
+                expect($scope.device.params[0]).toEqual(param_to_remove)
+                $scope.removeParam(param_to_remove);
+                expect($scope.device.params[0]).toEqual(param_to_keep)
+            });
+        });
+
+        describe('submit:', function() {
+            it('should run command and return results', function (){
+                $scope.robot = {'name':"myRobot"};
+                $scope.device.name = "led";
+                $scope.command = "brightness";
+                $scope.device.params = [{'name': 'brightness', 'value': 255, 'type':'string'}];
+                var params = {'brightness': 255};
+                var data= {'result': "brightness is 255"};
+
+                $scope.submit();
+                $httpBackend.expectPOST('/api/robots/myRobot/devices/led/commands/brightness', params).respond(data);
+                $httpBackend.flush();
+                expect($scope.device.results[0]).toEqual({'result': "brightness is 255"})
+            });
+        });
+
+    });
+});

data/test/controllers/device_events_ctrl.js

@@ -0,0 +1,82 @@
+describe("Testing Controllers", function() {
+    describe('Controller DeviceEventsCtrl:', function() {
+
+        beforeEach(module('robeaux'));
+        
+        var $scope, $rootScope, $httpBackend, $timeout, testController;
+        
+        beforeEach(inject(function($injector) {
+            $timeout = $injector.get('$timeout');
+            $httpBackend = $injector.get('$httpBackend');
+            $rootScope = $injector.get('$rootScope');
+            $scope = $rootScope.$new();
+
+            var $controller = $injector.get('$controller');
+
+            testController = function() {
+                return $controller('DeviceEventsCtrl', {
+                    '$scope': $scope
+                });
+            };
+            var controller = testController();
+
+            jasmine.getJSONFixtures().fixturesPath='base/test/support';
+
+            var data = loadJSONFixtures('myDevice.json')['myDevice.json'];
+
+            $scope.robot = {'name':"myRobot"};
+            $scope.eventName = "";
+            $scope.device = data[0];
+            $scope.device.events = null;
+            $scope.device.listeners = null;
+        }));
+
+        afterEach(function() {
+            $httpBackend.verifyNoOutstandingExpectation();
+            $httpBackend.verifyNoOutstandingRequest();
+        });
+
+        describe('listen:', function() {
+            it('should add a listener for an event and clear eventName', function (){
+                expect($scope.device.listeners).toBe(null);
+                $scope.eventName = "listen_event";
+                $scope.listen();
+                expect($scope.device.listeners['listen_event']).not.toBe(null);
+                expect($scope.eventName).toBe("");
+            });
+
+            it('should listen to multiple events', function (){
+                expect($scope.device.listeners).toBe(null);
+                
+                $scope.eventName = "first_event";
+                $scope.listen();
+                $scope.eventName = "second_event";
+                $scope.listen();
+                $scope.eventName = "third_event";
+                $scope.listen();
+
+                expect($scope.device.listeners['first_event']).not.toBe(null);
+                expect($scope.device.listeners['second_event']).not.toBe(null);
+                expect($scope.device.listeners['third_event']).not.toBe(null);
+            });
+        });
+
+        describe('remove:', function() {
+            it('should remove listener', function (){
+                expect($scope.device.listeners).toBe(null);
+                
+                $scope.eventName = "listen_event";
+                $scope.listen();
+                expect($scope.device.listeners['listen_event']).not.toBe(null);
+
+                $scope.remove("listen_event")
+
+                expect($scope.device.listeners['listen_event']).toBe(undefined);
+                
+            });
+        });
+
+
+        
+    });
+});

data/test/controllers/index_ctrl.js

@@ -0,0 +1,48 @@
+describe("Testing Controllers", function() {
+    describe('Controller IndexCtrl:', function() {
+        
+        beforeEach(module('robeaux'));
+        
+        var $scope, $rootScope, $httpBackend, $location, $timeout, testController, data;
+        
+        beforeEach(inject(function($injector) {
+            $timeout = $injector.get('$timeout');
+            $httpBackend = $injector.get('$httpBackend');
+            $rootScope = $injector.get('$rootScope');
+            $location = $injector.get('$location');
+            $scope = $rootScope.$new();
+
+            var $controller = $injector.get('$controller');
+
+            testController = function() {
+                return $controller('IndexCtrl', {
+                    '$scope': $scope
+                });
+            };
+
+            var controller = testController();
+
+            jasmine.getJSONFixtures().fixturesPath='base/test/support';
+            data = loadJSONFixtures('robots.json')['robots.json'];
+            $httpBackend.expect('GET', '/api/robots').respond(data);
+            $httpBackend.flush();
+        }));
+
+        afterEach(function() {
+            $httpBackend.verifyNoOutstandingExpectation();
+            $httpBackend.verifyNoOutstandingRequest();
+        });
+
+        it('should get array of robots', function() {
+            expect($scope.robots).toEqual(data.robots);
+        });
+
+        describe('details:', function() {
+            it('should redirect to robot show page', function() {
+                expect($location.path()).toEqual('');
+                $scope.details(data.robots[0].name);
+                expect($location.path()).toEqual('/robots/' + data.robots[0].name);
+            });
+        });
+    });
+});

data/test/controllers/nav_ctrl.js

@@ -0,0 +1,40 @@
+describe("Testing Controllers", function() {
+    describe('Controller NavCtrl:', function() {
+        
+        beforeEach(module('robeaux'));
+        
+        var $scope, $rootScope, $httpBackend, $location, $timeout, testController;
+        
+        beforeEach(inject(function($injector) {
+            $timeout = $injector.get('$timeout');
+            $httpBackend = $injector.get('$httpBackend');
+            $rootScope = $injector.get('$rootScope');
+            $location = $injector.get('$location');
+            $scope = $rootScope.$new();
+
+            var $controller = $injector.get('$controller');
+
+            testController = function() {
+                return $controller('NavCtrl', {
+                    '$scope': $scope
+                });
+            };
+
+            var controller = testController();
+        }));
+
+        afterEach(function() {
+            $httpBackend.verifyNoOutstandingExpectation();
+            $httpBackend.verifyNoOutstandingRequest();
+        });
+
+        describe('active:', function() {
+            it('should return if current path is the same as the location path', function() {
+                $location.path('robots');
+                
+                expect($scope.active('robots')).toEqual(true);
+                expect($scope.active('robots/myRobot')).toEqual(false);
+            });
+        });
+    });
+});

data/test/controllers/robot_commands_ctrl.js

@@ -0,0 +1,127 @@
+describe("Testing Controllers", function() {
+    describe('Controller RobotCommandsCtrl:', function() {
+        
+        beforeEach(module('robeaux'));
+        
+        var $scope, $rootScope, $httpBackend, $timeout, $routeParams, testController;
+        var $injector = angular.injector(['robeaux', 'ng']);
+        
+        beforeEach(inject(function($injector) {
+            $timeout = $injector.get('$timeout');
+            $httpBackend = $injector.get('$httpBackend');
+            $rootScope = $injector.get('$rootScope');
+            $routeParams = $injector.get('$routeParams');
+            $scope = $rootScope.$new();
+
+            var $controller = $injector.get('$controller');
+
+            testController = function() {
+                return $controller('RobotCommandsCtrl', {
+                    '$scope': $scope
+                });
+            };
+            var controller = testController();
+
+            jasmine.getJSONFixtures().fixturesPath='base/test/support';
+            var data = loadJSONFixtures('myRobot.json')['myRobot.json'];
+            $scope.robot = data.robot;
+            $scope.robot.params = [ { name: '', value: '', type: 'string' } ];
+            $scope.robot.results = [];
+        }));
+
+        afterEach(function() {
+            $httpBackend.verifyNoOutstandingExpectation();
+            $httpBackend.verifyNoOutstandingRequest();
+        });
+
+        describe('command:', function() {
+            it('should be an empty string', function (){
+                expect($scope.command).toBe("");
+            });
+        });
+
+        describe('command types:', function() {
+            it('should be an array of string, boolean and number', function (){
+                var command_types = [ 'string', 'boolean', 'number' ];
+                expect($scope.types).toEqual(command_types);
+            });
+        });
+
+        describe('isDisabled:', function() {
+            it('should return true if command is empty', function (){
+                expect($scope.isDisabled()).toBe(true);
+            });
+
+            it('should return false if command exist', function (){
+                $scope.command = 'test_command'
+                expect($scope.isDisabled()).toBe(false);
+            });
+        });
+
+        describe('addParam:', function() {
+            it('should add params if last', function (){
+                expect($scope.robot.params.length).toBe(1)
+                $scope.addParam($scope.robot);
+                expect($scope.robot.params.length).toBe(2)
+            });
+
+            it('should not add params if not last', function (){
+                expect($scope.robot.params.length).toBe(1)
+                $scope.addParam();
+                expect($scope.robot.params.length).toBe(1)
+            });
+        });
+
+        describe('removeParam:', function() {
+            it('should remove param if there is more than one', function (){
+                $scope.robot.params = [
+                  { name: '', value: '', type: 'string' },
+                  { name: '', value: '', type: 'string' }
+                ];
+
+                expect($scope.robot.params.length).toBe(2)
+                $scope.removeParam($scope.robot);
+                expect($scope.robot.params.length).toBe(1)
+            });
+
+            it('should not remove param if there just one', function (){
+                $scope.robot.params = [
+                  { name: '', value: '', type: 'string' }
+                ];
+
+                expect($scope.robot.params.length).toBe(1)
+                $scope.removeParam($scope.robot);
+                expect($scope.robot.params.length).toBe(1)
+            });
+
+            it('should remove the correct param passed to the function', function (){
+                $scope.robot.params = [
+                  { name: 'param1', value: 'value1', type: 'string' },
+                  { name: 'param2', value: 'value2', type: 'string' }
+                ];
+
+                var param_to_remove = { name: 'param1', value: 'value1', type: 'string' };
+                var param_to_keep = { name: 'param2', value: 'value2', type: 'string' };
+
+                expect($scope.robot.params[0]).toEqual(param_to_remove)
+                $scope.removeParam(param_to_remove);
+                expect($scope.robot.params[0]).toEqual(param_to_keep)
+            });
+        });
+
+        describe('submit:', function() {
+            it('should run command and return results', function (){
+                $scope.robot.name = "myRobot";
+                $scope.command = "relax";
+                $scope.robot.params= [{'name': 'relax', 'value':'true', 'type':'string'}];
+                var params  = {'relax': 'true'};
+                var data= {'result': "myRobot says relax"};
+
+                $scope.submit();
+                $httpBackend.expectPOST('/api/robots/myRobot/commands/relax', params).respond(data);
+                $httpBackend.flush();
+                expect($scope.robot.results).toEqual([{'result': "myRobot says relax"}])
+            });
+        });
+    });
+});

data/test/controllers/robot_ctrl.js

@@ -0,0 +1,62 @@
+describe("Testing Controllers", function() {
+    describe('Controller RobotCtrl:', function() {
+        
+        beforeEach(module('robeaux'));
+        
+        var $scope, $rootScope, $httpBackend, $timeout, $routeParams, testController;
+        
+        beforeEach(inject(function($injector) {
+            $timeout = $injector.get('$timeout');
+            $httpBackend = $injector.get('$httpBackend');
+            $rootScope = $injector.get('$rootScope');
+            $routeParams = $injector.get('$routeParams');
+            $scope = $rootScope.$new();
+
+            var $controller = $injector.get('$controller');
+
+            testController = function() {
+                return $controller('RobotCtrl', {
+                    '$scope': $scope
+
+                });
+            };
+            var controller = testController();
+
+            jasmine.getJSONFixtures().fixturesPath='base/test/support';
+            $httpBackend.expect('GET', '/api/robots/' + $routeParams.robot).respond(loadJSONFixtures('myRobot.json')['myRobot.json']);
+            $httpBackend.flush();
+
+        }));
+
+        afterEach(function() {
+            $httpBackend.verifyNoOutstandingExpectation();
+            $httpBackend.verifyNoOutstandingRequest();
+        });
+
+        it('should get robot details', function() {
+            var data = loadJSONFixtures('myRobot.json')['myRobot.json'];
+            data.robot.params = [ { name: '', value: '', type: 'string' } ];
+            data.robot.results = [];
+            expect($scope.robot).toEqual(data.robot);
+        });
+
+        describe('select:', function() {
+            it('should select a device', function (){
+                var robotArray= [{"name": "robo1"},{"name":"robo2"}];
+                $scope.robot = robotArray;
+                $scope.select($scope.robot[1]);
+                expect($scope.robot[1]).toEqual($scope.device);
+                expect($scope.robot[0]).toNotEqual($scope.device);
+            });
+        });
+
+        describe('selected:', function() {
+            it('should return if device is still selected', function (){
+                var robotArray= [{"name": "robo1"},{"name":"robo2"}];
+                $scope.robot = robotArray;
+                $scope.select($scope.robot);
+                expect($scope.selected($scope.robot)).toBeTruthy();
+            });
+        });
+    });
+});

data/test/controllers/themes_ctrl.js

@@ -0,0 +1,96 @@
+describe("Testing Controllers", function() {
+    describe('Controller ThemesCtrl:', function() {
+        
+        beforeEach(module('robeaux'));
+        
+        var $scope, $rootScope, $httpBackend, $timeout, $routeParams, testController, data;
+        
+        beforeEach(inject(function($injector) {
+            localStorage.clear();
+            $timeout = $injector.get('$timeout');
+            $httpBackend = $injector.get('$httpBackend');
+            $rootScope = $injector.get('$rootScope');
+            $routeParams = $injector.get('$routeParams');
+            $scope = $rootScope.$new();
+            $scope.themes = $injector.get('Themes')
+
+            var $controller = $injector.get('$controller');
+
+            testController = function() {
+                return $controller('ThemesCtrl', {
+                    '$scope': $scope
+
+                });
+            };
+            var controller = testController();
+            jasmine.getJSONFixtures().fixturesPath='base/test/support';
+            data = loadJSONFixtures('themes.json')['themes.json'];
+
+        }));
+
+        afterEach(function() {
+            $scope.themes = null;
+            $httpBackend.verifyNoOutstandingExpectation();
+            $httpBackend.verifyNoOutstandingRequest();
+        });
+
+        it('should get array of themes', function() {
+            expect($scope.themes.list).toEqual(data.themes);
+        });
+
+        describe('add:', function() {
+            it('should not add theme with empty name', function() {
+                expect($scope.themes.list.length).toEqual(5);
+                $scope.add('');
+                expect($scope.themes.list.length).toEqual(5);
+                $scope.add();
+                expect($scope.themes.list.length).toEqual(5);
+            });
+
+            it('should not add theme if name already exist', function() {
+                expect($scope.themes.list.length).toEqual(5);
+                $scope.add('artoo');
+                expect($scope.themes.list.length).toEqual(5);
+            });
+
+            it('should add theme', function() {
+                expect($scope.themes.list.length).toEqual(5);
+                $scope.add('first theme');
+                expect($scope.themes.list.length).toEqual(6);
+            });
+
+            it('should add theme and put it on edit mode', function() {
+                expect($scope.editing).toEqual(null);
+                $scope.add('second theme');
+                expect($scope.editing.name).toEqual('second theme');
+            });
+        });
+
+        describe('edit:', function() {
+            it('should not set theme on edit mode if is not a custom theme', function() {
+                expect($scope.editing).toEqual(null);
+                $scope.edit(data.themes[0].name)
+                expect($scope.editing).toEqual(null);
+            });
+
+            it('should not set theme on edit mode if theme is already being edited', function() {
+                expect($scope.editing).toEqual(null);
+                $scope.add('third theme')
+                expect($scope.editing.name).toEqual('third theme');
+
+                $scope.edit('third theme');
+                expect($scope.editing).toEqual(null);
+            });
+        });
+
+        describe('remove:', function() {
+            it('should remove theme', function() {
+                expect($scope.themes.list.length).toEqual(5);
+                $scope.remove('artoo');
+                expect($scope.themes.list.length).toEqual(4);
+            });
+        });
+        
+
+    });
+});