pact 0.1.28

data/spec/features/consumption_spec.rb

@@ -0,0 +1,146 @@
+require 'net/http'
+require 'pact/consumer'
+require 'pact/consumer/rspec'
+
+
+describe "A service consumer side of a pact", :pact => true  do
+
+  it "goes a little something like this" do
+    Pact.clear_configuration
+
+    Pact.configure do | config |
+      config.consumer do
+        name "Consumer"
+      end
+    end
+
+    Pact.with_producer "Alice Service" do
+      mock_service :alice_service do
+        verify true
+        port 1234
+      end
+    end
+
+    Pact.with_producer "Bob" do
+      mock_service :bob_service do
+        verify false
+        port 4321
+      end
+    end
+
+    alice_service.
+      upon_receiving("a retrieve Mallory request").with({
+      method: :get,
+      path: '/mallory'
+    }).
+      will_respond_with({
+      status: 200,
+      headers: { 'Content-Type' => 'text/html' },
+      body: Pact::Term.new(matcher: /Mallory/, generate: 'That is some good Mallory.')
+    })
+
+    bob_service.
+      upon_receiving('a create donut request').with({
+      method: :post,
+      path: '/donuts',
+      body: {
+        "name" => Pact::Term.new(matcher: /Bob/)
+      },
+      headers: {'Accept' => 'text/plain', "Content-Type" => 'application/json'}
+    }).
+      will_respond_with({
+      status: 201,
+      body: 'Donut created.'
+    })
+    bob_service.
+      upon_receiving('a delete charlie request').with({
+      method: :delete,
+      path: '/charlie'
+    }).
+      will_respond_with({
+      status: 200,
+      body: /deleted/
+    })
+    bob_service. 
+      upon_receiving('an update alligators request').with({
+        method: :put,
+        path: '/alligators',
+        body: [{"name" => 'Roger' }]
+    }).
+      will_respond_with({
+        status: 200,
+        body: [{"name" => "Roger", "age" => 20}]
+    })
+
+
+    alice_response = Net::HTTP.get_response(URI('http://localhost:1234/mallory'))
+
+    expect(alice_response.code).to eql '200'
+    expect(alice_response['Content-Type']).to eql 'text/html'
+    expect(alice_response.body).to eql 'That is some good Mallory.'
+
+    uri = URI('http://localhost:4321/donuts')
+    post_req = Net::HTTP::Post.new(uri.path)
+    post_req['Accept'] = "text/plain"
+    post_req['Content-Type'] = "application/json"
+    post_req.body = {"name" => "Bobby"}.to_json
+    bob_post_response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+      http.request post_req
+    end
+
+    expect(bob_post_response.code).to eql '201'
+    expect(bob_post_response.body).to eql 'Donut created.'
+
+    uri = URI('http://localhost:4321/alligators')
+    post_req = Net::HTTP::Put.new(uri.path)
+    post_req['Content-Type'] = "application/json"
+    post_req.body = [{"name" => "Roger"}].to_json
+    bob_post_response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+      http.request post_req
+    end
+
+    expect(bob_post_response.code).to eql '200'
+    expect(bob_post_response.body).to eql([{"name" => "Roger", "age" => 20}].to_json)
+    expect{ bob_service.verify('goes a little something like this') }.to raise_error /do not match/
+  end
+
+  context "with a producer state" do
+    before do
+      Pact.clear_configuration
+
+      Pact.configure do | config |
+        config.consumer do
+          name "Consumer"
+        end
+      end
+
+      Pact.with_producer "Zebra Service" do
+        mock_service :zebra_service do
+          verify false
+          port 1235
+        end
+      end
+    end
+
+    it "goes like this" do
+      zebra_service.
+        given(:the_zebras_are_here).
+        upon_receiving("a retrieve Mallory request").with({
+          method: :get,
+          path: '/mallory',
+          headers: {'Accept' => 'text/html'}
+        }).
+        will_respond_with({
+          status: 200,
+          headers: { 'Content-Type' => 'text/html' },
+          body: Pact::Term.new(matcher: /Mallory/, generate: 'That is some good Mallory.')
+        })
+
+        interactions = Pact::ConsumerContract.from_json(File.read(zebra_service.consumer_contract.pactfile_path)).interactions
+        interactions.first.producer_state.should eq("the_zebras_are_here")
+        sleep 1
+    end
+  end
+
+end
+

data/spec/features/producer_states/zebras.rb

@@ -0,0 +1,28 @@
+require 'json'
+require 'fileutils'
+
+Pact.with_consumer 'the-wild-beast-store' do
+
+  producer_state :the_zebras_are_here do
+    set_up do
+      FileUtils.mkdir_p 'tmp'
+      some_data = [{'name' => 'Jason'},{'name' => 'Sarah'}]
+      File.open("tmp/a_mock_database.json", "w") { |file| file << some_data.to_json }
+    end
+
+    tear_down do
+      FileUtils.rm_rf("tmp/a_mock_database.json")
+    end
+  end
+end
+
+Pact.producer_state "some other zebras are here" do
+  set_up do
+    some_data = [{'name' => 'Mark'},{'name' => 'Gertrude'}]
+    File.open("tmp/a_mock_database.json", "w") { |file| file << some_data.to_json }
+  end
+
+  tear_down do
+    FileUtils.rm_rf("tmp/a_mock_database.json")
+  end
+end

data/spec/features/production_spec.rb

@@ -0,0 +1,160 @@
+require 'pact/producer/rspec'
+require 'pact/consumer_contract'
+require 'features/producer_states/zebras'
+
+
+module Pact::Producer
+
+  describe "A service production side of a pact" do
+
+    class ServiceUnderTest
+
+      def call(env)
+        case env['PATH_INFO']
+        when '/donuts'
+          [201, {'Content-Type' => 'application/json'}, { message: "Donut created." }.to_json]
+        when '/charlie'
+          [200, {'Content-Type' => 'application/json'}, { message: "Your charlie has been deleted" }.to_json]
+        end
+      end
+
+    end
+
+    class ServiceUnderTestWithFixture
+
+      def find_zebra_names
+        #simulate loading data from a database
+        data = JSON.load(File.read('tmp/a_mock_database.json'))
+        data.collect{ | zebra | zebra['name'] }
+      end
+
+      def call(env)
+        case env['PATH_INFO']
+        when "/zebra_names"
+            [200, {'Content-Type' => 'application/json'}, { names: find_zebra_names }.to_json]
+        end
+      end
+
+    end
+
+    pact = Pact::ConsumerContract.from_json <<-EOS
+    {
+        "consumer" : { "name" : "a consumer"},
+        "interactions" : [
+            {
+                "description": "donut creation request",
+                "request": {
+                    "method": "post",
+                    "path": "/donuts"
+                },
+                "response": {
+                    "body": {"message": "Donut created."},
+                    "status": 201
+                }
+            },
+            {
+                "description": "charlie deletion request",
+                "request": {
+                    "method": "delete",
+                    "path": "/charlie"
+                },
+                "response": {
+                    "body": {
+                      "message": {
+                        "json_class": "Regexp",
+                        "o": 0,
+                        "s": "deleted"
+                      }
+                    },
+                    "status": 200
+                }
+            }
+        ]
+    }
+    EOS
+
+    before do
+        Pact.configure do |config|
+            config.producer do
+                name "My Producer"
+                app { ServiceUnderTest.new }
+            end
+        end
+    end
+
+    honour_consumer_contract pact
+
+  end
+
+  describe "with a producer_state" do
+
+    context "that is a symbol" do
+        consumer_contract = Pact::ConsumerContract.from_json <<-EOS
+        {
+            "consumer" : { "name" : "the-wild-beast-store"},
+            "interactions" : [
+                {
+                    "description": "donut creation request",
+                    "request": {
+                        "method": "delete",
+                        "path": "/zebra_names"
+                    },
+                    "response": {
+                        "body": {"names": ["Jason", "Sarah"]},
+                        "status": 200
+                    },
+                    "producer_state" : "the_zebras_are_here"
+                }
+            ]
+        }
+        EOS
+
+        before do
+            Pact.configure do |config|
+                config.producer do
+                    name "My Producer"
+                    app { ServiceUnderTestWithFixture.new }
+                end
+            end
+        end
+
+
+        honour_consumer_contract consumer_contract
+    end
+
+    context "that is a string" do
+        consumer_contract = Pact::ConsumerContract.from_json <<-EOS
+        {
+            "consumer" : { "name" : "some consumer"},
+            "interactions" : [
+                {
+                    "description": "donut creation request",
+                    "request": {
+                        "method": "post",
+                        "path": "/zebra_names"
+                    },
+                    "response": {
+                        "body": {"names": ["Mark", "Gertrude"]},
+                        "status": 200
+                    },
+                    "producer_state" : "some other zebras are here"
+                }
+            ]
+        }
+        EOS
+
+        before do
+            Pact.configure do |config|
+                config.producer do
+                    name "ServiceUnderTestWithFixture"
+                    app { ServiceUnderTestWithFixture.new }
+                end
+            end
+        end
+
+
+        honour_consumer_contract consumer_contract
+    end
+
+  end
+end

data/spec/integration/pact/configuration_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'pact/configuration'
+require 'pact/consumer/dsl'
+require 'pact/consumer/configuration_dsl'
+require 'pact/producer/configuration_dsl'
+
+describe "configure" do
+
+ before do
+    Pact.clear_configuration
+    Pact::Consumer::AppManager.instance.clear_all
+
+    Pact.configure do | config |
+      config.consumer do
+        name "My Consumer"
+      end
+    end
+
+    Pact.with_producer "My Service" do
+      mock_service :my_service do
+        port 1234
+        standalone true
+      end
+    end
+
+    Pact.with_producer "My Other Service" do
+      mock_service :my_other_service do
+        port 1235
+        standalone false
+      end
+    end
+  end
+
+  describe "configuration" do
+    it "should return the same configuration object each time" do
+      expect(Pact.configuration).to equal(Pact.configuration)
+    end
+  end
+
+  describe "consumer" do
+    it "should be configured" do
+      Pact.configuration.consumer.name.should eq "My Consumer"
+    end
+  end
+
+  describe "producers" do
+    include Pact::Consumer::ConsumerContractBuilders
+
+    it "should have defined methods in MockServices for the producers" do
+      my_service.should be_instance_of Pact::Consumer::ConsumerContractBuilder
+    end
+
+    context "when standalone is true" do
+      it "is not registerd with the AppManager" do
+        Pact::Consumer::AppManager.instance.app_registered_on?(1234).should be_false
+      end
+    end
+
+    context "when standalone is false" do
+      it "should register the MockServices on their given ports if they are not" do
+        Pact::Consumer::AppManager.instance.app_registered_on?(1235).should be_true
+      end
+    end
+  end
+end

data/spec/lib/pact/configuration_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'pact/configuration'
+
+describe Pact do
+
+  before do
+    Pact.clear_configuration
+  end
+
+  describe "configure" do
+    KEY_VALUE_PAIRS = {pact_dir: 'a path', log_dir: 'a dir', logger: 'a logger'}
+
+    KEY_VALUE_PAIRS.each do | key, value |
+      it "should allow configuration of #{key}" do
+        Pact.configure do | config |
+          config.send("#{key}=".to_sym, value)
+        end
+
+        expect(Pact.configuration.send(key)).to eql(value)
+      end
+    end
+  end
+
+  describe "configuration" do
+    it "should have a default pact_dir" do
+      expect(Pact.configuration.pact_dir).to eql File.expand_path('./spec/pacts')
+    end
+    it "should have a default log_dir" do
+      expect(Pact.configuration.log_dir).to eql File.expand_path('./log')
+    end
+    it "should have a default logger configured" do
+      expect(Pact.configuration.logger).to be_instance_of Logger
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Pact::Consumer
+  describe AppManager do
+    before do
+      AppManager.instance.clear_all
+    end
+
+    describe "start_service_for" do
+      before do
+        AppRegistration.any_instance.stub(:spawn) # Don't want process actually spawning during the tests
+      end
+      let(:name) { 'some_service'}
+      context "for http://localhost" do
+        let(:url) { 'http://localhost:1234'}
+        it "starts a mock service at the given port on localhost" do
+          AppRegistration.any_instance.should_receive(:spawn)
+          AppManager.instance.register_mock_service_for name, url
+          AppManager.instance.spawn_all
+        end
+
+        it "registers the mock service as running on the given port" do
+          AppManager.instance.register_mock_service_for name, url
+          AppManager.instance.app_registered_on?(1234).should be_true
+        end
+      end
+      context "for https://" do
+        let(:url) { 'https://localhost:1234'}
+        it "should throw an unsupported error" do
+          expect { AppManager.instance.register_mock_service_for name, url }.to raise_error "Currently only http is supported"
+        end
+      end
+      context "for a host other than localhost" do
+        let(:url) { 'http://aserver:1234'}
+        it "should throw an unsupported error" do
+          expect { AppManager.instance.register_mock_service_for name, url }.to raise_error "Currently only services on localhost are supported"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'fileutils'
+require 'pathname'
+
+module Pact
+	module Consumer
+		describe ConsumerContractBuilder do
+
+		   describe "initialize" do
+			   before do
+			      Pact.clear_configuration
+			      Pact.configuration.stub(:pact_dir).and_return(File.expand_path(tmp_pact_dir))
+			      FileUtils.rm_rf tmp_pact_dir
+			      FileUtils.mkdir_p tmp_pact_dir
+			      FileUtils.cp './spec/support/a_consumer-a_producer.json', "#{tmp_pact_dir}/a_consumer-a_producer.json"
+			   end
+
+			   let(:tmp_pact_dir) {"./tmp/pacts"}
+
+			   let(:consumer_name) { 'a consumer' }
+			   let(:producer_name) { 'a producer' }
+			   let(:consumer_contract_builder) { 
+			      Pact::Consumer::ConsumerContractBuilder.new(
+			         :pactfile_write_mode => pactfile_write_mode,
+			         :consumer_name => consumer_name,
+			         :producer_name => producer_name,
+			         :port => 1234)}
+
+			   context "when overwriting pact" do
+			      let(:pactfile_write_mode) {:overwrite}
+			      it "it overwrites the existing pact file" do
+			         expect(consumer_contract_builder.consumer_contract.interactions).to eq []
+			      end
+			   end
+
+			   context "when updating pact" do
+			      let(:pactfile_write_mode) {:update}
+			      it "updates the existing pact file" do
+			         expect(consumer_contract_builder.consumer_contract.interactions.size).to eq 2
+			      end
+			   end		   	
+		   end			
+
+			describe "handle_interaction_fully_defined" do
+
+				subject { 
+					Pact::Consumer::ConsumerContractBuilder.new({:consumer_name => 'blah', :producer_name => 'blah', :port => 2222})
+				}
+
+				let(:interaction_hash) {
+					{
+		            description: 'Test request',
+		            request: {
+		              method: 'post',
+		              path: '/foo',
+		              body: Term.new(generate: 'waffle', matcher: /ffl/),
+		              headers: { 'Content-Type' => 'application/json' },
+		              query: "",
+		            },
+		            response: {
+		              baz: 'qux',
+		              wiffle: 'wiffle'
+		            }
+	          	}
+				}
+
+				let(:interaction_json) { JSON.dump(interaction_hash) }
+
+				let(:interaction) { Pact::Consumer::Interaction.from_hash(JSON.parse(interaction_json)) }
+
+				before do
+					stub_request(:post, 'localhost:2222/interactions')
+				end
+
+	        	it "posts the interaction with generated response to the mock service" do
+	          	subject.handle_interaction_fully_defined interaction
+	          	WebMock.should have_requested(:post, 'localhost:2222/interactions').with(body: interaction_json)
+	        	end
+
+	        	it "updates the Producer's Pactfile" do
+	        		subject.consumer_contract.should_receive(:update_pactfile)
+	        		subject.handle_interaction_fully_defined interaction
+	        	end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'pact/consumer/dsl'
+require 'pact/consumer/configuration_dsl'
+
+module Pact::Consumer::DSL
+   describe Service do
+      before do
+         Pact.clear_configuration
+         Pact::Consumer::AppManager.instance.stub(:register_mock_service_for)
+      end
+      describe "configure_consumer_contract_builder" do
+         subject { 
+            Service.new :mock_service do
+               port 1234
+               standalone true
+               verify true
+            end
+         }
+
+         let(:producer_name) { 'Mock Producer'}
+         let(:consumer_contract_builder) { double('Pact::Consumer::ConsumerContractBuilder').as_null_object}
+         let(:url) { "http://localhost:1234"}
+
+         it "adds a verification to the Pact configuration" do
+            Pact::Consumer::ConsumerContractBuilder.stub(:new).and_return(consumer_contract_builder)
+            subject.configure_consumer_contract_builder({})
+            consumer_contract_builder.should_receive(:verify)
+            Pact.configuration.producer_verifications.first.call
+         end
+
+         context "when standalone" do
+            it "does not register the app with the AppManager" do
+               Pact::Consumer::AppManager.instance.should_not_receive(:register_mock_service_for)
+               subject.configure_consumer_contract_builder({})
+            end
+         end
+         context "when not standalone" do
+            subject { 
+               Service.new :mock_service do
+                  port 1234
+                  standalone false
+                  verify true
+               end
+            }            
+            it "registers the app with the AppManager" do
+               Pact::Consumer::AppManager.instance.should_receive(:register_mock_service_for).with(producer_name, url)
+               subject.configure_consumer_contract_builder({:producer_name => producer_name })
+            end
+         end         
+      end
+   end
+end