pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/pacts/generate_sha_spec.rb

@@ -1,92 +0,0 @@
-require "pact_broker/pacts/generate_sha"
-
-module PactBroker
-  module Pacts
-    describe GenerateSha do
-      describe ".call integration test" do
-        let(:json_content) do
-          {
-            interactions: [{a: 1, b: 2}, {c: 3, d: 4}],
-            metadata: {
-              pactSpecification: {
-                version: "1"
-              }
-            }
-          }.to_json
-        end
-
-        let(:json_content_with_only_order_difference) do
-          {
-            interactions: [{d: 4, c: 3}, {b: 2, a: 1}],
-            metadata: {
-              :'pact-specification' => {
-                version: "1"
-              }
-            }
-          }.to_json
-        end
-
-        let(:json_content_with_diff_interactions) do
-          {
-            interactions: [{a: 9999, b: 2}, {c: 3, d: 4}],
-            metadata: {
-              pactSpecification: {
-                version: "1"
-              }
-            }
-          }.to_json
-        end
-
-        before do
-          allow(Content).to receive(:from_json).and_return(content)
-          allow(content).to receive(:sort).and_return(content)
-        end
-
-        let(:content) { instance_double("PactBroker::Pacts::Content", content_that_affects_verification_results: content_that_affects_verification_results) }
-        let(:content_that_affects_verification_results) { double("content", to_json: "foo") }
-
-        subject { GenerateSha.call(json_content) }
-
-        it "accepts options in case there is any future requirement for a second argument" do
-          expect{ GenerateSha.call(json_content, some: "options") }.to_not raise_error
-        end
-
-        context "when equality is based on the verifiable content only" do
-          before do
-            PactBroker.configuration.base_equality_only_on_content_that_affects_verification_results = true
-          end
-
-          it "sorts the content" do
-            expect(content).to receive(:sort)
-            subject
-          end
-
-          it "creates the sha from the sorted content JSON" do
-            expect(Digest::SHA1).to receive(:hexdigest).with(content_that_affects_verification_results.to_json)
-            subject
-          end
-
-          it "returns the sha" do
-            expect(subject).to eq "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"
-          end
-        end
-
-        context "when equality is based on the verifiable content only" do
-          it "does not sort the content" do
-            expect(Content).to_not receive(:from_json)
-            subject
-          end
-
-          it "creates the sha from the original JSON" do
-            expect(Digest::SHA1).to receive(:hexdigest).with(json_content)
-            subject
-          end
-
-          it "returns the sha" do
-            expect(subject).to eq "ebc0feee91fb7fc0acf8420426184478ebaf648a"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/pacts/merger_spec.rb

@@ -1,171 +0,0 @@
-require "spec_helper"
-require "spec/support/test_data_builder"
-require "pact_broker/pacts/merger"
-require "json"
-
-module PactBroker
-  module Pacts
-    describe Merger do
-      let(:example_pact) { load_json_fixture("consumer-provider.json") }
-      let(:example_interaction) do
-        {
-          "description" => "some description",
-          "provider_state" => nil,
-          "request" => {
-            "method" => "get",
-            "path" => "/cash_money",
-            "headers" => {
-              "Content-Type" => "application/json"
-            }
-          },
-          "response" => {
-            "status" => 200,
-            "body" => "$$$$$$$$",
-            "headers" => {
-              "Content-Type" => "application/json"
-            }
-          }
-        }
-      end
-
-      describe "#merge" do
-        let(:pact_to_merge) { load_json_fixture("consumer-provider.json") }
-
-        it "merges two pacts" do
-          pact_to_merge["interactions"] << example_interaction
-          result = merge_pacts(example_pact, pact_to_merge)
-          expect(result["interactions"]).to match_array(example_pact["interactions"].push(example_interaction))
-        end
-
-        it "is idempotent" do
-          pact_to_merge["interactions"] << example_interaction
-          first_result = merge_pacts(example_pact, pact_to_merge)
-          second_result = merge_pacts(first_result, pact_to_merge)
-          expect(first_result).to contain_hash second_result
-        end
-
-        it "overwrites identical interactions" do
-          pact_to_merge["interactions"][0]["response"]["body"] = "changed!"
-          result = merge_pacts(example_pact, pact_to_merge)
-
-          expect(result["interactions"].length).to eq example_pact["interactions"].length
-          expect(result["interactions"].first["response"]["body"]).to eq "changed!"
-        end
-
-        it "appends interactions with a different provider state" do
-          pact_to_merge["interactions"][0]["provider_state"] = "upside down"
-
-          result = merge_pacts(example_pact, pact_to_merge)
-          expect(result["interactions"].length).to eq example_pact["interactions"].length + 1
-        end
-
-        it "appends interactions with a different description" do
-          pact_to_merge["interactions"][0]["description"] = "getting $$$"
-
-          result = merge_pacts(example_pact, pact_to_merge)
-          expect(result["interactions"].length).to eq example_pact["interactions"].length + 1
-        end
-
-        it "matches same provider state when is in v2 format" do
-          example_pact["interactions"][0]["providerState"] = "something in the way"
-          pact_to_merge["interactions"][0]["providerState"] = "something in the way"
-          pact_to_merge["interactions"][0]["response"]["body"] = "changed!"
-
-          result = merge_pacts(example_pact, pact_to_merge)
-
-          expect(result["interactions"].length).to eq example_pact["interactions"].length
-          expect(result["interactions"].first["response"]["body"]).to eq "changed!"
-        end
-
-        it "supports merging when provider state is in either v2 or v1 format" do
-          example_pact["interactions"][0]["provider_state"] = "system must resist"
-          pact_to_merge["interactions"][0]["providerState"] = "system must resist"
-          pact_to_merge["interactions"][0]["response"]["body"] = "changed!"
-
-          result = merge_pacts(example_pact, pact_to_merge)
-
-          expect(result["interactions"].length).to eq example_pact["interactions"].length
-          expect(result["interactions"].first["response"]["body"]).to eq "changed!"
-        end
-
-        it "supports merging when provider state is in v3 format with providerStates" do
-          example_pact["interactions"][0]["providerStates"] = [{ name: "a state" }]
-          pact_to_merge["interactions"][0]["providerStates"] = [{ name: "a state" }]
-          pact_to_merge["interactions"][0]["response"]["body"] = "changed!"
-
-          result = merge_pacts(example_pact, pact_to_merge)
-
-          expect(result["interactions"].length).to eq example_pact["interactions"].length
-          expect(result["interactions"].first["response"]["body"]).to eq "changed!"
-        end
-
-        # helper that lets these specs deal with hashes instead of JSON strings
-        def merge_pacts(a, b, return_hash = true)
-          result = PactBroker::Pacts::Merger.merge_pacts(a.to_json, b.to_json)
-
-          return_hash ? JSON.parse(result) : result
-        end
-      end
-
-      describe "#conflict?" do
-        let(:pact_to_compare) { load_json_fixture("consumer-provider.json") }
-
-        it "returns false if interactions have different descriptions" do
-          pact_to_compare["interactions"][0]["description"] = "something else"
-
-          expect(compare_pacts(example_pact, pact_to_compare)).to eq false
-        end
-
-        it "returns false if interactions have different provider states" do
-          pact_to_compare["interactions"][0]["provider_state"] = "some other thing"
-          expect(compare_pacts(example_pact, pact_to_compare)).to eq false
-        end
-
-        context "when interactions have the same desc/state" do
-          it "returns false if request parameters are the same" do
-            expect(compare_pacts(example_pact, pact_to_compare)).to eq false
-          end
-
-          it "returns true if requests have a different query" do
-            pact_to_compare["interactions"][0]["request"]["query"] = "foo=bar&baz=qux"
-            expect(compare_pacts(example_pact, pact_to_compare)).to eq true
-          end
-
-          it "returns true if requests have a different body" do
-            pact_to_compare["interactions"][0]["request"]["body"] = { "something" => { "nested" => "deeply" } }
-            expect(compare_pacts(example_pact, pact_to_compare)).to eq true
-          end
-
-          it "returns true if request method is different" do
-            pact_to_compare["interactions"][0]["request"]["method"] = "post"
-            expect(compare_pacts(example_pact, pact_to_compare)).to eq true
-          end
-
-          it "returns true if request path is different" do
-            pact_to_compare["interactions"][0]["request"]["path"] = "/new_path"
-            expect(compare_pacts(example_pact, pact_to_compare)).to eq true
-          end
-
-          it "returns true if request headers are different" do
-            pact_to_compare["interactions"][0]["request"]["headers"]["Content-Type"] = "text/html"
-            expect(compare_pacts(example_pact, pact_to_compare)).to eq true
-          end
-
-          it "returns true if request has additional headers" do
-            pact_to_compare["interactions"][0]["request"]["headers"]["Accept"] = "text/html"
-            expect(compare_pacts(example_pact, pact_to_compare)).to eq true
-          end
-
-          it "returns true if request has missing headers" do
-            pact_to_compare["interactions"][0]["request"]["headers"].delete("Content-Type")
-            expect(compare_pacts(example_pact, pact_to_compare)).to eq true
-          end
-        end
-
-        def compare_pacts(a, b)
-          PactBroker::Pacts::Merger.conflict?(a.to_json, b.to_json)
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/pacts/metadata_spec.rb

@@ -1,147 +0,0 @@
-require "pact_broker/pacts/metadata"
-
-module PactBroker
-  module Pacts
-    module Metadata
-      describe "#build_metadata_for_pact_for_verification" do
-        let(:selectors) do
-          Selectors.new([ResolvedSelector.new({ latest: true, consumer: "consumer", tag: "tag" }, consumer_version)])
-        end
-        let(:consumer_version) { double("version", number: "2", id: 1) }
-        let(:verifiable_pact) { double("PactBroker::Pacts::VerifiablePact", wip: wip, selectors: selectors, pending?: is_pending) }
-        let(:is_pending) { nil }
-        let(:wip) { false }
-
-        subject { Metadata.build_metadata_for_pact_for_verification(verifiable_pact) }
-
-        it "builds the metadata with the resolved selectors" do
-          expect(subject).to eq({
-            "s" => [
-              {
-                "l" => true,
-                "t" => "tag",
-                "cv" => 1
-              }
-            ]
-          })
-        end
-
-        context "when wip is true" do
-          let(:wip) { true }
-
-          it { is_expected.to eq "w" => true }
-        end
-
-        context "when the pact is pending" do
-          let(:is_pending) { true }
-
-          it { is_expected.to include "p" => true }
-        end
-      end
-
-      describe "parse_metadata" do
-        context "with a consumer version id" do
-          before do
-            allow(PactBroker::Domain::Version).to receive(:find).with(id: 1).and_return(consumer_version)
-          end
-
-          let(:consumer_version) { double("version", number: "2", id: 1) }
-
-          let(:incoming_metadata) do
-            {
-              "cv" => 1,
-              "cvt" => ["tag"],
-              "w" => true,
-              "s" => [
-                {
-                  "l" => true,
-                  "t" => "tag",
-                  "cv" => 1
-                }
-              ],
-              "p" => true
-            }
-          end
-
-          let(:parsed_metadata) do
-            {
-              :consumer_version_number => "2",
-              :consumer_version_tags => ["tag"],
-              :wip => true,
-              :pending => true,
-              :consumer_version_selectors => [
-                {
-                  :latest => true,
-                  :tag => "tag",
-                  :consumer_version_number => "2"
-                }
-              ]
-            }
-          end
-
-          it "expands the key names" do
-            expect(Metadata.parse_metadata(incoming_metadata)).to eq parsed_metadata
-          end
-
-          context "when the version can't be found" do
-            let(:consumer_version) { nil }
-
-            let(:parsed_metadata) do
-              {
-                :consumer_version_number => nil,
-                :consumer_version_tags => ["tag"],
-                :wip => true,
-                :pending => true,
-                :consumer_version_selectors => [
-                  {
-                    :latest => true,
-                    :tag => "tag",
-                    :consumer_version_number => nil
-                  }
-                ]
-              }
-            end
-
-            it "sets the consumer version number to nil" do
-              expect(Metadata.parse_metadata(incoming_metadata)).to eq parsed_metadata
-            end
-          end
-        end
-
-        context "with a consumer version number (support the old format for previously created URLs)" do
-          let(:incoming_metadata) do
-            {
-              "cvn" => "2",
-              "cvt" => ["tag"],
-              "w" => true,
-              "s" => [
-                {
-                  "l" => true,
-                  "t" => "tag"
-                }
-              ]
-            }
-          end
-
-          let(:parsed_metadata) do
-            {
-              :consumer_version_number => "2",
-              :consumer_version_tags => ["tag"],
-              :wip => true,
-              :consumer_version_selectors => [
-                {
-                  :latest => true,
-                  :tag => "tag"
-                }
-              ]
-            }
-          end
-
-          it "expands the key names" do
-            expect(Metadata.parse_metadata(incoming_metadata)).to eq parsed_metadata
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/pacts/pact_params_spec.rb

@@ -1,111 +0,0 @@
-require "spec_helper"
-require "pact_broker/pacts/pact_params"
-
-module PactBroker
-  module Pacts
-    describe PactParams do
-
-      let(:body) { load_fixture("a_consumer-a_provider.json") }
-      let(:consumer_version_number) { "1.2.3" }
-      let(:headers) { { "X-Pact-Consumer-Version" => consumer_version_number, "Host" => "example.org" } }
-      let(:revision_number) { "1" }
-      let(:path_info) do
-        {
-          consumer_name: "Consumer",
-          provider_name: "Provider",
-          consumer_version_number: "1.2.3",
-          revision_number: revision_number,
-          pact_version_sha: "123"
-        }
-      end
-
-      describe "from_path_info" do
-        subject { PactParams.from_path_info(path_info) }
-
-        it "extracts the consumer name from the path" do
-          expect(subject.consumer_name).to eq "Consumer"
-        end
-
-        it "extracts the provider name from the path" do
-          expect(subject.provider_name).to eq "Provider"
-        end
-
-        it "extracts the consumer_version_number from the path" do
-          expect(subject.consumer_version_number).to eq "1.2.3"
-        end
-
-        it "extracts the revision_number from the path" do
-          expect(subject.revision_number).to eq "1"
-        end
-
-        it "extracts the pact_version_sha from the path" do
-          expect(subject.pact_version_sha).to eq "123"
-        end
-      end
-
-      describe "from_request" do
-
-        context "from a PUT request" do
-          let(:request) { Webmachine::Request.new("PUT", "/", headers, body)}
-
-          subject { PactParams.from_request(request, path_info) }
-
-          it "extracts the consumer name from the path" do
-            expect(subject.consumer_name).to eq "Consumer"
-          end
-
-          it "extracts the provider name from the path" do
-            expect(subject.provider_name).to eq "Provider"
-          end
-
-          it "extracts the consumer_version_number from the path" do
-            expect(subject.consumer_version_number).to eq "1.2.3"
-          end
-
-          it "extracts the revision_number from the path" do
-            expect(subject.revision_number).to eq "1"
-          end
-
-          it "extracts the json_content" do
-            expect(subject.json_content).to eq JSON.parse(body).to_json
-          end
-
-          it "removes whitespace from the json_content" do
-            expect(subject.json_content).to_not include "\n"
-          end
-
-          it "extracts the consumer name from the pact" do
-            expect(subject.consumer_name_in_pact).to eq "A Consumer"
-          end
-
-          it "extracts the provider name from the pact" do
-            expect(subject.provider_name_in_pact).to eq "A Provider"
-          end
-
-          context "with no revision_number" do
-            let(:revision_number) { nil }
-            it "the revision_number is null" do
-              expect(subject.revision_number).to be nil
-            end
-          end
-
-          context "with missing data" do
-            let(:body){ "" }
-
-            it "the consumer name from the pact is nil" do
-              expect(subject.consumer_name_in_pact).to be nil
-            end
-
-            it "the provider name from the pact is nil" do
-              expect(subject.provider_name_in_pact).to be nil
-            end
-
-            it "extracts the json_content" do
-              expect(subject.json_content).to eq ""
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/pacts/pact_publication_clean_selector_dataset_module_spec.rb

@@ -1,97 +0,0 @@
-module PactBroker
-  module Pacts
-    describe PactPublicationCleanSelectorDatasetModule do
-      subject { PactPublication.latest_by_consumer_tag_for_clean_selector(selector).all.sort_by{ | pp | [pp.consumer_name, pp.consumer_version_number]} }
-
-      context "for latest for a specified tag" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_consumer_version_tag("dev")
-            .create_pact_with_hierarchy("Foo", "2", "Bar")
-            .create_consumer_version_tag("dev")
-            .create_pact_with_hierarchy("Foo", "3", "Bar")
-            .create_consumer_version_tag("prod")
-        end
-
-        let(:selector) { PactBroker::DB::Clean::Selector.new(tag: "dev", latest: true) }
-
-        it "returns matching rows" do
-          expect(subject.count).to eq 1
-          expect(subject.first.consumer_version_number).to eq "2"
-        end
-      end
-
-      context "for latest for a specified tag and consumer" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_consumer_version_tag("dev")
-            .create_pact_with_hierarchy("Foo", "2", "Bar")
-            .create_consumer_version_tag("dev")
-            .create_pact_with_hierarchy("Foo2", "3", "Bar")
-            .create_consumer_version_tag("dev")
-        end
-
-        let(:selector) { PactBroker::DB::Clean::Selector.new(tag: "dev", latest: true, pacticipant_name: "Foo") }
-
-        it "returns matching rows" do
-          expect(subject.count).to eq 1
-          expect(subject.first.consumer_version_number).to eq "2"
-        end
-      end
-
-      context "for all for a specified tag" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_consumer_version_tag("dev")
-            .create_pact_with_hierarchy("Foo", "2", "Bar")
-            .create_consumer_version_tag("dev")
-            .create_pact_with_hierarchy("Foo", "3", "Bar")
-            .create_consumer_version_tag("prod")
-        end
-
-        let(:selector) { PactBroker::DB::Clean::Selector.new(tag: "dev") }
-
-        it "returns matching rows (which are only the latest)" do
-          expect(subject.count).to eq 1
-          expect(subject.first.consumer_version_number).to eq "2"
-        end
-      end
-
-      context "for latest for any tag" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_consumer_version_tag("dev")
-            .create_pact_with_hierarchy("Foo", "2", "Bar")
-            .create_consumer_version_tag("dev")
-            .create_pact_with_hierarchy("Foo", "3", "Bar")
-            .create_consumer_version_tag("prod")
-        end
-
-        let(:selector) { PactBroker::DB::Clean::Selector.new(tag: true, latest: true) }
-
-        it "returns matching rows" do
-          expect(subject.count).to eq 2
-          expect(subject.first.consumer_version_number).to eq "2"
-        end
-      end
-
-      context "for latest for any tag with a max age" do
-        before do
-          td.subtract_days(7)
-            .create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_consumer_version_tag("prod")
-            .add_days(4)
-            .create_pact_with_hierarchy("Foo", "2", "Bar")
-            .create_consumer_version_tag("dev")
-        end
-
-        let(:selector) { PactBroker::DB::Clean::Selector.new(tag: true, latest: true, max_age: 5) }
-
-        it "returns matching rows" do
-          expect(subject.count).to eq 1
-          expect(subject.first.consumer_version_number).to eq "2"
-        end
-      end
-    end
-  end
-end