bogus 0.0.4 → 0.1.0

data/lib/bogus/version.rb

@@ -1,3 +1,3 @@
 module Bogus
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/spec/bogus/copies_classes_spec.rb

@@ -51,10 +51,6 @@ describe Bogus::CopiesClasses do
       subject.baa('hello')
       subject.baa('hello') {}
     end
-
-    it "makes the methods chainable" do
-      subject.foo.bar('hello').baz('hello', 'world', 'foo').bam.baa('foo')
-    end
   end
 
   let(:copies_classes) { Bogus.inject.copies_classes }
@@ -77,11 +73,22 @@ describe Bogus::CopiesClasses do
       Class.new do
         def initialize(hello)
         end
+
+        def foo
+        end
       end
     }
 
-    it "adds a constructor that allows passing any number of arguments" do
-      fake_class.new('hello', 'w', 'o', 'r', 'l', 'd') { test }
+    it "adds a no-arg constructor" do
+      instance = fake_class.__create__
+
+      instance.should respond_to(:foo)
+    end
+
+    it "adds a constructor that allows passing the correct number of arguments" do
+      instance = fake_class.new('hello')
+
+      instance.should respond_to(:foo)
     end
   end
 

data/spec/bogus/creates_fakes_spec.rb

@@ -14,7 +14,7 @@ describe Bogus::CreatesFakes do
   module Bar
   end
 
-  before { stub(fake_class).new{fake_instance} }
+  before { stub(fake_class).__create__{fake_instance} }
 
   context "without block" do
     before do

data/spec/bogus/fake_ar_attributes_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'active_record'
+require 'nulldb'
+
+describe "Stubbing ActiveRecord::Base subclasses" do
+  ActiveRecord::Schema.verbose = false
+  ActiveRecord::Base.establish_connection :adapter => :nulldb
+
+  ActiveRecord::Schema.define do
+    create_table :blog_posts do |t|
+      t.string :name
+      t.string :author
+    end
+  end
+
+  class BlogPost < ActiveRecord::Base
+    def author(x)
+      "#{x} #{self[:author]}!"
+    end
+  end
+
+  include Bogus::MockingDSL
+
+  before do
+    Bogus.configure do |c|
+      c.fake_ar_attributes = true
+    end
+  end
+
+  it "makes it possible to stub active record fields" do
+    post = fake(:blog_post, name: "hello")
+
+    post.name.should == "hello"
+  end
+
+  it "works only when enabled in configuration" do
+    Bogus.configure do |c|
+      c.fake_ar_attributes = false
+    end
+
+    expect {
+      fake(:blog_post, name: "hello")
+    }.to raise_error(NameError)
+  end
+
+  it "does not overwrite existing method signatures" do
+    post = fake(:blog_post)
+
+    post.author("hello")
+
+    post.should have_received.author("hello")
+  end
+
+  class ExampleForActiveRecordAttributes
+    def foo(x)
+    end
+  end
+
+  it "does not interfere with non-ar classes" do
+    fake = fake(:example_for_active_record_attributes)
+
+    fake.foo(1)
+
+    fake.should have_received.foo(1)
+  end
+
+  after do
+    Bogus.configure do |c|
+      c.fake_ar_attributes = false
+    end
+  end
+end

data/spec/bogus/faking_factories_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe "Faking Factories" do
+  include Bogus::MockingDSL
+
+  class ExampleFactory
+    def initialize(model_class)
+      @model_class = model_class
+    end
+
+    def create(y)
+      @model_class.new(1, y)
+    end
+  end
+
+  class ExampleModel1
+    def initialize(x, y)
+    end
+  end
+
+  it "allows spying on factory classes" do
+    model_class = fake(:example_model, as: :class) { ExampleModel1 }
+    factory = ExampleFactory.new(model_class)
+
+    factory.create(2)
+
+    model_class.should have_received.new(1, 2)
+  end
+
+  class ExampleModel2
+    def initialize(x, y, z)
+    end
+  end
+
+  it "retains the arity safety" do
+    model_class = fake(:example_model, as: :class) { ExampleModel2 }
+    factory = ExampleFactory.new(model_class)
+
+    expect {
+      factory.create(2)
+    }.to raise_error(ArgumentError)
+  end
+
+  class ExampleModel3
+  end
+
+  it "works with classes with no explicit constructor" do
+    model_class = fake(:example_model, as: :class) { ExampleModel3 }
+
+    model = model_class.new
+
+    model_class.should have_received.new
+  end
+
+  class ExampleModel4
+    def initialize(y)
+    end
+
+    def foo(x)
+    end
+  end
+
+  it "allows creating the model instances as usual" do
+    model = fake(:example_model) { ExampleModel4 }
+
+    model.foo(1)
+
+    model.should have_received.foo(1)
+  end
+
+  module ExampleModel5
+    def self.foo(x)
+    end
+  end
+
+  it "allows creating fakes of modules as usual" do
+    model = fake(:example_model, as: :class) { ExampleModel5 }
+
+    model.foo(1)
+
+    model.should have_received.foo(1)
+  end
+end

data/spec/bogus/frozen_fakes_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe "Frozen Fakes" do
+  include Bogus::MockingDSL
+
+  class ExampleForFreezing
+    def foo(x)
+    end
+  end
+
+  shared_examples_for "frozen fakes" do
+    before { object.freeze }
+
+    describe "stubbing" do
+      it "allows stubbing" do
+        stub(object).foo(1) { 123 }
+
+        object.foo(1).should == 123
+      end
+    end
+
+    describe "mocking" do
+      it "allows mocking" do
+        mock(object).foo(1) { 123 }
+
+        object.foo(1).should == 123
+      end
+
+      it "allows verifying expectations" do
+        mock(object).foo(1) { 123 }
+
+        expect {
+          Bogus.after_each_test
+        }.to raise_error(Bogus::NotAllExpectationsSatisfied)
+      end
+    end
+
+    describe "spying" do
+      it "allows spying" do
+        object.foo(1)
+
+        object.should have_received.foo(1)
+        object.should_not have_received.foo(2)
+      end
+    end
+  end
+
+  context "anonymous fakes" do
+    let(:object) { fake }
+
+    include_examples "frozen fakes"
+  end
+
+  context "named fakes" do
+    let(:object) { fake(:example_for_freezing) }
+
+    include_examples "frozen fakes"
+  end
+end

data/spec/bogus/interaction_spec.rb

@@ -6,6 +6,9 @@ describe Bogus::Interaction do
   same = [
     [[:foo, [:bar], "value"], [:foo, [:bar], "value"]],
     [[:foo, [:bar, Bogus::DefaultValue], "value"], [:foo, [:bar], "value"]],
+    [[:foo, [:bar, {foo: Bogus::DefaultValue}], "value"], [:foo, [:bar], "value"]],
+    [[:foo, [:bar, {foo: Bogus::DefaultValue}], "value"], [:foo, [:bar, {}], "value"]],
+    [[:foo, [:bar, {foo: Bogus::DefaultValue, bar: 1}], "value"], [:foo, [:bar, {bar: 1}], "value"]],
     [[:foo, [:bar]], [:foo, [:bar], "value"]],
     [[:foo, [:bar], "value"], [:foo, [:bar]]],
     [[:foo, [:bar]], [:foo, [:bar]]],
@@ -23,6 +26,7 @@ describe Bogus::Interaction do
     [[:foo, [:bar], "value"], [:baz, [:bar], "value"]],
     [[:foo, [:baz], "value"], [:foo, [:bar], "value"]],
     [[:foo, [Bogus::DefaultValue, :baz], "value"], [:foo, [:bar, :bar], "value"]],
+    [[:foo, [:bar, {foo: Bogus::DefaultValue, bar: 1}], "value"], [:foo, [:bar, {bar: 2}], "value"]],
     [[:foo, [Bogus::AnyArgs]], [:bar, [:bar]]],
     [[:foo, [:bar]], [:bar, [Bogus::AnyArgs]]],
     [[:foo, [Bogus::AnyArgs], "some value"], [:foo, [:bar], "other value"]],

data/spec/bogus/method_copiers_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe "Method Copiers" do
+  shared_examples_for "method copier" do
+    let(:klass) { Class.new }
+    subject { isolate(described_class) }
+
+    it { should respond_to(:all) }
+    it { should respond_to(:get) }
+    it { should respond_to(:remove) }
+    it { should respond_to(:define) }
+  end
+
+  describe Bogus::InstanceMethods do
+    it_behaves_like "method copier"
+  end
+
+  describe Bogus::ClassMethods do
+    it_behaves_like "method copier"
+  end
+
+  describe Bogus::ActiveRecordAccessors do
+    let(:instance_methods) { nil }
+    it_behaves_like "method copier"
+  end
+end

data/spec/bogus/mocking_dsl_spec.rb

@@ -269,12 +269,16 @@ describe Bogus::MockingDSL do
       greeter.greet("Jake")
 
       greeter.should have_received.greet("Jake")
+      greeter.should_not have_received.greet("Bob")
     end
 
-    it "allows chaining interactions" do
-      greeter = fake(foo: "bar")
+    it "verifies mock expectations set on anonymous fakes" do
+      greeter = fake
+      mock(greeter).greet("Jake") { "Hello Jake" }
 
-      greeter.baz.foo.should == "bar"
+      expect {
+        Bogus.after_each_test
+      }.to raise_error(Bogus::NotAllExpectationsSatisfied)
     end
   end
 

data/spec/bogus/overwrites_methods_spec.rb

@@ -24,7 +24,7 @@ module Bogus
       end
 
       it "does not change the method signature" do
-        object.greet("John").should == object
+        object.method(:greet).arity.should == 1
       end
 
       it "does not change the method signature" do
@@ -75,7 +75,7 @@ module Bogus
       end
 
       it "can overwrite the non-existent methods" do
-        object.greet.should equal(object)
+        object.methods.should include(:greet)
       end
 
       it "can be reset back to the original state" do

data/spec/bogus/record_interactions_spec.rb

@@ -21,6 +21,6 @@ describe Bogus::RecordInteractions do
   end
 
   it "returns self from record by default" do
-    sample.__record__(:foo).should == sample
+    sample.__record__(:foo).should be_a_default_return_value
   end
 end

data/spec/bogus/ruby_2_support_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+if RUBY_VERSION >= '2.0'
+  describe "Ruby 2.0 keyword arguments" do
+    class ExampleForKeywordArgs
+      eval "def foo(x: raise, y: 1); end"
+      eval "def bar(x: 1, **rest); end"
+    end
+
+    include Bogus::MockingDSL
+
+    shared_examples_for "stubbing methods with keyword arguments" do
+      it "can spy on stubbed methods" do
+        stub(subject).foo(any_args)
+
+        subject.foo(x: "test")
+
+        subject.should have_received.foo(x: "test")
+        subject.should_not have_received.foo(x: "baz")
+      end
+
+      it "can mock methods with keyword arguments" do
+        mock(subject).foo(x: 1) { :return }
+
+        subject.foo(x: 1).should == :return
+
+        expect { Bogus.after_each_test }.not_to raise_error
+      end
+
+      it "can stub methods with keyword arguments" do
+        stub(subject).foo(x: "bar") { :return_value }
+
+        subject.foo(x: "bar").should == :return_value
+      end
+
+      it "raises on error on unknown keyword" do
+        expect {
+          stub(subject).foo(x: "bar", baz: "baz")
+        }.to raise_error(ArgumentError)
+      end
+
+      it "does not overwrite the method signature" do
+        stub(subject).foo(x: 1)
+
+        expect {
+          subject.foo(bar: 1)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    shared_examples_for "stubbing methods with double splat" do
+      it "can spy on stubbed methods" do
+        stub(subject).bar(any_args)
+
+        subject.bar(x: "test", z: "spec")
+
+        subject.should have_received.bar(x: "test", z: "spec")
+        subject.should_not have_received.bar(y: "baz")
+      end
+
+      it "can mock methods with keyword arguments" do
+        mock(subject).bar(x: 1, z: 2) { :return }
+
+        subject.bar(x: 1, z: 2).should == :return
+
+        expect { Bogus.after_each_test }.not_to raise_error
+      end
+
+      it "can stub methods with keyword arguments" do
+        stub(subject).bar(x: "bar", z: "bar") { :return_value }
+
+        subject.bar(x: "bar", z: "bar").should == :return_value
+      end
+    end
+
+    context "with regular objects" do
+      subject { ExampleForKeywordArgs.new }
+
+      include_examples "stubbing methods with keyword arguments"
+      include_examples "stubbing methods with double splat"
+    end
+
+    context "with fakes" do
+      subject { fake(:example_for_keyword_args) }
+
+      it "allows spying without stubbing" do
+        subject.foo(x: "test")
+
+        subject.should have_received.foo(x: "test")
+      end
+
+      include_examples "stubbing methods with keyword arguments"
+      include_examples "stubbing methods with double splat"
+    end
+  end
+end