shoegaze 1.1.0

data/lib/shoegaze/version.rb

@@ -0,0 +1,3 @@
+module Shoegaze
+  VERSION = "1.1.0".freeze
+end

data/spec/features/basic_class_method_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+class BasicClassMethod
+  class << self
+    def basic_class_method(arg1, arg2)
+      raise "should never see this"
+    end
+  end
+end
+
+class FakeBasicClassMethod < Shoegaze::Mock
+  mock "BasicClassMethod"
+
+  implement_class_method :basic_class_method do
+    scenario :good do
+      datasource do |arg1, arg2|
+        :perfect_socks
+      end
+    end
+
+    scenario :bad do
+      datasource do |arg1, arg2|
+        :terrible_socks
+      end
+    end
+  end
+end
+
+describe FakeBasicClassMethod do
+  let!(:mock){ FakeBasicClassMethod.proxy }
+
+  describe "good scenario" do
+    let!(:args){ [:wool, :cotton] }
+
+    before do
+      FakeBasicClassMethod.class_call(:basic_class_method).with(*args).yields(:good)
+    end
+
+    it "runs the :good scenario datasource" do
+      expect(mock.basic_class_method(*args)).to eq(:perfect_socks)
+    end
+  end
+
+  describe "bad scenario" do
+    let!(:args){ [:burlap, :fiberglass] }
+
+    before do
+      FakeBasicClassMethod.class_call(:basic_class_method).with(*args).yields(:bad)
+    end
+
+    it "runs the :bad scenario datasource" do
+      expect(mock.basic_class_method(*args)).to eq(:terrible_socks)
+    end
+  end
+end

data/spec/features/basic_instance_method_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+class BasicInstanceMethod
+  def basic_instance_method(arg1, arg2)
+    raise "should never see this"
+  end
+end
+
+class FakeBasicInstanceMethod < Shoegaze::Mock
+  mock "BasicInstanceMethod"
+
+  implement_instance_method :basic_instance_method do
+    scenario :good do
+      datasource do |arg1, arg2|
+        :perfect_socks
+      end
+    end
+
+    scenario :bad do
+      datasource do |arg1, arg2|
+        :terrible_socks
+      end
+    end
+  end
+end
+
+describe FakeBasicInstanceMethod do
+  let!(:mock){ FakeBasicInstanceMethod.proxy }
+
+  describe "good scenario" do
+    let!(:args){ [:wool, :cotton] }
+
+    before do
+      FakeBasicInstanceMethod.instance_call(:basic_instance_method).with(*args).yields(:good)
+    end
+
+    it "runs the :good scenario datasource" do
+      expect(mock.new.basic_instance_method(*args)).to eq(:perfect_socks)
+    end
+  end
+
+  describe "bad scenario" do
+    let!(:args){ [:burlap, :fiberglass] }
+
+    before do
+      FakeBasicInstanceMethod.instance_call(:basic_instance_method).with(*args).yields(:bad)
+    end
+
+    it "runs the :bad scenario datasource" do
+      expect(mock.new.basic_instance_method(*args)).to eq(:terrible_socks)
+    end
+  end
+end

data/spec/features/class_default_scenario_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+class ClassDefaultScenario
+  class << self
+    def basic_class_method(arg1, arg2)
+      raise "should never see this"
+    end
+  end
+end
+
+class FakeClassDefaultScenario < Shoegaze::Mock
+  mock "ClassDefaultScenario"
+
+  implement_class_method :basic_class_method do
+    default do
+      datasource do |arg1, arg2|
+        :perfect_socks
+      end
+    end
+
+    scenario :bad do
+      datasource do |arg1, arg2|
+        :terrible_socks
+      end
+    end
+  end
+end
+
+describe FakeClassDefaultScenario do
+  let!(:mock){ FakeClassDefaultScenario.proxy }
+
+  describe "with no specific scenario orchestrated and a default scenario implemented" do
+    let!(:args){ [:wool, :cotton] }
+
+    it "the :default scenario is run" do
+      expect(mock.basic_class_method(*args)).to eq(:perfect_socks)
+    end
+  end
+
+  describe "with the bad scenario orchestrated" do
+    let!(:args){ [:burlap, :fiberglass] }
+
+    before do
+      FakeClassDefaultScenario.class_call(:basic_class_method).with(*args).yields(:bad)
+    end
+
+    it "runs the :bad scenario datasource" do
+      expect(mock.basic_class_method(*args)).to eq(:terrible_socks)
+    end
+  end
+end

data/spec/features/class_method_block_argument_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+class BlockClassMethod
+  class << self
+    def class_method_that_takes_a_block(&block)
+      block.call + " the grass"
+    end
+  end
+end
+
+class FakeBlockClassMethod < Shoegaze::Mock
+  mock "BlockClassMethod"
+
+  implement_class_method :class_method_that_takes_a_block do
+    default do
+      datasource do |*args, &block|
+        block.call + " my hair"
+      end
+    end
+
+    scenario :cheesy do
+      datasource do |*args, &block|
+        block.call + " the cheese"
+      end
+    end
+  end
+end
+
+describe FakeBlockClassMethod do
+  let!(:mock){ FakeBlockClassMethod.proxy }
+
+  describe "good scenario" do
+    let!(:block) do
+      proc do
+        "Cut"
+      end
+    end
+
+    it "runs the default scenario datasource, passing in the block" do
+      result = mock.class_method_that_takes_a_block(&block)
+      expect(result).to eq("Cut my hair")
+    end
+  end
+
+  describe "cheesy scenario" do
+    let!(:block) do
+      proc do
+        "Cut"
+      end
+    end
+
+    before do
+      FakeBlockClassMethod.class_call(:class_method_that_takes_a_block).with(no_args).yields(:cheesy)
+    end
+
+    it "runs the :cheesy scenario datasource, passing in the block" do
+      result = mock.class_method_that_takes_a_block(&block)
+      expect(result).to eq("Cut the cheese")
+    end
+  end
+end

data/spec/features/data_store_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+class DataStoreMethod
+  class << self
+    def create_sock(sock_data)
+      raise "should never see this"
+    end
+
+    def find_sock(sock_id)
+      raise "should never see this"
+    end
+  end
+end
+
+class SockRepresenter < Representable::Decorator
+  include Representable::JSON
+
+  property :id
+  property :created_at
+  property :material, exec_context: :decorator
+
+  def material
+    represented.material.reverse
+  end
+end
+
+class FakeDataStoreMethod < Shoegaze::Mock
+  extend Shoegaze::Datastore
+
+  mock "DataStoreMethod"
+
+  datastore :Sock do
+    id{ (Random.rand * 100).ceil }
+    material{ [:wool, :carpet, :seal_whiskers].sample }
+    created_at{ Time.now }
+  end
+
+  implement_class_method :create_sock do
+    default do
+      representer SockRepresenter
+      represent_method :as_json
+
+      datasource do |sock_data|
+        FactoryBot.create("fake_data_store_method/sock", sock_data)
+      end
+    end
+  end
+
+  implement_class_method :find_sock do
+    default do
+      representer SockRepresenter
+      represent_method :as_json
+
+      datasource do |id|
+        Sock.find(id)
+      end
+    end
+  end
+end
+
+describe FakeDataStoreMethod do
+  let!(:mock){ FakeDataStoreMethod.proxy }
+
+  describe "persistence" do
+    it "can store and retrieve objects from the datastore" do
+      created_sock_data = mock.create_sock({:material => "latex"})
+      expect(created_sock_data["material"]).to eq("xetal")
+
+      found_sock_data = mock.find_sock(created_sock_data["id"])
+      expect(created_sock_data).to eq(found_sock_data)
+    end
+  end
+end

data/spec/features/instance_customized_initializer.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+class InstanceWithInitializer
+  def initialize(_arg1, _arg2)
+    raise "should not see this because we're mocking it"
+  end
+end
+
+class FakeInstanceWithInitializer < Shoegaze::Mock
+  mock "InstanceWithInitializer"
+end
+
+describe FakeInstanceWithInitializer do
+  let!(:mock){ FakeInstanceWithInitializer.proxy }
+
+  describe "mock a class with an initializer that takes arguments" do
+    it "supports instantiation" do
+      # we just want to prove that mocks based on objects with initializers can be
+      # instantiated
+      instance = mock.new("arg1", "arg2")
+      expect(instance).to be_kind_of Shoegaze::Proxy::Template
+    end
+  end
+end

data/spec/features/instance_default_scenario_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+class InstanceDefaultScenario
+  def basic_instance_method(arg1, arg2)
+    raise "should never see this"
+  end
+end
+
+class FakeInstanceDefaultScenario < Shoegaze::Mock
+  mock "InstanceDefaultScenario"
+
+  implement_instance_method :basic_instance_method do
+    default do
+      datasource do |arg1, arg2|
+        :perfect_socks
+      end
+    end
+
+    scenario :bad do
+      datasource do |arg1, arg2|
+        :terrible_socks
+      end
+    end
+  end
+end
+
+describe FakeInstanceDefaultScenario do
+  let!(:mock){ FakeInstanceDefaultScenario.proxy }
+
+  describe "with no specific scenario orchestrated and a default scenario implemented" do
+    let!(:args){ [:wool, :cotton] }
+
+    it "the :default scenario is run" do
+      instance = mock.new
+
+      expect(instance.basic_instance_method(*args)).to eq(:perfect_socks)
+    end
+  end
+
+  describe "with the bad scenario orchestrated" do
+    let!(:args){ [:burlap, :fiberglass] }
+
+    before do
+      FakeInstanceDefaultScenario.instance_call(:basic_instance_method).with(*args).yields(:bad)
+    end
+
+    it "runs the :bad scenario datasource" do
+      expect(mock.new.basic_instance_method(*args)).to eq(:terrible_socks)
+    end
+  end
+end

data/spec/features/instance_method_block_argument_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+class BlockInstanceMethod
+  def instance_method_that_takes_a_block(&block)
+    block.call + " the grass"
+  end
+end
+
+class FakeBlockInstanceMethod < Shoegaze::Mock
+  mock "BlockInstanceMethod"
+
+  implement_instance_method :instance_method_that_takes_a_block do
+    default do
+      datasource do |*args, &block|
+        block.call + " my hair"
+      end
+    end
+
+    scenario :cheesy do
+      datasource do |*args, &block|
+        block.call + " the cheese"
+      end
+    end
+  end
+end
+
+describe FakeBlockInstanceMethod do
+  let!(:mock){ FakeBlockInstanceMethod.proxy }
+
+  describe "default scenario" do
+    let!(:block) do
+      proc do
+        "Cut"
+      end
+    end
+
+    it "runs the default scenario datasource, passing in the block" do
+      result = mock.new.instance_method_that_takes_a_block(&block)
+      expect(result).to eq("Cut my hair")
+    end
+  end
+
+  describe "cheesy scenario" do
+    let!(:block) do
+      proc do
+        "Cut"
+      end
+    end
+
+    before do
+      FakeBlockInstanceMethod.instance_call(:instance_method_that_takes_a_block).with(no_args).yields(:cheesy)
+    end
+
+    it "runs the :cheesy scenario datasource, passing in the block" do
+      result = mock.new.instance_method_that_takes_a_block(&block)
+
+      expect(result).to eq("Cut the cheese")
+    end
+  end
+end

data/spec/features/nested_class_method_spec.rb

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