bogus 0.0.1

data/features/contract_tests_mocks.feature

@@ -0,0 +1,100 @@
+Feature: Contract tests with mocks
+
+  Background:
+    Given a file named "foo.rb" with:
+    """ruby
+    class Library
+      def initialize
+        @books = []
+      end
+
+      def has_book?(book)
+        @books.include?(book)
+      end
+
+      def checkout(book)
+        @books.delete(book)
+      end
+
+      def return(book)
+        @books << book
+      end
+    end
+
+    class Student
+      def read(book, library = Library.new)
+        if library.has_book?(book)
+          library.checkout(book)
+        end
+      end
+    end
+    """
+    And a spec file named "student_spec.rb" with:
+    """ruby
+    describe Student do
+      fake(:library)
+
+      it "checks out the book from library if it is available" do
+        student = Student.new
+        mock(library).has_book?("Moby Dick") { true }
+        mock(library).checkout("Moby Dick") { "Moby Dick" }
+
+        student.read("Moby Dick", library)
+      end
+
+      it "does not check out the book from library if not available" do
+        student = Student.new
+        mock(library).has_book?("Moby Dick") { false }
+        dont_allow(library).checkout("Moby Dick")
+
+        student.read("Moby Dick", library)
+      end
+    end
+    """
+
+  Scenario: Fails when mocked methods are not called on real object
+    Then spec file with following content should fail:
+    """ruby
+    describe Library do
+      verify_contract(:library)
+
+      let(:library) { Library.new }
+
+      it "marks books as unavailable after they are checked out" do
+        library.return("Moby Dick")
+
+        library.checkout("Moby Dick")
+
+        library.has_book?("Moby Dick").should be_false
+      end
+    end
+    """
+
+  Scenario: Verifies that mocked methods are called
+    Then spec file with following content should pass:
+    """ruby
+    describe Library do
+      verify_contract(:library)
+
+      let(:library) { Library.new }
+
+      it "allows checking out books that are in the inventory" do
+        library.return("Moby Dick")
+
+        library.has_book?("Moby Dick").should be_true
+      end
+
+      it "does not allow checking out unavailable books" do
+        library.has_book?("Moby Dick").should be_false
+      end
+
+      it "marks books as unavailable after they are checked out" do
+        library.return("Moby Dick")
+
+        library.checkout("Moby Dick")
+
+        library.has_book?("Moby Dick").should be_false
+      end
+    end
+    """
+

data/features/contract_tests_spies.feature

@@ -0,0 +1,72 @@
+Feature: Contract tests with spies
+
+  Background:
+    Given a file named "foo.rb" with:
+    """ruby
+    class Library
+      def checkout(book)
+      end
+    end
+
+    class Student
+      def read(book, library = Libarary.new)
+        library.checkout(book)
+        # ...
+      end
+    end
+    """
+    And a spec file named "student_spec.rb" with:
+    """ruby
+    describe Student do
+      fake(:library)
+
+      it "reads books from library" do
+        student = Student.new
+
+        student.read("Moby Dick", library)
+
+        library.should have_received.checkout("Moby Dick")
+      end
+    end
+    """
+
+  Scenario: Stubbing methods that exist on real object
+    Then spec file with following content should pass:
+    """ruby
+    describe Library do
+      verify_contract(:library)
+
+      it "checks out books" do
+        library = Library.new
+
+        library.checkout("Moby Dick")
+
+        # ...
+      end
+    end
+    """
+
+  Scenario: Verifing that stubbed methods are tested
+    Then spec file with following content should fail:
+    """ruby
+    describe Library do
+      verify_contract(:library)
+
+    end
+    """
+
+  Scenario: Verifying that methods are tested with right arguments
+    Then spec file with following content should fail:
+    """ruby
+    describe Library do
+      verify_contract(:library)
+
+      it "checks out books" do
+        library = Library.new
+
+        library.checkout("Moby Dick 2: The ulitmate")
+
+        # ...
+      end
+    end
+    """

data/features/contract_tests_stubs.feature

@@ -0,0 +1,101 @@
+Feature: Contract tests with stubs
+
+  Background:
+    Given a file named "foo.rb" with:
+    """ruby
+      class Library
+        def initialize
+          @books = []
+        end
+
+        def has_book?(book)
+          @books.include?(book)
+        end
+
+        def checkout(book)
+          @books.delete(book)
+        end
+
+        def return(book)
+          @books << book
+        end
+      end
+
+      class Student
+        def read(book, library = Library.new)
+          if library.has_book?(book)
+            library.checkout(book)
+          end
+        end
+      end
+    """
+    And a spec file named "student_spec.rb" with:
+    """ruby
+    describe Student do
+      fake(:library)
+
+      it "checks out the book from library if it is available" do
+        student = Student.new
+        stub(library).has_book?("Moby Dick") { true }
+
+        student.read("Moby Dick", library)
+
+        library.should have_received.checkout("Moby Dick")
+      end
+
+      it "does not check out the book from library if not available" do
+        student = Student.new
+        stub(library).has_book?("Moby Dick") { false }
+
+        student.read("Moby Dick", library)
+
+        library.should_not have_received.checkout("Moby Dick")
+      end
+    end
+    """
+
+  Scenario: Fails when stubbed methods are not called on real object
+    Then spec file with following content should fail:
+    """ruby
+    describe Library do
+      verify_contract(:library)
+
+      let(:library) { Library.new }
+
+      it "marks books as unavailable after they are checked out" do
+        library.return("Moby Dick")
+
+        library.checkout("Moby Dick")
+
+        library.has_book?("Moby Dick").should be_false
+      end
+    end
+    """
+
+  Scenario: Verifies that stubbed methods are called
+    Then spec file with following content should pass:
+    """ruby
+    describe Library do
+      verify_contract(:library)
+
+      let(:library) { Library.new }
+
+      it "allows checking out books that are in the inventory" do
+        library.return("Moby Dick")
+
+        library.has_book?("Moby Dick").should be_true
+      end
+
+      it "does not allow checking out unavailable books" do
+        library.has_book?("Moby Dick").should be_false
+      end
+
+      it "marks books as unavailable after they are checked out" do
+        library.return("Moby Dick")
+
+        library.checkout("Moby Dick")
+
+        library.has_book?("Moby Dick").should be_false
+      end
+    end
+    """

data/features/fake_objects.feature

@@ -0,0 +1,94 @@
+Feature: Faking existing classes
+
+  Bogus makes it easy to create fakes, which behave like a null-object and
+  have the same interface as the object being faked.
+
+  Background:
+    Given a file named "foo.rb" with:
+    """ruby
+    class Library
+      def checkout(book)
+      end
+
+      def return_book(book)
+      end
+
+      def self.look_up(book)
+      end
+    end
+
+    class Student
+      def self.learn(library = Library.new)
+        library.checkout("hello world")
+        true
+      end
+    end
+    """
+
+  Scenario: Calling methods that exist on real object
+    Then spec file with following content should pass:
+    """ruby
+    describe Student do
+      fake(:library)
+
+      it "does something" do
+        Student.learn(library).should be_true
+      end
+    end
+    """
+
+  Scenario: Fakes have null-object semantics
+    Then spec file with following content should pass:
+    """ruby
+    describe "library fake" do
+      fake(:library)
+
+      it "returns self from all methods" do
+        library.checkout("hello").should == library
+      end
+
+      it "makes method chaining possible" do
+        library.checkout("hello").return_book("world").should == library
+      end
+    end
+    """
+
+  Scenario: Taking the guesswork out of finding a class to copy
+    Then spec file with following content should pass:
+    """ruby
+    class PublicLibrary
+      def checkout(book)
+      end
+    end
+
+    describe "logger fake" do
+      fake(:library) { PublicLibrary }
+
+      it "uses the class provided in block instead of the guessed one" do
+        library.class.name.should == "PublicLibrary"
+      end
+    end
+    """
+
+  Scenario: Fakes which are classes
+    Then spec file with following content should pass:
+    """ruby
+    describe "library class fake" do
+      fake(:library, as: :class)
+
+      it "is a class" do
+        library.should be_a(Class)
+      end
+
+      it "has the same name as original class" do
+        library.name.should == Library.name
+      end
+
+      it "has same methods as original class" do
+        library.look_up('something')
+      end
+    end
+    """
+
+  Scenario: Fakes which are objects
+    Given pending

data/features/return_value_contracts.feature

@@ -0,0 +1,90 @@
+Feature: Return value contracts
+
+  Background:
+    Given a file named "foo.rb" with:
+    """ruby
+    class SessionController
+      def initialize(authentication_service)
+        @authentication_service = authentication_service
+      end
+
+      def create(params)
+        @authentication_service.authenticate(params[:login], params[:password])
+        :render_welcome
+      rescue
+        :render_error
+      end
+    end
+
+    class WrongPassword < StandardError
+    end
+
+    class AuthenticationService
+      def initialize(user_db)
+        @user_db = user_db
+      end
+
+      def authenticate(login, password)
+        unless @user_db[login] == Digest::SHA1.hexdigest(password)
+          raise WrongPassword
+        end
+      end
+    end
+    """
+    And a spec file named "session_controller_spec.rb" with:
+    """ruby
+    describe SessionController do
+      fake(:authentication_service)
+      let(:controller) { SessionController.new(authentication_service) }
+
+      it "logs in the user with valid data" do
+        stub(authentication_service).authenticate('foo', 'bar')
+
+        controller.create(login: 'foo', password: 'bar').should == :render_welcome
+      end
+
+      it "fails with invalid data" do
+        stub(authentication_service).authenticate('baz', 'bar') { raise WrongPassword }
+
+        controller.create(login: 'baz', password: 'bar').should == :render_error
+      end
+    end
+    """
+
+  Scenario: Fails when returned values differ
+    Then spec file with following content should fail:
+    """ruby
+    describe AuthenticationService do
+      verify_contract(:authentication_service)
+
+      it "logs in the user" do
+        service = AuthenticationService.new('foo' => Digest::SHA1.hexdigest('bar'))
+        expect {
+          service.authenticate('foo', 'bar')
+        }.not_to raise_error
+      end
+    end
+    """
+
+  Scenario: Passes when interfaces match
+    Then spec file with following content should pass:
+    """ruby
+    describe AuthenticationService do
+      verify_contract(:authentication_service)
+
+      it "logs in the user" do
+        service = AuthenticationService.new('foo' => Digest::SHA1.hexdigest('bar'))
+        expect {
+          service.authenticate('foo', 'bar')
+        }.not_to raise_error
+      end
+
+      it "raises WrongPassword with incorrect credentials" do
+        service = AuthenticationService.new('foo' => Digest::SHA1.hexdigest('bar'))
+        expect {
+          service.authenticate('baz', 'bar')
+        }.to raise_error(WrongPassword)
+      end
+    end
+    """
+