rack-noncache 0.0.4 → 1.0.0

data/features/support/web_app/public/test/lib/jasmine-jquery.js

@@ -0,0 +1,306 @@
+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) {
+      var trimmedText = $.trim(this.actual.text());
+      if (text && jQuery.isFunction(text.test)) {
+        return text.test(trimmedText);
+      } else {
+        return trimmedText == 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/features/support/web_app/public/test/spec/models/todo.coffee

@@ -0,0 +1,37 @@
+define ["models/todo", "collections/todos"], (Todo, TodoList) ->
+
+  describe "Todo", ->
+    beforeEach ->
+      @todo = new Todo
+      @todo.urlRoot = "/"
+
+    it "a done should be false be default", ->
+      expect(@todo.get("done")).toBeFalsy()
+
+    it "should return the text", ->
+      @todo.set "text", "hola"
+      expect(@todo.getText()).toEqual "hola"
+
+    it "should set and return the done state", ->
+      @todo.setText "ok"
+      @todo.done()
+      expect(@todo.isDone()).toBeTruthy()
+
+    it "should validate the text length", ->
+      expect(@todo.setText("")).toBeFalsy()
+      expect(@todo.setText("wat")).toBeTruthy()
+
+    
+   describe "TodoList", ->
+     beforeEach ->
+       @collection = new TodoList
+       @collection.add({done: false, text: "uncompleted task"})
+       @collection.add({done: true, text: "done task"})
+
+     it "should return the remaining todos", ->
+       count = @collection.getRemaining().length
+       expect(count).toEqual(1)
+
+     it "should return the completed todos", ->
+       count = @collection.getCompleted().length
+       expect(count).toEqual(1)

data/features/support/web_app/public/test/spec/models/todo.js

@@ -0,0 +1,48 @@
+
+define(["models/todo", "collections/todos"], function(Todo, TodoList) {
+  describe("Todo", function() {
+    beforeEach(function() {
+      this.todo = new Todo;
+      return this.todo.urlRoot = "/";
+    });
+    it("a done should be false be default", function() {
+      return expect(this.todo.get("done")).toBeFalsy();
+    });
+    it("should return the text", function() {
+      this.todo.set("text", "hola");
+      return expect(this.todo.getText()).toEqual("hola");
+    });
+    it("should set and return the done state", function() {
+      this.todo.setText("ok");
+      this.todo.done();
+      return expect(this.todo.isDone()).toBeTruthy();
+    });
+    return it("should validate the text length", function() {
+      expect(this.todo.setText("")).toBeFalsy();
+      return expect(this.todo.setText("wat")).toBeTruthy();
+    });
+  });
+  return describe("TodoList", function() {
+    beforeEach(function() {
+      this.collection = new TodoList;
+      this.collection.add({
+        done: false,
+        text: "uncompleted task"
+      });
+      return this.collection.add({
+        done: true,
+        text: "done task"
+      });
+    });
+    it("should return the remaining todos", function() {
+      var count;
+      count = this.collection.getRemaining().length;
+      return expect(count).toEqual(1);
+    });
+    return it("should return the completed todos", function() {
+      var count;
+      count = this.collection.getCompleted().length;
+      return expect(count).toEqual(1);
+    });
+  });
+});

data/features/support/web_app/public/test/spec/spec_helper.coffee

@@ -0,0 +1,20 @@
+# Helper functions available to all specs in the this.scope.
+
+define ["models/todo", "collections/todos", "views/todoedit"], (Todo, TodoList, TodoEditor) ->
+  beforeEach ->
+
+    # set fake url to not hit the DB with each test.
+    # TODO use sinon or stub out Backbone.sync() for better handling
+    @todoList = new TodoList
+    @todoList.url = "/"
+
+    @todo = new Todo(text: "new todo") 
+    @todo.urlRoot = "/"
+
+    @editor = new TodoEditor
+
+    # Returns the default options for todos views.
+    @viewOptions =
+      model     : @todo
+      collection  : @todoList
+      editor    : @editor

data/features/support/web_app/public/test/spec/spec_helper.js

@@ -0,0 +1,17 @@
+
+define(["models/todo", "collections/todos", "views/todoedit"], function(Todo, TodoList, TodoEditor) {
+  return beforeEach(function() {
+    this.todoList = new TodoList;
+    this.todoList.url = "/";
+    this.todo = new Todo({
+      text: "new todo"
+    });
+    this.todo.urlRoot = "/";
+    this.editor = new TodoEditor;
+    return this.viewOptions = {
+      model: this.todo,
+      collection: this.todoList,
+      editor: this.editor
+    };
+  });
+});

data/features/support/web_app/public/test/spec/views/stats.coffee

@@ -0,0 +1,9 @@
+define ["views/stats"], (TodoStatsView) ->
+  describe "TodoStatsView", ->
+    beforeEach ->
+      @view = new TodoStatsView(@viewOptions)
+
+    it "should render on the 'all' event", ->
+      spyOn(@view.$el, "html").andCallThrough()
+      @view.collection.trigger("all")
+      expect(@view.$el.html).toHaveBeenCalled()

data/features/support/web_app/public/test/spec/views/stats.js

@@ -0,0 +1,13 @@
+
+define(["views/stats"], function(TodoStatsView) {
+  return describe("TodoStatsView", function() {
+    beforeEach(function() {
+      return this.view = new TodoStatsView(this.viewOptions);
+    });
+    return it("should render on the 'all' event", function() {
+      spyOn(this.view.$el, "html").andCallThrough();
+      this.view.collection.trigger("all");
+      return expect(this.view.$el.html).toHaveBeenCalled();
+    });
+  });
+});