shoegaze 1.1.0

data/spec/features/nested_instance_method_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+class NestedInstanceMethodSubclass
+  def another_instance_method(arg1, arg2)
+    raise "should never see this"
+  end
+end
+
+class NestedInstanceMethod
+  def nested_instance_method(arg1, arg2)
+    return NestedInstanceMethodSubclass.new(*args)
+  end
+end
+
+class FakeNestedInstanceMethod < Shoegaze::Mock
+  mock "NestedInstanceMethod"
+
+  implement_instance_method :nested_instance_method do
+    scenario :good do
+      datasource do |arg1, arg2|
+        implement :another_instance_method do
+          default do
+            datasource do
+              :perfect_socks
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+describe FakeNestedInstanceMethod do
+  let!(:mock){ FakeNestedInstanceMethod.proxy }
+
+  describe "good scenario" do
+    let!(:args){ [:wool, :cotton] }
+
+    before do
+      FakeNestedInstanceMethod.instance_call(:nested_instance_method).with(*args).yields(:good)
+    end
+
+    it "runs the :good scenario datasource and chains into its nested scenario" do
+      expect(mock.new.nested_instance_method(*args).another_instance_method).to eq(:perfect_socks)
+    end
+  end
+end

data/spec/shoegaze/datastore_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Shoegaze::Datastore do
+  include SpecHelpers
+
+  before :all do
+    @klass = random_named_class
+    @klass.extend(Shoegaze::Datastore)
+
+    @klass.datastore("Pony") do
+      id { 123 }
+      hoofs { 5 }
+      name { "Jeff" }
+    end
+  end
+
+  describe "#datastore" do
+    let!(:created_class){ @klass.const_get("Pony") }
+
+    describe "created model class" do
+      it "creates a TopModel class with the specified name inside the class' namespace" do
+        expect(created_class.ancestors[1]).to eq Shoegaze::Model
+      end
+    end
+
+    describe "factory" do
+      let!(:model_instance) do
+        FactoryBot.create(created_class.name.underscore, id: 5, name: "Carlos")
+      end
+
+      it "creates persisted instances" do
+        expect(model_instance.hoofs).to eq(5)
+        expect(model_instance.name).to eq("Carlos")
+        expect(created_class.find(5)).to eq(model_instance)
+      end
+    end
+  end
+end

data/spec/shoegaze/implementation_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Shoegaze::Implementation do
+  include ImplementationSpecHelpers
+
+  let!(:subject){ Shoegaze::Implementation }
+  let!(:mock_class){ double }
+
+  let!(:mock_double) do
+    mock_double = double
+
+    Shoegaze::Mock.send(:extend_double_with_extra_methods, mock_double)
+    mock_double
+  end
+
+  let!(:scope){ :instance }
+  let!(:method_name){ :bicycle }
+  let!(:implementation){ subject.new(mock_class, mock_double, scope, method_name){} }
+
+  describe "#initialize" do
+    describe "instance variables" do
+      it "are assigned" do
+        expect(implementation.instance_variable_get(:@_mock_class)).to eq(mock_class)
+        expect(implementation.instance_variable_get(:@_mock_double)).to eq(mock_double)
+        expect(implementation.instance_variable_get(:@_scope)).to eq(scope)
+        expect(implementation.instance_variable_get(:@_method_name)).to eq(method_name)
+        expect(implementation.instance_variable_get(:@scenarios)).to eq({})
+      end
+    end
+
+    describe "block" do
+      it "is called in the scope of the implementation instance" do
+        expect_any_instance_of(subject).to receive(:booyah)
+        subject.new(mock_class, mock_double, scope, method_name){ booyah }
+      end
+    end
+  end
+
+  describe "#scenario" do
+    let!(:fake_block){ proc { } }
+    let!(:fake_scenario){ double }
+
+    it "creates a Scenario with the method name and the block, keyed as the scenario name within scenarios" do
+      expect(Shoegaze::Scenario).to receive(:new).with(method_name) do |name, &block|
+        expect(block).to eq(fake_block)
+        expect(name).to eq(method_name)
+
+        fake_scenario
+      end
+
+      implementation.scenario(:dude_wheres_my_car, &fake_block)
+
+      scenario = implementation.scenarios[:dude_wheres_my_car]
+      expect(scenario).to eq(fake_scenario)
+    end
+  end
+
+  describe "#default" do
+    let!(:fake_block){ proc { } }
+    let!(:fake_scenario){ double }
+    let!(:fake_scenario_orchestrator){ double }
+    let!(:fake_method_args){ ["chainring", "braze-on"] }
+
+    before :each do
+      allow(mock_double).to receive(:define_method)
+      allow(Shoegaze::Scenario).to receive(:new).with(method_name).and_return(fake_scenario)
+    end
+
+    it "creates a Scenario with the method name and the block, keyed as :default within scenarios" do
+      expect(Shoegaze::Scenario).to receive(:new).with(method_name) do |name, &block|
+        expect(block).to eq(fake_block)
+        expect(name).to eq(method_name)
+
+        fake_scenario
+      end
+
+      implementation.default(&fake_block)
+
+      scenario = implementation.scenarios[:default]
+      expect(scenario).to eq(fake_scenario)
+    end
+
+    describe "with an :instance scope" do
+      it "creates a named method that ultimately triggers :execute_scenario on a Scenario::Orchestrator" do
+        expect_default_scenario_to_be_defined_for_scope(scope)
+      end
+    end
+
+    describe "with a :class scope" do
+      let!(:scope){ :class }
+
+      it "creates a named singleton method that ultimately triggers :execute_scenario on a Scenario::Orchestrator" do
+        expect_default_scenario_to_be_defined_for_scope(scope)
+      end
+    end
+  end
+end

data/spec/shoegaze/mock_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Shoegaze::Mock do
+  include SpecHelpers
+
+  subject{ Shoegaze::Mock }
+
+  describe "included modules" do
+    it "includes Proxy::Interface" do
+      expect(subject).to respond_to :implement_class_method
+    end
+  end
+
+  describe "#self.mock" do
+    let!(:test_class){ random_named_class }
+    let!(:mocked){ subject.mock(test_class.name) }
+
+    it "sets empty implementations" do
+      expect(Shoegaze::Mock.implementations).to eq({class: {}, instance: {}})
+    end
+
+    it "creates class and instance doubles of the provided class" do
+      # hork
+      expect(
+        Shoegaze::Mock.instance_variable_get(:@mock_class_double).
+          instance_variable_get(:@doubled_module).
+          instance_variable_get(:@const_name)
+      ).to eq(test_class.name)
+
+      expect(
+        Shoegaze::Mock.instance_variable_get(:@mock_instance_double).
+          instance_variable_get(:@doubled_module).
+          instance_variable_get(:@const_name)
+      ).to eq(test_class.name)
+    end
+
+    it "returns a mock proxy anonymous class" do
+      expect(mocked).to respond_to :class_double
+      expect(mocked).to respond_to :instance_double
+    end
+  end
+end

data/spec/shoegaze/proxy/interface_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Shoegaze::Proxy::Interface do
+  include SpecHelpers
+
+  let!(:test_class){ random_named_class }
+  let!(:method_name){ :jiu_jitsu }
+  let!(:test_block){ proc { } }
+  let!(:mock_class_double){ double }
+  let!(:mock_instance_double){ double }
+  let!(:fake_implementation){ double }
+
+  before do
+    test_class.include(Shoegaze::Proxy::Interface)
+    test_class.instance_variable_set(:@mock_class_double, mock_class_double)
+    test_class.instance_variable_set(:@mock_instance_double, mock_instance_double)
+    test_class.instance_variable_set(:@implementations, {class: {}, instance: {}})
+  end
+
+  describe "#self.implement_class_method" do
+    it "stores a class implementation keyed by the method name" do
+      expect(Shoegaze::Implementation).to receive(:new).with(test_class, mock_class_double, :class, method_name) do |*args, &block|
+        expect(block).to eq(test_block)
+
+        fake_implementation
+      end
+
+      test_class.implement_class_method(method_name, &test_block)
+      expect(test_class.implementations[:class][method_name]).to eq(fake_implementation)
+    end
+  end
+
+  describe "#self.implement_instance_method" do
+    it "stores an instance implementation keyed by the method name" do
+      expect(Shoegaze::Implementation).to receive(:new).with(test_class, mock_instance_double, :instance, method_name) do |*args, &block|
+        expect(block).to eq(test_block)
+
+        fake_implementation
+      end
+
+      test_class.implement_instance_method(method_name, &test_block)
+      expect(test_class.implementations[:instance][method_name]).to eq(fake_implementation)
+    end
+  end
+
+  describe "#self.implement" do
+    it "is an alias of :implement_instance_method" do
+      expect(test_class.method(:implement)).to eq(test_class.method(:implement_instance_method))
+    end
+  end
+
+  describe "#self.instance_call" do
+    let!(:fake_scenario_orchestrator){ double }
+
+    it "returns an instance Scenario::Orchestrator" do
+      expect(Shoegaze::Scenario::Orchestrator).to receive(:new).with(test_class, mock_instance_double, :instance, method_name).and_return(fake_scenario_orchestrator)
+      expect(test_class.instance_call(method_name)).to eq(fake_scenario_orchestrator)
+    end
+  end
+
+  describe "#self.class_call" do
+    let!(:fake_scenario_orchestrator){ double }
+
+    it "returns a class Scenario::Orchestrator" do
+      expect(Shoegaze::Scenario::Orchestrator).to receive(:new).with(test_class, mock_class_double, :class, method_name).and_return(fake_scenario_orchestrator)
+      expect(test_class.class_call(method_name)).to eq(fake_scenario_orchestrator)
+    end
+  end
+
+  describe "#self.calling" do
+    it "is an alias to :instance_call" do
+      expect(test_class.method(:calling)).to eq(test_class.method(:instance_call))
+    end
+  end
+
+  describe "#self.proxy" do
+    let!(:fake_proxy){ double }
+
+    it "returns and caches a Shoegaze::Proxy" do
+      expect(Shoegaze::Proxy).to receive(:new).with(mock_class_double, mock_instance_double).and_return(fake_proxy)
+      expect(test_class.proxy).to eq(fake_proxy)
+
+      # test caching
+      allow(Shoegaze::Proxy).to receive(:new).with(mock_class_double, mock_instance_double).and_return(:should_not_see_this)
+      expect(test_class.proxy).to eq(fake_proxy)
+    end
+  end
+end

data/spec/shoegaze/proxy/template_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Shoegaze::Proxy::Template do
+  let!(:instance_double) do
+    mock_double = double
+
+    Shoegaze::Mock.send(:extend_double_with_extra_methods, mock_double)
+    mock_double
+  end
+
+  let!(:class_double) do
+    mock_double = double
+
+    Shoegaze::Mock.send(:extend_double_with_extra_methods, mock_double)
+    mock_double
+  end
+
+  before :each do
+    Shoegaze::Proxy::Template.class_double = class_double
+    Shoegaze::Proxy::Template.instance_double = instance_double
+  end
+
+  describe "instance method calls" do
+    it "get delegated to the instance double" do
+      expect(instance_double).to receive(:rights).and_return(:liberties)
+      expect(Shoegaze::Proxy::Template.new.rights).to eq(:liberties)
+    end
+  end
+
+  describe "class method calls" do
+    it "get delegated to the class double" do
+      expect(class_double).to receive(:government).and_return(:nothing_of_value)
+      expect(Shoegaze::Proxy::Template.government).to eq(:nothing_of_value)
+    end
+  end
+end

data/spec/shoegaze/proxy_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Shoegaze::Proxy do
+  describe "#new" do
+    let!(:mock_class_double){ double }
+    let!(:mock_instance_double){ double }
+    let!(:proxy){ Shoegaze::Proxy.new(mock_class_double, mock_instance_double) }
+
+    it "returns a new anonymous class inherited from Shoegaze::Proxy::Template" do
+      expect(proxy.ancestors[1]).to eq(Shoegaze::Proxy::Template)
+    end
+
+    it "sets the proxy class and instance doubles" do
+      expect(proxy.class_double).to eq(mock_class_double)
+      expect(proxy.instance_double).to eq(mock_instance_double)
+    end
+  end
+end

data/spec/shoegaze/scenario/mock_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Shoegaze::Scenario::Mock do
+  include SpecHelpers
+
+  subject{ Shoegaze::Scenario::Mock }
+
+  describe "included modules" do
+    it "includes Proxy::Interface" do
+      expect(subject).to respond_to :implement_class_method
+    end
+  end
+
+  describe "#self.mock" do
+    let!(:mocked){ subject.mock }
+
+    it "sets empty implementations" do
+      expect(Shoegaze::Scenario::Mock.implementations).to eq({class: {}, instance: {}})
+    end
+
+    it "creates class and instance doubles" do
+      expect(Shoegaze::Scenario::Mock.instance_variable_get(:@mock_class_double)).to be_a RSpec::Mocks::Double
+      expect(Shoegaze::Scenario::Mock.instance_variable_get(:@mock_instance_double)).to be_a RSpec::Mocks::Double
+    end
+
+    it "returns a mock proxy anonymous class" do
+      expect(mocked).to respond_to :class_double
+      expect(mocked).to respond_to :instance_double
+    end
+  end
+end

data/spec/shoegaze/scenario/orchestrator_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe Shoegaze::Scenario::Orchestrator do
+  include SpecHelpers
+
+  let!(:scope){ :instance }
+  let!(:mock_class){ double }
+  let!(:mock_double){ double }
+  let!(:method_name){ :techno_viking }
+  let!(:scenario_orchestrator){ Shoegaze::Scenario::Orchestrator.new(mock_class, mock_double, scope, method_name) }
+
+  describe "#initialize" do
+    it "sets instance variables" do
+      expect(scenario_orchestrator.instance_variable_get(:@_scope)).to eq(scope)
+      expect(scenario_orchestrator.instance_variable_get(:@_mock_class)).to eq(mock_class)
+      expect(scenario_orchestrator.instance_variable_get(:@_mock_double)).to eq(mock_double)
+      expect(scenario_orchestrator.instance_variable_get(:@_method_name)).to eq(method_name)
+    end
+  end
+
+  describe "#with" do
+    let!(:args){ [:boy, :howdy] }
+
+    it "sets the args and returns self" do
+      expect(scenario_orchestrator.with(*args)).to eq(scenario_orchestrator)
+      expect(scenario_orchestrator.instance_variable_get(:@_args)).to eq(args)
+    end
+  end
+
+  describe "#yields" do
+    let!(:test_class){
+      random_named_class do
+        def self.techno_viking(arg1, arg2)
+        end
+
+        def techno_viking(arg1, arg2)
+        end
+      end
+    }
+    let!(:args){ [:one, :two] }
+    let!(:scenario_name){ :invisible_pickles }
+    let!(:fake_scenario){ double }
+    let!(:fake_implementation){ double(scenarios: {invisible_pickles: fake_scenario}) }
+
+    describe "for an instance" do
+      let!(:mock_double){ instance_double(test_class.name) }
+      let!(:scenario_orchestrator){ Shoegaze::Scenario::Orchestrator.new(mock_class, mock_double, :instance, method_name) }
+
+      describe "with a scenario" do
+        before :each do
+          allow(mock_class).to receive(:implementations).and_return(
+                                 {instance: {techno_viking: fake_implementation}}
+                               )
+        end
+
+        it "sets up the specific scenario with rspec" do
+          scenario_orchestrator.with(*args).yields(scenario_name)
+
+          expect(scenario_orchestrator).to receive(:execute_scenario).with(fake_scenario)
+          mock_double.send(:techno_viking, *args)
+
+          expect{
+            mock_double.send(:techno_viking, :wrong, :args)
+          }.to raise_exception RSpec::Mocks::MockExpectationError
+        end
+      end
+
+      describe "for a class" do
+        let!(:mock_double){ class_double(test_class.name) }
+        let!(:scenario_orchestrator){ Shoegaze::Scenario::Orchestrator.new(mock_class, mock_double, :class, method_name) }
+
+        describe "with a scenario" do
+          before :each do
+            allow(mock_class).to receive(:implementations).and_return(
+                                   {class: {techno_viking: fake_implementation}}
+                                 )
+          end
+
+          it "sets up the scenario with rspec" do
+            scenario_orchestrator.with(*args).yields(scenario_name)
+
+            expect(scenario_orchestrator).to receive(:execute_scenario).with(fake_scenario)
+            mock_double.send(:techno_viking, *args)
+
+            expect{
+              mock_double.send(:techno_viking, :wrong, :args)
+            }.to raise_exception RSpec::Mocks::MockExpectationError
+          end
+        end
+      end
+    end
+
+    describe "with no scenario" do
+      let!(:scenario_orchestrator){ Shoegaze::Scenario::Orchestrator.new(mock_class, mock_double, :class, method_name) }
+      let!(:fake_implementation){ double(scenarios: {}) }
+
+      before :each do
+        allow(mock_class).to receive(:implementations).and_return(
+                               {class: {techno_viking: fake_implementation}}
+                             )
+      end
+
+      it "raises a NoImplementationError" do
+        expect{ scenario_orchestrator.with(*args).yields(scenario_name) }.to raise_exception Shoegaze::Scenario::Orchestrator::NoImplementationError
+      end
+    end
+  end
+
+  describe "#execute_scenario" do
+    let!(:test_block){ proc { } }
+    let!(:fake_scenario){ double }
+    let!(:fake_args){ [:one, :two] }
+
+    before :each do
+      scenario_orchestrator.with(*fake_args)
+
+      # FIXME: this is a big fugly
+      allow(fake_scenario).to receive(:to_proc).
+                                and_return(
+                                  proc do |*args|
+                                    raise "bogus" unless args == [:one, :two]
+
+
+                                    :some_data
+                                  end
+                                )
+    end
+
+    it "runs the block with the args and passes the result to #represent" do
+      expect(scenario_orchestrator).to receive(:represent).with(:some_data, fake_scenario)
+
+      scenario_orchestrator.execute_scenario(fake_scenario)
+    end
+  end
+
+  describe "#implement" do
+    let!(:proxy_interface){ scenario_orchestrator.send(:proxy_interface) }
+    let!(:test_block){ proc { } }
+
+    it "calls #implement_class_method on the implementation proxy and returns the proxy" do
+      expect(proxy_interface).to receive(:implement_class_method).with(method_name, &test_block)
+      expect(scenario_orchestrator.implement(method_name, &test_block)).to eq(proxy_interface.proxy)
+    end
+  end
+end