pact_broker 1.1.0 → 1.2.0

data/spec/lib/pact_broker/api/resources/group_spec.rb

@@ -26,7 +26,7 @@ module PactBroker::Api
           allow(decorator).to receive(:to_csv).and_return(csv)
         end
 
-        subject { get "/groups/Some%20Service" }
+        subject { get "/groups/Some%20Service", '', {"HTTP_X_My_App_Version" => '2'} }
 
         context "when the pacticipant exists" do
 

data/spec/lib/pact_broker/api/resources/latest_pact_spec.rb

@@ -34,7 +34,7 @@ module PactBroker::Api
           end
 
           it "uses the configured HTML renderer" do
-            expect(PactBroker.configuration.html_pact_renderer).to receive(:call).with(json_content)
+            expect(PactBroker.configuration.html_pact_renderer).to receive(:call).with(pact)
             subject
           end
 

data/spec/lib/pact_broker/api/resources/pact_spec.rb

@@ -11,25 +11,54 @@ module PactBroker::Api
       include Rack::Test::Methods
 
       let(:app) { PactBroker::API }
+      let(:json) { {some: 'json'}.to_json }
 
       describe "PUT" do
 
+        subject { put "/pacts/provider/Provider/consumer/Consumer/version/1.2", json, {'CONTENT_TYPE' => "application/json"} }
+
+        let(:response) { subject; last_response }
+
         context "with invalid JSON" do
+          let(:json) { '{' }
+
+          it "returns a 400 response" do
+            expect(response.status).to eq 400
+          end
+
+          it "returns a JSON content type" do
+            expect(response.headers['Content-Type']).to eq "application/json"
+          end
+
+          it "returns an error message" do
+            expect(JSON.parse(response.body)["error"]).to match /Error parsing JSON/
+          end
+        end
+
+        context "with a potential duplicate pacticipant" do
+
+          let(:pacticipant_service) { PactBroker::Services::PacticipantService }
+          let(:messages) { ["message1", "message2"] }
 
           before do
-            put "/pacts/provider/Provider/consumer/Consumer/version/1.2", '{', {'CONTENT_TYPE' => "application/json"}
+            allow(pacticipant_service).to receive(:messages_for_potential_duplicate_pacticipants).and_return(messages)
+          end
+
+          it "checks for duplicates" do
+            expect(pacticipant_service).to receive(:messages_for_potential_duplicate_pacticipants).with(['Consumer', 'Provider'], 'http://example.org')
+            response
           end
 
           it "returns a 400 response" do
-            expect(last_response.status).to eq 400
+            expect(response.status).to eq 400
           end
 
-          it "returns a JSON content type" do
-            expect(last_response.headers['Content-Type']).to eq "application/json"
+          it "returns a text response" do
+            expect(response.headers['Content-Type']).to eq 'text/plain'
           end
 
-          it "returns an error message" do
-            expect(JSON.parse(last_response.body)["error"]).to match /Invalid JSON/
+          it "returns the messages in the response body" do
+            expect(response.body).to eq "message1\nmessage2"
           end
         end
 

data/spec/lib/pact_broker/api/resources/pact_webhooks_spec.rb

@@ -10,7 +10,7 @@ module PactBroker::Api
       let(:path) { "/webhooks/provider/Some%20Provider/consumer/Some%20Consumer" }
       let(:headers) { {'CONTENT_TYPE' => 'application/json'} }
       let(:webhook) { double('webhook')}
-      let(:saved_webhook) { double('saved_webhook', uuid: 'webhook-uuid')}
+      let(:saved_webhook) { double('saved_webhook')}
       let(:provider) { instance_double(PactBroker::Models::Pacticipant)}
       let(:consumer) { instance_double(PactBroker::Models::Pacticipant)}
 
@@ -56,11 +56,13 @@ module PactBroker::Api
             some: 'json'
           }.to_json
         end
+        let(:next_uuid) { '123k2nvkkwjrwk34' }
 
         let(:errors) { [] }
 
         before do
           allow(PactBroker::Services::WebhookService).to receive(:create).and_return(saved_webhook)
+          allow(PactBroker::Services::WebhookService).to receive(:next_uuid).and_return(next_uuid)
           allow(webhook).to receive(:validate).and_return(errors)
           allow(PactBroker::Models::Webhook).to receive(:new).and_return(webhook)
         end
@@ -144,7 +146,7 @@ module PactBroker::Api
           end
 
           it "saves the webhook" do
-            expect(PactBroker::Services::WebhookService).to receive(:create).with(webhook, consumer, provider)
+            expect(PactBroker::Services::WebhookService).to receive(:create).with(next_uuid, webhook, consumer, provider)
             subject
           end
 
@@ -155,12 +157,12 @@ module PactBroker::Api
 
           it "returns the Location header" do
             subject
-            expect(last_response.headers['Location']).to include('webhook-uuid')
+            expect(last_response.headers['Location']).to include(next_uuid)
           end
 
           it "returns a JSON content type" do
             subject
-            expect(last_response.headers['Content-Type']).to eq 'application/json'
+            expect(last_response.headers['Content-Type']).to eq 'application/hal+json'
           end
 
           it "generates the JSON response body" do

data/spec/lib/pact_broker/api/resources/pacticipants_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'pact_broker/api/resources/pacticipants'
+
+module PactBroker
+  module Api
+    module Resources
+
+      describe Pacticipants do
+
+        describe "POST" do
+          let(:params) { {name: 'New Consumer'} }
+          let(:json) { params.to_json }
+          let(:model) { instance_double(model_class, validate: errors) }
+          let(:created_model) { instance_double(model_class) }
+          let(:errors) { [] }
+          let(:model_class) { PactBroker::Models::Pacticipant }
+          let(:decorator_class) { PactBroker::Api::Decorators::PacticipantRepresenter }
+          let(:decorator) { instance_double(decorator_class, to_json: response_json, from_json: model) }
+          let(:response_json) { {some: 'json'}.to_json }
+
+          before do
+            allow(model_class).to receive(:new).and_return(model)
+            allow(PactBroker::Services::PacticipantService).to receive(:create).and_return(created_model)
+            allow(decorator_class).to receive(:new).with(model).and_return(decorator)
+            allow(decorator_class).to receive(:new).with(created_model).and_return(decorator)
+          end
+
+          subject { post "/pacticipants", json, 'CONTENT_TYPE' => 'application/json' }
+
+          context "structurally incorrect JSON" do
+            let(:json) { "{" }
+
+            it "returns a 400" do
+              subject
+              expect(last_response.status).to eq 400
+            end
+          end
+
+          context "when the model is invalid" do
+            let(:errors) { ['error'] }
+
+            it "returns a 400" do
+              subject
+              expect(last_response.status).to eq 400
+            end
+          end
+
+          context "with valid JSON" do
+            it "creates the pacticipant" do
+              expect(PactBroker::Services::PacticipantService).to receive(:create).with(params)
+              subject
+            end
+
+            it "parses the request JSON" do
+              expect(decorator).to receive(:from_json).with(json)
+              subject
+            end
+
+            it "returns a 201" do
+              subject
+              expect(last_response.status).to eq 201
+            end
+
+            it "returns a Content-Type of application/hal+json" do
+              subject
+              expect(last_response.headers['Content-Type']).to eq 'application/hal+json'
+            end
+
+            it "creates a JSON representation of the new pacticipant" do
+              expect(decorator_class).to receive(:new).with(created_model)
+              expect(decorator).to receive(:to_json).with(instance_of(Decorators::DecoratorContext))
+              subject
+            end
+
+            it "includes the JSON pacticipant in the response body" do
+              subject
+              expect(last_response.body).to eq response_json
+            end
+
+            it "includes the newly created Location" do
+              subject
+              expect(last_response.headers['Location']).to eq "http://example.org/pacticpants/New%20Consumer"
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+end

data/spec/lib/pact_broker/configuration_spec.rb

@@ -8,11 +8,11 @@ module PactBroker
     context "default configuration" do
       describe ".html_pact_renderer" do
 
-        let(:json_content) { {a: 'b'}.to_json }
+        let(:pact) { double('pact') }
 
         it "calls the inbuilt HtmlPactRenderer" do
-          expect(PactBroker::Api::Renderers::HtmlPactRenderer).to receive(:call).with(json_content)
-          PactBroker.configuration.html_pact_renderer.call json_content
+          expect(PactBroker::Api::Renderers::HtmlPactRenderer).to receive(:call).with(pact)
+          PactBroker.configuration.html_pact_renderer.call pact
         end
 
       end

data/spec/lib/pact_broker/functions/find_potential_duplicate_pacticipant_names_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'pact_broker/functions/find_potential_duplicate_pacticipant_names'
+
+module PactBroker
+
+  module Functions
+
+    describe FindPotentialDuplicatePacticipantNames do
+
+      describe ".call" do
+
+        subject { FindPotentialDuplicatePacticipantNames.call(new_name, existing_names) }
+
+        context "when an existing name exactly equals the new name" do
+          let(:new_name) { 'Contracts Service' }
+          let(:existing_names) { ['Contracts Service', 'Contracts', 'Something'] }
+
+          it "does not return any potential duplicate names" do
+            expect(subject).to eq []
+          end
+        end
+
+        context "when an existing name mostly includes the new name" do
+          let(:new_name) { 'Contracts' }
+          let(:existing_names) { ['Contract Service', 'Contacts', 'Something'] }
+
+          it "returns the existing names that match" do
+            expect(subject).to eq ['Contract Service']
+          end
+        end
+
+        context "when a new name mostly includes an existing name" do
+          let(:new_name) { 'Contract Service' }
+          let(:existing_names) { ['Contracts', 'Contacts', 'Something'] }
+
+          it "returns the existing names that match" do
+            expect(subject).to eq ['Contracts']
+          end
+        end
+
+        context 'when a new name is the same but a different case' do
+          let(:new_name) { 'Contract Service' }
+          let(:existing_names) { ['contracts', 'Contacts', 'Something'] }
+
+          it "returns the existing names that match" do
+            expect(subject).to eq ['contracts']
+          end
+        end
+
+        context "when a new name is the same as an existing name but without spaces" do
+          let(:new_name) { 'ContractService' }
+          let(:existing_names) { ['Contracts Service', 'Contacts', 'Something'] }
+
+          it "returns the existing names that match" do
+            expect(subject).to eq ['Contracts Service']
+          end
+        end
+
+        context "when an existing name is the same as the new name but without spaces" do
+          let(:new_name) { 'Contract Service' }
+          let(:existing_names) { ['ContractsService', 'Contacts', 'Something'] }
+
+          it "returns the existing names that match" do
+            expect(subject).to eq ['ContractsService']
+          end
+        end
+
+        context "when the new name is similar to an existing but with underscores or dashes instead of spaces" do
+          let(:new_name) { 'Contract_Service' }
+          let(:existing_names) { ['ContractsService', 'Contracts Service', 'contracts-service', 'Contacts', 'Something'] }
+
+          it "returns the existing names that match" do
+            expect(subject).to eq ['ContractsService', 'Contracts Service', 'contracts-service']
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/lib/pact_broker/messages_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'pact_broker/messages'
+
+module PactBroker
+  module Messages
+
+
+    describe "#potential_duplicate_pacticipant_message" do
+      let(:new_name) { 'Contracts' }
+      let(:fred) { double('Contracts Service', name: 'Contracts Service') }
+      let(:frederich) { double('Accepted Contracts', name: 'Accepted Contracts') }
+      let(:potential_duplicate_pacticipants) { [fred, frederich]}
+
+      let(:expected_message) { String.new <<-EOS
+This is the first time a pact has been published for "Contracts".
+The name "Contracts" is very similar to the following existing consumers/providers:
+* Contracts Service
+* Accepted Contracts
+If you meant to specify one of the above names, please correct the pact configuration, and re-publish the pact.
+If the pact is intended to be for a new consumer or provider, please manually create "Contracts" using the following command, and then re-publish the pact:
+$ curl -v -XPOST -H "Content-Type: application/json" -d "{\\\"name\\\": \\\"Contracts\\\"}" http://example.org/pacticipants
+EOS
+      }
+      subject { Messages.potential_duplicate_pacticipant_message new_name, potential_duplicate_pacticipants, 'http://example.org' }
+
+      it "returns a message" do
+        expect(subject).to eq expected_message
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/models/pacticipant_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'pact_broker/models/pacticipant'
+
+module PactBroker
+
+  module Models
+
+    describe Pacticipant do
+
+      describe "validate" do
+
+        context "with all valid attributes" do
+          subject { Pacticipant.new name: 'Name' }
+
+          it "returns an empty array" do
+            expect(subject.validate).to eq []
+          end
+        end
+
+        context "with no name" do
+          subject { Pacticipant.new }
+
+          it "returns an error" do
+            expect(subject.validate).to eq ["Missing required attribute 'name'"]
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/spec/lib/pact_broker/repositories/pact_repository_spec.rb

@@ -5,6 +5,35 @@ module PactBroker
   module Repositories
     describe PactRepository do
 
+      describe "#find_all_pacts_between" do
+        let(:consumer_name) { 'Consumer' }
+        let(:provider_name) { 'Provider' }
+
+        before do
+          ProviderStateBuilder.new
+            .create_consumer(consumer_name)
+            .create_consumer_version("1.2.3")
+            .create_provider(provider_name)
+            .create_pact
+            .create_consumer_version("2.3.4")
+            .create_consumer_version_tag("prod")
+            .create_pact
+            .create_provider("Another Provider")
+            .create_pact
+        end
+
+        subject { PactRepository.new.find_all_pacts_between consumer_name, :and => provider_name }
+
+        it "returns the pacts between the specified consumer and provider" do
+          expect(subject.size).to eq 2
+          expect(subject.first.consumer.name).to eq consumer_name
+          expect(subject.first.provider.name).to eq provider_name
+          expect(subject.first.consumer_version.number).to eq "2.3.4"
+          expect(subject.first.consumer_version.tags.first.name).to eq "prod"
+        end
+
+      end
+
       describe "find_previous_pact" do
         before do
           ProviderStateBuilder.new

data/spec/lib/pact_broker/repositories/pacticipant_repository_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'pact_broker/repositories/pacticipant_repository'
+require 'support/provider_state_builder'
+
+module PactBroker
+  module Repositories
+    describe PacticipantRepository do
+
+
+      describe "#pacticipant_names" do
+
+        before do
+          ProviderStateBuilder.new
+            .create_pacticipant("Plants")
+            .create_pacticipant("Animals")
+        end
+
+        subject { PacticipantRepository.new.pacticipant_names }
+
+        it "returns an array of pacticipant names" do
+          expect(subject).to eq ["Animals", "Plants"]
+        end
+
+      end
+
+
+    end
+  end
+end