pact_broker 2.82.0 → 2.85.1

data/spec/lib/pact_broker/api/decorators/{verifiable_pacts_query_decorator_spec.rb → pacts_for_verification_query_decorator_spec.rb}

@@ -1,14 +1,14 @@
-require "pact_broker/api/decorators/verifiable_pacts_query_decorator"
+require "pact_broker/api/decorators/pacts_for_verification_query_decorator"
 
 module PactBroker
   module Api
     module Decorators
-      describe VerifiablePactsQueryDecorator do
+      describe PactsForVerificationQueryDecorator do
 
         let(:provider_version_tags) { %w[dev] }
         let(:provider_version_branch) { "main" }
 
-        subject { VerifiablePactsQueryDecorator.new(OpenStruct.new).from_hash(params)  }
+        subject { PactsForVerificationQueryDecorator.new(OpenStruct.new).from_hash(params)  }
 
         context "when parsing JSON params" do
           let(:params) do

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

@@ -80,13 +80,13 @@ module PactBroker
           context "when the reason is NoEnvironmentSpecified" do
             let(:reason) { PactBroker::Matrix::NoEnvironmentSpecified.new }
 
-            its(:to_s) { is_expected.to start_with "WARN: For production use of can-i-deploy, it is recommended to specify the environment" }
+            its(:to_s) { is_expected.to start_with "WARN: It is recommended to specify the environment" }
           end
 
           context "when the reason is SelectorWithoutPacticipantVersionNumberSpecified" do
             let(:reason) { PactBroker::Matrix::SelectorWithoutPacticipantVersionNumberSpecified.new }
 
-            its(:to_s) { is_expected.to start_with "WARN: For production use of can-i-deploy, it is recommended to specify the version number" }
+            its(:to_s) { is_expected.to start_with "WARN: It is recommended to specify the version number" }
           end
         end
       end

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

@@ -23,12 +23,14 @@ module PactBroker
             execution_date: DateTime.now,
             provider_version_tags: provider_version_tags)
         end
+
         let(:pact_version) do
           instance_double("PactBroker::Pacts::PactVersion", name: "Name")
         end
 
         let(:provider_version_tags) { [instance_double(PactBroker::Tags::TagWithLatestFlag, name: "prod", latest?: true)] }
         let(:pact) { instance_double("PactBroker::Domain::Pact", name: "Some pact", consumer_name: "Foo", provider_name: "Bar", consumer_version_number: "1.2.3") }
+        let(:is_pending) { true }
         let(:options) { {base_url: "http://example.org", consumer_name: "Foo", consumer_version_number: "1.2.3", resource_url: "http://self"} }
 
         subject { JSON.parse VerificationSummaryDecorator.new(summary).to_json(user_options: options), symbolize_names: true }

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

@@ -8,7 +8,6 @@ module PactBroker
         describe "from_json" do
           let(:hash) do
             {
-              branch: "branch",
               buildUrl: "buildUrl",
               tags: [{ name: "main" }]
             }
@@ -17,7 +16,6 @@ module PactBroker
           subject { VersionDecorator.new(OpenStruct.new).from_json(hash.to_json) }
 
           it "sets the properties" do
-            expect(subject.branch).to eq "branch"
             expect(subject.build_url).to eq "buildUrl"
             expect(subject.tags.first.name).to eq "main"
           end
@@ -32,7 +30,7 @@ module PactBroker
             TestDataBuilder.new
               .create_consumer("Consumer")
               .create_provider("providerA")
-              .create_consumer_version("1.2.3")
+              .create_consumer_version("1.2.3", branch: "main")
               .create_consumer_version_tag("prod")
               .create_pact
               .create_provider("ProviderB")
@@ -85,6 +83,12 @@ module PactBroker
             expect(subject[:_embedded][:tags].first[:name]).to eq "prod"
           end
 
+          it "includes the branches" do
+            expect(subject[:_embedded][:branches]).to be_instance_of(Array)
+            expect(subject[:_embedded][:branches].first[:name]).to eq "main"
+            expect(subject[:_embedded][:branches].first[:latest]).to eq true
+          end
+
           it "includes the timestamps" do
             expect(subject[:createdAt]).to_not be nil
           end

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

@@ -6,7 +6,7 @@ module PactBroker
     module Decorators
       describe WebhookExecutionResultDecorator do
         describe "to_json" do
-          let(:webhook_execution_result) { PactBroker::Webhooks::WebhookExecutionResult.new(request, response, logs, error) }
+          let(:webhook_execution_result) { PactBroker::Webhooks::WebhookExecutionResult.new(request, response, true, logs, error) }
           let(:logs) { "logs" }
           let(:headers) { { "Something" => ["blah", "thing"]} }
           let(:request) do

data/spec/lib/pact_broker/api/middleware/configuration_spec.rb

@@ -0,0 +1,43 @@
+require "pact_broker/api/middleware/configuration"
+
+module PactBroker
+  module Api
+    module Middleware
+      class TestApp
+        def call(_)
+          [200, {}, [PactBroker.configuration.allow_dangerous_contract_modification.to_s]]
+        end
+      end
+
+      describe Configuration do
+        describe "#call" do
+          let(:configuration) do
+            conf = PactBroker::Configuration.default_configuration
+            conf.allow_dangerous_contract_modification = false
+            conf
+          end
+          let(:app) { Configuration.new(TestApp.new, configuration) }
+          let(:rack_env) { {} }
+
+          subject { get("/", nil, rack_env) }
+
+          context "with no overrides" do
+            it "uses the default configuration" do
+              expect(subject.body).to eq "false"
+            end
+          end
+
+          context "with overrides" do
+            let(:rack_env) do
+              { "pactbroker.configuration_overrides" => { allow_dangerous_contract_modification: true }}
+            end
+
+            it "overrides the configuration for the duration of the request" do
+              expect(subject.body).to eq "true"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-require "spec_helper"
 require "pact_broker/api/resources/verifications"
 require "pact_broker/pacts/service"
 require "pact_broker/verifications/service"
@@ -17,7 +16,7 @@ module PactBroker
           let(:database_connector) { double("database_connector" )}
           let(:verification) { double(PactBroker::Domain::Verification) }
           let(:errors_empty) { true }
-          let(:parsed_metadata) { { the: "metadata", consumer_version_number: "2"} }
+          let(:parsed_metadata) { { the: "metadata", consumer_version_number: "2", pending: true } }
           let(:base_url) { "http://example.org" }
           let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration) }
 
@@ -62,11 +61,14 @@ module PactBroker
 
             before do
               allow(Pacts::Service).to receive(:find_pact).and_return(pact)
+              allow(Pacts::Service).to receive(:find_for_verification_publication).and_return(verified_pacts)
               allow(PactBroker::Verifications::Service).to receive(:next_number).and_return(next_verification_number)
               allow(PactBroker::Api::Decorators::VerificationDecorator).to receive(:new).and_return(decorator)
               allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return("some-boolean")
             end
 
+            let(:verified_pacts) { double("verified pacts") }
+
             it "parses the webhook metadata" do
               expect(PactBrokerUrls).to receive(:decode_pact_metadata).with("abcd")
               subject
@@ -83,8 +85,8 @@ module PactBroker
             it "stores the verification in the database" do
               expect(PactBroker::Verifications::Service).to receive(:create).with(
                 next_verification_number,
-                hash_including("some" => "params", "wip" => false),
-                pact,
+                hash_including("some" => "params", "wip" => false, "pending" => true),
+                verified_pacts,
                 parsed_metadata
               )
               subject

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

@@ -30,7 +30,7 @@ module PactBroker
             let(:pact) { instance_double("PactBroker::Domain::Pact") }
             let(:consumer_name) { "foo" }
             let(:provider_name) { "bar" }
-            let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration, webhook_context: event_context) }
+            let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration, retry_schedule: [], webhook_context: event_context) }
             let(:event_context) { { some: "data" } }
 
             before do

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

@@ -203,6 +203,18 @@ module PactBroker
           end
         end
 
+        context "when the pseudo_branch_verification_status is :failed_pending" do
+          let(:pseudo_branch_verification_status) { :failed_pending }
+          let(:expected_color) { "red" }
+          let(:expected_right_text) { "failed%20%28pending%29" }
+
+          it "create a red badge with left text 'failed'" do
+            subject
+            expect(http_request).to have_been_made
+            expect(pact_verification_badge_url).to eq URI(expected_url)
+          end
+        end
+
         context "when the pseudo_branch_verification_status is :stale" do
           let(:pseudo_branch_verification_status) { :stale }
           let(:expected_color) { "orange" }
@@ -248,6 +260,16 @@ module PactBroker
             end
           end
 
+          # TODO save a static image for this
+          context "when the pseudo_branch_verification_status is failed_pending" do
+            let(:pseudo_branch_verification_status) { :failed_pending }
+
+            it "returns a static failed image" do
+              expect(subject).to include ">pact</"
+              expect(subject).to include ">failed</"
+            end
+          end
+
           context "when the pseudo_branch_verification_status is stale" do
             let(:pseudo_branch_verification_status) { :stale }
 

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

@@ -39,7 +39,7 @@ module PactBroker
 
         it "sets the version branch" do
           subject
-          expect(PactBroker::Domain::Version.order(:id).last.branch).to eq "main"
+          expect(PactBroker::Domain::Version.order(:id).last.branch_names).to include "main"
         end
 
         it "returns a results object" do
@@ -60,6 +60,27 @@ module PactBroker
               expect(subject.notices.find{ |log| log.type == "success" && log.text.include?(" published ") }).to_not be nil
             end
           end
+
+          context "when no branch is specified but tags are" do
+            before do
+              allow(PactBroker.configuration).to receive(:use_first_tag_as_branch).and_return(true)
+            end
+
+            let(:contracts_to_publish) do
+              ContractsToPublish.from_hash(
+                pacticipant_name: "Foo",
+                pacticipant_version_number: "1",
+                tags: ["a", "b"],
+                branch: nil,
+                contracts: contracts
+              )
+            end
+
+            it "uses the first tag as the branch" do
+              subject
+              expect(PactBroker::Domain::Version.order(:id).last.branch_versions.collect(&:branch_name)).to eq ["a"]
+            end
+          end
         end
 
         context "when the pact already exists" do
@@ -74,8 +95,8 @@ module PactBroker
             expect { subject }.to change { PactBroker::Domain::Version.order(:id).last.tags.count}.from(1).to(3)
           end
 
-          it "updates the branch (TODO this should add to the branches when branches is updated to be a collection)" do
-            expect { subject }.to change { PactBroker::Domain::Version.order(:id).last.branch}.from("feat/x").to("main")
+          it "adds the branch to the existing version" do
+            expect { subject }.to change { PactBroker::Domain::Version.order(:id).last.branch_versions.collect(&:branch_name)}.from(["feat/x"]).to(["feat/x", "main"])
           end
 
           context "when the write mode is overwrite" do

data/spec/lib/pact_broker/db/clean_spec.rb

@@ -14,8 +14,8 @@ module PactBroker
       let(:db) { PactBroker::DB.connection }
 
       subject { Clean.call(PactBroker::DB.connection, options) }
-      let(:latest_dev_selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "dev", latest: true) }
-      let(:all_prod_selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "prod") }
+      let(:latest_dev_selector) { { tag: "dev", latest: true } }
+      let(:all_prod_selector) { { tag: "prod" } }
 
       describe ".call"do
         context "when there are specified versions to keep" do

data/spec/lib/pact_broker/db/data_migrations/create_branches_spec.rb

@@ -0,0 +1,57 @@
+require "pact_broker/db/data_migrations/create_branches"
+
+module PactBroker
+  module DB
+    module DataMigrations
+      describe CreateBranches do
+        let(:db) { PactBroker::Domain::Version.db }
+
+        subject { CreateBranches.call(db) }
+
+        context "when there are no branch objects" do
+          before do
+            td.create_pacticipant("Foo")
+              .create_version("1")
+              .create_version("2")
+              .create_version("3")
+              .create_pacticipant("Bar")
+              .create_version("10")
+              .create_version("11")
+              .create_version("12")
+
+            db[:versions].where(number: ["1", "2"]).update(branch: "main")
+            db[:versions].where(number: ["10", "11"]).update(branch: "main")
+          end
+
+          it "creates the missing branch versions" do
+            subject
+            expect(db[:branches].count).to eq 2
+            expect(db[:branch_heads].count).to eq 2
+            expect(db[:branch_versions].count).to eq 4
+            expect(db[:branch_heads].order(:branch_id).first[:version_id]).to eq db[:versions].where(number: "2").single_record[:id]
+            expect(db[:branch_heads].order(:branch_id).last[:version_id]).to eq db[:versions].where(number: "11").single_record[:id]
+          end
+        end
+
+        context "when there is a branch already" do
+          before do
+            td.create_pacticipant("Foo")
+              .create_version("1", branch: "main")
+              .create_version("2")
+              .create_version("3", branch: "main")
+              .create_version("4")
+            db[:versions].where(number: ["1", "2"]).update(branch: "main")
+          end
+
+          it "creates the missing branch versionsq" do
+            subject
+            expect(db[:branches].count).to eq 1
+            expect(db[:branch_heads].count).to eq 1
+            expect(db[:branch_versions].count).to eq 3
+            expect(db[:branch_heads].order(:branch_id).last[:version_id]).to eq db[:versions].where(number: "3").single_record[:id]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/diagnostic/resources/dependencies_spec.rb

@@ -5,22 +5,22 @@ module PactBroker
   module Diagnostic
     module Resources
       describe Dependencies do
-
         describe "GET /diagnostic/status/dependencies" do
-
           include Rack::Test::Methods
 
+          let(:rack_env) { { "pactbroker.base_url" => "http://pact-broker"} }
           let(:app) { PactBroker::Diagnostic::App.new }
           let(:parsed_response_body) { JSON.parse(subject.body) }
 
-          subject { get "/diagnostic/status/dependencies"; last_response }
+
+          subject { get("/diagnostic/status/dependencies", nil, rack_env) }
 
           it "returns application/hal+json" do
             expect(subject.headers["Content-Type"]).to eq "application/hal+json"
           end
 
           it "returns a link to itself" do
-            expect(parsed_response_body["_links"]["self"]["href"]).to eq "http://example.org/diagnostic/status/dependencies"
+            expect(parsed_response_body["_links"]["self"]["href"]).to eq "http://pact-broker/diagnostic/status/dependencies"
           end
 
           context "when we can connect to the database" do

data/spec/lib/pact_broker/diagnostic/resources/heartbeat_spec.rb

@@ -6,16 +6,15 @@ module PactBroker
   module Diagnostic
     module Resources
       describe Heartbeat do
-
         include Rack::Test::Methods
 
         let(:app) { PactBroker::Diagnostic::App.new }
 
         describe "GET /diagnostic/status/heartbeat" do
-
+          let(:rack_env) { { "pactbroker.base_url" => "http://pact-broker"} }
           let(:parsed_response_body) { JSON.parse(subject.body) }
 
-          subject { get "/diagnostic/status/heartbeat"; last_response }
+          subject { get("/diagnostic/status/heartbeat", nil, rack_env) }
 
           it "returns a 200" do
             expect(subject.status).to eq 200
@@ -26,7 +25,7 @@ module PactBroker
           end
 
           it "returns a link to itself" do
-            expect(parsed_response_body["_links"]["self"]["href"]).to eq "http://example.org/diagnostic/status/heartbeat"
+            expect(parsed_response_body["_links"]["self"]["href"]).to eq "http://pact-broker/diagnostic/status/heartbeat"
           end
         end
       end

data/spec/lib/pact_broker/domain/index_item_spec.rb

@@ -13,7 +13,7 @@ module PactBroker
           allow(webhook_executions).to receive(:sort).and_return(webhook_executions)
         end
 
-        subject { IndexItem.create(nil, nil, nil, true, nil, [], webhook_executions) }
+        subject { IndexItem.create(nil, nil, nil, nil, true, nil, [], webhook_executions) }
 
         it "returns the created_at date of the last execution" do
           expect(subject.last_webhook_execution_date).to eq DateTime.new(2015)

data/spec/lib/pact_broker/domain/version_spec.rb

@@ -1,4 +1,5 @@
 require "pact_broker/domain/version"
+require "pact_broker/db/clean/selector"
 
 module PactBroker
   module Domain
@@ -131,7 +132,7 @@ module PactBroker
               .create_consumer_version("3", tag_names: %w{master})
           end
 
-          let(:selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "master", max_age: max_age) }
+          let(:selector) { PactBroker::DB::Clean::Selector.new(tag: "master", max_age: max_age) }
 
           let(:max_age) { 3 }
           let(:four_days_ago) { Date.today - 4 }
@@ -141,6 +142,76 @@ module PactBroker
           end
         end
 
+        context "when selecting the latest version for each branch" do
+          before do
+            td.create_consumer("Foo")
+              .create_consumer_version("1", branch: "main")
+              .create_consumer_version("2", branch: "main")
+              .create_consumer("Bar")
+              .create_consumer_version("3", branch: "main")
+          end
+
+          let(:selector) { PactBroker::DB::Clean::Selector.new(branch: true, latest: true) }
+
+          it "selects the consumer versions that are the latest for their branches" do
+            expect(version_numbers).to eq %w{2 3}
+          end
+        end
+
+        context "when selecting all versions with a branch" do
+          before do
+            td.create_consumer("Foo")
+              .create_consumer_version("1", branch: "main")
+              .create_consumer_version("2")
+              .create_consumer("Bar")
+              .create_consumer_version("3", branch: "main")
+          end
+
+          let(:selector) { PactBroker::DB::Clean::Selector.new(branch: true, latest: true) }
+
+          it "selects the consumer versions that are the latest for their branches" do
+            expect(version_numbers).to eq %w{1 3}
+          end
+        end
+
+        context "when selecting the latest versions from the main branches" do
+          before do
+            td.create_consumer("Foo", main_branch: "main")
+              .create_consumer_version("1", branch: "main")
+              .create_consumer_version("2", branch: "main")
+              .create_consumer_version("3", branch: "not-main")
+              .create_consumer("Bar", main_branch: "develop")
+              .create_consumer_version("4", branch: "develop")
+              .create_consumer_version("5", branch: "develop")
+              .create_consumer_version("6", branch: "main")
+          end
+
+          let(:selector) { PactBroker::DB::Clean::Selector.new(main_branch: true, latest: true) }
+
+          it "selects the consumer versions that are the latest for their branches" do
+            expect(version_numbers).to eq %w{2 5}
+          end
+        end
+
+        context "when selecting all versions from the main branches" do
+          before do
+            td.create_consumer("Foo", main_branch: "main")
+              .create_consumer_version("1", branch: "main")
+              .create_consumer_version("2", branch: "main")
+              .create_consumer_version("3", branch: "not-main")
+              .create_consumer("Bar", main_branch: "develop")
+              .create_consumer_version("4", branch: "develop")
+              .create_consumer_version("5", branch: "develop")
+              .create_consumer_version("6", branch: "main")
+          end
+
+          let(:selector) { PactBroker::DB::Clean::Selector.new(main_branch: true) }
+
+          it "selects the consumer versions that are the latest for their branches" do
+            expect(version_numbers).to eq %w{1 2 4 5}
+          end
+        end
+
         context "when selecting all versions of a pacticipant currently deployed to an environment" do
           let(:selector) { PactBroker::Matrix::UnresolvedSelector.new(environment_name: "prod", pacticipant_name: "Foo") }
 
@@ -194,6 +265,60 @@ module PactBroker
           end
         end
 
+        context "when selecting all currently deployed versions" do
+          let(:selector) { PactBroker::DB::Clean::Selector.new(deployed: true) }
+
+          before do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_consumer_version("1")
+              .create_deployed_version_for_consumer_version(target: "1")
+              .create_consumer_version("2")
+              .create_environment("prod")
+              .create_deployed_version_for_consumer_version(target: "2")
+              .create_consumer_version("3")
+              .create_consumer_version("5")
+              .create_consumer("Bar")
+              .create_consumer_version("10")
+              .create_deployed_version_for_consumer_version(target: "3")
+              .create_consumer_version("11")
+              .create_deployed_version_for_consumer_version(currently_deployed: false)
+              .create_consumer_version("12")
+              .create_released_version_for_consumer_version
+          end
+
+          it "returns the versions that are currently deployed" do
+            expect(version_numbers).to eq %w{1 2 10}
+          end
+        end
+
+        context "when selecting all currently released+supported versions" do
+          let(:selector) { PactBroker::DB::Clean::Selector.new(released: true) }
+
+          before do
+            td.create_environment("test")
+              .create_consumer("Foo")
+              .create_consumer_version("1")
+              .create_released_version_for_consumer_version
+              .create_consumer_version("2")
+              .create_environment("prod")
+              .create_released_version_for_consumer_version
+              .create_consumer_version("3")
+              .create_consumer_version("5")
+              .create_consumer("Bar")
+              .create_consumer_version("10")
+              .create_released_version_for_consumer_version
+              .create_consumer_version("11")
+              .create_released_version_for_consumer_version(currently_supported: false)
+              .create_consumer_version("12")
+              .create_deployed_version_for_consumer_version
+          end
+
+          it "returns the versions that are currently released+supported" do
+            expect(version_numbers).to eq %w{1 2 10}
+          end
+        end
+
         context "selecting versions for a branch" do
           before do
             td.create_consumer("Foo")
@@ -277,40 +402,6 @@ module PactBroker
         end
       end
 
-      describe "latest_version_for_branch" do
-        before do
-          td.create_consumer("Foo")
-            .create_consumer_version("1", branch: "main")
-            .create_consumer_version("2", branch: "main")
-            .create_consumer_version("3", branch: "feat/x")
-            .create_consumer_version("4", branch: "feat/x")
-            .create_consumer_version("5")
-        end
-
-        subject { Version.order(:order) }
-
-        it "lazy loads" do
-          expect(subject.all[0].latest_version_for_branch.number).to eq "2"
-          expect(subject.all[2].latest_version_for_branch.number).to eq "4"
-          expect(subject.all[4].latest_version_for_branch).to eq nil
-        end
-
-        it "eager loads" do
-          all = subject.eager(:latest_version_for_branch).all
-
-          expect(all[0].associations[:latest_version_for_branch]).to_not be nil
-          expect(all[1].associations[:latest_version_for_branch]).to_not be nil
-          expect(all[2].associations[:latest_version_for_branch]).to_not be nil
-          expect(all[3].associations[:latest_version_for_branch]).to_not be nil
-          expect(all[4].associations.fetch(:latest_version_for_branch)).to be nil
-
-          expect(all[0].latest_version_for_branch.number).to eq "2"
-          expect(all[1].latest_version_for_branch.number).to eq "2"
-          expect(all[2].latest_version_for_branch.number).to eq "4"
-          expect(all[4].latest_version_for_branch).to eq nil
-        end
-      end
-
       describe "#latest_pact_publication" do
         let!(:pact) do
           TestDataBuilder.new
@@ -367,7 +458,7 @@ module PactBroker
         context "when there is no branch" do
           let(:version) { Version.for("Foo", "3") }
 
-          it { is_expected.to be nil }
+          it { is_expected.to be false }
         end
       end