pact_broker 2.40.0 → 2.41.0

data/spec/lib/pact_broker/api/decorators/verifiable_pact_decorator_spec.rb

@@ -29,6 +29,7 @@ module PactBroker
         let(:pact) do
           double('pact',
             pending: true,
+            wip: wip,
             name: "name",
             provider_name: "Bar",
             pending_provider_tags: pending_provider_tags,
@@ -37,7 +38,9 @@ module PactBroker
         let(:pending_provider_tags) { %w[dev] }
         let(:consumer_tags) { %w[dev] }
         let(:json) { decorator.to_json(options) }
-        let(:options) { { user_options: { base_url: 'http://example.org' } } }
+        let(:options) { { user_options: { base_url: 'http://example.org', include_pending_status: include_pending_status } } }
+        let(:include_pending_status) { true }
+        let(:wip){ false }
 
         subject { JSON.parse(json) }
 
@@ -49,6 +52,26 @@ module PactBroker
           expect(decorator).to receive(:pact_version_url).with(pact, 'http://example.org')
           subject
         end
+
+        context "when include_pending_status is false" do
+          let(:include_pending_status) { false }
+
+          it "does not include the pending flag" do
+            expect(subject['verificationProperties']).to_not have_key('pending')
+          end
+
+          it "does not include the pending reason" do
+            expect(subject['verificationProperties']).to_not have_key('pendingReason')
+          end
+        end
+
+        context "when wip is true" do
+          let(:wip) { true }
+
+          it "includes the wip flag" do
+            expect(subject['verificationProperties']['wip']).to be true
+          end
+        end
       end
     end
   end

data/spec/lib/pact_broker/api/decorators/verifiable_pacts_query_decorator_spec.rb

@@ -4,40 +4,84 @@ module PactBroker
   module Api
     module Decorators
       describe VerifiablePactsQueryDecorator do
-        let(:params) do
-          {
-            "provider_version_tags" => provider_version_tags,
-            "consumer_version_selectors" => consumer_version_selectors
-          }
-        end
+
         let(:provider_version_tags) { %w[dev] }
-        let(:consumer_version_selectors) do
-          [{"tag" => "dev", "ignored" => "foo"}]
-        end
 
         subject { VerifiablePactsQueryDecorator.new(OpenStruct.new).from_hash(params)  }
 
-        context "when latest is not specified" do
-          it "defaults to nil" do
-            expect(subject.consumer_version_selectors.first.latest).to be nil
+        context "when parsing JSON params" do
+          let(:params) do
+            {
+              "providerVersionTags" => provider_version_tags,
+              "consumerVersionSelectors" => consumer_version_selectors
+            }
+          end
+
+          let(:consumer_version_selectors) do
+            [{"tag" => "dev", "ignored" => "foo", "latest" => true}]
+          end
+
+          context "when latest is not specified" do
+            let(:consumer_version_selectors) do
+              [{"tag" => "dev"}]
+            end
+
+            it "defaults to nil" do
+              expect(subject.consumer_version_selectors.first.latest).to be nil
+            end
+          end
+
+          it "parses the latest as a boolean" do
+            expect(subject.consumer_version_selectors.first.latest).to be true
+          end
+
+          context "when there are no consumer_version_selectors" do
+            let(:params) { {} }
+
+            it "returns an empty array" do
+              expect(subject.consumer_version_selectors).to eq []
+            end
+          end
+
+          context "when there are no provider_version_tags" do
+            let(:params) { {} }
+
+            it "returns an empty array" do
+              expect(subject.provider_version_tags).to eq []
+            end
           end
         end
 
-        context "when latest is a string" do
+        context "when parsing query string params" do
+          let(:params) do
+            {
+              "provider_version_tags" => provider_version_tags,
+              "consumer_version_selectors" => consumer_version_selectors
+            }
+          end
+
           let(:consumer_version_selectors) do
             [{"tag" => "dev", "latest" => "true"}]
           end
 
-          it "casts it to a boolean" do
+          it "parses the provider_version_tags" do
+            expect(subject.provider_version_tags).to eq provider_version_tags
+          end
+
+          it "parses a string 'latest' to a boolean" do
             expect(subject.consumer_version_selectors.first.latest).to be true
           end
         end
 
-        context "when there are no consumer_version_selectors" do
-          let(:params) { {} }
+        context "when specifying include_wip_pacts_since" do
+          let(:params) do
+            {
+              "include_wip_pacts_since" => "2013-02-13T20:04:45.000+11:00"
+            }
+          end
 
-          it "returns an empty array" do
-            expect(subject.consumer_version_selectors).to eq []
+          it "parses the date" do
+            expect(subject.include_wip_pacts_since).to eq DateTime.parse("2013-02-13T20:04:45.000+11:00")
           end
         end
       end

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

@@ -31,6 +31,16 @@ module PactBroker
           it "includes OPTIONS in the list of allowed_methods" do
             expect(resource.new(request, response).allowed_methods).to include "OPTIONS"
           end
+
+          it "calls super in its constructor" do
+            expect(PactBroker.configuration.before_resource).to receive(:call)
+            resource.new(request, response)
+          end
+
+          it "calls super in finish_request" do
+            expect(PactBroker.configuration.after_resource).to receive(:call)
+            resource.new(request, response).finish_request
+          end
         end
       end
     end

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

@@ -14,18 +14,87 @@ module PactBroker
         let(:pacts) { double('pacts') }
         let(:path) { '/pacts/provider/Bar/for-verification' }
         let(:decorator) { instance_double('PactBroker::Api::Decorators::VerifiablePactsDecorator') }
+        let(:query) do
+          {
+            provider_version_tags: ['master'],
+            consumer_version_selectors: [ { tag: 'dev', latest: 'true' }],
+            include_pending_status: false,
+            include_wip_pacts_since: '2018-01-01'
+          }
+        end
 
-        subject { get(path, provider_version_tags: ['master'], consumer_version_selectors: [ { tag: "dev", latest: true}]) }
+        subject { get(path, query) }
 
-        it "finds the pacts for verification by the provider" do
-          # Naughty not mocking out the query parsing...
-          expect(PactBroker::Pacts::Service).to receive(:find_for_verification).with("Bar", ["master"], [ OpenStruct.new(tag: "dev", latest: true)])
-          subject
+        describe "GET" do
+          it "finds the pacts for verification by the provider" do
+            # Naughty not mocking out the query parsing...
+            expect(PactBroker::Pacts::Service).to receive(:find_for_verification).with(
+              "Bar",
+              ["master"],
+              [OpenStruct.new(tag: "dev", latest: true)],
+              { include_wip_pacts_since: DateTime.parse('2018-01-01') })
+            subject
+          end
+
+          context "when there are validation errors" do
+            let(:query) do
+              {
+                provider_version_tags: true,
+              }
+            end
+
+            it "returns the keys with the right case" do
+              expect(JSON.parse(subject.body)['errors']).to have_key('provider_version_tags')
+            end
+          end
+        end
+
+        describe "POST" do
+          let(:request_body) do
+            {
+              providerVersionTags: ['master'],
+              consumerVersionSelectors: [ { tag: 'dev', latest: true }],
+              includePendingStatus: false,
+              includeWipPactsSince: '2018-01-01'
+            }
+          end
+
+          let(:request_headers) do
+            {
+              'CONTENT_TYPE' => 'application/json',
+              'HTTP_ACCEPT' => 'application/hal+json'
+            }
+          end
+
+          subject { post(path, request_body.to_json, request_headers) }
+
+          it "finds the pacts for verification by the provider" do
+            # Naughty not mocking out the query parsing...
+            expect(PactBroker::Pacts::Service).to receive(:find_for_verification).with(
+              "Bar",
+              ["master"],
+              [OpenStruct.new(tag: "dev", latest: true)],
+              { include_wip_pacts_since: DateTime.parse('2018-01-01') })
+            subject
+          end
+
+          context "when there are validation errors" do
+            let(:request_body) do
+              {
+                providerVersionTags: true
+              }
+            end
+
+            it "returns the keys with the right case" do
+              expect(JSON.parse(subject.body)['errors']).to have_key('providerVersionTags')
+            end
+          end
         end
 
-        it "sets the correct resource title" do
+        it "uses the correct options for the decorator" do
           expect(decorator).to receive(:to_json) do | options |
             expect(options[:user_options][:title]).to eq "Pacts to be verified by provider Bar"
+            expect(options[:user_options][:include_pending_status]).to eq false
           end
           subject
         end

data/spec/lib/pact_broker/hash_refinements_spec.rb

@@ -11,5 +11,29 @@ module PactBroker
     it "merges" do
       expect(a.deep_merge(b)).to eq expected
     end
+
+    describe "snakecase_keys" do
+      let(:hash_1) do
+        {
+          "fooBar" => {
+            :meepMoop => "blahBlah",
+            "already_snake" => ""
+          }
+        }
+      end
+
+      let(:expected) do
+        {
+          "foo_bar" => {
+            :meep_moop => "blahBlah",
+            "already_snake" => ""
+          }
+        }
+      end
+
+      it "snake cases the keys" do
+        expect(hash_1.snakecase_keys).to eq expected
+      end
+    end
   end
 end

data/spec/lib/pact_broker/index/service_spec.rb

@@ -4,13 +4,19 @@ require 'pact_broker/domain/tag'
 require 'pact_broker/domain/pact'
 
 module PactBroker
-
   module Index
     describe Service do
       let(:td) { TestDataBuilder.new }
       let(:tags) { ['prod', 'production'] }
-      let(:options) { { tags: tags } }
+      let(:options) { { tags: tags, optimised: optimised, page_size: page_size, page_number: page_number } }
+      let(:page_number) { nil }
+      let(:page_size) { nil }
       let(:rows) { subject.find_index_items(options) }
+      let(:optimised) { true }
+
+      before do
+        td.create_global_webhook
+      end
 
       subject{ Service }
 
@@ -252,6 +258,36 @@ module PactBroker
             end
           end
         end
+
+        describe "with pagination" do
+          let(:page_number) { 1 }
+          let(:page_size) { 2 }
+          let(:tags) { nil }
+
+          before do
+            td.create_pact_with_hierarchy("Foo1", "1", "Bar1")
+              .create_pact_with_hierarchy("Foo2", "1", "Bar2")
+              .create_pact_with_hierarchy("Foo3", "1", "Bar3")
+          end
+
+          it "it returns the total number of records" do
+            expect(rows.pagination_record_count).to eq 3
+          end
+
+          describe "the first page" do
+            it "contains 2 rows" do
+              expect(rows.count).to eq 2
+            end
+          end
+
+          describe "the second page" do
+            let(:page_number) { 2 }
+
+            it "contains 1 row" do
+              expect(rows.count).to eq 1
+            end
+          end
+        end
       end
 
       describe "find_index_items_for_api" do

data/spec/lib/pact_broker/integrations/integration_spec.rb

@@ -3,58 +3,96 @@ require 'pact_broker/integrations/integration'
 module PactBroker
   module Integrations
     describe Integration do
-      before do
-        td.set_now(DateTime.new(2019, 1, 1))
-          .create_pact_with_hierarchy("Foo", "1", "Bar")
-          .set_now(DateTime.new(2019, 1, 2))
-          .create_consumer_version("2")
-          .create_pact
-          .set_now(DateTime.new(2019, 1, 3))
-          .create_verification(provider_version: "3")
-          .set_now(DateTime.new(2019, 1, 4))
-          .create_verification(provider_version: "4", number: 2)
-      end
-
-      it "has a relationship to the latest pact" do
-        integration = Integration.eager(:latest_pact).all.first
-        expect(integration.latest_pact.consumer_version_number).to eq "2"
-      end
+      describe "relationships" do
+        before do
+          td.set_now(DateTime.new(2019, 1, 1))
+            .create_pact_with_hierarchy("Foo", "1", "Bar")
+            .set_now(DateTime.new(2019, 1, 2))
+            .create_consumer_version("2")
+            .create_pact
+            .set_now(DateTime.new(2019, 1, 3))
+            .create_verification(provider_version: "3")
+            .set_now(DateTime.new(2019, 1, 4))
+            .create_verification(provider_version: "4", number: 2)
+        end
 
-      it "has a relationship to the latest verification via the latest pact" do
-        integration = Integration.eager(latest_pact: :latest_verification).all.first
-        expect(integration.latest_pact.latest_verification.provider_version_number).to eq "4"
-      end
+        it "has a relationship to the latest pact" do
+          integration = Integration.eager(:latest_pact).all.first
+          expect(integration.latest_pact.consumer_version_number).to eq "2"
+        end
 
-      it "has a verification status" do
-        expect(Integration.first.verification_status_for_latest_pact).to be_instance_of(PactBroker::Verifications::PseudoBranchStatus)
-      end
+        it "has a relationship to the latest verification via the latest pact" do
+          integration = Integration.eager(latest_pact: :latest_verification).all.first
+          expect(integration.latest_pact.latest_verification.provider_version_number).to eq "4"
+        end
 
-      it "has a latest verification - this may not be the same as the latest verification for the latest pact" do
-        integration = Integration.eager(:latest_verification).all.first
-        expect(integration.latest_verification.provider_version_number).to eq "4"
-      end
+        it "has a verification status" do
+          expect(Integration.first.verification_status_for_latest_pact).to be_instance_of(PactBroker::Verifications::PseudoBranchStatus)
+        end
 
-      describe "latest_pact_or_verification_publication_date" do
-        context "when the last publication is a verification" do
-          it "returns the verification execution date" do
-            date = td.in_utc { DateTime.new(2019, 1, 4) }
-            expect(Integration.first.latest_pact_or_verification_publication_date.to_datetime).to eq date
-          end
+        it "has a latest verification - this may not be the same as the latest verification for the latest pact" do
+          integration = Integration.eager(:latest_verification).all.first
+          expect(integration.latest_verification.provider_version_number).to eq "4"
         end
 
-        context "when the last publication is a pact" do
-          before do
-            td.set_now(DateTime.new(2019, 1, 5))
-              .create_consumer_version("3")
-              .create_pact
+        describe "latest_pact_or_verification_publication_date" do
+          context "when the last publication is a verification" do
+            it "returns the verification execution date" do
+              date = td.in_utc { DateTime.new(2019, 1, 4) }
+              expect(Integration.first.latest_pact_or_verification_publication_date.to_datetime).to eq date
+            end
           end
 
-          it "returns the pact publication date" do
-            date = td.in_utc { DateTime.new(2019, 1, 5) }
-            expect(Integration.first.latest_pact_or_verification_publication_date.to_datetime).to eq date
+          context "when the last publication is a pact" do
+            before do
+              td.set_now(DateTime.new(2019, 1, 5))
+                .create_consumer_version("3")
+                .create_pact
+            end
+
+            it "returns the pact publication date" do
+              date = td.in_utc { DateTime.new(2019, 1, 5) }
+              expect(Integration.first.latest_pact_or_verification_publication_date.to_datetime).to eq date
+            end
           end
         end
       end
+
+      describe "latest_triggered_webhooks" do
+        before do
+          td.create_consumer("Foo")
+            .create_provider("Bar")
+            .create_consumer_version
+            .create_pact
+            .create_global_webhook
+            .create_triggered_webhook
+            .create_webhook_execution
+        end
+
+        it "returns a list of triggered webhooks" do
+          integrations = Integration.eager(:latest_triggered_webhooks).all
+          expect(integrations.first.latest_triggered_webhooks.count).to eq 1
+        end
+      end
+
+      describe "webhooks" do
+        before do
+          td.create_consumer("Foo")
+            .create_provider("Bar")
+            .create_consumer_version
+            .create_pact
+            .create_global_webhook
+            .create_consumer_webhook
+            .create_provider_webhook
+            .create_provider("Wiffle")
+            .create_provider_webhook
+        end
+
+        it "returns all the webhooks" do
+          integrations = Integration.eager(:webhooks).all
+          expect(integrations.first.webhooks.count).to eq 3
+        end
+      end
     end
   end
 end