gem_repackager 0.1.0

data/support/gems/rspec-mocks-2.11.1/features/message_expectations/expect_message.feature

@@ -0,0 +1,94 @@
+Feature: expect a message
+
+  Use should_receive() to set an expectation that a receiver should receive a
+  message before the example is completed.
+
+  Scenario: expect a message
+    Given a file named "spec/account_spec.rb" with:
+      """
+      require "account"
+
+      describe Account do
+        context "when closed" do
+          it "logs an account closed message" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_closed)
+
+            account.close
+          end
+        end
+      end
+      """
+    And a file named "lib/account.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def close
+          logger.account_closed
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: expect a message with an argument
+    Given a file named "spec/account_spec.rb" with:
+      """
+      require "account"
+
+      describe Account do
+        context "when closed" do
+          it "logs an account closed message" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_closed).with(account)
+
+            account.close
+          end
+        end
+      end
+      """
+    And a file named "lib/account.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def close
+          logger.account_closed(self)
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: provide a return value
+    Given a file named "message_expectation_spec.rb" with:
+      """
+      describe "a message expectation" do
+        context "with a return value" do
+          context "specified in a block" do
+            it "returns the specified value" do
+              receiver = double("receiver")
+              receiver.should_receive(:message) { :return_value }
+              receiver.message.should eq(:return_value)
+            end
+          end
+
+          context "specified with and_return" do
+            it "returns the specified value" do
+              receiver = double("receiver")
+              receiver.should_receive(:message).and_return(:return_value)
+              receiver.message.should eq(:return_value)
+            end
+          end
+        end
+      end
+      """
+    When I run `rspec message_expectation_spec.rb`
+    Then the output should contain "2 examples, 0 failures"

data/support/gems/rspec-mocks-2.11.1/features/message_expectations/receive_counts.feature

@@ -0,0 +1,209 @@
+Feature: receive counts
+
+  Scenario: expect a message once
+    Given a file named "spec/account_spec.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def open
+          logger.account_opened
+        end
+      end
+
+      describe Account do
+        context "when opened" do
+          it "logger#account_opened was called once" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_opened).once
+
+            account.open
+          end
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: expect a message twice
+    Given a file named "spec/account_spec.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def open
+          logger.account_opened
+        end
+      end
+
+      describe Account do
+        context "when opened" do
+          it "logger#account_opened was called once" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_opened).twice
+
+            account.open
+            account.open
+          end
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: expect a message 3 times
+    Given a file named "spec/account_spec.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def open
+          logger.account_opened
+        end
+      end
+
+      describe Account do
+        context "when opened" do
+          it "logger#account_opened was called once" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_opened).exactly(3).times
+
+            account.open
+            account.open
+            account.open
+          end
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: expect a message at least (:once)
+    Given a file named "spec/account_spec.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def open
+          logger.account_opened
+        end
+      end
+
+      describe Account do
+        context "when opened" do
+          it "logger#account_opened was called once" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_opened).at_least(:once)
+
+            account.open
+          end
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+
+  Scenario: expect a message at least (n) times
+    Given a file named "spec/account_spec.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def open
+          logger.account_opened
+        end
+      end
+
+      describe Account do
+        context "when opened" do
+          it "logger#account_opened was called once" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_opened).at_least(3).times
+
+            # Note that I am calling method under test 4 times
+            # and I specified it to be called at least 3 times
+            account.open
+            account.open
+            account.open
+            account.open
+          end
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: expect a message at most (:once)
+    Given a file named "spec/account_spec.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def open
+          logger.account_opened
+        end
+      end
+
+      describe Account do
+        context "when opened" do
+          it "logger#account_opened was called once" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_opened).at_most(:once)
+
+            account.open
+            account.open
+          end
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "expected: 1 time"
+     And the output should contain "received: 2 times"
+
+  Scenario: expect a message at most (n) times
+    Given a file named "spec/account_spec.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        def open
+          logger.account_opened
+        end
+      end
+
+      describe Account do
+        context "when opened" do
+          it "logger#account_opened was called once" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_opened).at_most(2).times
+
+            account.open
+            account.open
+          end
+        end
+      end
+      """
+    When I run `rspec spec/account_spec.rb`
+    Then the output should contain "1 example, 0 failures"

data/support/gems/rspec-mocks-2.11.1/features/message_expectations/warn_when_expectation_is_set_on_nil.feature

@@ -0,0 +1,50 @@
+Feature: warn when expectation is set on nil
+
+  Scenario: nil instance variable
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec.configure {|c| c.mock_with :rspec}
+      describe "something" do
+        it "does something" do
+          @i_do_not_exist.should_receive(:foo)
+          @i_do_not_exist.foo
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "An expectation of :foo was set on nil"
+
+  Scenario: allow
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec.configure {|c| c.mock_with :rspec}
+      describe "something" do
+        it "does something" do
+          allow_message_expectations_on_nil
+          nil.should_receive(:foo)
+          nil.foo
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should not contain "An expectation"
+
+  Scenario: allow in one example, but not on another
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec.configure {|c| c.mock_with :rspec}
+      describe "something" do
+        it "does something (foo)" do
+          allow_message_expectations_on_nil
+          nil.should_receive(:foo)
+          nil.foo
+        end
+        it "does something (bar)" do
+          nil.should_receive(:bar)
+          nil.bar
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "An expectation of :bar"
+    And  the output should not contain "An expectation of :foo"

data/support/gems/rspec-mocks-2.11.1/features/method_stubs/README.md

@@ -0,0 +1,43 @@
+### Stub return values
+
+    obj.stub(:message) { :value }
+    obj.stub(:message => :value)
+    obj.stub(:message).and_return(:value)
+
+These forms are somewhat interchangeable. The difference is that the block
+contents are evaluated lazily when the `obj` receives the `message` message,
+whereas the others are evaluated as they are read.
+
+### Fake implementation
+
+    obj.stub(:message) do |arg1, arg2|
+      # set expectations about the args in this block
+      # and/or set a return value
+    end
+
+### Raising/Throwing
+
+    obj.stub(:message).and_raise("this error")
+    obj.stub(:message).and_throw(:this_symbol)
+
+You can also use the block format, for consistency with other stubs:
+
+    obj.stub(:message) { raise "this error" }
+    obj.stub(:message) { throw :this_symbol }
+
+### Argument constraints
+   
+#### Explicit arguments
+
+    obj.stub(:message).with('an argument') { ... }
+    obj.stub(:message).with('more_than', 'one_argument') { ... }
+
+#### Argument matchers
+
+    obj.stub(:message).with(anything()) { ... }
+    obj.stub(:message).with(an_instance_of(Money)) { ... }
+    obj.stub(:message).with(hash_including(:a => 'b')) { ... }
+
+#### Regular expressions
+
+    obj.stub(:message).with(/abc/) { ... }

data/support/gems/rspec-mocks-2.11.1/features/method_stubs/any_instance.feature

@@ -0,0 +1,133 @@
+Feature: stub on any instance of a class
+
+  Use `any_instance.stub` on a class to tell any instance of that class to
+  return a value (or values) in response to a given message.  If no instance
+  receives the message, nothing happens.
+
+  Messages can be stubbed on any class, including those in Ruby's core library.
+
+  Scenario: any_instance stub with a single return value
+    Given a file named "example_spec.rb" with:
+      """
+      describe "any_instance.stub" do
+        it "returns the specified value on any instance of the class" do
+          Object.any_instance.stub(:foo).and_return(:return_value)
+
+          o = Object.new
+          o.foo.should eq(:return_value)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+    
+  Scenario: any_instance stub with a hash
+    Given a file named "example_spec.rb" with:
+      """
+      describe "any_instance.stub" do
+        context "with a hash" do
+          it "returns the hash values on any instance of the class" do
+            Object.any_instance.stub(:foo => 'foo', :bar => 'bar')
+
+            o = Object.new
+            o.foo.should eq('foo')
+            o.bar.should eq('bar')
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass  
+    
+  Scenario: any_instance stub with specific arguments matchers
+    Given a file named "example_spec.rb" with:
+      """
+      describe "any_instance.stub" do
+        context "with arguments" do
+          it "returns the stubbed value when arguments match" do
+            Object.any_instance.stub(:foo).with(:param_one, :param_two).and_return(:result_one)
+            Object.any_instance.stub(:foo).with(:param_three, :param_four).and_return(:result_two)
+          
+            o = Object.new
+            o.foo(:param_one, :param_two).should eq(:result_one)
+            o.foo(:param_three, :param_four).should eq(:result_two)
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+  
+  Scenario: any_instance unstub
+    Given a file named "example_spec.rb" with:
+      """
+      describe "any_instance.unstub" do
+        it "unstubs a stubbed method" do
+          class Object
+            def foo
+              :foo
+            end
+          end
+          
+          Object.any_instance.stub(:foo)
+          Object.any_instance.unstub(:foo)
+
+          Object.new.foo.should eq(:foo)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass  
+  
+  Scenario: any_instance unstub
+    Given a file named "example_spec.rb" with:
+      """
+      describe "any_instance.unstub" do
+        context "with both an expectation and a stub already set" do
+          it "only removes the stub" do
+            class Object
+              def foo
+                :foo
+              end
+            end
+            Object.any_instance.should_receive(:foo).and_return(:bar)
+            Object.any_instance.stub(:foo)
+            Object.any_instance.unstub(:foo)
+            
+            Object.new.foo.should eq(:bar)
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+    
+  Scenario: stub a chain of methods an any instance
+    Given a file named "stub_chain_spec.rb" with:
+      """
+      describe "stubbing a chain of methods" do
+        context "given symbols representing methods" do
+          it "returns the correct value" do
+            Object.any_instance.stub_chain(:one, :two, :three).and_return(:four)
+            Object.new.one.two.three.should eq(:four)
+          end
+        end
+
+        context "given a hash at the end" do
+          it "returns the correct value" do
+            Object.any_instance.stub_chain(:one, :two, :three => :four)
+            Object.new.one.two.three.should eq(:four)
+          end
+        end
+
+        context "given a string of methods separated by dots" do
+          it "returns the correct value" do
+            Object.any_instance.stub_chain("one.two.three").and_return(:four)
+            Object.new.one.two.three.should eq(:four)
+          end
+        end
+      end
+      """
+    When I run `rspec stub_chain_spec.rb`
+    Then the examples should all pass
+