picolena 0.1.8 → 0.2.0

data/rails_plugins/rspec/spec/spec/mocks/options_hash_spec.rb

@@ -1,45 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Mocks
-    describe "calling :should_receive with an options hash" do
-      it_should_behave_like "sandboxed rspec_options"
-      attr_reader :reporter, :example_group
-      before do
-        @reporter = ::Spec::Runner::Reporter.new(options)
-        @example_group = Class.new(::Spec::Example::ExampleGroup) do
-          plugin_mock_framework
-          describe("Some Examples")
-        end
-        reporter.add_example_group example_group
-      end
-
-      it "should report the file and line submitted with :expected_from" do
-        example_definition = example_group.it "spec" do
-          mock = Spec::Mocks::Mock.new("a mock")
-          mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
-          mock.rspec_verify
-        end
-        example = example_group.new(example_definition)
-
-        reporter.should_receive(:example_finished) do |spec, error|
-          error.backtrace.detect {|line| line =~ /\/path\/to\/blah.ext:37/}.should_not be_nil
-        end
-        example.execute(options, {})
-      end
-
-      it "should use the message supplied with :message" do
-        example_definition = @example_group.it "spec" do
-          mock = Spec::Mocks::Mock.new("a mock")
-          mock.should_receive(:message, :message => "recebi nada")
-          mock.rspec_verify
-        end
-        example = @example_group.new(example_definition)
-        @reporter.should_receive(:example_finished) do |spec, error|
-          error.message.should == "recebi nada"
-        end
-        example.execute(@options, {})
-      end
-    end
-  end
-end

data/rails_plugins/rspec/spec/spec/mocks/partial_mock_spec.rb

@@ -1,106 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Mocks
-    describe "using a Partial Mock," do
-      before(:each) do
-        @object = Object.new
-      end
-
-      it "should name the class in the failure message" do
-        @object.should_receive(:foo)
-        lambda do
-          @object.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError, /Object/)
-      end
-
-      it "should not conflict with @options in the object" do
-        @object.instance_eval { @options = Object.new }
-        @object.should_receive(:blah)
-        @object.blah
-      end
-
-      it "should_not_receive should mock out the method" do
-        @object.should_not_receive(:fuhbar)
-        @object.fuhbar
-        lambda do
-          @object.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError)
-      end
-
-      it "should_not_receive should return a negative message expectation" do
-        @object.should_not_receive(:foobar).should be_kind_of(NegativeMessageExpectation)
-      end
-
-      it "should_receive should mock out the method" do
-        @object.should_receive(:foobar).with(:test_param).and_return(1)
-        @object.foobar(:test_param).should equal(1)
-      end
-
-      it "should_receive should handle a hash" do
-        @object.should_receive(:foobar).with(:key => "value").and_return(1)
-        @object.foobar(:key => "value").should equal(1)
-      end
-
-      it "should_receive should handle an inner hash" do
-        hash = {:a => {:key => "value"}}
-        @object.should_receive(:foobar).with(:key => "value").and_return(1)
-        @object.foobar(hash[:a]).should equal(1)
-      end
-
-      it "should_receive should return a message expectation" do
-        @object.should_receive(:foobar).should be_kind_of(MessageExpectation)
-        @object.foobar
-      end
-
-      it "should_receive should verify method was called" do
-        @object.should_receive(:foobar).with(:test_param).and_return(1)
-        lambda do
-          @object.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError)
-      end
-
-      it "should_receive should also take a String argument" do
-        @object.should_receive('foobar')
-        @object.foobar
-      end
-
-      it "should_not_receive should also take a String argument" do
-        @object.should_not_receive('foobar')
-        @object.foobar
-        lambda do
-          @object.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError)
-      end
-
-      it "should use report nil in the error message" do
-        @this_will_resolve_to_nil.should_receive(:foobar)
-        lambda do
-          @this_will_resolve_to_nil.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError, /NilClass.*expected :foobar with/)
-      end
-    end
-
-    describe "Partially mocking an object that defines ==, after another mock has been defined" do
-      before(:each) do
-        stub("existing mock", :foo => :foo)
-      end
-
-      class PartiallyMockedEquals
-        attr_reader :val
-        def initialize(val)
-          @val = val
-        end
-
-        def ==(other)
-          @val == other.val
-        end
-      end
-
-      it "should not raise an error when stubbing the object" do
-        o = PartiallyMockedEquals.new :foo
-        lambda { o.stub!(:bar) }.should_not raise_error(NoMethodError)
-      end
-    end
-  end
-end

data/rails_plugins/rspec/spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -1,66 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-module Mocks
-describe "PartialMockUsingMocksDirectly" do
-    before(:each) do
-
-        klass=Class.new
-        klass.class_eval do
-          def existing_method
-            :original_value
-          end
-        end
-        @obj = klass.new
-
-    end
-
-    # See http://rubyforge.org/tracker/index.php?func=detail&aid=10263&group_id=797&atid=3149
-    # specify "should clear expectations on verify" do
-    #     @obj.should_receive(:msg)
-    #     @obj.msg
-    #     @obj.rspec_verify
-    #     lambda do
-    #       @obj.msg
-    #     end.should raise_error(NoMethodError)
-    #
-    # end
-    it "should fail when expected message is not received" do
-        @obj.should_receive(:msg)
-        lambda do
-          @obj.rspec_verify
-        end.should raise_error(MockExpectationError)
-
-    end
-    it "should fail when message is received with incorrect args" do
-        @obj.should_receive(:msg).with(:correct_arg)
-        lambda do
-          @obj.msg(:incorrect_arg)
-        end.should raise_error(MockExpectationError)
-        @obj.msg(:correct_arg)
-
-    end
-    it "should pass when expected message is received" do
-        @obj.should_receive(:msg)
-        @obj.msg
-        @obj.rspec_verify
-
-    end
-    it "should pass when message is received with correct args" do
-        @obj.should_receive(:msg).with(:correct_arg)
-        @obj.msg(:correct_arg)
-        @obj.rspec_verify
-
-    end
-    it "should revert to original method if existed" do
-        @obj.existing_method.should equal(:original_value)
-        @obj.should_receive(:existing_method).and_return(:mock_value)
-        @obj.existing_method.should equal(:mock_value)
-        @obj.rspec_verify
-        @obj.existing_method.should equal(:original_value)
-
-    end
-
-end
-end
-end

data/rails_plugins/rspec/spec/spec/mocks/passing_mock_argument_constraints_spec.rb

@@ -1,154 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Mocks
-    describe "mock argument constraints", :shared => true do
-      before(:each) do
-        @mock = Mock.new("test mock")
-        Kernel.stub!(:warn)
-      end
-
-      after(:each) do
-        @mock.rspec_verify
-      end
-    end
-
-    describe Methods, "handling argument constraints with DEPRECATED symbols" do
-      it_should_behave_like "mock argument constraints"
-
-      it "should accept true as boolean" do
-        @mock.should_receive(:random_call).with(:boolean)
-        @mock.random_call(true)
-      end
-
-      it "should accept false as boolean" do
-        @mock.should_receive(:random_call).with(:boolean)
-        @mock.random_call(false)
-      end
-
-      it "should accept fixnum as numeric" do
-        @mock.should_receive(:random_call).with(:numeric)
-        @mock.random_call(1)
-      end
-
-      it "should accept float as numeric" do
-        @mock.should_receive(:random_call).with(:numeric)
-        @mock.random_call(1.5)
-      end
-
-      it "should accept string as anything" do
-        @mock.should_receive(:random_call).with("a", :anything, "c")
-        @mock.random_call("a", "whatever", "c")
-      end
-
-      it "should match string" do
-        @mock.should_receive(:random_call).with(:string)
-        @mock.random_call("a string")
-      end
-
-      it "should match no args against any_args" do
-        @mock.should_receive(:random_call).with(:any_args)
-        @mock.random_call("a string")
-      end
-
-      it "should match no args against no_args" do
-        @mock.should_receive(:random_call).with(:no_args)
-        @mock.random_call
-      end
-    end
-
-    describe Methods, "handling argument constraints" do
-      it_should_behave_like "mock argument constraints"
-
-      it "should accept true as boolean()" do
-        @mock.should_receive(:random_call).with(boolean())
-        @mock.random_call(true)
-      end
-
-      it "should accept false as boolean()" do
-        @mock.should_receive(:random_call).with(boolean())
-        @mock.random_call(false)
-      end
-
-      it "should accept fixnum as an_instance_of(Numeric)" do
-        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
-        @mock.random_call(1)
-      end
-
-      it "should accept float as an_instance_of(Numeric)" do
-        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
-        @mock.random_call(1.5)
-      end
-
-      it "should accept string as anything()" do
-        @mock.should_receive(:random_call).with("a", anything(), "c")
-        @mock.random_call("a", "whatever", "c")
-      end
-
-      it "should match duck type with one method" do
-        @mock.should_receive(:random_call).with(duck_type(:length))
-        @mock.random_call([])
-      end
-
-      it "should match duck type with two methods" do
-        @mock.should_receive(:random_call).with(duck_type(:abs, :div))
-        @mock.random_call(1)
-      end
-
-      it "should match no args against any_args()" do
-        @mock.should_receive(:random_call).with(any_args)
-        @mock.random_call()
-      end
-
-      it "should match one arg against any_args()" do
-        @mock.should_receive(:random_call).with(any_args)
-        @mock.random_call("a string")
-      end
-
-      it "should match no args against no_args()" do
-        @mock.should_receive(:random_call).with(no_args)
-        @mock.random_call()
-      end
-    end
-
-    describe Methods, "handling non-constraint arguments" do
-
-      it "should match non special symbol (can be removed when deprecated symbols are removed)" do
-        @mock.should_receive(:random_call).with(:some_symbol)
-        @mock.random_call(:some_symbol)
-      end
-
-      it "should match string against regexp" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        @mock.random_call("abcde")
-      end
-
-      it "should match regexp against regexp" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        @mock.random_call(/bcd/)
-      end
-
-      it "should match against a hash submitted and received by value" do
-        @mock.should_receive(:random_call).with(:a => "a", :b => "b")
-        @mock.random_call(:a => "a", :b => "b")
-      end
-
-      it "should match against a hash submitted by reference and received by value" do
-        opts = {:a => "a", :b => "b"}
-        @mock.should_receive(:random_call).with(opts)
-        @mock.random_call(:a => "a", :b => "b")
-      end
-
-      it "should match against a hash submitted by value and received by reference" do
-        opts = {:a => "a", :b => "b"}
-        @mock.should_receive(:random_call).with(:a => "a", :b => "b")
-        @mock.random_call(opts)
-      end
-
-      it "should match against a Matcher" do
-        @mock.should_receive(:msg).with(equal(37))
-        @mock.msg(37)
-      end
-    end
-  end
-end

data/rails_plugins/rspec/spec/spec/mocks/precise_counts_spec.rb

@@ -1,52 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Mocks
-    describe "PreciseCounts" do
-      before(:each) do
-        @mock = mock("test mock")
-      end
-
-      it "should fail when exactly n times method is called less than n times" do
-        @mock.should_receive(:random_call).exactly(3).times
-        @mock.random_call
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-
-      it "should fail when exactly n times method is never called" do
-        @mock.should_receive(:random_call).exactly(3).times
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-
-      it "should pass if exactly n times method is called exactly n times" do
-        @mock.should_receive(:random_call).exactly(3).times
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.rspec_verify
-      end
-
-      it "should pass multiple calls with different args and counts" do
-        @mock.should_receive(:random_call).twice.with(1)
-        @mock.should_receive(:random_call).once.with(2)
-        @mock.random_call(1)
-        @mock.random_call(2)
-        @mock.random_call(1)
-        @mock.rspec_verify
-      end
-
-      it "should pass mutiple calls with different args" do
-        @mock.should_receive(:random_call).once.with(1)
-        @mock.should_receive(:random_call).once.with(2)
-        @mock.random_call(1)
-        @mock.random_call(2)
-        @mock.rspec_verify
-      end
-    end
-  end
-end

data/rails_plugins/rspec/spec/spec/mocks/record_messages_spec.rb

@@ -1,26 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module Mocks
-    describe "a mock" do
-      before(:each) do
-        @mock = mock("mock", :null_object => true)
-      end
-      it "should answer false for received_message? when no messages received" do
-        @mock.received_message?(:message).should be_false
-      end
-      it "should answer true for received_message? when message received" do
-        @mock.message
-        @mock.received_message?(:message).should be_true
-      end
-      it "should answer true for received_message? when message received with correct args" do
-        @mock.message 1,2,3
-        @mock.received_message?(:message, 1,2,3).should be_true
-      end
-      it "should answer false for received_message? when message received with incorrect args" do
-        @mock.message 1,2,3
-        @mock.received_message?(:message, 1,2).should be_false
-      end
-    end
-  end
-end

data/rails_plugins/rspec/spec/spec/mocks/stub_spec.rb

@@ -1,181 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Mocks
-    describe "A method stub" do
-      before(:each) do
-        @class = Class.new do
-          def self.existing_class_method
-            :original_value
-          end
-
-          def existing_instance_method
-            :original_value
-          end
-        end
-        @instance = @class.new
-      end
-
-      it "should return expected value when expected message is received" do
-        @instance.stub!(:msg).and_return(:return_value)
-        @instance.msg.should equal(:return_value)
-        @instance.rspec_verify
-      end
-
-      it "should ignore when expected message is received" do
-        @instance.stub!(:msg)
-        @instance.msg
-        lambda do
-          @instance.rspec_verify
-        end.should_not raise_error
-      end
-
-      it "should ignore when message is received with args" do
-        @instance.stub!(:msg)
-        @instance.msg(:an_arg)
-        lambda do
-          @instance.rspec_verify
-        end.should_not raise_error
-      end
-
-      it "should ignore when expected message is not received" do
-        @instance.stub!(:msg)
-        lambda do
-          @instance.rspec_verify
-        end.should_not raise_error
-      end
-
-      it "should clear itself when verified" do
-        @instance.stub!(:this_should_go).and_return(:blah)
-        @instance.this_should_go.should == :blah
-        @instance.rspec_verify
-        lambda do
-          @instance.this_should_go
-        end.should raise_error(NameError)
-      end
-
-      it "should return values in order to consecutive calls" do
-        return_values = ["1",2,Object.new]
-        @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
-        @instance.msg.should == return_values[0]
-        @instance.msg.should == return_values[1]
-        @instance.msg.should == return_values[2]
-      end
-
-      it "should keep returning last value in consecutive calls" do
-        return_values = ["1",2,Object.new]
-        @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
-        @instance.msg.should == return_values[0]
-        @instance.msg.should == return_values[1]
-        @instance.msg.should == return_values[2]
-        @instance.msg.should == return_values[2]
-        @instance.msg.should == return_values[2]
-      end
-
-      it "should revert to original instance method if there is one" do
-        @instance.existing_instance_method.should equal(:original_value)
-        @instance.stub!(:existing_instance_method).and_return(:mock_value)
-        @instance.existing_instance_method.should equal(:mock_value)
-        @instance.rspec_verify
-        @instance.existing_instance_method.should equal(:original_value)
-      end
-
-      it "should revert to original class method if there is one" do
-        @class.existing_class_method.should equal(:original_value)
-        @class.stub!(:existing_class_method).and_return(:mock_value)
-        @class.existing_class_method.should equal(:mock_value)
-        @class.rspec_verify
-        @class.existing_class_method.should equal(:original_value)
-      end
-
-      it "should yield a specified object" do
-        @instance.stub!(:method_that_yields).and_yield(:yielded_obj)
-        current_value = :value_before
-        @instance.method_that_yields {|val| current_value = val}
-        current_value.should == :yielded_obj
-        @instance.rspec_verify
-      end
-
-      it "should yield multiple times with multiple calls to and_yield" do
-        @instance.stub!(:method_that_yields_multiple_times).and_yield(:yielded_value).
-                                                       and_yield(:another_value)
-        current_value = []
-        @instance.method_that_yields_multiple_times {|val| current_value << val}
-        current_value.should == [:yielded_value, :another_value]
-        @instance.rspec_verify
-      end
-
-      it "should yield a specified object and return another specified object" do
-        yielded_obj = mock("my mock")
-        yielded_obj.should_receive(:foo).with(:bar)
-        @instance.stub!(:method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz)
-        @instance.method_that_yields_and_returns { |o| o.foo :bar }.should == :baz
-      end
-
-      it "should throw when told to" do
-        @mock.stub!(:something).and_throw(:up)
-        lambda do
-          @mock.something
-        end.should throw_symbol(:up)
-      end
-
-      it "should override a pre-existing stub" do
-        @stub.stub!(:existing_instance_method).and_return(:updated_stub_value)
-        @stub.existing_instance_method.should == :updated_stub_value
-      end
-
-      it "should limit " do
-        @stub.stub!(:foo).with("bar")
-        @stub.should_receive(:foo).with("baz")
-        @stub.foo("bar")
-        @stub.foo("baz")
-      end
-    end
-
-    describe "A method stub with args" do
-      before(:each) do
-        @stub = Object.new
-        @stub.stub!(:foo).with("bar")
-      end
-
-      it "should not complain if not called" do
-      end
-
-      it "should not complain if called with arg" do
-        @stub.foo("bar")
-      end
-
-      it "should complain if called with no arg" do
-        lambda do
-          @stub.foo
-        end.should raise_error
-      end
-
-      it "should complain if called with other arg" do
-        lambda do
-          @stub.foo("other")
-        end.should raise_error
-      end
-
-      it "should not complain if also mocked w/ different args" do
-        @stub.should_receive(:foo).with("baz")
-        @stub.foo("bar")
-        @stub.foo("baz")
-      end
-
-      it "should complain if also mocked w/ different args AND called w/ a 3rd set of args" do
-        @stub.should_receive(:foo).with("baz")
-        @stub.foo("bar")
-        @stub.foo("baz")
-        lambda do
-          @stub.foo("other")
-        end.should raise_error
-      end
-
-      it "should support options" do
-        @stub.stub!(:foo, :expected_from => "bar")
-      end
-    end
-
-  end
-end

data/rails_plugins/rspec/spec/spec/mocks/twice_counts_spec.rb

@@ -1,67 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Mocks
-    describe "TwiceCounts" do
-      before(:each) do
-        @mock = mock("test mock")
-      end
-
-      it "twice should fail when call count is higher than expected" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-
-      it "twice should fail when call count is lower than expected" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-
-      it "twice should fail when called twice with wrong args on the first call" do
-        @mock.should_receive(:random_call).twice.with("1", 1)
-        lambda do
-          @mock.random_call(1, "1")
-        end.should raise_error(MockExpectationError)
-        @mock.rspec_reset
-      end
-
-      it "twice should fail when called twice with wrong args on the second call" do
-        @mock.should_receive(:random_call).twice.with("1", 1)
-        @mock.random_call("1", 1)
-        lambda do
-          @mock.random_call(1, "1")
-        end.should raise_error(MockExpectationError)
-        @mock.rspec_reset
-      end
-
-      it "twice should pass when called twice" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call
-        @mock.random_call
-        @mock.rspec_verify
-      end
-
-      it "twice should pass when called twice with specified args" do
-        @mock.should_receive(:random_call).twice.with("1", 1)
-        @mock.random_call("1", 1)
-        @mock.random_call("1", 1)
-        @mock.rspec_verify
-      end
-
-      it "twice should pass when called twice with unspecified args" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call("1")
-        @mock.random_call(1)
-        @mock.rspec_verify
-      end
-    end
-  end
-end