rhoconnect 3.1.2 → 3.2.0.beta1

data/spec/javascripts/PlayerSpec.js

@@ -0,0 +1,58 @@
+// describe("Player", function() {
+//   var player;
+//   var song;
+// 
+//   beforeEach(function() {
+//     player = new Player();
+//     song = new Song();
+//   });
+// 
+//   it("should be able to play a Song", function() {
+//     player.play(song);
+//     expect(player.currentlyPlayingSong).toEqual(song);
+// 
+//     //demonstrates use of custom matcher
+//     expect(player).toBePlaying(song);
+//   });
+// 
+//   describe("when song has been paused", function() {
+//     beforeEach(function() {
+//       player.play(song);
+//       player.pause();
+//     });
+// 
+//     it("should indicate that the song is currently paused", function() {
+//       expect(player.isPlaying).toBeFalsy();
+// 
+//       // demonstrates use of 'not' with a custom matcher
+//       expect(player).not.toBePlaying(song);
+//     });
+// 
+//     it("should be possible to resume", function() {
+//       player.resume();
+//       expect(player.isPlaying).toBeTruthy();
+//       expect(player.currentlyPlayingSong).toEqual(song);
+//     });
+//   });
+// 
+//   // demonstrates use of spies to intercept and test method calls
+//   it("tells the current song if the user has made it a favorite", function() {
+//     spyOn(song, 'persistFavoriteStatus');
+// 
+//     player.play(song);
+//     player.makeFavorite();
+// 
+//     expect(song.persistFavoriteStatus).toHaveBeenCalledWith(true);
+//   });
+// 
+//   //demonstrates use of expected exceptions
+//   describe("#resume", function() {
+//     it("should throw an exception if song is already playing", function() {
+//       player.play(song);
+// 
+//       expect(function() {
+//         player.resume();
+//       }).toThrow("song is already playing");
+//     });
+//   });
+// });

data/spec/javascripts/admins_routes_spec.js

@@ -0,0 +1,117 @@
+describe("Admins routes", function() {
+  beforeEach(function() {
+    this.router = new App.Controllers.Admins();
+    this.routeSpy = sinon.spy();
+    try {
+      Backbone.History.start({silent:true, pushState:true});
+    } catch(e) {}
+    this.router.navigate("test");
+  });
+  
+  it("fires the index route with a blank hash", function() {
+     this.router.bind("route:index", this.routeSpy);
+     this.router.navigate("", true);
+     expect(this.routeSpy).toHaveBeenCalledOnce();
+     expect(this.routeSpy).toHaveBeenCalledWith();
+   });
+  
+  it("fires the home route with a blank hash", function() {
+     this.router.bind("route:index", this.routeSpy);
+     this.router.navigate("home", true);
+     expect(this.routeSpy).toHaveBeenCalledOnce();
+     expect(this.routeSpy).toHaveBeenCalledWith();
+   });
+
+  it("fires the show_source route", function() {
+   	this.router.bind('route:show_source', this.routeSpy);
+   	this.router.navigate("sources/1", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith("1");
+   });
+
+  it("fires the login route", function() {
+   	this.router.bind('route:login', this.routeSpy);
+   	this.router.navigate("login", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith();
+  });
+
+  it("fires the logout route", function() {
+   	this.router.bind('route:logout', this.routeSpy);
+   	this.router.navigate("logout", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith();
+  });
+
+  it("fires the get_doc route", function() {
+   	this.router.bind('route:get_doc', this.routeSpy);
+   	this.router.navigate("doc/testdoc/2", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith("testdoc","2");
+  });
+
+  it("fires the server_doc route", function() {
+   	this.router.bind('route:server_doc', this.routeSpy);
+   	this.router.navigate("docselect", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith();
+  });
+
+  it("fires the adapter route", function() {
+   	this.router.bind('route:adapter', this.routeSpy);
+   	this.router.navigate("adapter", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith();
+  });
+
+  it("fires the users route", function() {
+   	this.router.bind('route:users', this.routeSpy);
+   	this.router.navigate("users", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith();
+  });
+
+  it("fires the new_user route", function() {
+   	this.router.bind('route:new_user', this.routeSpy);
+   	this.router.navigate("users/new", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith();
+  });
+
+  it("fires the show_user route", function() {
+   	this.router.bind('route:show_user', this.routeSpy);
+   	this.router.navigate("user/1", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith("1");
+  });
+
+  it("fires the new_ping route", function() {
+   	this.router.bind('route:new_ping', this.routeSpy);
+   	this.router.navigate("user/newping/1", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith("1");
+  });
+
+  it("fires the new_ping_all route", function() {
+   	this.router.bind('route:new_ping_all', this.routeSpy);
+   	this.router.navigate("users/newping", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith();
+  });
+
+  it("fires the user_device route", function() {
+   	this.router.bind('route:user_device', this.routeSpy);
+   	this.router.navigate("device/1/2", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith("1","2");
+  });
+
+  it("fires the change_admin route", function() {
+   	this.router.bind('route:change_admin', this.routeSpy);
+   	this.router.navigate("change_admin", true);
+   	expect(this.routeSpy).toHaveBeenCalledOnce();
+   	expect(this.routeSpy).toHaveBeenCalledWith();
+  });
+
+});
+

data/spec/javascripts/admins_spec.js

@@ -0,0 +1,27 @@
+// describe("Admins", function() {
+// 
+//   beforeEach(function() {
+//    	 this.router      = new App.Controllers.Admins();
+// 	 this.session     = new Session();
+// 	 this.sessionStub = sinon.stub(this.session,"getAuthenticated").returns("true")
+// 
+// 	 this.home = new App.Views.Home({model:new Source()});
+// 	 this.fetchStub = sinon.stub(this.model.home,'fetch').returns(null);
+// 	 this.fetchSave = sinon.stub(this.model.home,'save').returns(null);
+//   });
+//   
+//   afterEach(function() {
+//     
+//   });
+// 
+//   it("creats a new Index page if not logged in",function(){
+// 	
+// 	
+// 	 this.router.index();
+// 	
+// 	 expect(sessionStub).toHaveBeenCalledOnce();
+// 	 //expect(this.fetchStub).toHaveBeenCalledOnce();
+// 	 //expect(this.fetchSave).toHaveBeenCalledOnce();
+//   });
+// 
+// });

data/spec/javascripts/doc_view_spec.js

@@ -0,0 +1,37 @@
+describe("DocView", function(){
+	
+	beforeEach(function(){
+		var session = new Session();
+		session.setAuthenticated('true');
+		session.setApiKey('testtoken');
+		
+	    doc = new Doc();
+	    doc.set("dbkey",'testkey');
+	
+		sinon.stub(doc,'get_doc')
+	
+		this.docView = new App.Views.Doc({model : doc});
+	});
+	
+	afterEach(function(){
+		var session = new Session();
+		session.setAuthenticated('false');
+		session.setApiKey(null);
+	});
+	
+	it("should have render initial html",function(){
+		this.docRenderSpy = sinon.spy(this.docView,'render');
+			
+		this.docView.render();
+		expect(this.docRenderSpy).toHaveBeenCalledOnce();
+	});
+	
+	it("should have correct html rendered ",function(){
+		var title = this.docView.el.innerHTML.search('[testkey]');
+		expect(title).toBeGreaterThan(0);
+		
+		var change_btn = this.docView.el.innerHTML.search('Upload Token string');
+		expect(change_btn).toBeGreaterThan(0);
+		
+	})
+});

data/spec/javascripts/edit_user_view_spec.js

@@ -0,0 +1,44 @@
+describe("EditUserView", function(){
+	
+	beforeEach(function(){
+		var session = new Session();
+		session.setAuthenticated('true');
+		session.setApiKey('testtoken');
+		this.editUserView = new App.Views.EditUser();
+	});
+	
+	afterEach(function(){
+		var session = new Session();
+		session.setAuthenticated('false');
+		session.setApiKey(null);
+	});
+	
+	it("should have render initial html",function(){
+		this.UserRenderSpy = sinon.spy(this.editUserView,'render');
+			
+		this.editUserView.render();
+		expect(this.UserRenderSpy).toHaveBeenCalledOnce();
+	});
+	
+	it("should call edit",function(){
+		this.editUserRenderSpy = sinon.spy(this.editUserView,'edit');
+		sinon.stub(jQuery,'ajax').yieldsTo("success");
+		function myevent(){
+			this.preventDefault=function(){return true;}
+		}
+		e = new myevent();
+		
+		this.editUserView.edit(e);
+		expect(this.editUserRenderSpy).toHaveBeenCalledOnce();
+		jQuery.ajax.restore();
+	});
+	
+	it("should have correct html rendered ",function(){
+		var title = this.editUserView.el.innerHTML.search('Edit admin');
+		expect(title).toBeGreaterThan(0);
+		
+		var password = this.editUserView.el.innerHTML.search('Password');
+		expect(password).toBeGreaterThan(0);
+		
+	})
+});

data/spec/javascripts/helpers/SpecHelper.js

@@ -0,0 +1,9 @@
+// beforeEach(function() {
+//   this.addMatchers({
+//     toBePlaying: function(expectedSong) {
+//       var player = this.actual;
+//       return player.currentlyPlayingSong === expectedSong && 
+//              player.isPlaying;
+//     }
+//   });
+// });

data/spec/javascripts/helpers/jasmine-jquery.js

@@ -0,0 +1,305 @@
+var readFixtures = function() {
+  return jasmine.getFixtures().proxyCallTo_('read', arguments);
+};
+
+var preloadFixtures = function() {
+  jasmine.getFixtures().proxyCallTo_('preload', arguments);
+};
+
+var loadFixtures = function() {
+  jasmine.getFixtures().proxyCallTo_('load', arguments);
+};
+
+var setFixtures = function(html) {
+  jasmine.getFixtures().set(html);
+};
+
+var sandbox = function(attributes) {
+  return jasmine.getFixtures().sandbox(attributes);
+};
+
+var spyOnEvent = function(selector, eventName) {
+  jasmine.JQuery.events.spyOn(selector, eventName);
+};
+
+jasmine.getFixtures = function() {
+  return jasmine.currentFixtures_ = jasmine.currentFixtures_ || new jasmine.Fixtures();
+};
+
+jasmine.Fixtures = function() {
+  this.containerId = 'jasmine-fixtures';
+  this.fixturesCache_ = {};
+  this.fixturesPath = 'spec/javascripts/fixtures';
+};
+
+jasmine.Fixtures.prototype.set = function(html) {
+  this.cleanUp();
+  this.createContainer_(html);
+};
+
+jasmine.Fixtures.prototype.preload = function() {
+  this.read.apply(this, arguments);
+};
+
+jasmine.Fixtures.prototype.load = function() {
+  this.cleanUp();
+  this.createContainer_(this.read.apply(this, arguments));
+};
+
+jasmine.Fixtures.prototype.read = function() {
+  var htmlChunks = [];
+
+  var fixtureUrls = arguments;
+  for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) {
+    htmlChunks.push(this.getFixtureHtml_(fixtureUrls[urlIndex]));
+  }
+
+  return htmlChunks.join('');
+};
+
+jasmine.Fixtures.prototype.clearCache = function() {
+  this.fixturesCache_ = {};
+};
+
+jasmine.Fixtures.prototype.cleanUp = function() {
+  jQuery('#' + this.containerId).remove();
+};
+
+jasmine.Fixtures.prototype.sandbox = function(attributes) {
+  var attributesToSet = attributes || {};
+  return jQuery('<div id="sandbox" />').attr(attributesToSet);
+};
+
+jasmine.Fixtures.prototype.createContainer_ = function(html) {
+  var container;
+  if(html instanceof jQuery) {
+    container = jQuery('<div id="' + this.containerId + '" />');
+    container.html(html);
+  } else {
+    container = '<div id="' + this.containerId + '">' + html + '</div>'
+  }
+  jQuery('body').append(container);
+};
+
+jasmine.Fixtures.prototype.getFixtureHtml_ = function(url) {
+  if (typeof this.fixturesCache_[url] == 'undefined') {
+    this.loadFixtureIntoCache_(url);
+  }
+  return this.fixturesCache_[url];
+};
+
+jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function(relativeUrl) {
+  var url = this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl;
+  var request = new XMLHttpRequest();
+  request.open("GET", url + "?" + new Date().getTime(), false);
+  request.send(null);
+  this.fixturesCache_[relativeUrl] = request.responseText;
+};
+
+jasmine.Fixtures.prototype.proxyCallTo_ = function(methodName, passedArguments) {
+  return this[methodName].apply(this, passedArguments);
+};
+
+
+jasmine.JQuery = function() {};
+
+jasmine.JQuery.browserTagCaseIndependentHtml = function(html) {
+  return jQuery('<div/>').append(html).html();
+};
+
+jasmine.JQuery.elementToString = function(element) {
+  return jQuery('<div />').append($(element).clone()).html();
+};
+
+jasmine.JQuery.matchersClass = {};
+
+(function(namespace) {
+  var data = {
+    spiedEvents: {},
+    handlers:    []
+  };
+
+  namespace.events = {
+    spyOn: function(selector, eventName) {
+      var handler = function(e) {
+        data.spiedEvents[[selector, eventName]] = e;
+      };
+      jQuery(selector).bind(eventName, handler);
+      data.handlers.push(handler);
+    },
+
+    wasTriggered: function(selector, eventName) {
+      return !!(data.spiedEvents[[selector, eventName]]);
+    },
+
+    wasPrevented: function(selector, eventName) {
+      return data.spiedEvents[[selector, eventName]].isDefaultPrevented();
+    },
+
+    cleanUp: function() {
+      data.spiedEvents = {};
+      data.handlers    = [];
+    }
+  }
+})(jasmine.JQuery);
+
+(function(){
+  var jQueryMatchers = {
+    toHaveClass: function(className) {
+      return this.actual.hasClass(className);
+    },
+
+    toBeVisible: function() {
+      return this.actual.is(':visible');
+    },
+
+    toBeHidden: function() {
+      return this.actual.is(':hidden');
+    },
+
+    toBeSelected: function() {
+      return this.actual.is(':selected');
+    },
+
+    toBeChecked: function() {
+      return this.actual.is(':checked');
+    },
+
+    toBeEmpty: function() {
+      return this.actual.is(':empty');
+    },
+
+    toExist: function() {
+      return this.actual.size() > 0;
+    },
+
+    toHaveAttr: function(attributeName, expectedAttributeValue) {
+      return hasProperty(this.actual.attr(attributeName), expectedAttributeValue);
+    },
+
+    toHaveProp: function(propertyName, expectedPropertyValue) {
+      return hasProperty(this.actual.prop(propertyName), expectedPropertyValue);
+    },
+
+    toHaveId: function(id) {
+      return this.actual.attr('id') == id;
+    },
+
+    toHaveHtml: function(html) {
+      return this.actual.html() == jasmine.JQuery.browserTagCaseIndependentHtml(html);
+    },
+
+    toHaveText: function(text) {
+      if (text && jQuery.isFunction(text.test)) {
+        return text.test(this.actual.text());
+      } else {
+        return this.actual.text() == text;
+      }
+    },
+
+    toHaveValue: function(value) {
+      return this.actual.val() == value;
+    },
+
+    toHaveData: function(key, expectedValue) {
+      return hasProperty(this.actual.data(key), expectedValue);
+    },
+
+    toBe: function(selector) {
+      return this.actual.is(selector);
+    },
+
+    toContain: function(selector) {
+      return this.actual.find(selector).size() > 0;
+    },
+
+    toBeDisabled: function(selector){
+      return this.actual.is(':disabled');
+    },
+
+	toBeFocused: function(selector) {
+	  return this.actual.is(':focus');
+    },
+
+    // tests the existence of a specific event binding
+    toHandle: function(eventName) {
+      var events = this.actual.data("events");
+      return events && events[eventName].length > 0;
+    },
+
+    // tests the existence of a specific event binding + handler
+    toHandleWith: function(eventName, eventHandler) {
+      var stack = this.actual.data("events")[eventName];
+      var i;
+      for (i = 0; i < stack.length; i++) {
+        if (stack[i].handler == eventHandler) {
+          return true;
+        }
+      }
+      return false;
+    }
+  };
+
+  var hasProperty = function(actualValue, expectedValue) {
+    if (expectedValue === undefined) {
+      return actualValue !== undefined;
+    }
+    return actualValue == expectedValue;
+  };
+
+  var bindMatcher = function(methodName) {
+    var builtInMatcher = jasmine.Matchers.prototype[methodName];
+
+    jasmine.JQuery.matchersClass[methodName] = function() {
+      if (this.actual
+          && (this.actual instanceof jQuery
+             || jasmine.isDomNode(this.actual))) {
+        this.actual = $(this.actual);
+        var result = jQueryMatchers[methodName].apply(this, arguments);
+        this.actual = jasmine.JQuery.elementToString(this.actual);
+        return result;
+      }
+
+      if (builtInMatcher) {
+        return builtInMatcher.apply(this, arguments);
+      }
+
+      return false;
+    };
+  };
+
+  for(var methodName in jQueryMatchers) {
+    bindMatcher(methodName);
+  }
+})();
+
+beforeEach(function() {
+  this.addMatchers(jasmine.JQuery.matchersClass);
+  this.addMatchers({
+    toHaveBeenTriggeredOn: function(selector) {
+      this.message = function() {
+        return [
+          "Expected event " + this.actual + " to have been triggered on " + selector,
+          "Expected event " + this.actual + " not to have been triggered on " + selector
+        ];
+      };
+      return jasmine.JQuery.events.wasTriggered($(selector), this.actual);
+    }
+  });
+  this.addMatchers({
+    toHaveBeenPreventedOn: function(selector) {
+      this.message = function() {
+        return [
+          "Expected event " + this.actual + " to have been prevented on " + selector,
+          "Expected event " + this.actual + " not to have been prevented on " + selector
+        ];
+      };
+      return jasmine.JQuery.events.wasPrevented(selector, this.actual);
+    }
+  });
+});
+
+afterEach(function() {
+  jasmine.getFixtures().cleanUp();
+  jasmine.JQuery.events.cleanUp();
+});

data/spec/javascripts/helpers/jasmine-sinon.js

@@ -0,0 +1,43 @@
+(function(global) {
+
+  var spyMatchers = "called calledOnce calledTwice calledThrice calledBefore calledAfter calledOn alwaysCalledOn calledWith alwaysCalledWith calledWithExactly alwaysCalledWithExactly".split(" "),
+    i = spyMatchers.length,
+    spyMatcherHash = {},
+    unusualMatchers = {
+      "returned": "toHaveReturned",
+      "alwaysReturned": "toHaveAlwaysReturned",
+      "threw": "toHaveThrown",
+      "alwaysThrew": "toHaveAlwaysThrown"
+    },
+
+  getMatcherFunction = function(sinonName) {
+    return function() {
+      var sinonProperty = this.actual[sinonName];
+      return (typeof sinonProperty === 'function') ? sinonProperty.apply(this.actual, arguments) : sinonProperty;
+    };
+  };
+
+  while(i--) {
+    var sinonName = spyMatchers[i],
+      matcherName = "toHaveBeen" + sinonName.charAt(0).toUpperCase() + sinonName.slice(1);
+
+    spyMatcherHash[matcherName] = getMatcherFunction(sinonName);
+  };
+
+  for (var j in unusualMatchers) {
+    spyMatcherHash[unusualMatchers[j]] = getMatcherFunction(j);
+  }
+
+  global.sinonJasmine = {
+    getMatchers: function() {
+      return spyMatcherHash;
+    }
+  };
+
+})(window);
+
+beforeEach(function() {
+
+  this.addMatchers(sinonJasmine.getMatchers());
+
+});