magic_lamp 0.9.9 → 1.0.0

data/spec/javascripts/spec_helper.js

@@ -37,10 +37,11 @@
 // You can require your own javascript files here. By default this will include everything in application, however you
 // may get better load performance if you require the specific files that are being used in the spec that tests them.
 //= require magic_lamp/application
+//= require support/underscore-1.6
 //= require support/chai
+//= require support/chai-fuzzy
 //= require support/sinon
 //= require support/sinon-chai
-//= require support/underscore-1.6
 window.expect = chai.expect;
 
 var spies;
@@ -65,12 +66,12 @@ function stub(object, method, retVal) {
   return stubObj;
 }
 
-function findById(id) {
-  return document.getElementById(id);
+function findByClassName(className) {
+  return document.getElementsByClassName(className)[0];
 }
 
 function testFixtureContainer() {
-  return findById('magic-lamp');
+  return findByClassName('magic-lamp');
 }
 
 function removeNode(node) {

data/spec/javascripts/support/chai-fuzzy.js

@@ -0,0 +1,110 @@
+(function(plugin){
+  if (
+    typeof require === "function"
+    && typeof exports === "object"
+    && typeof module === "object"
+  ) {
+    // NodeJS
+    module.exports = plugin;
+  } else if (
+    typeof define === "function"
+    && define.amd
+  ) {
+    // AMD
+    define(function () {
+      return plugin;
+    });
+  } else {
+    // Other environment (usually <script> tag): plug in to global chai instance directly.
+    chai.use(plugin);
+  }
+}(function(chai, utils){
+  var _;
+
+  if (
+    typeof window === "object"
+    && typeof window._ == "function"
+  ) {
+    // browser-side
+    _ = window._;
+  } else {
+    // server-side
+    _ = require('underscore');
+  }
+
+  // contain => _.where, check _.isEqual
+  // containOnce => contain, check size of returned array
+  // like => _.isEqual
+
+  chai.Assertion.addMethod('like', function(expected){
+    var obj = this._obj
+    this.assert(
+      _.isEqual(obj, expected)
+      , "expected #{this} to be like #{exp}"
+      , "expected #{this} not to be like #{exp}"
+      , expected
+      , obj
+      , true
+    )
+  });
+
+  chai.Assertion.addMethod('jsonOf', function(expected){
+    var obj            = this._obj;
+    var expectedAsJSON = JSON.parse(JSON.stringify(expected));
+
+    this.assert(
+      _.isEqual(obj, expectedAsJSON)
+      , "expected #{this} to be like JSON #{exp}"
+      , "expected #{this} not to be like JSON #{exp}"
+      , expectedAsJSON
+      , obj
+      , true
+    )
+  });
+
+  chai.Assertion.addMethod('containOneLike', function(expected){
+    var obj = this._obj
+
+    var _obj = _(obj);
+
+    if (!_obj.isObject() && !_obj.isArray()) {
+      this.assert(
+        false
+        , "expected #{this} to be an array, object, or string"
+        , "expected #{this} to be an array, object, or string"
+      )
+    }
+
+    var found = _obj.some(function(needle){
+      return _.isEqual(needle,expected);
+    });
+
+    this.assert(
+      found
+      , "expected #{this} to contain one thing like #{exp}"
+      , "expected #{this} not to contain one thing like #{exp}"
+      , expected
+    )
+  });
+
+  //export tdd style
+  var assert = chai.assert;
+  assert.like = function (val, exp, msg) {
+    new chai.Assertion(val, msg).to.be.like(exp);
+  };
+  assert.notLike = function (val, exp, msg) {
+    new chai.Assertion(val, msg).to.not.be.like(exp);
+  };
+  assert.containOneLike = function (val, exp, msg) {
+    new chai.Assertion(val, msg).to.containOneLike(exp);
+  };
+  assert.notContainOneLike = function (val, exp, msg) {
+    new chai.Assertion(val, msg).to.not.containOneLike(exp);
+  };
+  assert.jsonOf = function (val, exp, msg) {
+    new chai.Assertion(val, msg).to.be.jsonOf(exp);
+  };
+  assert.notJsonOf = function (val, exp, msg) {
+    new chai.Assertion(val, msg).to.not.be.jsonOf(exp);
+  };
+}));

data/spec/lib/callbacks_spec.rb

@@ -0,0 +1,58 @@
+require "rails_helper"
+
+describe MagicLamp::Callbacks do
+  class DummyObject
+    include MagicLamp::Callbacks
+  end
+
+  subject { DummyObject.new(MagicLamp::Configuration.new) }
+
+  context "attr_accessor" do
+    it { is_expected.to respond_to(:configuration) }
+    it { is_expected.to respond_to(:configuration=) }
+  end
+
+  describe "#initialize" do
+    it "sets configuration to the given argument" do
+      configuration = double
+      subject = DummyObject.new(configuration)
+      expect(subject.configuration).to eq(configuration)
+    end
+  end
+
+  describe "#execute_before_each_callback" do
+    it "calls the before each callback" do
+      dummy = double
+      expect(dummy).to receive(:call)
+      subject.configuration.before_each_proc = dummy
+      subject.execute_before_each_callback
+    end
+
+    context "no callback" do
+      it "does not raise an error" do
+        subject.configuration.before_each_proc = nil
+        expect do
+          subject.execute_before_each_callback
+        end.to_not raise_error
+      end
+    end
+  end
+
+  describe "#execute_after_each_callback" do
+    it "calls the after each callback" do
+      dummy = double
+      expect(dummy).to receive(:call)
+      subject.configuration.after_each_proc = dummy
+      subject.execute_after_each_callback
+    end
+
+    context "no callback" do
+      it "does not raise an error" do
+        subject.configuration.after_each_proc = nil
+        expect do
+          subject.execute_after_each_callback
+        end.to_not raise_error
+      end
+    end
+  end
+end

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,48 @@
+require "rails_helper"
+
+describe MagicLamp::Configuration do
+  context "attr_accessor" do
+    it { is_expected.to respond_to :before_each_proc }
+    it { is_expected.to respond_to :before_each_proc= }
+
+    it { is_expected.to respond_to :after_each_proc }
+    it { is_expected.to respond_to :after_each_proc= }
+
+    it { is_expected.to respond_to :infer_names }
+    it { is_expected.to respond_to :infer_names= }
+  end
+
+  describe "#initialize" do
+    it "infers names by default" do
+      expect(subject.infer_names).to eq(true)
+    end
+  end
+
+  describe "#before_each" do
+    it "saves its given block" do
+      block = proc { "something before" }
+      subject.before_each(&block)
+      expect(subject.before_each_proc).to eq(block)
+    end
+
+    it "raises an error when not given a block" do
+      expect do
+        subject.before_each
+      end.to raise_error(MagicLamp::ArgumentError, /configuration#before_each requires a block/)
+    end
+  end
+
+  describe "#after_each" do
+    it "saves its given block" do
+      block = proc { "something before" }
+      subject.after_each(&block)
+      expect(subject.after_each_proc).to eq(block)
+    end
+
+    it "raises an error when not given a block" do
+      expect do
+        subject.after_each
+      end.to raise_error(MagicLamp::ArgumentError, /configuration#after_each requires a block/)
+    end
+  end
+end

data/spec/lib/fixture_creator_spec.rb

@@ -1,21 +1,14 @@
 require "rails_helper"
 
 describe MagicLamp::FixtureCreator do
-  context "attr_accessor" do
-    context "render_arguments" do
-      it { should respond_to :render_arguments }
-      it { should respond_to :render_arguments= }
-    end
+  subject { MagicLamp::FixtureCreator.new(MagicLamp::Configuration.new) }
 
-    context "namespace" do
-      it { should respond_to :namespace }
-      it { should respond_to :namespace= }
-    end
-  end
+  it { is_expected.to be_kind_of(MagicLamp::Callbacks) }
 
-  describe "#initialize" do
-    it "sets MagicLamp as namespace" do
-      expect(subject.namespace).to eq(MagicLamp)
+  context "attr_accessor" do
+    context "render_arguments" do
+      it { is_expected.to respond_to :render_arguments }
+      it { is_expected.to respond_to :render_arguments= }
     end
   end
 
@@ -33,10 +26,20 @@ describe MagicLamp::FixtureCreator do
     it "does not render the layout by default" do
       expect(rendered).to_not match(/The layout/)
     end
+
+    it "executes the callbacks around generation of the template" do
+      dummy = double
+      expect(subject).to receive(:execute_before_each_callback).ordered
+      expect(dummy).to receive(:render).ordered
+      expect(subject).to receive(:execute_after_each_callback).ordered
+      subject.generate_template(OrdersController) do
+        dummy.render
+        render :foo
+      end
+    end
   end
 
   describe "#new_controller" do
-
     it "returns an instance of the passed controller class" do
       expect(subject.new_controller(OrdersController) {} ).to be_a(OrdersController)
     end

data/spec/lib/magic_lamp_spec.rb

@@ -1,17 +1,12 @@
 require "rails_helper"
 
 describe MagicLamp do
-  before do
-    subject.registered_fixtures = {}
-  end
-
-  after do
-    subject.registered_fixtures = {}
-  end
-
   context "attr_accessor" do
-    it { should respond_to :registered_fixtures }
-    it { should respond_to :registered_fixtures= }
+    it { is_expected.to respond_to :registered_fixtures }
+    it { is_expected.to respond_to :registered_fixtures= }
+
+    it { is_expected.to respond_to :configuration }
+    it { is_expected.to respond_to :configuration= }
   end
 
   context "aliases" do
@@ -26,20 +21,59 @@ describe MagicLamp do
     end
   end
 
+  describe "#configure" do
+    it "yields a configuration object to the block" do
+      subject.configure do |config|
+        expect(config).to be_a(MagicLamp::Configuration)
+      end
+    end
+
+    it "replaces its configuration object if called again" do
+      subject.configure { |config| config.infer_names = false }
+      first_config = subject.configuration
+      subject.configure { |config| config.infer_names = false }
+      second_config = subject.configuration
+      expect(first_config).to_not eq(second_config)
+    end
+
+    it "raises an error without a block" do
+      expect do
+        subject.configure
+      end.to raise_error(MagicLamp::ArgumentError, /configure requires a block/)
+    end
+  end
+
+  context "callbacks with database cleaner" do
+    it "keeps the database clean" do
+      allow(subject).to receive(:path).and_return(Rails.root.join("persisted_specs"))
+      subject.generate_all_fixtures
+      expect(Order.count).to eq(0)
+    end
+  end
+
   describe "#register_fixture" do
     let(:fixture_name) { "foo" }
     let(:controller_class) { "doesn't matter here" }
-    let(:block) { Proc.new { "so?" } }
+    let(:block) { proc { "so?" } }
 
     it "caches the controller class and block" do
-      subject.register_fixture(controller_class, fixture_name, &block)
+      subject.register_fixture(controller: controller_class, name: fixture_name, &block)
       expect(subject.registered_fixtures[fixture_name]).to eq([controller_class, block])
     end
 
     it "raises an error without a block" do
       expect do
-        subject.register_fixture(controller_class, fixture_name)
-      end.to raise_error(ArgumentError, /requires a block/)
+        subject.register_fixture(controller: controller_class, name: fixture_name)
+      end.to raise_error(MagicLamp::ArgumentError, /register_fixture requires a block/)
+    end
+
+    context "don't infer names" do
+      it "raises an error without a specified name" do
+        subject.configuration.infer_names = false
+        expect do
+          subject.register_fixture { render :foo }
+        end.to raise_error(MagicLamp::ArgumentError, /You must specify a name since `infer_names` is configured to `false`/)
+      end
     end
 
     context "defaults" do
@@ -60,34 +94,39 @@ describe MagicLamp do
 
         context "ApplicationController" do
           it "uses the first argument to render when given 2" do
-            render_block = Proc.new { render :index, foo: :bar }
-            subject.register_fixture(::ApplicationController, &render_block)
+            render_block = proc { render :index, foo: :bar }
+            subject.register_fixture(controller: ::ApplicationController, &render_block)
 
             expect(at_index).to eq([::ApplicationController, render_block])
           end
 
           it "uses the only argument when it isn't a hash" do
-            render_block = Proc.new { render :index }
-            subject.register_fixture(::ApplicationController, &render_block)
+            render_block = proc { render :index }
+            subject.register_fixture(controller: ::ApplicationController, &render_block)
             expect(at_index).to eq([::ApplicationController, render_block])
           end
 
+          it "passes its configuration object to the render catcher" do
+            expect(MagicLamp::RenderCatcher).to receive(:new).with(subject.configuration).and_call_original
+            subject.register_fixture { render :foo }
+          end
+
           context "1 hash argument" do
             it "raises an error if it can't figure out a default name" do
               expect do
-                subject.register_fixture(::ApplicationController) { render collection: [1, 2, 3] }
+                subject.register_fixture(controller: ::ApplicationController) { render collection: [1, 2, 3] }
               end.to raise_error(MagicLamp::AmbiguousFixtureNameError, /Unable to infer fixture name/)
             end
 
             it "uses the name at the template key" do
-              render_block = Proc.new { render template: :index }
-              subject.register_fixture(::ApplicationController, &render_block)
+              render_block = proc { render template: :index }
+              subject.register_fixture(controller: ::ApplicationController, &render_block)
               expect(at_index).to eq([::ApplicationController, render_block])
             end
 
             it "uses the name at the partial key" do
-              render_block = Proc.new { render partial: :index }
-              subject.register_fixture(::ApplicationController, &render_block)
+              render_block = proc { render partial: :index }
+              subject.register_fixture(controller: ::ApplicationController, &render_block)
               expect(at_index).to eq([::ApplicationController, render_block])
             end
           end
@@ -95,15 +134,35 @@ describe MagicLamp do
 
         context "other controller" do
           it "prepends the controller's name to the fixture_name" do
-            render_block = Proc.new { render partial: :index }
-            subject.register_fixture(OrdersController, &render_block)
+            render_block = proc { render partial: :index }
+            subject.register_fixture(controller: OrdersController, &render_block)
             expect(subject.registered_fixtures["orders/index"]).to eq([OrdersController, render_block])
           end
+
+          it "does not prepend the controller's name when it is already the beginning of the string" do
+            render_block = proc { render partial: "orders/order" }
+            subject.register_fixture(controller: OrdersController, &render_block)
+            expect(subject.registered_fixtures["orders/orders/order"]).to be_nil
+            expect(subject.registered_fixtures["orders/order"]).to eq([OrdersController, render_block])
+          end
         end
       end
     end
   end
 
+  describe "#load_config" do
+    it "loads the magic lamp config file" do
+      expect(subject).to receive(:registered_fixtures)
+      subject.load_config
+    end
+
+    it "does not raise an error if there's no config" do
+      allow(Dir).to receive(:[]).and_return([])
+      expect(subject).to_not receive(:registered_fixtures)
+      subject.load_config
+    end
+  end
+
   describe "#load_lamp_files" do
     it "loads all lamp files" do
       subject.load_lamp_files
@@ -119,6 +178,11 @@ describe MagicLamp do
       subject.load_lamp_files
       expect(subject.registered_fixtures).to_not equal(old_registry)
     end
+
+    it "loads its config" do
+      expect(subject).to receive(:load_config)
+      subject.load_lamp_files
+    end
   end
 
   describe "#registered?" do
@@ -134,7 +198,7 @@ describe MagicLamp do
   end
 
   describe "#generate_fixture" do
-    let(:block) { Proc.new { render :foo } }
+    let(:block) { proc { render :foo } }
 
     before do
       subject.registered_fixtures["foo_test"] = [OrdersController, block]
@@ -149,6 +213,13 @@ describe MagicLamp do
         subject.generate_fixture("brokenture")
       end.to raise_error(MagicLamp::UnregisteredFixtureError, /is not a registered fixture/)
     end
+
+    it "passes its configuration object to the render catcher" do
+      subject.registered_fixtures["foo"] = []
+      dummy = double(generate_template: :generate_template)
+      expect(MagicLamp::FixtureCreator).to receive(:new).with(subject.configuration).and_return(dummy)
+      subject.generate_fixture("foo")
+    end
   end
 
   describe "#generate_all_fixtures" do