magic_lamp 1.0.0 → 1.1.0

data/spec/dummy/spec/magical/a_lamp_file_with_a_different_name_lamp.rb

@@ -5,3 +5,60 @@ end
 MagicLamp.register_fixture(controller: OrdersController, name: "super_specified") do
   render :foo
 end
+
+module AuthStub
+  def current_user_name
+    "Stevenson"
+  end
+end
+
+module AdminStub
+  def current_admin_name
+    "Paulson"
+  end
+end
+
+module OtherAdminStub
+  def current_admin_name
+    "Peterson"
+  end
+end
+
+MagicLamp.define(extend: [AuthStub, AdminStub]) do
+  fixture do
+    current_user_name # called here to make sure we can call it here
+    render "orders/needs_extending"
+  end
+end
+
+MagicLamp.define do
+  define(namespace: "arbitrary") do
+    define(extend: [AuthStub, AdminStub]) do
+      define(controller: OrdersController) do
+        define(extend: OtherAdminStub) do
+          fixture(name: "other_admin_extending") do
+            render :needs_extending
+          end
+
+          fixture(name: "admin_extending", extend: AdminStub) do
+            render :needs_extending
+          end
+        end
+      end
+    end
+  end
+end
+
+MagicLamp.define(controller: OrdersController) do
+  define(namespace: :errors) do
+    define do
+      define(namespace: "foos") do
+        define do
+          fixture(controller: OrdersController, namespace: :bar, name: :baz) do
+            render :foo
+          end
+        end
+      end
+    end
+  end
+end

data/spec/javascripts/genie_spec.js

@@ -121,7 +121,17 @@ describe('Genie', function() {
   describe('#preload', function() {
     it('requests all of the fixtures and puts them in the cache', function() {
       subject.preload();
-      expect(subject.cache).to.have.keys(['orders/foo', 'orders/bar', 'orders/form', 'custom_name', 'super_specified']);
+      expect(subject.cache).to.have.keys([
+        'orders/foo',
+        'orders/bar',
+        'orders/form',
+        'custom_name',
+        'orders/super_specified',
+        'orders/needs_extending',
+        'orders/errors/foos/bar/baz',
+        'arbitrary/orders/other_admin_extending',
+        'arbitrary/orders/admin_extending'
+      ]);
     });
 
     it('sets cacheOnly to true', function() {
@@ -266,7 +276,7 @@ describe('Genie', function() {
       stub(subject, 'xhrStatus', 500);
       var path = '/magic_lamp/foo/bar';
       var xhr = subject.xhrRequest(path);
-      expect(subject.handleError).to.have.been.calledWith('Something went wrong while generating the fixture, please check the server log or run `rake magic_lamp:lint` for more information');
+      expect(subject.handleError).to.have.been.calledWith('Something went wrong, please check the server log or run `rake magic_lamp:lint` for more information');
     });
   });
 

data/spec/javascripts/magic_lamp_spec.js

@@ -210,9 +210,22 @@ describe('MagicLamp', function() {
       expect(testFixtureContainer().innerHTML).to.equal('foo\n');
     });
 
+    it('can load fixtures with extensions', function() {
+      subject.load('orders/needs_extending');
+      expect(testFixtureContainer().innerHTML).to.equal('Stevenson\nPaulson\n');
+    });
+
     it('can load fixtures with specified names and controllers', function() {
-      subject.load('super_specified')
+      subject.load('orders/super_specified')
       expect(testFixtureContainer().innerHTML).to.equal('foo\n');
     });
+
+    it('can load fixtures deeply nested in define blocks', function() {
+      subject.load('arbitrary/orders/other_admin_extending');
+      expect(testFixtureContainer().innerHTML).to.equal('Stevenson\nPeterson\n');
+
+      subject.load('arbitrary/orders/admin_extending');
+      expect(testFixtureContainer().innerHTML).to.equal('Stevenson\nPaulson\n');
+    });
   });
 });

data/spec/lib/callbacks_spec.rb

@@ -8,8 +8,7 @@ describe MagicLamp::Callbacks do
   subject { DummyObject.new(MagicLamp::Configuration.new) }
 
   context "attr_accessor" do
-    it { is_expected.to respond_to(:configuration) }
-    it { is_expected.to respond_to(:configuration=) }
+    it { is_expected.to attr_accessorize(:configuration) }
   end
 
   describe "#initialize" do

data/spec/lib/configuration_spec.rb

@@ -2,20 +2,20 @@ 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= }
+    it { is_expected.to attr_accessorize :before_each_proc }
+    it { is_expected.to attr_accessorize :after_each_proc }
+    it { is_expected.to attr_accessorize :infer_names }
+    it { is_expected.to attr_accessorize :global_defaults }
   end
 
   describe "#initialize" do
     it "infers names by default" do
       expect(subject.infer_names).to eq(true)
     end
+
+    it "has an empty hash for global defaults" do
+      expect(subject.global_defaults).to eq({})
+    end
   end
 
   describe "#before_each" do

data/spec/lib/defaults_manager_spec.rb

@@ -0,0 +1,160 @@
+require "rails_helper"
+
+describe MagicLamp::DefaultsManager do
+  subject { MagicLamp::DefaultsManager.new(MagicLamp::Configuration.new, {}) }
+
+  context "attr_accessor" do
+    it { is_expected.to attr_accessorize(:configuration) }
+    it { is_expected.to attr_accessorize(:parent) }
+    it { is_expected.to attr_accessorize(:defaults) }
+  end
+
+  context "aliases" do
+    MagicLamp::REGISTER_FIXTURE_ALIASES.each do |method_name|
+      it { is_expected.to alias_the_method(:register_fixture).to(method_name) }
+    end
+  end
+
+  describe "#initialize" do
+    let(:configuration) { double }
+    let(:defaults) { double }
+    let(:parent) { double }
+
+    it "sets configuration to the given argument" do
+      subject = MagicLamp::DefaultsManager.new(configuration, {})
+      expect(subject.configuration).to eq(configuration)
+    end
+
+    it "sets defaults" do
+      subject = MagicLamp::DefaultsManager.new(configuration, defaults)
+      expect(subject.defaults).to eq(defaults)
+    end
+
+    it "defaults parent to nil" do
+      expect(subject.parent).to be_nil
+    end
+
+    it "sets parent when given" do
+      subject = MagicLamp::DefaultsManager.new(configuration, {}, parent)
+      expect(subject.parent).to eq(parent)
+    end
+  end
+
+  describe "#branch" do
+    let(:configuration) { MagicLamp::Configuration.new }
+    let(:great_grandparent) { MagicLamp::DefaultsManager.new(configuration, {}) }
+    let(:grandparent) { MagicLamp::DefaultsManager.new(configuration, {}, great_grandparent) }
+    let(:parent) { MagicLamp::DefaultsManager.new(configuration, {}, grandparent) }
+    subject { MagicLamp::DefaultsManager.new(configuration, {}, parent) }
+    let(:actual) { subject.branch }
+    let(:branch) { [great_grandparent, grandparent, parent, subject] }
+
+    it "returns all of the manager's parents and itself in hierarchical order" do
+      expect(actual).to match_array(branch)
+      expect(actual).to eq(branch)
+    end
+  end
+
+  describe "#all_defaults" do
+    let(:global_defaults) { { global: :defaults } }
+    let(:grandparent_defaults) { { grandparent: :defaults } }
+    let(:parent_defaults) { { parent: :defaults } }
+    let(:subject_defaults) { { subject: :defaults } }
+    let(:configuration) { MagicLamp::Configuration.new.tap { |config| config.global_defaults = global_defaults } }
+    let(:grandparent) { MagicLamp::DefaultsManager.new(configuration, grandparent_defaults) }
+    let(:parent) { MagicLamp::DefaultsManager.new(configuration, parent_defaults, grandparent) }
+    let(:passed_in_defaults) { { passed: :in } }
+    subject { MagicLamp::DefaultsManager.new(configuration, subject_defaults, parent) }
+    let(:actual) { subject.all_defaults(passed_in_defaults) }
+    let(:expected_defaults) { [global_defaults, grandparent_defaults, parent_defaults, subject_defaults, passed_in_defaults] }
+
+    it "returns the global defaults, all parent defaults, the manager's defaults, and the passed in defaults" do
+      expect(actual).to match_array(expected_defaults)
+      expect(actual).to eq(expected_defaults)
+    end
+  end
+
+  describe "#merge_with_defaults" do
+    let(:extension) { Module.new }
+    let(:other_extension) { Module.new }
+    let(:global_defaults) { { global: :defaults, namespace: :global } }
+    let(:grandparent_defaults) { { grandparent: :defaults, that: :is_ignored, namespace: "", extend: [extension] } }
+    let(:parent_defaults) { { parent: :defaults, this: :is_ignored, controller: OrdersController, extend: other_extension } }
+    let(:subject_defaults) { { subject: :defaults, this: :is_there, namespace: :subject } }
+    let(:configuration) { MagicLamp::Configuration.new.tap { |config| config.global_defaults = global_defaults } }
+    let(:grandparent) { MagicLamp::DefaultsManager.new(configuration, grandparent_defaults) }
+    let(:parent) { MagicLamp::DefaultsManager.new(configuration, parent_defaults, grandparent) }
+    subject { MagicLamp::DefaultsManager.new(configuration, subject_defaults, parent) }
+    let(:actual) { subject.merge_with_defaults(that: :is_there, namespace: :passed, controller: OrdersController) }
+    let(:expected_defaults) do
+      {
+        controller: OrdersController,
+        global: :defaults,
+        grandparent: :defaults,
+        parent: :defaults,
+        subject: :defaults,
+        this: :is_there,
+        that: :is_there,
+        namespace: "global/orders/subject/passed",
+        extend: [extension, other_extension]
+      }
+    end
+
+    it "merges all of the branch's defaults into one hash where the children take precedence" do
+      expect(actual).to eq(expected_defaults)
+    end
+  end
+
+  describe "#define" do
+    let(:new_defaults) { { very_new: :defaults } }
+
+    it "creates a new defaults manager and evaluates the block in its context" do
+      suspect = subject.define(new_defaults) do
+        @foo = "foo"
+      end
+      expect(suspect).to be_a(MagicLamp::DefaultsManager)
+      expect(suspect).to_not eq(subject)
+      expect(suspect.instance_variable_get(:@foo)).to eq("foo")
+      expect(suspect.defaults).to eq(new_defaults)
+      expect(suspect.configuration).to eq(subject.configuration)
+      expect(suspect.parent).to eq(subject)
+    end
+
+    it "does not require a defaults hash argument" do
+      expect { subject.define {} }.to_not raise_error
+    end
+
+    it "raises an error if called without a block" do
+      expect do
+        subject.define(foo: :bar)
+      end.to raise_error(MagicLamp::ArgumentError, "`define` requires a block")
+    end
+  end
+
+  describe "#register_fixture" do
+    context "calling MagicLamp.register_fixture" do
+      let(:configuration) { MagicLamp::Configuration.new }
+      let(:block) { proc { "foo" } }
+      let(:given_options) { { this: :is_there } }
+      let(:parent_defaults) { { parent: :defaults, this: :is_ignored } }
+      let(:subject_defaults) { { subject: :defaults, this: :is_not_there_either } }
+      let(:parent) { MagicLamp::DefaultsManager.new(configuration, parent_defaults) }
+      subject { MagicLamp::DefaultsManager.new(configuration, subject_defaults, parent) }
+      let(:expected_options) { { this: :is_there, subject: :defaults, parent: :defaults, extend: [] } }
+
+      it "passes the block and the given options (merged with defaults) through" do
+        expect(MagicLamp).to receive(:register_fixture) do |options, &passed_block|
+          expect(options).to eq(expected_options)
+          expect(passed_block).to eq(block)
+        end
+        subject.register_fixture(given_options, &block)
+      end
+
+      it "does not require options to be passed in" do
+        expect do
+          subject.register_fixture { render :foo }
+        end.to_not raise_error
+      end
+    end
+  end
+end

data/spec/lib/fixture_creator_spec.rb

@@ -6,15 +6,12 @@ describe MagicLamp::FixtureCreator do
   it { is_expected.to be_kind_of(MagicLamp::Callbacks) }
 
   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
+    it { is_expected.to attr_accessorize :render_arguments }
   end
 
   describe "#generate_template" do
     let(:rendered) do
-      subject.generate_template(OrdersController) do
+      subject.generate_template(OrdersController, []) do
         render :foo
       end
     end
@@ -32,7 +29,7 @@ describe MagicLamp::FixtureCreator do
       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
+      subject.generate_template(OrdersController, []) do
         dummy.render
         render :foo
       end
@@ -41,11 +38,21 @@ describe MagicLamp::FixtureCreator do
 
   describe "#new_controller" do
     it "returns an instance of the passed controller class" do
-      expect(subject.new_controller(OrdersController) {} ).to be_a(OrdersController)
+      expect(subject.new_controller(OrdersController, []) {}).to be_a(OrdersController)
     end
 
     context "contoller" do
-      let(:controller) { subject.new_controller(OrdersController) { params[:foo] = "bar" } }
+      module Foo
+        def foo_module_method
+        end
+      end
+
+      module Bar
+        def bar_module_method
+        end
+      end
+
+      let(:controller) { subject.new_controller(OrdersController, [Foo, Bar]) { params[:foo] = "bar" } }
 
       it "can have render_to_string called on it without blowing up" do
         expect do
@@ -57,6 +64,22 @@ describe MagicLamp::FixtureCreator do
         expect(controller.params[:foo]).to eq("bar")
       end
 
+      it "has been extended with the extensions" do
+        expect(controller.class.ancestors).to_not include(Foo)
+        expect(controller.class.ancestors).to_not include(Bar)
+        expect(controller).to respond_to(:foo_module_method)
+        expect(controller).to respond_to(:bar_module_method)
+      end
+
+      context "view_context" do
+        it "has the extensions mixed into it" do
+          expect(controller.view_context.class.ancestors).to_not include(Foo)
+          expect(controller.view_context.class.ancestors).to_not include(Bar)
+          expect(controller.view_context).to respond_to(:foo_module_method)
+          expect(controller.view_context).to respond_to(:bar_module_method)
+        end
+      end
+
       context "stubbed controller#render" do
         it "passes its arguments to the fixture creator at render arguments" do
           controller.render :foo, :bar