pact_broker 1.0.0 → 1.1.0

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

@@ -5,6 +5,32 @@ module PactBroker
   module Repositories
     describe PactRepository do
 
+      describe "find_previous_pact" do
+        before do
+          ProviderStateBuilder.new
+            .create_consumer("Consumer")
+            .create_consumer_version("1.2.2")
+            .create_provider("Provider")
+            .create_pact
+            .create_consumer_version("1.2.4")
+            .create_pact
+            .create_consumer_version("1.2.6")
+            .create_pact
+            .create_provider("Another Provider")
+            .create_consumer_version("1.2.5")
+            .create_pact
+        end
+
+        let(:pact) { PactRepository.new.find_latest_pact "Consumer", "Provider"  }
+
+        subject  { PactRepository.new.find_previous_pact pact }
+
+        it "finds the previous pact" do
+          expect(subject.consumer_version_number).to eq "1.2.4"
+          expect(subject.consumer_version.number).to eq "1.2.4"
+        end
+      end
+
       describe "find_latest_pact" do
 
         context "with a tag" do
@@ -25,6 +51,10 @@ module PactBroker
             it "returns the pact for the latest tagged version" do
               expect(latest_prod_pact.consumer_version.number).to eq("1.2.3")
             end
+
+            xit "has timestamps" do
+
+            end
           end
 
         end
@@ -53,14 +83,24 @@ module PactBroker
 
           expect(pacts[0].consumer_version.pacticipant.name).to eq("Condor")
           expect(pacts[0].consumer.name).to eq("Condor")
+          expect(pacts[0].consumer.id).to_not be nil
           expect(pacts[0].provider.name).to eq("Pricing Service")
+          expect(pacts[0].provider.id).to_not be nil
           expect(pacts[0].consumer_version.number).to eq("1.4.0")
+          expect(pacts[0].consumer_version_number).to eq("1.4.0")
 
           expect(pacts[1].consumer_version.pacticipant.name).to eq("Contract Email Service")
           expect(pacts[1].consumer.name).to eq("Contract Email Service")
           expect(pacts[1].provider.name).to eq("Contract Proposal Service")
           expect(pacts[1].consumer_version.number).to eq("2.7.0")
         end
+
+        xit "includes the timestamps" do
+          pacts = PactRepository.new.find_latest_pacts
+
+          expect(pacts[0].updated_at).to be_instance_of DateTime
+          expect(pacts[0].created_at).to be_instance_of DateTime
+        end
       end
     end
   end

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

@@ -0,0 +1,257 @@
+require 'spec_helper'
+require 'pact_broker/repositories/webhook_repository'
+
+module PactBroker
+  module Repositories
+    describe WebhookRepository do
+
+      let(:url) { 'http://example.org' }
+      let(:body) { {'some' => 'json' } }
+      let(:headers) { {'Content-Type' => 'application/json', 'Accept' => 'application/json'} }
+      let(:request) do
+        Models::WebhookRequest.new(
+          method: 'post',
+          url: url,
+          headers: headers,
+          username: 'username',
+          password: 'password',
+          body: body)
+      end
+      let(:webhook) { Models::Webhook.new(request: request)}
+      let(:test_data_builder) { ProviderStateBuilder.new }
+      let(:consumer) { test_data_builder.create_pacticipant 'Consumer'; test_data_builder.pacticipant}
+      let(:provider) { test_data_builder.create_pacticipant 'Provider'; test_data_builder.pacticipant}
+      let(:uuid) { 'the-uuid' }
+      let(:created_webhook_record) { ::DB::PACT_BROKER_DB[:webhooks].order(:id).last }
+      let(:created_headers) { ::DB::PACT_BROKER_DB[:webhook_headers].where(webhook_id: created_webhook_record[:id]).order(:name).all }
+      let(:expected_webhook_record) { {
+        :uuid=>"the-uuid",
+        :method=>"post",
+        :url=>"http://example.org",
+        :username => 'username',
+        :password => "cGFzc3dvcmQ=",
+        :body=>body.to_json,
+        :consumer_id=> consumer.id,
+        :provider_id=> provider.id } }
+
+      before do
+        allow(SecureRandom).to receive(:urlsafe_base64).and_return(uuid)
+      end
+
+      describe "#create" do
+
+        subject { WebhookRepository.new.create webhook, consumer, provider }
+
+
+        it "generates a UUID" do
+          expect(SecureRandom).to receive(:urlsafe_base64)
+          subject
+        end
+
+        it "saves webhook" do
+          subject
+          expect(created_webhook_record).to include expected_webhook_record
+        end
+
+        it "saves the headers" do
+          subject
+          expect(created_headers.size).to eq 2
+          expect(created_headers.first[:name]).to eq "Accept"
+          expect(created_headers.first[:value]).to eq "application/json"
+          expect(created_headers.last[:name]).to eq "Content-Type"
+          expect(created_headers.last[:value]).to eq "application/json"
+        end
+
+      end
+
+      describe "delete_by_uuid" do
+
+        before do
+          allow(SecureRandom).to receive(:urlsafe_base64).and_return(uuid, 'another-uuid')
+          WebhookRepository.new.create webhook, consumer, provider
+          WebhookRepository.new.create webhook, consumer, provider
+        end
+
+        subject { WebhookRepository.new.delete_by_uuid uuid }
+
+        it "deletes the webhook headers" do
+          expect { subject }.to change {
+            ::DB::PACT_BROKER_DB[:webhook_headers].count
+            }.by(-2)
+        end
+
+        it "deletes the webhook" do
+          expect { subject }.to change {
+            ::DB::PACT_BROKER_DB[:webhooks].where(uuid: uuid).count
+            }.by(-1)
+        end
+      end
+
+      describe "delete_by_pacticipant" do
+
+        before do
+          allow(SecureRandom).to receive(:urlsafe_base64).and_return(uuid, 'another-uuid')
+          WebhookRepository.new.create webhook, consumer, provider
+        end
+
+        context "when the pacticipant is the consumer" do
+
+          subject { WebhookRepository.new.delete_by_pacticipant consumer }
+
+          it "deletes the webhook" do
+            expect { subject }.to change {
+              ::DB::PACT_BROKER_DB[:webhooks].where(uuid: uuid).count
+              }.by(-1)
+          end
+        end
+
+        context "when the pacticipant is the provider" do
+
+          subject { WebhookRepository.new.delete_by_pacticipant provider }
+
+          it "deletes the webhook" do
+            expect { subject }.to change {
+              ::DB::PACT_BROKER_DB[:webhooks].where(uuid: uuid).count
+              }.by(-1)
+          end
+        end
+
+      end
+
+      describe "find_by_uuid" do
+
+
+        subject { WebhookRepository.new.find_by_uuid uuid }
+
+        context "when a webhook is found" do
+          before do
+            WebhookRepository.new.create webhook, consumer, provider
+          end
+
+          it "returns a webhook with the consumer set" do
+            expect(subject.consumer.id).to eq consumer.id
+            expect(subject.consumer.name).to eq consumer.name
+          end
+
+          it "returns a webhook with the provider set" do
+            expect(subject.provider.id).to eq provider.id
+            expect(subject.provider.name).to eq provider.name
+          end
+
+          it "returns a webhook with the uuid set" do
+            expect(subject.uuid).to eq uuid
+          end
+
+          it "returns a webhook with the body set" do
+            expect(subject.request.body).to eq body
+          end
+
+          it "returns a webhook with the headers set" do
+            expect(subject.request.headers).to eq headers
+          end
+
+
+          it "returns a webhook with the username set" do
+            expect(subject.request.username).to eq 'username'
+          end
+
+          it "returns a webhook with the password set" do
+            expect(subject.request.password).to eq 'password'
+          end
+
+          it "returns a webhook with the url set" do
+            expect(subject.request.url).to eq url
+          end
+
+          it "returns a webhook with a created_at date" do
+            expect(subject.created_at).to be_instance_of(DateTime)
+          end
+
+          it "returns a webhook with a updated_at date" do
+            expect(subject.updated_at).to be_instance_of(DateTime)
+          end
+
+          context "when the body is a XML string" do
+            let(:body) { "<xml>Why would you do this?</xml>" }
+
+            it "returns the body as the XML String, not an JSON Object" do
+              expect(subject.request.body).to eq body
+            end
+          end
+
+          context "when the optional attributes are nil" do
+            let(:body) { nil }
+            let(:headers) { nil }
+
+            it "does not blow up" do
+              expect(subject.request.body).to eq body
+              expect(subject.request.headers).to eq({})
+            end
+          end
+        end
+
+        context "when a webhook is not found" do
+          it "returns nil" do
+            expect(subject).to be nil
+          end
+        end
+
+      end
+
+      describe "find_all" do
+        before do
+          allow(SecureRandom).to receive(:urlsafe_base64).and_return(uuid, 'some-other-uuid')
+          WebhookRepository.new.create webhook, consumer, provider
+          WebhookRepository.new.create webhook, consumer, provider
+        end
+
+        subject { WebhookRepository.new.find_all }
+
+        it "returns a list of webhooks" do
+          expect(subject.size).to be 2
+          expect(subject.first).to be_instance_of Models::Webhook
+        end
+      end
+
+      describe "find_by_consumer_and_provider" do
+        let(:test_data_builder) { ProviderStateBuilder.new }
+        subject { WebhookRepository.new.find_by_consumer_and_provider test_data_builder.consumer, test_data_builder.provider}
+
+        context "when a webhook exists with a matching consumer and provider" do
+
+          before do
+            allow(SecureRandom).to receive(:urlsafe_base64).and_call_original
+            test_data_builder
+              .create_consumer("Consumer")
+              .create_provider("Another Provider")
+              .create_webhook
+              .create_provider("Provider")
+              .create_webhook
+          end
+
+
+          it "returns an array of webhooks" do
+            expect(subject).to be_instance_of Array
+            expect(subject.first.uuid).to eq test_data_builder.webhook.uuid
+          end
+        end
+
+        context "when a webhook does not exist with a matching consumer and provider" do
+
+          before do
+            test_data_builder
+              .create_consumer("Consumer")
+              .create_provider("Provider")
+              .create_webhook
+              .create_provider("Another Provider")
+          end
+
+          it "returns an empty array" do
+            expect(subject).to eq []
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/pact_broker/services/group_service_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'pact_broker/services/group_service'
+
+module PactBroker
+
+  module Services
+    describe GroupService do
+
+
+      describe "#find_group_containing" do
+
+        let(:consumer_a) { double('consumer a', name: 'consumer a', id: 1)}
+        let(:consumer_b) { double('consumer b', name: 'consumer b', id: 2)}
+
+        let(:provider_x) { double('provider x', name: 'provider x', id: 3)}
+        let(:provider_y) { double('provider y', name: 'provider y', id: 4)}
+
+        let(:relationship_1) { Models::Relationship.new(consumer_a, provider_x) }
+        let(:relationship_2) { Models::Relationship.new(consumer_b, provider_y) }
+
+        let(:group_1) { Models::Group.new(relationship_1) }
+        let(:group_2) { Models::Group.new(relationship_2) }
+
+        let(:relationship_list) { double('relationship list') }
+        let(:groups) { [group_1, group_2]}
+
+        subject  { GroupService.find_group_containing(consumer_b) }
+
+        before do
+          allow(PacticipantService).to receive(:find_relationships).and_return(relationship_list)
+          allow(Functions::Groupify).to receive(:call).and_return(groups)
+        end
+
+        it "retrieves a list of the relationships" do
+          allow(PacticipantService).to receive(:find_relationships)
+          subject
+        end
+
+        it "turns the relationships into groups" do
+          expect(Functions::Groupify).to receive(:call).with(relationship_list)
+          subject
+        end
+
+        it "returns the Group containing the given pacticipant" do
+          expect(subject).to be group_2
+        end
+
+      end
+
+    end
+  end
+end

data/spec/lib/pact_broker/services/pact_service_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'pact_broker/services/pact_service'
+
+module PactBroker
+
+  module Services
+    module PactService
+
+      describe "#pact_has_changed_since_previous_version?" do
+
+        let(:json_content) { { 'some' => 'json'}.to_json }
+        let(:pact) { instance_double(PactBroker::Models::Pact, json_content: json_content)}
+
+        before do
+          allow_any_instance_of(Repositories::PactRepository).to receive(:find_previous_pact).and_return(previous_pact)
+        end
+
+        subject { PactService.pact_has_changed_since_previous_version? pact }
+
+        context "when a previous pact is found" do
+          let(:previous_pact) { instance_double(PactBroker::Models::Pact, json_content: previous_json_content)}
+          let(:previous_json_content) { {'some' => 'json'}.to_json }
+
+          context "when the json_content is the same" do
+            it "returns false" do
+              expect(subject).to be_falsey
+            end
+          end
+
+          context "when the json_content is not the same" do
+            let(:previous_json_content) { {'some-other' => 'json'}.to_json }
+            it "returns truthy" do
+              expect(subject).to be_truthy
+            end
+          end
+        end
+
+        context "when a previous pact is not found" do
+          let(:previous_pact) { nil }
+          it "returns false" do
+            expect(subject).to be_falsey
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/spec/lib/pact_broker/services/pacticipant_service_spec.rb

@@ -1,5 +1,8 @@
 require 'spec_helper'
 require 'pact_broker/services/pacticipant_service'
+require 'pact_broker/models/tag'
+require 'pact_broker/models/pact'
+
 
 module PactBroker
 
@@ -25,6 +28,53 @@ module PactBroker
 
       end
 
+      describe "delete" do
+
+        before do
+          ProviderStateBuilder.new
+            .create_consumer("Consumer")
+            .create_consumer_version("2.3.4")
+            .create_provider("Provider")
+            .create_pact
+            .create_consumer_version("1.2.3")
+            .create_consumer_version_tag("prod")
+            .create_pact
+            .create_webhook
+        end
+
+        let(:delete_pacticipant) { subject.delete "Consumer" }
+
+        it "deletes the pacticipant" do
+          expect{ delete_pacticipant }.to change{
+              PactBroker::Models::Pacticipant.all.count
+            }.by(-1)
+        end
+
+        it "deletes the child versions" do
+          expect{ delete_pacticipant }.to change{
+            PactBroker::Models::Version.where(number: "1.2.3").count
+            }.by(-1)
+        end
+
+        it "deletes the child tags" do
+          expect{ delete_pacticipant }.to change{
+            PactBroker::Models::Tag.where(name: "prod").count
+            }.by(-1)
+        end
+
+        it "deletes the webhooks" do
+          expect{ delete_pacticipant }.to change{
+            PactBroker::Repositories::Webhook.count
+            }.by(-1)
+        end
+
+        it "deletes the child pacts" do
+          expect{ delete_pacticipant }.to change{
+            PactBroker::Models::Pact.count
+            }.by(-2)
+        end
+      end
+
     end
   end
 end