pact_broker 2.89.1 → 2.93.0

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

@@ -1,84 +0,0 @@
-require "spec_helper"
-require "spec/support/test_data_builder"
-require "pact_broker/domain/order_versions.rb"
-
-describe PactBroker::Domain::OrderVersions do
-
-  before do
-    allow(PactBroker.configuration).to receive(:order_versions_by_date).and_return(false)
-  end
-  context "when order_versions_by_date is false (the default)" do
-    before do
-      TestDataBuilder.new
-        .create_condor
-        .create_consumer_version("1.5.0")
-        .create_consumer_version("1.4.0")
-        .create_consumer_version("1.3.0")
-        .create_consumer_version("1.6.0")
-    end
-
-    let(:ordered_versions) { PactBroker::Domain::Version.order(:order).all.collect(&:number) }
-
-    it "orders the versions semantically" do
-      expect(ordered_versions).to eq(["1.3.0", "1.4.0", "1.5.0", "1.6.0"])
-    end
-  end
-
-  context "when order_versions_by_date is true (recommended)" do
-    before do
-      allow(PactBroker.configuration).to receive(:order_versions_by_date).and_return(true)
-    end
-    let(:consumer) { TestDataBuilder.new.create_consumer.and_return(:consumer) }
-    let!(:version_1) { PactBroker::Domain::Version.create(pacticipant_id: consumer.id, number: "2") }
-    let!(:version_2) { PactBroker::Domain::Version.create(pacticipant_id: consumer.id, number: "1") }
-    let!(:version_3) { PactBroker::Domain::Version.create(pacticipant_id: consumer.id, number: "3") }
-    let!(:version_4) { PactBroker::Domain::Version.create(pacticipant_id: consumer.id, number: "4") }
-
-    let(:ordered_versions) { PactBroker::Domain::Version.order(:order).all.collect(&:number) }
-
-    it "orders by insertion order" do
-      expect(ordered_versions).to eq(["2", "1", "3", "4"])
-    end
-
-  end
-
-  context "when an existing version number in the database that Versionomy could parse cannot be parsed by SemVer" do
-    let!(:consumer) do
-      TestDataBuilder.new
-        .create_consumer
-        .create_consumer_version("1")
-        .create_consumer_version("2")
-        .create_consumer_version("3")
-        .create_consumer_version("4")
-        .and_return(:consumer)
-    end
-
-    let(:ordered_versions) { PactBroker::Domain::Version.order(:order).all.collect(&:number) }
-
-    context "when the new version is considered to be the latest" do
-      before do
-        Sequel::Model.db[:versions].where(number: "1").update(number: "z")
-        Sequel::Model.db[:versions].where(number: "2").update(number: "a")
-        Sequel::Model.db[:versions].where(number: "4").update(number: "h")
-      end
-
-      it "just uses the next order number for the new version" do
-        PactBroker::Domain::Version.create(number: "5", pacticipant_id: consumer.id)
-        expect(ordered_versions).to eq(["z", "a", "3", "h", "5"])
-      end
-    end
-
-    context "when the new version is considered to be earlier than the previous latest version" do
-      before do
-        Sequel::Model.db[:versions].where(number: "2").update(number: "z")
-        Sequel::Model.db[:versions].where(number: "3").update(number: "a")
-      end
-
-      it "inserts the new version in the right place" do
-        # 1 z a 4
-        PactBroker::Domain::Version.create(number: "2", pacticipant_id: consumer.id)
-        expect(ordered_versions).to eq(["1", "z", "a", "2", "4"])
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-require "pact_broker/domain/pact"
-
-module PactBroker
-  module Domain
-    describe Pact do
-      describe "latest_verification" do
-        context "when it has been set to an object" do
-          subject { Pact.new(latest_verification: "verification") }
-
-          its(:latest_verification) { is_expected.to eq "verification" }
-        end
-
-        context "when it has been set to nil" do
-          subject { Pact.new(latest_verification: nil) }
-
-          its(:latest_verification) { is_expected.to eq nil }
-        end
-
-        context "when it has not been set" do
-          it "raises an error" do
-            expect { Pact.new.latest_verification.foo }.to raise_error UnsetAttributeError
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,134 +0,0 @@
-require "pact_broker/domain/tag"
-
-module PactBroker
-  module Domain
-    describe Tag do
-
-      describe "#latest_tags_for_pacticipant_ids" do
-        before do
-          td.create_consumer("foo")
-            .create_consumer_version("1")
-            .create_consumer_version_tag("dev")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version("2")
-            .create_consumer_version_tag("dev")
-            .create_consumer_version_tag("bloop")
-            .create_consumer_version("3")
-            .create_consumer_version_tag("dev")
-            .create_consumer("bar")
-            .create_consumer_version("1")
-            .create_consumer_version_tag("test")
-        end
-
-        it "returns the latest tags for the given pacticipant ids" do
-          pacticipant = PactBroker::Domain::Pacticipant.order(:id).first
-          tags = Tag.latest_tags_for_pacticipant_ids([pacticipant.id]).all
-          expect(tags.collect(&:name).sort).to eq %w{bloop dev prod}
-          expect(tags.find{ |t| t.name == "dev" }.version.number).to eq "3"
-          expect(tags.find{ |t| t.name == "prod" }.version.number).to eq "1"
-          expect(tags.find{ |t| t.name == "bloop" }.version.number).to eq "2"
-          expect(tags.collect(&:version_id).compact.size).to eq 3
-          expect(tags.collect(&:created_at).compact.size).to eq 3
-        end
-      end
-
-      describe "latest_tags" do
-        before do
-          td.create_consumer("foo")
-            .create_consumer_version("1")
-            .create_consumer_version_tag("dev")
-            .create_consumer_version_tag("prod")
-            .create_consumer_version("2")
-            .create_consumer_version_tag("dev")
-            .create_consumer_version_tag("bloop")
-            .create_consumer_version("3")
-            .create_consumer_version_tag("dev")
-            .create_consumer("bar")
-            .create_consumer_version("1")
-            .create_consumer_version_tag("test")
-        end
-
-        it "returns the tags that belong to the most recent version with that tag/pacticipant" do
-          tags = Tag.latest_tags.all
-          expect(tags.collect(&:name).sort).to eq %w{bloop dev prod test}
-          expect(tags.find{ |t| t.name == "dev" }.version.number).to eq "3"
-          expect(tags.find{ |t| t.name == "prod" }.version.number).to eq "1"
-          expect(tags.find{ |t| t.name == "bloop" }.version.number).to eq "2"
-          expect(tags.collect(&:version_id).compact.size).to eq 4
-          expect(tags.collect(&:created_at).compact.size).to eq 4
-        end
-      end
-
-      describe "latest_for_pacticipant?" do
-        before do
-          # Foo v1 Bar1
-          # Foo v1 Bar2
-          # Foo v2 Bar1
-          td.create_pact_with_verification_and_tags("Foo", "1", ["dev", "prod"], "Bar1")
-            .create_provider("Bar2")
-            .create_pact
-            .create_pact_with_verification_and_tags("Foo", "2", ["dev"], "Bar1")
-            .create_consumer_version("3")
-            .create_consumer_version_tag("dev")
-        end
-
-        it "returns true if there are no other tags with that name for that pacticipant for a later version" do
-          version_1 = PactBroker::Versions::Repository.new.find_by_pacticipant_name_and_number("Foo", "1")
-          expect(version_1.tags.find { |t| t.name == "prod" }.latest_for_pacticipant?).to be true
-          expect(version_1.tags.find { |t| t.name == "dev" }.latest_for_pacticipant?).to be false
-        end
-      end
-
-      describe "head_tags_for_pact_publication" do
-        before do
-          # Foo v1 Bar1
-          # Foo v1 Bar2
-          # Foo v2 Bar1
-          td.create_pact_with_verification_and_tags("Foo", "1", ["dev", "prod"], "Bar1")
-            .create_provider("Bar2")
-            .create_pact
-            .create_pact_with_verification_and_tags("Foo", "2", ["dev"], "Bar1")
-            .create_consumer_version("3")
-            .create_consumer_version_tag("dev")
-        end
-
-        it "returns the names of the tags for which this pact publication is the latest" do
-          pact_0 = PactBroker::Pacts::PactPublication.find(id: PactBroker::Pacts::Repository.new.find_pact("Foo", "1", "Bar1").id)
-          expect(pact_0.consumer_version.tags.collect(&:name).sort).to eq ["dev", "prod"]
-          expect(Tag.head_tags_for_pact_publication(pact_0).collect(&:name).sort).to eq ["prod"]
-
-          pact_1 = PactBroker::Pacts::PactPublication.find(id: PactBroker::Pacts::Repository.new.find_pact("Foo", "2", "Bar1").id)
-          expect(Tag.head_tags_for_pact_publication(pact_1).collect(&:name).sort).to eq ["dev"]
-
-          pact_2 = PactBroker::Pacts::PactPublication.find(id: PactBroker::Pacts::Repository.new.find_pact("Foo", "1", "Bar2").id)
-          expect(Tag.head_tags_for_pact_publication(pact_2).collect(&:name).sort).to eq ["dev", "prod"]
-        end
-      end
-
-      describe "head_tag" do
-        before do
-          td.create_consumer("Foo")
-            .create_consumer_version("1", tag_names: ["main", "test"])
-            .create_consumer_version("2", tag_names: ["main", "test"])
-            .create_consumer_version("3", tag_names: ["main"])
-            .create_provider("Bar")
-            .create_provider_version("1", tag_names: ["main", "test"])
-            .create_provider_version("2", tag_names: ["main", "test"])
-            .create_provider_version("3", tag_names: ["main"])
-        end
-
-        it "lazy loads" do
-          expect(Tag.for("Foo", "2", "main").head_tag).to eq Tag.for("Foo", "3", "main")
-          expect(Tag.for("Foo", "3", "main").head_tag).to eq Tag.for("Foo", "3", "main")
-          expect(Tag.for("Bar", "1", "test").head_tag).to eq Tag.for("Bar", "2", "test")
-        end
-
-        it "eager loads" do
-          tags = Tag.order(:version_order, :name).eager(:head_tag).all
-          expect(tags[0].head_tag).to eq Tag.for("Foo", "3", "main")
-          expect(tags[1].head_tag).to eq Tag.for("Foo", "2", "test")
-        end
-      end
-    end
-  end
-end

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

@@ -1,133 +0,0 @@
-require "pact_broker/domain/verification"
-
-module PactBroker
-
-  module Domain
-    describe Verification do
-      describe "latest_by_pact_version" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "10", "Bar")
-            .create_verification(provider_version: "3", number: 1)
-            .create_verification(provider_version: "4", number: 2)
-            .create_pact_with_hierarchy("Foo2", "10", "Bar2")
-            .create_verification(provider_version: "30", number: 1)
-            .create_verification(provider_version: "31", number: 2)
-        end
-
-        subject { Verification.latest_by_pact_version.order(:id).all }
-
-        it "returns the latest by pact version" do
-          expect(subject.size).to eq 2
-          expect(subject.collect(&:provider_version_number).sort).to eq ["31", "4"]
-        end
-      end
-      describe "latest_verifications_for_all_consumer_version_tags" do
-        before do
-          td.create_pact_with_verification_and_tags("Foo", "1", ["fmain"], "Bar", "2")
-            .create_pact_with_verification_and_tags("Foo", "3", ["fmain"], "Bar", "4")
-            .create_pact_with_verification_and_tags("Foo", "5", ["fmain"], "Bar", "5")
-            .create_pact_with_verification_and_tags("Foo", "6", ["other"], "Bar", "5")
-            .create_pact_with_verification_and_tags("Foo2", "6", ["fprod"], "Bar", "7")
-            .create_pact_with_verification_and_tags("Ignored", "6", ["fmain"], "Bar", "8")
-        end
-
-        subject { Verification.latest_verifications_for_all_consumer_version_tags.all }
-
-        it "returns the same number of rows as the view" do
-          expect(subject.size).to eq Verification.db[:latest_verifications_for_consumer_version_tags].count
-        end
-
-        it "allows eager" do
-          expect(Verification.latest_verifications_for_all_consumer_version_tags.eager(:provider_version).all.first.provider_version.number).to_not be nil
-        end
-      end
-
-      describe "latest_verifications_for_consumer_version_tags" do
-        before do
-          td.create_pact_with_verification_and_tags("Foo", "1", ["fmain"], "Bar", "2")
-            .create_pact_with_verification_and_tags("Foo", "3", ["fmain"], "Bar", "4")
-            .create_pact_with_verification_and_tags("Foo", "5", ["fmain"], "Bar", "5")
-            .create_pact_with_verification_and_tags("Foo", "6", ["other"], "Bar", "5")
-            .create_pact_with_verification_and_tags("Foo2", "6", ["fprod"], "Bar", "7")
-            .create_pact_with_verification_and_tags("Ignored", "6", ["fmain"], "Bar", "8")
-        end
-
-        let(:consumer_ids) { PactBroker::Domain::Pacticipant.where(name: ["Foo", "Foo2"]).all.collect(&:id) }
-
-        subject { Verification.latest_verifications_for_consumer_version_tags(consumer_ids, ["fmain", "fprod"]).order(:id) }
-
-        it "returns the latest verifications for the given consumer ids and consumer version tag names" do
-          expect(subject.first.provider_version_number).to eq "5"
-          expect(subject.first.consumer_name).to eq "Foo"
-          expect(subject.first.consumer_version_tag_name).to eq "fmain"
-          expect(subject.last.provider_version_number).to eq "7"
-          expect(subject.last.consumer_name).to eq "Foo2"
-          expect(subject.last.consumer_version_tag_name).to eq "fprod"
-        end
-
-        it "allows eager" do
-          expect(subject.eager(:provider_version).all.first.provider_version.number).to eq "5"
-        end
-      end
-
-      describe "delete" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_verification_webhook
-            .create_verification(provider_version: "2")
-            .create_triggered_webhook
-            .create_webhook_execution
-        end
-
-        it "deletes stuff" do
-          Verification.delete
-        end
-      end
-
-      describe "#save" do
-        let!(:verification) do
-          TestDataBuilder.new
-            .create_pact_with_hierarchy("A", "1", "B")
-            .create_verification(test_results: {"some" => "thing"})
-            .and_return(:verification)
-        end
-
-        it "saves and loads the test_results" do
-          expect(Verification.find(id: verification.id).test_results).to eq({ "some" => "thing" })
-        end
-      end
-
-      describe "#consumer" do
-        let!(:consumer) do
-          TestDataBuilder.new
-            .create_consumer
-            .create_provider
-            .create_consumer_version
-            .create_pact
-            .create_verification
-            .and_return(:consumer)
-        end
-
-        it "returns the consumer for the verification" do
-          expect(Verification.order(:id).first.consumer).to eq consumer
-        end
-      end
-
-      describe "#provider" do
-        let!(:provider) do
-          TestDataBuilder.new
-            .create_consumer
-            .create_provider
-            .create_consumer_version
-            .create_pact
-            .create_verification
-            .and_return(:provider)
-        end
-
-        it "returns the provider for the verification" do
-          expect(Verification.order(:id).first.provider).to eq provider
-        end
-      end
-    end
-  end
-end