pact 0.1.28 → 1.3.3

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

@@ -1,147 +0,0 @@
-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_contract_spec.rb

@@ -1,125 +0,0 @@
-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

data/spec/lib/pact/producer/configuration_dsl_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-require 'pact/producer/configuration_dsl'
-
-module Pact::Producer
-  describe ConfigurationDSL do
-
-    class MockConfig
-      include ConfigurationDSL
-    end
-
-    describe "producer" do
-      let(:mock_config) { MockConfig.new }
-      context "when a producer is configured" do
-        before do
-          mock_config.producer do
-            name "Fred"
-            app { "An app" }
-          end
-        end
-        it "should allow configuration of the name" do
-          expect(mock_config.producer.name).to eql "Fred"
-        end
-        it "should allow configuration of the test app" do
-          expect(mock_config.producer.app).to eql "An app"
-        end
-      end
-      context "when a producer is not configured" do
-        it "raises an error" do
-          expect{ mock_config.producer }.to raise_error(/Please configure your producer/)
-        end
-      end
-    end
-
-
-    module ConfigurationDSL
-
-      describe ProducerDSL do
-
-        describe "initialize" do
-
-          context "with an object instead of a block" do
-            subject do
-              ProducerDSL.new do
-                name nil
-                app 'blah'
-              end
-            end
-            it "raises an error" do
-              expect{ subject }.to raise_error
-            end
-          end
-
-
-        end
-        describe "validate" do
-          context "when no name is provided" do
-            subject do
-              ProducerDSL.new do
-                app { Object.new }
-              end
-            end
-            it "raises an error" do
-              expect{ subject.validate}.to raise_error("Please provide a name for the Producer")
-            end
-          end
-          context "when nil name is provided" do
-            subject do
-              ProducerDSL.new do
-                name nil
-                app { Object.new }
-              end
-            end
-            it "raises an error" do
-              expect{ subject.validate}.to raise_error("Please provide a name for the Producer")
-            end
-          end
-          context "when no app is provided" do
-            subject do
-              ProducerDSL.new do
-                name 'Blah'
-              end
-            end
-            it "raises an error" do
-              expect{ subject.validate }.to raise_error("Please configure an app for the Producer")
-            end
-          end
-        end
-      end
-
-      describe ProducerConfig do
-        describe "app" do
-          subject { ProducerConfig.new("blah") { Object.new } }
-          it "should execute the app_block each time" do
-            expect(subject.app.object_id).to_not equal(subject.app.object_id)
-          end
-        end
-      end
-
-    end
-  end
-end

data/spec/lib/pact/producer/producer_state_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-require 'pact/producer/producer_state'
-
-module Pact
-  module Producer
-
-    describe 'global ProducerState' do
-
-      MESSAGES = []
-
-      Pact.producer_state :no_alligators do
-        set_up do
-          MESSAGES << 'set_up'
-        end
-        tear_down do
-          MESSAGES << 'tear_down'
-        end
-      end
-
-      Pact.producer_state 'some alligators' do
-      end
-
-      before do
-        MESSAGES.clear
-      end
-
-      subject { ProducerState.get('no_alligators') }
-
-      describe 'set_up' do
-        it 'should call the block passed to set_up' do
-          subject.set_up
-          MESSAGES.should eq ['set_up']
-        end
-      end
-
-      describe 'tear_down' do
-        it 'should call the block passed to set_up' do
-          subject.tear_down
-          MESSAGES.should eq ['tear_down']
-        end
-      end
-
-      describe '.get' do
-        context 'when the name is a matching symbol' do
-          it 'will return the ProducerState' do
-            ProducerState.get('no_alligators').should_not be_nil
-          end
-        end
-        context 'when the name is a matching string' do
-          it 'will return the ProducerState' do
-            ProducerState.get('some alligators').should_not be_nil
-          end
-        end
-      end
-    end
-
-
-    describe 'namespaced ProducerStates' do
-
-      NAMESPACED_MESSAGES = []
-
-      Pact.with_consumer 'a consumer' do
-        producer_state 'the weather is sunny' do
-          set_up do
-            NAMESPACED_MESSAGES << 'sunny!'
-          end
-        end
-      end
-
-      Pact.producer_state 'the weather is cloudy' do
-        set_up do
-          NAMESPACED_MESSAGES << 'cloudy :('
-        end
-      end
-
-      before do
-        NAMESPACED_MESSAGES.clear
-      end
-
-      describe '.get' do
-        context 'for a consumer' do
-          it 'has a namespaced name' do
-            ProducerState.get('the weather is sunny', :for => 'a consumer').should_not be_nil
-          end
-
-          it 'falls back to a global state of the same name if one is not found for the specified consumer' do
-            ProducerState.get('the weather is cloudy', :for => 'a consumer').should_not be_nil
-          end
-        end
-
-      end
-
-      describe 'set_up' do
-        context 'for a consumer' do
-          it 'runs its own setup' do
-            ProducerState.get('the weather is sunny', :for => 'a consumer').set_up
-            NAMESPACED_MESSAGES.should eq ['sunny!']
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/producer/rspec_spec.rb

@@ -1,48 +0,0 @@
-require 'pact/producer/rspec'
-
-describe "the match_term matcher" do
-
-  it 'does not match a hash to an array' do
-    expect({}).to_not match_term([])
-  end
-
-  it 'does not match an array to a hash' do
-    expect([]).to_not match_term({})
-  end
-
-  it 'matches regular expressions' do
-    expect('blah').to match_term(/[a-z]*/)
-  end
-
-  it 'matches pact terms' do
-    expect('wootle').to match_term Pact::Term.new(generate:'wootle', matcher:/woot../)
-  end
-
-  it 'matches all elements of arrays' do
-    expect(['one', 'two', ['three']]).to match_term [/one/, 'two', [Pact::Term.new(generate:'three', matcher:/thr../)]]
-  end
-
-  it 'matches all values of hashes' do
-    expect({1 => 'one', 2 => 2, 3 => 'three'}).to match_term({1 => /one/, 2 => 2, 3 => Pact::Term.new(generate:'three', matcher:/thr../)})
-  end
-
-  it 'matches all other objects using ==' do
-    expect('wootle').to match_term 'wootle'
-  end
-
-  # Note: because a consumer specifies only the keys it cares about, the pact ignores keys that are returned
-  # by the producer, but not are not specified in the pact. This means that any hash will match an
-  # expected empty hash, because there is currently no way for a consumer to expect an absence of keys.
-  it 'is confused by an empty hash' do
-    expect({:hello => 'everyone'}).to match_term({})
-  end
-
-  it 'should not be confused by an empty array' do
-    expect(['blah']).to_not match_term([])
-  end
-
-  it "should allow matches on an array where each item in the array only contains a subset of the actual" do
-    expect([{name: 'Fred', age: 12}, {name: 'John', age: 13}]).to match_term([{name: 'Fred'}, {name: 'John'}])
-  end
-
-end

data/spec/lib/pact/verification_task_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'pact/verification_task'
-
-module Pact
-	describe VerificationTask do
-		before :all do
-			@support_file = 'some_file.rb'
-			@pact_uri = 'http://example.org/pact.json'
-			@task_name = 'pact:verify:pact_rake_spec'
-			@consumer = 'some-consumer'
-
-			VerificationTask.new(:pact_rake_spec) do | pact |
-				pact.uri @pact_uri, support_file: @support_file, consumer: @consumer
-			end
-		end
-
-		describe '.initialize' do
-
-			it 'creates the tasks' do
-				Rake::Task.tasks.should include_task @task_name
-			end
-
-		end
-
-		describe 'execute' do
-
-			let(:consumer_contract) { [ uri: @pact_uri, support_file: @support_file, consumer: @consumer] }
-
-			it 'verifies the pacts using PactSpecRunner' do
-				Producer::PactSpecRunner.should_receive(:run).with(consumer_contract).and_return(0)
-				Rake::Task[@task_name].execute
-			end
-
-			context 'when all specs pass' do
-
-				before do
-					Producer::PactSpecRunner.stub(:run).and_return(0)
-				end
-
-				it 'does not raise an exception' do
-					Rake::Task[@task_name].execute
-				end
-			end
-
-			context 'when one or more specs fail' do
-
-				before do
-					Producer::PactSpecRunner.stub(:run).and_return(1)
-				end
-
-				it 'raises an exception' do
-					expect { Rake::Task[@task_name].execute }.to raise_error RuntimeError
-				end
-
-			end
-		end
-	end
-end
-
-RSpec::Matchers.define :include_task do |expected|
-	match do |actual|
-	  actual.any? { |task| task.name == expected }
-	end
-end

data/spec/support/pact_rake_support.rb

@@ -1,41 +0,0 @@
-require 'json'
-
-module Pact
-	module Test
-		class TestApp
-			def call env
-				if env['PATH_INFO'] == '/weather'
-					[200, {'Content-Type' => 'application/json'}, [{message: WEATHER[:current_state]}.to_json]]
-				else
-					raise "unexpected path #{env['PATH_INFO']}!!!"
-				end
-			end
-		end
-
-		Pact.configure do | config |
-			config.producer do
-				name "Some Producer"
-				app { TestApp.new }
-			end
-		end
-
-
-		#one with a top level consumer
-		Pact.with_consumer 'some-test-consumer' do
-			producer_state "the weather is sunny" do
-				set_up do
-					WEATHER ||= {}
-					WEATHER[:current_state] = 'sunny'
-				end
-			end
-		end
-
-		#one without a top level consumer
-		Pact.producer_state "the weather is cloudy" do
-			set_up do
-				WEATHER ||= {}
-				WEATHER[:current_state] = 'cloudy'
-			end
-		end
-	end
-end