pact_broker 1.3.1 → 1.3.2.rc1

data/spec/lib/pact_broker/{models → domain}/group_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
-require 'pact_broker/models/group'
-require 'pact_broker/models/relationship'
+require 'pact_broker/domain/group'
+require 'pact_broker/domain/relationship'
 
 module PactBroker
-  module Models
+  module Domain
     describe Group do
 
 
@@ -15,8 +15,8 @@ module PactBroker
         let(:provider_x) { double('provider x') }
         let(:provider_y) { double('provider y') }
 
-        let(:relationship_1) { Models::Relationship.new(consumer_a, provider_x)}
-        let(:relationship_2) { Models::Relationship.new(consumer_b, provider_y)}
+        let(:relationship_1) { Domain::Relationship.new(consumer_a, provider_x)}
+        let(:relationship_2) { Domain::Relationship.new(consumer_b, provider_y)}
 
         subject { Group.new(relatio)}
       end

data/spec/lib/pact_broker/{models → domain}/order_versions_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 require 'spec/support/provider_state_builder'
-require 'pact_broker/models/order_versions.rb'
+require 'pact_broker/domain/order_versions.rb'
 
-describe PactBroker::Models::OrderVersions do
+describe PactBroker::Domain::OrderVersions do
 
 
   before do
@@ -13,8 +13,8 @@ describe PactBroker::Models::OrderVersions do
       .create_condor_version('1.4.0')
   end
 
-  let(:ordered_versions) { PactBroker::Models::Version.order(:order).all.collect(&:number) }
-  let(:condor) { PactBroker::Models::Pacticipant.where(name: 'Condor').single_record }
+  let(:ordered_versions) { PactBroker::Domain::Version.order(:order).all.collect(&:number) }
+  let(:condor) { PactBroker::Domain::Pacticipant.where(name: 'Condor').single_record }
 
   it "orders the versions so they can be loaded from the database in order" do
     expect(ordered_versions).to eq(['1.3.0','1.4.0', '1.5.0'])

data/spec/lib/pact_broker/{models → domain}/pacticipant_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
-require 'pact_broker/models/pacticipant'
+require 'pact_broker/domain/pacticipant'
 
 module PactBroker
 
-  module Models
+  module Domain
 
     describe Pacticipant do
 

data/spec/lib/pact_broker/{models → domain}/webhook_request_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
-require 'pact_broker/models/webhook_request'
+require 'pact_broker/domain/webhook_request'
 require 'webmock/rspec'
 
 module PactBroker
 
-  module Models
+  module Domain
 
     describe WebhookRequest do
 

data/spec/lib/pact_broker/{models → domain}/webhook_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
-require 'pact_broker/models/webhook'
+require 'pact_broker/domain/webhook'
 
 module PactBroker
 
-  module Models
+  module Domain
 
     describe Webhook do
 
       let(:consumer) { Pacticipant.new(name: 'Consumer')}
       let(:provider) { Pacticipant.new(name: 'Provider')}
-      let(:request) { instance_double(PactBroker::Models::WebhookRequest, execute: nil)}
+      let(:request) { instance_double(PactBroker::Domain::WebhookRequest, execute: nil)}
       subject { Webhook.new(request: request, consumer: consumer, provider: provider,) }
 
       describe "description" do

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require 'pact_broker/functions/groupify'
-require 'pact_broker/models/relationship'
+require 'pact_broker/domain/relationship'
 
 module PactBroker
 
@@ -24,23 +24,23 @@ module PactBroker
         let(:provider_z) { double('provider z', name: 'provider z') }
 
 
-        let(:relationship_1) { Models::Relationship.new(consumer_a, provider_x) }
-        let(:relationship_4) { Models::Relationship.new(consumer_a, provider_y) }
-        let(:relationship_2) { Models::Relationship.new(consumer_b, provider_y) }
+        let(:relationship_1) { Domain::Relationship.new(consumer_a, provider_x) }
+        let(:relationship_4) { Domain::Relationship.new(consumer_a, provider_y) }
+        let(:relationship_2) { Domain::Relationship.new(consumer_b, provider_y) }
 
-        let(:relationship_3) { Models::Relationship.new(consumer_c, provider_z) }
+        let(:relationship_3) { Domain::Relationship.new(consumer_c, provider_z) }
 
 
-        let(:relationship_5) { Models::Relationship.new(consumer_l, provider_p) }
-        let(:relationship_6) { Models::Relationship.new(consumer_m, provider_p) }
+        let(:relationship_5) { Domain::Relationship.new(consumer_l, provider_p) }
+        let(:relationship_6) { Domain::Relationship.new(consumer_m, provider_p) }
 
         let(:relationships) { [relationship_1, relationship_2, relationship_3, relationship_4, relationship_5, relationship_6 ]}
 
         it "separates the relationships into isolated groups" do
           groups = Groupify.call(relationships)
-          expect(groups[0]).to eq(Models::Group.new(relationship_1, relationship_4, relationship_2))
-          expect(groups[1]).to eq(Models::Group.new(relationship_3))
-          expect(groups[2]).to eq(Models::Group.new(relationship_5, relationship_6))
+          expect(groups[0]).to eq(Domain::Group.new(relationship_1, relationship_4, relationship_2))
+          expect(groups[1]).to eq(Domain::Group.new(relationship_3))
+          expect(groups[2]).to eq(Domain::Group.new(relationship_5, relationship_6))
         end
 
       end

data/spec/lib/pact_broker/{repositories/pact_repository_spec.rb → pacts/repository_spec.rb}

@@ -1,41 +1,77 @@
-require 'spec_helper'
+require 'pact_broker/pacts/repository'
 require 'spec/support/provider_state_builder'
+require 'pact_broker/pacts/pact_params'
 
 module PactBroker
-  module Repositories
-    describe PactRepository do
+  module Pacts
+    describe Repository do
+
+      let(:consumer_name) { 'Consumer' }
+      let(:provider_name) { 'Provider' }
 
       describe "create" do
-        let(:consumer) { PacticipantRepository.new.create name: 'Consumer' }
-        let(:provider) { PacticipantRepository.new.create name: 'Provider' }
-        let(:version) { VersionRepository.new.create number: '1.2.3', pacticipant_id: consumer.id }
+        let(:consumer) { Repositories::PacticipantRepository.new.create name: 'Consumer' }
+        let(:provider) { Repositories::PacticipantRepository.new.create name: 'Provider' }
+        let(:version) { Repositories::VersionRepository.new.create number: '1.2.3', pacticipant_id: consumer.id }
         let(:json_content) { {some: 'json'}.to_json }
 
-        subject { PactRepository.new.create version_id: version.id, provider_id: provider.id, json_content: json_content}
+        subject { Repository.new.create version_id: version.id, provider_id: provider.id, json_content: json_content }
 
         it "saves the pact" do
-          expect{subject}.to change{ Pact.count }.by(1)
+          expect{subject}.to change{ DatabaseModel.count }.by(1)
         end
 
         it "returns a Pact::Model" do
-          expect(subject).to be_instance_of(PactBroker::Models::Pact)
+          expect(subject).to be_instance_of(PactBroker::Domain::Pact)
         end
 
         it "sets all the Pact::Model attributes" do
           expect(subject.consumer).to eq consumer
           expect(subject.provider).to eq provider
           expect(subject.consumer_version_number).to eq '1.2.3'
-          expect(subject.consumer_version).to eq version
+          expect(subject.consumer_version.number).to eq '1.2.3'
           expect(subject.json_content).to eq json_content
           expect(subject.created_at).to be_instance_of(DateTime)
           expect(subject.updated_at).to be_instance_of(DateTime)
         end
+
+        context "when a pact already exists with the same content" do
+          let(:another_version) { Repositories::VersionRepository.new.create number: '2.0.0', pacticipant_id: consumer.id }
+
+          before do
+            Repository.new.create version_id: version.id, provider_id: provider.id, json_content: json_content
+          end
+
+          subject do
+            Repository.new.create version_id: another_version.id, provider_id: provider.id, json_content: json_content
+          end
+
+          it "reuses the same PactVersionContent to save room" do
+            expect { subject }.to change{ PactVersionContent.count }.by(0)
+          end
+        end
+
+        context "when a pact already exists with different content" do
+          let(:another_version) { Repositories::VersionRepository.new.create number: '2.0.0', pacticipant_id: consumer.id }
+
+          before do
+            Repository.new.create version_id: version.id, provider_id: provider.id, json_content: {some_other: 'json_content'}.to_json
+          end
+
+          subject do
+            Repository.new.create version_id: another_version.id, provider_id: provider.id, json_content: json_content
+          end
+
+          it "creates a new PactVersionContent" do
+            expect { subject }.to change{ PactVersionContent.count }.by(1)
+          end
+        end
       end
 
       describe "update" do
 
         let(:existing_pact) do
-          ProviderStateBuilder.new.create_pact_with_hierarchy "A Consumer", "1.2.3", "A Provider"
+          ProviderStateBuilder.new.create_pact_with_hierarchy "A Consumer", "1.2.3", "A Provider", original_json_content
         end
 
         before do
@@ -44,17 +80,23 @@ module PactBroker
             .update(
               created_at: created_at,
               updated_at: updated_at)
+          ::DB::PACT_BROKER_DB[:pact_version_contents]
+              .update(
+                created_at: created_at,
+                updated_at: updated_at)
         end
 
         let(:created_at) { DateTime.new(2014, 3, 2) }
         let(:updated_at) { DateTime.new(2014, 3, 4) }
 
-        let(:json_content) { {some: 'json'}.to_json }
+        let(:original_json_content) { {some: 'json'}.to_json }
+        let(:json_content) { {some_other: 'json'}.to_json }
 
-        subject { PactRepository.new.update existing_pact.id, json_content: json_content }
 
         context "when the attributes have changed" do
 
+          subject { Repository.new.update existing_pact.id, json_content: json_content }
+
           it "updates the existing content" do
             expect(subject.json_content).to eq json_content
           end
@@ -69,29 +111,52 @@ module PactBroker
 
         end
 
-        context "when the attributes have not changed" do
-          before do
-            ::DB::PACT_BROKER_DB[:pacts]
-              .where(id: existing_pact.id)
-              .update(
-                json_content: json_content)
+        context "when the content has not changed" do
+
+          subject { Repository.new.update existing_pact.id, json_content: original_json_content }
+
+          it "the json_content is the same" do
+            expect(subject.json_content).to eq original_json_content
           end
 
-          it "does not update the updated_at timestamp" do
+          it "does not update the timestamp" do
             expect(subject.updated_at).to eq updated_at
           end
 
           it "does not update the created_at timestamp" do
             expect(subject.created_at).to eq created_at
           end
+        end
+      end
+
+      describe "delete" do
+        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_pact
+            .create_provider("Another Provider")
+            .create_pact
+        end
+
+        let(:pact_params) { PactBroker::Pacts::PactParams.new(consumer_name: consumer_name, provider_name: provider_name, consumer_version_number: '1.2.3') }
 
+        subject { Repository.new.delete pact_params }
+
+        it "deletes the Pact" do
+          expect { subject }.to change { DatabaseModel.count }.by(-1)
+        end
+
+        it "does not delete the content because it may be used by another pact" do
+          expect { subject }.to change { PactVersionContent.count }.by(0)
         end
 
       end
 
       describe "#find_all_pacts_between" do
-        let(:consumer_name) { 'Consumer' }
-        let(:provider_name) { 'Provider' }
 
         before do
           ProviderStateBuilder.new
@@ -101,12 +166,13 @@ module PactBroker
             .create_pact
             .create_consumer_version("2.3.4")
             .create_consumer_version_tag("prod")
+            .create_consumer_version_tag("branch")
             .create_pact
             .create_provider("Another Provider")
             .create_pact
         end
 
-        subject { PactRepository.new.find_all_pacts_between consumer_name, :and => provider_name }
+        subject { Repository.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
@@ -114,8 +180,38 @@ module PactBroker
           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"
+          expect(subject.first.consumer_version.tags.last.name).to eq "branch"
+        end
+
+      end
+
+      describe "find_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_consumer_version_tag("prod")
+            .create_pact
+            .create_consumer_version("1.2.6")
+            .create_pact
+            .create_provider("Another Provider")
+            .create_consumer_version("1.2.5")
+            .create_pact
         end
 
+        subject  { Repository.new.find_pact "Consumer", "1.2.4", "Provider" }
+
+        it "finds the pact with the given version" do
+          expect(subject.consumer.name).to eq "Consumer"
+          expect(subject.provider.name).to eq "Provider"
+          expect(subject.consumer_version_number).to eq "1.2.4"
+          expect(subject.consumer_version.number).to eq "1.2.4"
+          expect(subject.consumer_version.tags.first.name).to eq "prod"
+          expect(subject.json_content).to_not be_nil
+        end
       end
 
       describe "find_previous_pact" do
@@ -134,9 +230,9 @@ module PactBroker
             .create_pact
         end
 
-        let(:pact) { PactRepository.new.find_latest_pact "Consumer", "Provider"  }
+        let(:pact) { Repository.new.find_latest_pact "Consumer", "Provider"  }
 
-        subject  { PactRepository.new.find_previous_pact pact }
+        subject  { Repository.new.find_previous_pact pact }
 
         it "finds the previous pact" do
           expect(subject.consumer_version_number).to eq "1.2.4"
@@ -159,12 +255,16 @@ module PactBroker
                 .create_pact
             end
 
-            let(:latest_prod_pact) { PactRepository.new.find_latest_pact("Consumer", "Provider", "prod") }
+            let(:latest_prod_pact) { Repository.new.find_latest_pact("Consumer", "Provider", "prod") }
 
             it "returns the pact for the latest tagged version" do
               expect(latest_prod_pact.consumer_version.number).to eq("1.2.3")
             end
 
+            it "has JSON content" do
+              expect(latest_prod_pact.json_content).to_not be nil
+            end
+
             it "has timestamps" do
               expect(latest_prod_pact.created_at).to be_instance_of(DateTime)
               expect(latest_prod_pact.updated_at).to be_instance_of(DateTime)
@@ -193,7 +293,7 @@ module PactBroker
         end
 
         it "finds the latest pact for each consumer/provider pair" do
-          pacts = PactRepository.new.find_latest_pacts
+          pacts = Repository.new.find_latest_pacts
 
           expect(pacts[0].consumer_version.pacticipant.name).to eq("Condor")
           expect(pacts[0].consumer.name).to eq("Condor")
@@ -209,7 +309,7 @@ module PactBroker
         end
 
         it "includes the timestamps - need to update view" do
-          pacts = PactRepository.new.find_latest_pacts
+          pacts = Repository.new.find_latest_pacts
 
           expect(pacts[0].updated_at).to be_instance_of DateTime
           expect(pacts[0].created_at).to be_instance_of DateTime

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

@@ -9,7 +9,7 @@ module PactBroker
       let(:body) { {'some' => 'json' } }
       let(:headers) { {'Content-Type' => 'application/json', 'Accept' => 'application/json'} }
       let(:request) do
-        Models::WebhookRequest.new(
+        Domain::WebhookRequest.new(
           method: 'post',
           url: url,
           headers: headers,
@@ -17,7 +17,7 @@ module PactBroker
           password: 'password',
           body: body)
       end
-      let(:webhook) { Models::Webhook.new(request: request)}
+      let(:webhook) { Domain::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}
@@ -198,7 +198,7 @@ module PactBroker
 
         it "returns a list of webhooks" do
           expect(subject.size).to be 2
-          expect(subject.first).to be_instance_of Models::Webhook
+          expect(subject.first).to be_instance_of Domain::Webhook
         end
       end
 

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

@@ -15,11 +15,11 @@ module PactBroker
         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(:relationship_1) { Domain::Relationship.new(consumer_a, provider_x) }
+        let(:relationship_2) { Domain::Relationship.new(consumer_b, provider_y) }
 
-        let(:group_1) { Models::Group.new(relationship_1) }
-        let(:group_2) { Models::Group.new(relationship_2) }
+        let(:group_1) { Domain::Group.new(relationship_1) }
+        let(:group_2) { Domain::Group.new(relationship_2) }
 
         let(:relationship_list) { double('relationship list') }
         let(:groups) { [group_1, group_2]}