pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/verifications/repository_spec.rb

@@ -1,350 +0,0 @@
-require "pact_broker/verifications/repository"
-
-module PactBroker
-  module Verifications
-    describe Repository do
-      describe "#create" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar").and_return(:pact)
-        end
-
-        let(:verification) do
-          PactBroker::Domain::Verification.new(
-            success: true,
-            consumer_version_selector_hashes: [{ foo: "bar" }]
-          )
-        end
-
-        let(:provider_version_number) { "2" }
-        let(:pact_version) do
-          PactBroker::Pacts::PactVersion.first
-        end
-
-        subject { Repository.new.create(verification, provider_version_number, pact_version) }
-
-        it "creates a LatestVerificationIdForPactVersionAndProviderVersion" do
-          expect { subject }.to change { LatestVerificationIdForPactVersionAndProviderVersion.count }.by(1)
-        end
-
-        it "sets the created_at of the LatestVerificationIdForPactVersionAndProviderVersion to the same as the verification" do
-          expect(subject.created_at).to eq LatestVerificationIdForPactVersionAndProviderVersion.first.created_at
-        end
-
-        context "when the provider version already exists" do
-          before do
-            td.create_provider_version(provider_version_number, tag_names: ["foo", "bar"], branch: "main")
-          end
-
-          it "sets the tag names" do
-            expect(subject.reload.tag_names.sort).to eq ["bar", "foo"]
-          end
-
-          it "saves the consumer_version_selector_hashes" do
-            expect(subject.reload.consumer_version_selector_hashes).to eq [{ foo: "bar" }]
-          end
-        end
-      end
-
-      describe "#find" do
-        let!(:pact) do
-
-          pact = td
-            .create_provider("Provider1")
-            .create_consumer("Consumer1")
-            .create_consumer_version("1.0.0")
-            .create_pact
-            .and_return(:pact)
-
-          td.create_verification(number: 1)
-            .create_verification(number: 2, provider_version: "3.7.4")
-            .create_consumer_version("1.2.3")
-            .create_pact
-            .create_verification(number: 1)
-
-          td.create_provider("Provider3")
-            .create_consumer("Consumer2")
-            .create_consumer_version("1.2.3")
-            .create_pact
-            .create_verification(number: 1)
-          pact
-        end
-
-        subject { Repository.new.find "Consumer1", "Provider1", pact.pact_version_sha, 2}
-
-        it "finds the latest verifications for the given consumer version" do
-          expect(subject.provider_version_number).to eq "3.7.4"
-          expect(subject.consumer_name).to eq "Consumer1"
-          expect(subject.provider_name).to eq "Provider1"
-          expect(subject.pact_version_sha).to eq pact.pact_version_sha
-        end
-      end
-
-      describe "#find_latest_verifications_for_consumer_version" do
-        before do
-          td.create_provider("Provider1")
-            .create_consumer("Consumer1")
-            .create_consumer_version("1.0.0")
-            .create_pact
-            .create_verification(number: 1)
-            .create_consumer_version("1.2.3")
-            .create_pact
-            .create_verification(number: 1)
-            .create_verification(number: 2, provider_version: "7.8.9")
-            .create_provider("Provider2")
-            .create_pact
-            .create_verification(number: 1, provider_version: "6.5.4")
-
-          td.create_provider("Provider3")
-            .create_consumer("Consumer2")
-            .create_consumer_version("1.2.3")
-            .create_pact
-            .create_verification(number: 1)
-        end
-
-        subject { Repository.new.find_latest_verifications_for_consumer_version("Consumer1", "1.2.3")}
-
-        it "finds the latest verifications for the given consumer version" do
-          expect(subject.first.provider_version_number).to eq "7.8.9"
-          expect(subject.last.provider_version_number).to eq "6.5.4"
-        end
-      end
-
-      describe "#search_for_latest" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_verification(provider_version: "2")
-            .create_verification(provider_version: "3", number: 2)
-            .create_provider("Wiffle")
-            .create_pact
-            .create_verification(provider_version: "4")
-        end
-
-        context "with just the consumer name" do
-          subject { Repository.new.search_for_latest("Foo", nil) }
-
-          its(:provider_version_number) { is_expected.to eq "4" }
-        end
-
-        context "with the consumer and provider name" do
-          subject { Repository.new.search_for_latest("Foo", "Bar") }
-
-          its(:provider_version_number) { is_expected.to eq "3" }
-        end
-
-        context "with just the provider name" do
-          subject { Repository.new.search_for_latest(nil, "Bar") }
-
-          its(:provider_version_number) { is_expected.to eq "3" }
-        end
-
-        context "with neither name" do
-          subject { Repository.new.search_for_latest(nil, nil) }
-
-          its(:provider_version_number) { is_expected.to eq "4" }
-        end
-      end
-
-      describe "#find_latest_verification_for" do
-        context "when there is a revision" do
-          before do
-            td.create_provider("Provider1")
-              .create_consumer("Consumer1")
-              .create_consumer_version("1.2.3")
-              .create_pact
-              .create_verification(number: 1, provider_version: "2.3.4")
-              .revise_pact
-              .create_verification(number: 1, provider_version: "7.8.9")
-          end
-
-          subject { Repository.new.find_latest_verification_for("Consumer1", "Provider1")}
-
-          it "finds the latest verifications for the given consumer version" do
-            expect(subject.provider_version_number).to eq "7.8.9"
-          end
-        end
-
-        context "when no tag is specified" do
-          before do
-            PactBroker.configuration.order_versions_by_date = false
-            td.create_provider("Provider1")
-              .create_consumer("Consumer1")
-              .create_consumer_version("1.2.3")
-              .create_pact
-              .create_verification(number: 1, provider_version: "2.3.4")
-              .create_verification(number: 2, provider_version: "7.8.9")
-              .create_consumer_version("1.0.0")
-              .create_pact
-              .create_verification(number: 1, provider_version: "5.4.3")
-              .create_provider("Provider2")
-              .create_pact
-              .create_verification(number: 1, provider_version: "6.5.4")
-              .create_consumer_version("2.0.0")
-              .create_pact
-          end
-
-          subject { Repository.new.find_latest_verification_for("Consumer1", "Provider1")}
-
-          it "finds the latest verifications for the given consumer version" do
-            expect(subject.provider_version_number).to eq "7.8.9"
-          end
-        end
-
-        context "when a tag is specified" do
-          before do
-            td.create_provider("Provider1")
-              .create_consumer("Consumer1")
-              .create_consumer_version("1.0.0")
-              .create_consumer_version_tag("prod")
-              .create_pact
-              .create_verification(number: 1, provider_version: "1.0.0")
-              .create_verification(number: 2, provider_version: "5.4.3")
-              .create_consumer_version("1.1.0")
-              .create_consumer_version_tag("prod")
-              .create_pact
-              .create_consumer_version("1.2.3")
-              .create_pact
-              .create_verification(number: 1, provider_version: "2.3.4")
-              .create_verification(number: 2, provider_version: "7.8.9")
-              .create_provider("Provider2")
-              .create_pact
-              .create_verification(number: 1, provider_version: "6.5.4")
-              .create_consumer_version("2.0.0")
-              .create_pact
-          end
-
-          subject { Repository.new.find_latest_verification_for("Consumer1", "Provider1", "prod")}
-
-          it "finds the latest verifications for the given consumer version with the specified tag" do
-            expect(subject.provider_version_number).to eq "5.4.3"
-          end
-
-          context "when no verification exists" do
-            subject { Repository.new.find_latest_verification_for("Consumer1", "Provider1", "foo")}
-
-            it "returns nil" do
-              expect(subject).to be nil
-            end
-          end
-        end
-
-        context "when the latest untagged verification is required" do
-          before do
-            td.create_provider("Provider1")
-              .create_consumer("Consumer1")
-              .create_consumer_version("1.0.0")
-              .create_pact
-              .create_verification(number: 1, provider_version: "1.0.0")
-              .create_verification(number: 2, provider_version: "5.4.3")
-              .create_consumer_version("1.1.0")
-              .create_consumer_version_tag("prod")
-              .create_pact
-              .create_consumer_version("1.2.3")
-              .create_consumer_version_tag("prod")
-              .create_pact
-              .create_verification(number: 1, provider_version: "2.3.4")
-              .create_verification(number: 2, provider_version: "7.8.9")
-              .create_provider("Provider2")
-              .create_pact
-              .create_verification(number: 1, provider_version: "6.5.4")
-              .create_consumer_version("2.0.0")
-              .create_pact
-          end
-
-          subject { Repository.new.find_latest_verification_for("Consumer1", "Provider1", :untagged)}
-
-          it "finds the latest verifications for the given consumer version with no tag" do
-            expect(subject.provider_version_number).to eq "5.4.3"
-          end
-        end
-      end
-
-      describe "find_latest_verification_for_tags" do
-        context "with no revisions" do
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar")
-              .create_consumer_version_tag("feat-x")
-              .create_verification(provider_version: "5")
-              .use_provider_version("5")
-              .create_provider_version_tag("feat-y")
-              .create_verification(provider_version: "6", number: 2)
-              .use_provider_version("6")
-              .create_provider_version_tag("feat-y")
-              .create_verification(provider_version: "7", number: 3)
-              .create_consumer_version("2")
-              .create_pact
-              .create_verification(provider_version: "8")
-          end
-
-          subject { Repository.new.find_latest_verification_for_tags("Foo", "Bar", "feat-x", "feat-y") }
-
-          it "returns the latest verification for a pact with the given consumer tag, by a provider version with the given provider tag" do
-            expect(subject.provider_version_number).to eq "6"
-          end
-        end
-
-        context "when a verification exists for a pact revision that was then overwritten by a new revision of the pact" do
-          let(:content_1) { { content: 1 }.to_json }
-          let(:content_2) { { content: 2 }.to_json }
-
-          before do
-            td.create_pact_with_hierarchy("Foo", "1", "Bar", content_1)
-              .create_consumer_version_tag("develop")
-              .create_verification(provider_version: "5", number: 1, tag_name: "develop", comment: "not this because pact revised")
-              .create_verification(provider_version: "6", number: 2, tag_name: "develop", comment: "not this because pact revised")
-              .revise_pact(content_2)
-              .create_verification(provider_version: "1", number: 1, tag_name: "develop", comment: "not this because later one exists")
-              .create_verification(provider_version: "2", number: 2, tag_name: "develop", comment: "this one!")
-              .create_consumer_version("2")
-              .create_pact(json_content: content_1)
-          end
-
-          subject { Repository.new.find_latest_verification_for_tags("Foo", "Bar", "develop", "develop") }
-
-          it "returns the latest verification " do
-            expect(subject.provider_version_number).to eq "2"
-            expect(subject.number).to eq 2
-          end
-        end
-
-        context "when the consumer does not exist" do
-          subject { Repository.new.find_latest_verification_for_tags("Foo", "Bar", "feat-x", "feat-y") }
-
-          it "raises an error" do
-            expect{ subject }.to raise_error PactBroker::Error, /Foo/
-          end
-        end
-
-        context "when the provider does not exist" do
-          before do
-            td.create_consumer("Foo")
-          end
-
-          subject { Repository.new.find_latest_verification_for_tags("Foo", "Bar", "feat-x", "feat-y") }
-
-          it "raises an error" do
-            expect{ subject }.to raise_error PactBroker::Error, /Bar/
-          end
-        end
-      end
-
-      describe "delete_by_provider_version_id" do
-        let!(:provider_version) do
-          td.create_consumer
-            .create_provider
-            .create_consumer_version
-            .create_pact
-            .create_verification(provider_version: "1.0.0")
-            .create_verification(provider_version: "2.0.0", number: 2)
-            .create_verification(provider_version: "2.0.0", number: 3)
-            .and_return(:provider_version)
-        end
-
-        subject { Repository.new.delete_by_provider_version_id(provider_version.id) }
-
-        it "deletes the verifications associated with the given version id" do
-          expect { subject }.to change { PactBroker::Domain::Verification.count }.by(-2)
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/verifications/sequence_spec.rb

@@ -1,73 +0,0 @@
-require "pact_broker/verifications/sequence"
-
-module PactBroker
-  module Verifications
-    describe Sequence do
-      describe "#next_val", migration: true do
-        context "for proper databases with proper sequences", skip: !::DB.postgres? do
-          it "increments the value each time" do
-            PactBroker::Database.migrate
-            expect(Sequence.next_val).to eq 200
-            expect(Sequence.next_val).to eq 201
-          end
-
-          it "can rollback without duplicating a sequence number" do
-            PactBroker::Database.migrate
-            row = database.from(:verification_sequence_number).select(:value).limit(1).first
-            expect(row[:value]).to eq 100
-            Sequence.next_val
-            PactBroker::Database.migrate(20201006)
-            row = database.from(:verification_sequence_number).select(:value).limit(1).first
-            expect(row[:value]).to eq 301
-          end
-
-          it "can deal with there not being an existing value in the verification_sequence_number table" do
-            PactBroker::Database.migrate(20201006)
-            database.from(:verification_sequence_number).delete
-            PactBroker::Database.migrate
-            expect(Sequence.next_val).to eq 1
-          end
-        end
-
-        context "for databases without sequences", skip: ::DB.postgres? do
-          before do
-            PactBroker::Database.migrate
-          end
-
-          context "when there is a row in the verification_sequence_number table" do
-            before do
-              Sequence.select_all.delete
-              Sequence.insert(value: 1)
-            end
-
-            it "increments the value and returns it" do
-              expect(Sequence.next_val).to eq 2
-            end
-          end
-
-          context "when there is no row in the verification_sequence_number table and no existing verifications" do
-            before do
-              Sequence.select_all.delete
-            end
-
-            it "inserts and returns the value 1" do
-              expect(Sequence.next_val).to eq 1
-            end
-          end
-
-          context "when there is no row in the verification_sequence_number table and there are existing verifications" do
-            before do
-              Sequence.select_all.delete
-              TestDataBuilder.new.create_pact_with_hierarchy("A", "1", "B")
-                .create_verification(provider_version: "2")
-            end
-
-            it "inserts a number that is guaranteed to be higher than any of the existing verification numbers from when we tried to do this without a sequence" do
-              expect(Sequence.next_val).to eq 101
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,266 +0,0 @@
-require "pact_broker/verifications/service"
-require "pact_broker/verifications/repository"
-require "pact_broker/webhooks/execution_configuration"
-require "pact_broker/webhooks/trigger_service"
-
-module PactBroker
-  module Verifications
-    describe Service do
-      before do
-        allow(Service).to receive(:logger).and_return(logger)
-      end
-
-      let(:logger) { double("logger").as_null_object }
-
-      subject { PactBroker::Verifications::Service }
-
-      describe "#create" do
-        before do
-          allow(Service).to receive(:broadcast)
-        end
-
-        let(:event_context) { { some: "data", consumer_version_selectors: [{ foo: "bar" }] } }
-        let(:expected_event_context) { { some: "data", provider_version_tags: ["dev"] } }
-        let(:params) do
-          {
-            "success" => success,
-            "providerApplicationVersion" => "4.5.6",
-            "wip" => true,
-            "pending" => is_pending,
-            "testResults" => { "some" => "results" },
-            "verifiedBy" => {
-              "implementation" => "Ruby",
-              "version" => "1234"
-            }
-          }
-        end
-        let(:is_pending) { true }
-        let(:success) { true }
-        let(:pact) do
-          td.create_pact_with_hierarchy
-            .create_provider_version("4.5.6")
-            .create_provider_version_tag("dev")
-            .and_return(:pact)
-        end
-        let(:selected_pacts) { [PactBroker::Pacts::SelectedPact.new(pact, PactBroker::Pacts::Selectors.new)]}
-        let(:create_verification) { subject.create 3, params, selected_pacts, event_context }
-
-        it "logs the creation" do
-          expect(logger).to receive(:info).with(/.*verification.*3/, payload: hash_including("providerApplicationVersion"=>"4.5.6", "success"=>true, "wip"=>true, "pending" => is_pending))
-          create_verification
-        end
-
-        it "sets the verification attributes" do
-          verification = create_verification
-          expect(verification.wip).to be true
-          expect(verification.pact_pending?).to eq is_pending
-          expect(verification.success).to be true
-          expect(verification.number).to eq 3
-          expect(verification.test_results).to eq "some" => "results"
-          expect(verification.consumer_version_selector_hashes).to eq [{ foo: "bar" }]
-          expect(verification.tag_names).to eq ["dev"]
-          expect(verification.verified_by_implementation).to eq "Ruby"
-          expect(verification.verified_by_version).to eq "1234"
-        end
-
-        it "sets the pact content for the verification" do
-          verification = create_verification
-          expect(verification.pact_version_id).to_not be_nil
-          expect(verification.pact_version).to_not be_nil
-        end
-
-        it "sets the provider version" do
-          verification = create_verification
-          expect(verification.provider_version).to_not be nil
-          expect(verification.provider_version_number).to eq "4.5.6"
-        end
-
-        it "it broadcasts the provider_verification_published event" do
-          expect(Service).to receive(:broadcast).with(:provider_verification_published, pact: pact, verification: instance_of(PactBroker::Domain::Verification), event_context: hash_including(provider_version_tags: %w[dev]))
-          create_verification
-        end
-
-        context "when the verification is successful" do
-          it "it broadcasts the provider_verification_succeeded event" do
-            expect(Service).to receive(:broadcast).with(:provider_verification_succeeded, pact: pact, verification: instance_of(PactBroker::Domain::Verification), event_context: hash_including(provider_version_tags: %w[dev]))
-            create_verification
-          end
-        end
-
-        context "when the verification is not successful" do
-          let(:success) { false }
-
-          it "it broadcasts the provider_verification_failed event" do
-            expect(Service).to receive(:broadcast).with(:provider_verification_failed, pact: pact, verification: instance_of(PactBroker::Domain::Verification), event_context: hash_including(provider_version_tags: %w[dev]))
-            create_verification
-          end
-        end
-
-      end
-
-      describe "#calculate_required_verifications_for_pact" do
-        subject { Service.calculate_required_verifications_for_pact(pact) }
-
-        context "when there is no verification from the latest version from the main branch" do
-          let!(:pact) do
-            td.create_consumer("Foo")
-              .create_provider("Bar", main_branch: "main")
-              .create_provider_version("1", branch: "main")
-              .create_consumer_version("1")
-              .create_pact
-              .and_return(:pact)
-          end
-
-          it "returns the required verification for the main branch" do
-            expect(subject).to contain_exactly(
-              have_attributes(
-                provider_version: td.find_version("Bar", "1"),
-                provider_version_selectors: contain_exactly(
-                  have_attributes(resolved_branch_name: "main", main_branch: true)
-                ),
-                provider_version_descriptions: ["latest from main branch"]
-              )
-            )
-          end
-        end
-
-        context "when there is a verification from the latest version from the main branch" do
-          let!(:pact) do
-            td.create_consumer("Foo")
-              .create_provider("Bar", main_branch: "main")
-              .create_provider_version("1", branch: "main")
-              .create_consumer_version("1")
-              .create_pact
-              .create_verification(provider_version: "2", branch: "main")
-              .and_return(:pact)
-          end
-
-          it "does not return a required verification" do
-            expect(subject).to eq []
-          end
-        end
-
-        context "when there is no verification for a deployed version" do
-          let!(:pact) do
-            td.create_environment("test")
-              .create_consumer("Foo")
-              .create_provider("Bar")
-              .create_provider_version("1")
-              .create_consumer_version("1")
-              .create_pact
-              .create_deployed_version_for_provider_version
-              .and_return(:pact)
-          end
-
-          it "returns the required verification for the deployed version" do
-            expect(subject).to eq [
-              RequiredVerification.new(
-                provider_version: td.find_version("Bar", "1"),
-                provider_version_selectors: PactBroker::Versions::Selectors.new(PactBroker::Versions::Selector.for_currently_deployed),
-                provider_version_descriptions: ["deployed in test"]
-              )
-            ]
-          end
-        end
-
-        context "when there is a verification for a deployed version" do
-          let!(:pact) do
-            td.create_environment("test")
-              .create_consumer("Foo")
-              .create_provider("Bar")
-              .create_provider_version("1")
-              .create_consumer_version("1")
-              .create_pact
-              .create_verification(provider_version: "1")
-              .create_deployed_version_for_provider_version
-              .and_return(:pact)
-          end
-
-          it "does not return a required verification for the deployed version" do
-            expect(subject).to eq []
-          end
-        end
-
-        context "when there is no verification for a released version" do
-          let!(:pact) do
-            td.create_environment("test")
-              .create_consumer("Foo")
-              .create_provider("Bar")
-              .create_provider_version("1")
-              .create_consumer_version("1")
-              .create_pact
-              .create_released_version_for_provider_version
-              .and_return(:pact)
-          end
-
-          it "returns the required verification for the released version" do
-            expect(subject).to eq [
-              RequiredVerification.new(
-                provider_version: td.find_version("Bar", "1"),
-                provider_version_selectors: PactBroker::Versions::Selectors.new(PactBroker::Versions::Selector.for_currently_supported),
-                provider_version_descriptions: ["released in test"]
-              )
-            ]
-          end
-        end
-
-        context "when there is a verification for a released version" do
-          let!(:pact) do
-            td.create_environment("test")
-              .create_consumer("Foo")
-              .create_provider("Bar")
-              .create_provider_version("1")
-              .create_consumer_version("1")
-              .create_pact
-              .create_verification(provider_version: "1")
-              .create_released_version_for_provider_version
-              .and_return(:pact)
-          end
-
-          it "does not return a required verification for the deployed version" do
-            expect(subject).to eq []
-          end
-        end
-
-        context "when the latest version from the main branch is deployed and released and has no verification" do
-          let!(:pact) do
-            td.create_environment("test")
-              .create_consumer("Foo")
-              .create_provider("Bar", main_branch: "main")
-              .create_provider_version("1", branch: "main")
-              .create_consumer_version("1")
-              .create_pact
-              .create_deployed_version_for_provider_version
-              .create_released_version_for_provider_version
-              .and_return(:pact)
-          end
-
-          it "deduplicates the required versions" do
-            expect(subject.size).to eq 1
-            expect(subject.first.provider_version).to eq td.find_version("Bar", "1")
-            expect(subject.first.provider_version_selectors[0]).to have_attributes(main_branch: true, resolved_branch_name: "main")
-            expect(subject.first.provider_version_selectors[1]).to eq PactBroker::Versions::Selector.for_currently_deployed
-            expect(subject.first.provider_version_selectors[2]).to eq PactBroker::Versions::Selector.for_currently_supported
-            expect(subject.first.provider_version_descriptions).to eq [
-                                                                        "latest from main branch",
-                                                                        "deployed in test",
-                                                                        "released in test"
-                                                                      ]
-          end
-        end
-      end
-
-      describe "#errors" do
-        let(:params) { {} }
-
-        it "returns errors" do
-          expect(subject.errors(params)).to_not be_empty
-        end
-
-        it "returns something that responds to :messages" do
-          expect(subject.errors(params).messages).to_not be_empty
-        end
-      end
-    end
-  end
-end