magic_carpet 0.5.0

data/spec/dummy/tmp/jasmine/assets/magic_carpet_spec.js

@@ -0,0 +1,317 @@
+describe("MagicCarpet", function() {
+  var subject;
+
+  beforeEach(function() {
+    subject = MagicCarpet;
+  });
+
+  afterEach(function() {
+    $("#magic-carpet").remove();
+  });
+
+  it("has its async property set to false by default", function(){
+    expect(subject.async).toBeFalse();
+  });
+
+  it("has its asyncComplete property set to true by default", function(){
+    expect(subject.asyncComplete).toBeTrue();
+  });
+
+  it("has an object for caching request results", function(){
+    expect(subject.cache).toBeObject();
+  });
+
+  describe("initialize", function() {
+    beforeEach(function() {
+      spyOn(subject, "cacheElements");
+      spyOn(subject, "appendSandbox");
+      spyOn(subject, "bindAll");
+      subject.initialize();
+    });
+
+    it("caches the necessary elements", function() {
+      expect(subject.cacheElements).toHaveBeenCalled();
+    });
+
+    it("appends the sandbox", function(){
+      expect(subject.appendSandbox).toHaveBeenCalled();
+    });
+
+    it("binds all of its functions", function(){
+      expect(subject.bindAll).toHaveBeenCalled();
+    });
+  });
+
+  describe("bindAll", function(){
+    var dummyFunction;
+    beforeEach(function() {
+      subject.dummyOption = false;
+      dummyFunction = function() { this.dummyOption = true; };
+      subject.dummy = dummyFunction;
+      subject.bindAll();
+    });
+
+    afterEach(function() {
+      delete subject.dummy;
+      delete subject.dummyOption;
+    });
+
+    it("binds all methods", function(){
+      expect(subject.dummy).not.toEqual(dummyFunction);
+      subject.dummy();
+      expect(subject.dummyOption).toBeTrue();
+    });
+  });
+
+  describe("bind", function(){
+    it("binds the function to the context", function(){
+      var obj = {};
+      obj.func = function(arg) { this.funcArg = arg; };
+      subject.bind(obj, "func");
+      var func = obj.func;
+      func("arg");
+      expect(obj.funcArg).toEqual("arg");
+    });
+  });
+
+  describe("cacheElements", function() {
+    beforeEach(function() {
+      spyOn(subject, "createSandbox").and.returnValue("sandbox");
+      subject.cacheElements();
+    });
+
+    it("caches a sandbox", function() {
+      expect(subject.sandbox).toEqual("sandbox");
+    });
+  });
+
+  describe("createSandbox", function() {
+    it("returns a div", function() {
+      expect(subject.createSandbox().tagName).toEqual("DIV");
+    });
+
+    it("returns a div with an ID of #magic-carpet", function() {
+      expect(subject.createSandbox().getAttribute("id")).toEqual("magic-carpet");
+    });
+  });
+
+  describe("appendSandbox", function() {
+    beforeEach(function() {
+      subject.cacheElements();
+      subject.appendSandbox();
+    });
+
+    it("appends the sandbox to the body", function() {
+      expect(subject.sandbox).toBeDefined();
+      expect(subject.sandbox).toEqual($("body #magic-carpet")[0]);
+    });
+  });
+
+  describe("emptySandbox", function(){
+    beforeEach(function() {
+      subject.cacheElements();
+      subject.sandbox.innerHTML = '<div id="dummy"></div>';
+      subject.emptySandbox();
+    });
+
+    it("empties the sandbox", function(){
+      expect($("#dummy")[0]).toBeUndefined();
+      expect(subject.sandbox.innerHTML).toEqual("");
+    });
+  });
+
+  describe("request", function(){
+    var requestData;
+    beforeEach(function() {
+      subject.cacheElements();
+      spyOn(subject, "fetch");
+      requestData = { some: "template" };
+    });
+
+    it("fetches the markup if the request isn't cached", function(){
+      subject.cache = {};
+      subject.request(requestData);
+      expect(subject.fetch).toHaveBeenCalledWith(requestData);
+      expect(subject.sandbox.innerHTML).toEqual("");
+    });
+
+    it("puts the markup on the page when it's already cached", function(){
+      subject.cache[$.param(requestData)] = "markup";
+      subject.request(requestData);
+      expect(subject.fetch).not.toHaveBeenCalled();
+      expect(subject.sandbox.innerHTML).toEqual("markup");
+    });
+  });
+
+  describe("fetch", function(){
+    var arg;
+    beforeEach(function() {
+      subject.asyncComplete = true;
+      subject.lastRequest = undefined;
+      spyOn($, "ajax").and.returnValue(promiseStub);
+      subject.async = "default async setting";
+      subject.fetch("data");
+      arg = $.ajax.calls.argsFor(0)[0];
+    });
+
+    it("makes a get request to /magic_carpet", function(){
+      expect(arg.url).toEqual("/magic_carpet");
+      expect(arg.method).toEqual("get");
+    });
+
+    it("uses the global magic carpet async setting", function(){
+      expect(arg.async).toEqual("default async setting");
+    });
+
+    it("passes its argument as data", function(){
+      expect(arg.data).toEqual("data");
+    });
+
+    it("sets asyncComplete to false", function(){
+      expect(subject.asyncComplete).toBeFalse();
+    });
+
+    it("handles success", function(){
+      expect(promiseStub.done).toHaveBeenCalledWith(subject.handleSuccess);
+    });
+
+    it("handles failure", function(){
+      expect(promiseStub.fail).toHaveBeenCalledWith(subject.handleFailure);
+    });
+
+    it("cleans up after itself", function(){
+      expect(promiseStub.always).toHaveBeenCalledWith(subject.afterRequest);
+    });
+
+    it("caches the request object", function(){
+      expect(subject.lastRequest).toEqual("data");
+    });
+  });
+
+  describe("handleSuccess", function(){
+    var lastRequest;
+    var markup;
+    beforeEach(function() {
+      subject.appendSandbox();
+      lastRequest = { some: "template" };
+      subject.lastRequest = lastRequest;
+      subject.cache = {};
+      markup = '<div id="fresh-markup"></div>';
+      subject.handleSuccess(markup);
+    });
+
+    it("puts the markup in the sandbox", function(){
+      expect($("#magic-carpet #fresh-markup")[0]).toBeDefined();
+    });
+
+    it("caches the markup", function(){
+      expect(subject.cache[$.param(lastRequest)]).toEqual(markup);
+    });
+  });
+
+  describe("handleFailure", function(){
+    it("throws an error with a message", function(){
+      var errorObj = { error: "There was a problem" };
+      var response = { responseJSON: errorObj };
+      expect(function() {
+        subject.handleFailure(response);
+      }).toThrow(new Error(errorObj.error));
+    });
+  });
+
+  describe("afterRequest", function(){
+    beforeEach(function() {
+      subject.asyncComplete = false;
+      subject.afterRequest();
+    });
+
+    it("sets asyncComplete to true", function(){
+      expect(subject.asyncComplete).toBeTrue();
+    });
+  });
+
+  describe("integration specs", function(){
+    beforeEach(function() {
+      subject.async = false;
+      subject.initialize();
+      console.log("*********************************************");
+      console.log(window.location);
+      console.log("*********************************************");
+    });
+
+    describe("templates", function(){
+      it("renders templates", function(){
+        subject.request({
+          controller_name: "Wishes",
+          template: "plain"
+        });
+        expect($("#magic-carpet h1")[0]).toBeDefined();
+      });
+
+      it("action_name can be used instead of template", function(){
+        subject.request({
+          controller_name: "Wishes",
+          action_name: "plain"
+        });
+        expect($("#magic-carpet h1")[0]).toBeDefined();
+      });
+
+      it("renders partials", function(){
+        subject.request({
+          controller_name: "Wishes",
+          partial: "some_partial"
+        });
+        expect($("#magic-carpet h1")[0]).toBeDefined();
+      });
+
+      it("renders local variables", function(){
+        subject.request({
+          controller_name: "Wishes",
+          partial: "wish_list_item",
+          locals: {
+            wish: { id: 1, model: "Wish", text: "some wish text" }
+          }
+        });
+        expect($("#magic-carpet li")[0]).toBeDefined();
+      });
+
+      it("renders collections (with 'as' option)", function(){
+        subject.request({
+          controller_name: "Wishes",
+          partial: "wish_list_item",
+          collection: [
+            { id: 1, model: "Wish", text: "wish text" },
+            { id: 2, model: "Wish", text: "wish text" },
+            { id: 3, model: "Wish", text: "wish text" }
+          ],
+          as: "wish"
+        });
+        expect($("#magic-carpet li").length).toEqual(3);
+      });
+
+      it("renders templates with instance variables", function(){
+        subject.request({
+          controller_name: "Wishes",
+          template: "new",
+          instance_variables: {
+            wish: {
+              model: "Wish"
+            }
+          }
+        });
+        expect($("#magic-carpet #new_wish")[0]).toBeDefined();
+      });
+
+      describe("errors", function(){
+        it("renders missing controller errors", function(){
+          expect(function() {
+            subject.request({
+              controller_name: "blort",
+              action_name: "new"
+            });
+          }).toThrow(new Error("Magic Carpet Error: wrong constant name blortController for 'new' template."));
+        });
+      });
+    });
+  });
+});

data/spec/dummy/tmp/jasmine/assets/users.js

@@ -0,0 +1,3 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.
+;

data/spec/dummy/tmp/jasmine/assets/wishes.js

@@ -0,0 +1,3 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.
+;

data/spec/dummy/tmp/jasmine/runner.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta content="text/html;charset=UTF-8" http-equiv="Content-Type"/>
+    <title>Jasmine Specs</title>
+
+    <link href="./assets/jasmine.css" media="screen" rel="stylesheet" />
+  </head>
+  <body>
+    <div id="jasmine_content"></div>
+    
+    <script src="./assets/jasmine.js"></script>
+<script src="./assets/jasmine-html.js"></script>
+<script src="./assets/json2.js"></script>
+<script src="./assets/boot.js"></script>
+<script src="./assets/jasmine-console-shims.js"></script>
+<script src="./assets/jasmine-console-reporter.js"></script>
+<script src="./assets/jquery-2.1.0.js"></script>
+<script src="./assets/users.js"></script>
+<script src="./assets/wishes.js"></script>
+<script src="./assets/application.js"></script>
+<script src="./assets/magic_carpet/magic_carpet.js"></script>
+<script src="./assets/magic_carpet/application.js"></script>
+<script src="./assets/helpers/spec_helper.js"></script>
+<script src="./assets/magic_carpet_spec.js"></script>
+<script src="./assets/jasmine-specs.js"></script>
+  </body>
+</html>

data/spec/dummy/tmp/pids/server.pid

@@ -0,0 +1 @@
+936

data/spec/helpers/magic_carpet/js_fixtures_helper_spec.rb

@@ -0,0 +1,249 @@
+require "spec_helper"
+require "ostruct"
+
+module MagicCarpet
+  describe JsFixturesHelper do
+    describe "#hydrate" do
+      context "hashes" do
+        it "doesn't change the true values" do
+          original = { truncate: true }.with_indifferent_access
+          actual = helper.hydrate(original)
+          expect(actual[:truncate]).to be_true
+        end
+
+        it "doesn't change the false values" do
+          original = { truncate: false }.with_indifferent_access
+          actual = helper.hydrate(original)
+          expect(actual[:truncate]).to be_false
+        end
+
+        it "doesn't change the nil values" do
+          original = { truncate: nil }.with_indifferent_access
+          actual = helper.hydrate(original)
+          expect(actual[:truncate]).to be_nil
+        end
+
+        it "converts model hashes to models" do
+          hash = {
+            user: {
+              model: "User",
+              username: "username"
+            }.with_indifferent_access
+          }.with_indifferent_access
+          actual = helper.hydrate(hash)
+          expect(actual[:user].username).to eq("username")
+        end
+
+        it "converts numbers" do
+          hash = { some_number: { number: "1.2" } }
+          actual = helper.hydrate(hash)
+          expect(actual[:some_number]).to eq(1.2)
+        end
+
+        it "processes all values in an array" do
+          expected = [1, 2, 3].map { |num| "wish text #{num}" }
+          hash = {
+            wishes: [
+              { model: "Wish", text: expected.first }.with_indifferent_access,
+              { model: "Wish", text: expected.second }.with_indifferent_access,
+              { model: "Wish", text: expected.last }.with_indifferent_access
+            ]
+          }.with_indifferent_access
+          wishes = helper.hydrate(hash)[:wishes].map(&:text)
+          expect(wishes).to eq(expected)
+        end
+
+        it "processes all values in a nested hash" do
+          hash = {
+            numbers: [{ number: "5" }.with_indifferent_access],
+            named_wishes: {
+              favorite_wish: { model: "Wish", text: "fave" }.with_indifferent_access,
+              other_wishes: [
+                { model: "Wish", text: "not fave" }.with_indifferent_access,
+                { model: "Wish", text: "something silly" }.with_indifferent_access
+              ]
+            }.with_indifferent_access
+          }.with_indifferent_access
+
+          actual = helper.hydrate(hash)
+          named_wishes = actual[:named_wishes]
+          expect(actual[:numbers]).to eq([5])
+          expect(named_wishes[:favorite_wish].text).to eq("fave")
+          expect(named_wishes[:other_wishes].map(&:text)).to eq(["not fave", "something silly"])
+        end
+      end
+
+      context "'numbers'" do
+        it "returns a float by default" do
+          hash = { number: "1.5" }.with_indifferent_access
+          actual = helper.hydrate(hash)
+          expect(actual).to eq(1.5)
+          expect(actual.class).to eq(Float)
+        end
+
+        it "returns an integer when 'integer' is set to true" do
+          hash = { number: "1.5", integer: true }.with_indifferent_access
+          actual = helper.hydrate(hash)
+          expect(actual).to eq(1)
+          expect(actual).to be_kind_of(Integer)
+        end
+      end
+
+      context "dates and times" do
+        let(:now) { Time.now }
+
+        context "'dates'" do
+          it "returns a date" do
+            hash = { date: now.to_s }.with_indifferent_access
+            actual = helper.hydrate(hash)
+            expect(actual).to eq(Date.today)
+          end
+        end
+
+        context "'times'" do
+          it "returns a time" do
+            hash = { time: now.to_s }.with_indifferent_access
+            actual = helper.hydrate(hash)
+            expect(actual.to_i).to eq(now.to_i)
+          end
+
+          it "returns a utc time when specified" do
+            hash = { time: now.to_s, utc: "true" }.with_indifferent_access
+            actual = helper.hydrate(hash)
+            expect(actual).to be_utc
+          end
+        end
+
+        context "'date times'" do
+          it "returns a date time" do
+            hash = { datetime: now.to_s }.with_indifferent_access
+            actual = helper.hydrate(hash)
+            expect(actual.class).to eq(DateTime)
+            expect(actual.to_time.to_i).to eq(now.to_time.to_i)
+          end
+        end
+      end
+
+      context "nil" do
+        it "converts a string of 'nil' to nil" do
+          expect(helper.hydrate("nil")).to be_nil
+        end
+      end
+
+      context "false" do
+        it "converts a string of 'false' to false" do
+          expect(helper.hydrate("false")).to eq(false)
+        end
+      end
+
+      context "true" do
+        it "converts a string of 'true' to true" do
+          expect(helper.hydrate("true")).to eq(true)
+        end
+      end
+
+      context "'models'" do
+        it "converts the hash into the model specified by 'model'" do
+          hash = { model: "Wish", text: "wish text" }.with_indifferent_access
+          actual = helper.hydrate(hash)
+          expect(actual.attributes).to eq(Wish.new(text: "wish text").attributes)
+        end
+
+        it "converts nested associations into specified models" do
+          hash = {
+            model: "Wish",
+            text: "wish text",
+            user: {
+              username: "username",
+              model: "User"
+            }
+          }
+          wish = helper.hydrate(hash)
+          expect(wish.text).to eq("wish text")
+          expect(wish.user.username).to eq("username")
+        end
+
+        it "converts nested numbers" do
+          hash = {
+            model: "Wish",
+            id: "5",
+            text: "wish text",
+            user: {
+              username: "username",
+              model: "User",
+              id: "1"
+            }
+          }
+          wish = helper.hydrate(hash)
+          expect(wish.id).to eq(5)
+          expect(wish.user.id).to eq(1)
+        end
+
+        it "converts nested hashes and arrays" do
+          hash = {
+            model: "OpenStruct",
+            text: "ostruct",
+            array: [{ number: "5" }.with_indifferent_access],
+            my_hash: {
+              wish: { model: "Wish", text: "wish text" }
+            }
+          }
+          actual = helper.hydrate(hash)
+          expect(actual.text).to eq("ostruct")
+          expect(actual.array).to eq([5])
+          expect(actual.my_hash[:wish].text).to eq("wish text")
+        end
+      end
+
+      context "arrays" do
+        it "converts each element of the array" do
+          array = [
+            "hello",
+            { number: "5" }.with_indifferent_access,
+            { model: "Wish", text: "wish text" }.with_indifferent_access
+          ]
+          string, number, wish = helper.hydrate(array)
+          expect(string).to eq("hello")
+          expect(number).to eq(5)
+          expect(wish.text).to eq("wish text")
+        end
+
+        it "converts nested arrays" do
+          array = [
+            [{ model: "Wish", text: "wish text" }.with_indifferent_access],
+            { number: "5" }.with_indifferent_access
+          ]
+          sub_array, number = helper.hydrate(array)
+          expect(sub_array.first.text).to eq("wish text")
+          expect(number).to eq(5)
+        end
+
+        it "converts hashes the array contains" do
+          array = [
+            {
+              my_wish: { model: "Wish", text: "my wish" }.with_indifferent_access,
+              my_number: { number: "5" }
+            }.with_indifferent_access
+          ]
+          actual = helper.hydrate(array).first
+          expect(actual[:my_wish].text).to eq("my wish")
+          expect(actual[:my_number]).to eq(5)
+        end
+      end
+
+      context "'arrays'" do
+        it "converts each element of the 'array'" do
+          pretend_array = {
+            "0" => "hello",
+            "1" => { number: "5" }.with_indifferent_access,
+            "2" => { model: "Wish", text: "wish text" }.with_indifferent_access
+          }
+          string, number, wish = helper.hydrate(pretend_array)
+          expect(string).to eq("hello")
+          expect(number).to eq(5)
+          expect(wish.text).to eq("wish text")
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+ENV["RAILS_ENV"] ||= "test"
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rspec/rails"
+require "rspec/autorun"
+Rails.backtrace_cleaner.remove_silencers!
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.use_transactional_fixtures = true
+  config.infer_base_class_for_anonymous_controllers = false
+  config.order = "random"
+end