pact 0.1.28

data/spec/lib/pact/consumer/interaction_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+module Pact
+  module Consumer
+    describe InteractionBuilder do
+
+      subject { 
+        interaction_builder = InteractionBuilder.new('Test request', nil).with(request) 
+        interaction_builder.on_interaction_fully_defined do | interaction |
+          producer.callback interaction
+        end
+        interaction_builder
+      }
+
+      let(:pact_path) { File.expand_path('../../../../pacts/mock', __FILE__) }
+
+      let(:request) do
+        {
+          method: 'post',
+          path: '/foo',
+          body: Term.new(generate: 'waffle', matcher: /ffl/),
+          headers: { 'Content-Type' => 'application/json' },
+          query: '',
+        }
+      end
+
+      let(:response) do
+        { baz: /qux/, wiffle: Term.new(generate: 'wiffle', matcher: /iff/) }
+      end
+
+      let(:producer) do
+        double(callback: nil)
+      end
+
+      describe "setting up responses" do
+
+        it "invokes the callback" do
+          producer.should_receive(:callback).with(subject.interaction)
+          subject.will_respond_with response
+        end
+
+      end
+
+      describe "to JSON" do
+
+        let(:parsed_result) do
+          JSON.load(JSON.dump(subject.interaction))
+        end
+
+        before do
+          subject.will_respond_with response
+        end
+
+        it "contains the request" do
+          expect(parsed_result['request']).to eq({
+              'method' => 'post',
+              'path' => '/foo',
+              'headers' => {
+                'Content-Type' => 'application/json'
+              },
+              'body' => Term.new(generate: 'waffle', matcher: /ffl/),
+              'query' => ''
+            })
+        end
+
+        describe "response" do
+
+          it "serialises regexes" do
+            expect(parsed_result['response']['baz']).to eql /qux/
+          end
+
+          it "serialises terms" do
+            term = Term.new(generate:'wiffle', matcher: /iff/)
+            parsed_term = parsed_result['response']['wiffle']
+            expect(term.matcher).to eql parsed_term.matcher
+            expect(term.generate).to eql parsed_term.generate
+          end
+
+        end
+
+        context "with a producer_state" do
+          context "described with a string" do
+            subject { 
+              interaction_builder = InteractionBuilder.new('Test request', "there are no alligators").with(request) 
+              interaction_builder.on_interaction_fully_defined {}
+              interaction_builder
+            }
+
+            it "includes the state name as a string" do
+              expect(parsed_result['producer_state']).to eql("there are no alligators")
+            end
+          end
+          context "described with a symbol" do
+            subject { 
+              interaction_builder = InteractionBuilder.new('Test request', :there_are_no_alligators).with(request) 
+              interaction_builder.on_interaction_fully_defined {}
+              interaction_builder
+            }
+
+            it "includes the state name as a symbol" do
+              expect(parsed_result['producer_state']).to eql("there_are_no_alligators")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/consumer/mock_service_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+require 'pact/consumer/mock_service'
+
+module Pact::Consumer
+
+  describe InteractionList do
+    before do
+      InteractionList.instance.clear
+    end
+
+    shared_context "unexpected requests and missed interactions" do
+      let(:expected_call) { {request: 'blah'} }
+      let(:unexpected_call) { {request: 'meh'} }
+      subject {
+        interactionList = InteractionList.instance
+        interactionList.add expected_call
+        interactionList.register_unexpected unexpected_call
+        interactionList
+       }
+    end
+
+    shared_context "no unexpected requests or missed interactions exist" do
+      let(:expected_call) { {request: 'blah'} }
+      let(:unexpected_call) { {request: 'meh'} }
+      subject {
+        interactionList = InteractionList.instance
+        interactionList.add expected_call
+        interactionList.register_matched expected_call
+        interactionList
+       }
+    end
+
+    describe "interaction_diffs" do
+      context "when unexpected requests and missed interactions exist" do
+        include_context "unexpected requests and missed interactions"
+        let(:expected) {
+          {:missing_interactions=>[{:request=>"blah"}], :unexpected_requests=>[{:request=>"meh"}]}
+        }
+        it "returns the unexpected requests and missed interactions" do
+          expect(subject.interaction_diffs).to eq expected
+        end
+      end
+
+      context "when no unexpected requests or missed interactions exist" do
+        include_context "no unexpected requests or missed interactions exist"
+        let(:expected) {
+          {}
+        }
+        it "returns an empty hash" do
+          expect(subject.interaction_diffs).to eq expected
+        end
+      end
+    end
+
+    describe "all_matched?" do
+      context "when unexpected requests or missed interactions exist" do
+        include_context "unexpected requests and missed interactions"
+        it "returns false" do
+          expect(subject.all_matched?).to be_false
+        end
+      end
+      context "when unexpected requests or missed interactions do not exist" do
+        include_context "no unexpected requests or missed interactions exist"
+        it "returns false" do
+          expect(subject.all_matched?).to be_true
+        end
+      end
+    end
+  end
+
+  describe RequestExtractor do
+    class TestSubject
+      include RequestExtractor
+    end
+
+    let(:rack_env) {
+      {
+             "CONTENT_LENGTH" => "16",
+               "CONTENT_TYPE" => content_type,
+          "GATEWAY_INTERFACE" => "CGI/1.1",
+                  "PATH_INFO" => "/donuts",
+               "QUERY_STRING" => "",
+                "REMOTE_ADDR" => "127.0.0.1",
+                "REMOTE_HOST" => "localhost",
+             "REQUEST_METHOD" => "POST",
+                "REQUEST_URI" => "http://localhost:4321/donuts",
+                "SCRIPT_NAME" => "",
+                "SERVER_NAME" => "localhost",
+                "SERVER_PORT" => "4321",
+            "SERVER_PROTOCOL" => "HTTP/1.1",
+            "SERVER_SOFTWARE" => "WEBrick/1.3.1 (Ruby/1.9.3/2013-02-22)",
+                "HTTP_ACCEPT" => "text/plain",
+            "HTTP_USER_AGENT" => "Ruby",
+                  "HTTP_HOST" => "localhost:4321",
+               "rack.version" => [1, 2 ],
+                 "rack.input" => StringIO.new(body),
+                "rack.errors" => nil,
+           "rack.multithread" => true,
+          "rack.multiprocess" => false,
+              "rack.run_once" => false,
+            "rack.url_scheme" => "http",
+               "HTTP_VERSION" => "HTTP/1.1",
+               "REQUEST_PATH" => "/donuts"
+      }
+     }
+
+    subject { TestSubject.new }
+
+    let(:expected_request) {
+      {
+            "query" => "",
+           "method" => "post",
+             "body" => expected_body,
+             "path" => "/donuts",
+          "headers" => {
+              "Content-Type" => content_type,
+                    "Accept" => "text/plain",
+                "User-Agent" => "Ruby",
+                      "Host" => "localhost:4321",
+                   "Version" => "HTTP/1.1"
+          }
+      }
+    }
+
+    context "with a text body" do
+      let(:content_type) { "application/x-www-form-urlencoded" }
+      let(:body) { 'this is the body' }
+      let(:expected_body) { body }
+
+      it "extracts the body" do
+        expect(subject.request_from(rack_env)).to eq expected_request
+      end
+    end
+
+    context "with a json body" do
+      let(:content_type) { "application/json" }
+      let(:body) { '{"a" : "body" }' }
+      let(:expected_body) { {"a" => "body"} }
+
+      it "extracts the body" do
+        expect(subject.request_from(rack_env)).to eq expected_request
+      end
+    end
+
+
+  end
+end

data/spec/lib/pact/consumer/service_consumer_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+module Pact::Consumer
+   describe ServiceConsumer do
+      describe "as_json" do
+         it "returns a hash representation of the object" do
+            expect(ServiceConsumer.new(:name => "Bob").as_json).to eq :name => "Bob"
+         end
+      end
+   end
+end   

data/spec/lib/pact/consumer_contract_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'pact/consumer_contract'
+
+module Pact
+  describe ConsumerContract do
+    describe "as_json" do
+
+      class MockInteraction
+        def as_json(options ={})
+          {:mock => "interaction"}
+        end
+      end
+
+      before do
+        @backup_version = Pact::VERSION
+        Pact::VERSION = "1.0"
+        DateTime.stub(:now).and_return(DateTime.strptime("2013-08-15T13:27:13+10:00"))
+      end
+
+      let(:service_consumer) { double('ServiceConsumer', :as_json => {:a => 'consumer'}) }
+      let(:service_producer) { double('ServiceProducer', :as_json => {:a => 'producer'}) }
+      let(:pact) { ConsumerContract.new({:interactions => [MockInteraction.new], :consumer => service_consumer, :producer => service_producer }) }
+      let(:expected_as_json) { {:producer=>{:a=>"producer"}, :consumer=>{:a=>"consumer"}, :interactions=>[{:mock=>"interaction"}], :metadata=>{:pact_gem=>{:version=>"1.0"}}} }
+
+      it "should return a hash representation of the Pact" do
+        pact.as_json.should eq expected_as_json
+      end
+
+      after do
+        Pact::VERSION = @backup_version
+      end
+    end
+
+    describe ".from_json" do
+      let(:loaded_pact) { ConsumerContract.from_json(string) }
+      context "when the top level object is a ConsumerContract" do
+        let(:string) { '{"interactions":[{"request": {"path":"/path", "method" : "get"}}], "consumer": {"name" : "Bob"} }' }
+
+        it "should create a Pact" do
+          loaded_pact.should be_instance_of ConsumerContract
+        end
+
+        it "should have interactions" do
+          loaded_pact.interactions.should be_instance_of Array
+        end
+
+        it "should have a consumer" do
+          loaded_pact.consumer.should be_instance_of Pact::Consumer::ServiceConsumer
+        end
+
+        it "should have a producer" do
+          loaded_pact.producer.should be_instance_of Pact::Consumer::ServiceProducer
+        end
+      end
+    end
+
+    describe "find_interactions" do
+      let(:consumer) { double('ServiceConsumer', :name => 'Consumer')}
+      let(:producer) { double('ServiceProducer', :name => 'Producer')}
+      let(:interaction1) { {'description' => 'a request for food'} }
+      let(:interaction2) { {'description' => 'a request for drink'} }
+      subject { ConsumerContract.new(:interactions => [interaction1, interaction2], :consumer => consumer, :producer => producer) }
+      context "by description" do
+        context "when no interactions are found" do
+          it "returns an empty array" do
+            expect(subject.find_interactions(:description => /blah/)).to eql []
+          end
+        end
+        context "when interactions are found" do
+          it "returns an array of the matching interactions" do
+            expect(subject.find_interactions(:description => /request/)).to eql [interaction1, interaction2]
+          end
+        end
+      end
+    end
+    describe "find_interaction" do
+      let(:consumer) { double('ServiceConsumer', :name => 'Consumer')}
+      let(:producer) { double('ServiceProducer', :name => 'Producer')}
+      let(:interaction1) { {'description' => 'a request for food'} }
+      let(:interaction2) { {'description' => 'a request for drink'} }
+      subject { ConsumerContract.new(:interactions => [interaction1, interaction2], :consumer => consumer, :producer => producer) }
+      context "by description" do
+        context "when a match is found" do
+          it "returns the interaction" do
+            expect(subject.find_interaction :description => /request.*food/).to eql interaction1
+          end
+        end
+        context "when more than one match is found" do
+          it "raises an error" do
+            expect{ subject.find_interaction(:description => /request/) }.to raise_error "Found more than 1 interaction matching {:description=>/request/} in pact file between Consumer and Producer."
+          end
+        end
+        context "when a match is not found" do
+          it "raises an error" do
+            expect{ subject.find_interaction(:description => /blah/) }.to raise_error "Could not find interaction matching {:description=>/blah/} in pact file between Consumer and Producer."
+          end
+        end
+      end
+    end
+    describe "update_pactfile" do
+      let(:pacts_dir) { Pathname.new("./tmp/pactfiles") }
+      let(:expected_pact_path) { pacts_dir + "test_consumer-test_service.json" }
+      let(:expected_pact_string) { 'the_json' }
+      let(:consumer) { Pact::Consumer::ServiceConsumer.new(:name => 'test_consumer')}
+      let(:producer) { Pact::Consumer::ServiceProducer.new(:name => 'test_service')}
+      let(:interactions) { [double("interaction", as_json: "something")]}
+      subject { ConsumerContract.new(:consumer => consumer, :producer => producer, :interactions => interactions) }
+      before do
+        Pact.configuration.stub(:pact_dir).and_return(Pathname.new("./tmp/pactfiles"))
+        FileUtils.rm_rf pacts_dir
+        FileUtils.mkdir_p pacts_dir
+        JSON.should_receive(:pretty_generate).with(instance_of(Pact::ConsumerContract)).and_return(expected_pact_string)
+        subject.update_pactfile
+      end
+
+      it "should write to a file specified by the consumer and producer name" do
+        File.exist?(expected_pact_path).should be_true
+      end
+
+      it "should write the interactions to the file" do
+        File.read(expected_pact_path).should eql expected_pact_string
+      end
+    end    
+  end 
+end