pact_broker 2.89.1 → 2.90.0

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

@@ -1,447 +0,0 @@
-require "pact_broker/pacts/content"
-
-module PactBroker
-  module Pacts
-    describe Content do
-      describe "with_ids" do
-        let(:pact_hash) do
-          {
-            "ignored" => "foo",
-            "interactions" => [interaction],
-            "metadata" => {
-              "foo" => "bar"
-            }
-          }
-        end
-        let(:interaction) { { "foo" => "bar" } }
-
-        before do
-          allow(GenerateInteractionSha).to receive(:call).and_return("some-id")
-        end
-
-        subject { Content.from_hash(pact_hash).with_ids }
-
-        context "when the interaction has an existing _id" do
-          let(:interaction) { { "_id" => "blah", "foo" => "bar" } }
-
-          it "removes the i_d before creating the sha" do
-            expect(GenerateInteractionSha).to receive(:call).with("foo" => "bar")
-            subject
-          end
-        end
-
-        context "when the interaction is a hash" do
-          it "adds an _id to each interaction" do
-            expect(subject.interactions.first["_id"]).to eq "some-id"
-          end
-        end
-
-        context "when the interaction is not a hash" do
-          let(:interaction) { 1 }
-
-          it "does not add an _id" do
-            expect(subject.interactions.first).to eq interaction
-          end
-        end
-
-        context "when the pact is a message pact" do
-          let(:pact_hash) do
-            {
-              "ignored" => "foo",
-              "messages" => [interaction],
-              "metadata" => {
-                "foo" => "bar"
-              }
-            }
-          end
-
-          it "adds an _id to each message" do
-            expect(subject.messages.first["_id"]).to eq "some-id"
-          end
-        end
-
-        context "when override_existing_ids = false (for setting up test data)" do
-          let(:interaction) { { "_id" => "1", "foo" => "bar" } }
-
-          it "does not override the existing ids" do
-            expect(subject.interactions.first["_id"]).to eq "1"
-          end
-        end
-      end
-
-      describe "content_that_affects_verification_results" do
-
-        subject { Content.from_hash(pact_hash).content_that_affects_verification_results }
-
-        context "with messages" do
-          let(:pact_hash) do
-            {
-              "ignored" => "foo",
-              "messages" => [1],
-              "metadata" => {
-                "pactSpecification" => {
-                  "version" => "1"
-                }
-              }
-            }
-          end
-
-          let(:expected_content) do
-            {
-              "messages" => [1],
-              "pact_specification_version" => "1"
-            }
-          end
-
-          it "extracts the messages and pact_specification_version" do
-            expect(subject).to eq expected_content
-          end
-        end
-
-        context "with interactions" do
-          let(:pact_hash) do
-            {
-              "ignored" => "foo",
-              "interactions" => [1],
-              "metadata" => {
-                "pactSpecification" => {
-                  "version" => "1"
-                }
-              }
-            }
-          end
-
-          let(:expected_content) do
-            {
-              "interactions" => [1],
-              "pact_specification_version" => "1"
-            }
-          end
-
-          it "extracts the interactions and pact_specification_version" do
-            expect(subject).to eq expected_content
-          end
-        end
-
-        context "with both messages and interactions (v4)" do
-          let(:pact_hash) do
-            {
-              "ignored" => "foo",
-              "interactions" => [1],
-              "messages" => [2],
-              "metadata" => {
-                "pactSpecification" => {
-                  "version" => "1"
-                }
-              }
-            }
-          end
-
-          let(:expected_content) do
-            {
-              "interactions" => [1],
-              "messages" => [2],
-              "pact_specification_version" => "1"
-            }
-          end
-
-          it "extracts the interactions and pact_specification_version" do
-            expect(subject).to eq expected_content
-          end
-        end
-
-        context "with neither messages nor interactions" do
-          let(:pact_hash) do
-            {
-              "ignored" => "foo",
-              "foo" => [1],
-              "metadata" => {
-                "pactSpecification" => {
-                  "version" => "1"
-                }
-              }
-            }
-          end
-
-          it "returns the entire hash" do
-            expect(subject).to eq pact_hash
-          end
-        end
-
-        context "when somebody publishes an array as the top level element" do
-          let(:pact_hash) do
-            [{ "foo" => "bar" }]
-          end
-
-          it "returns the entire document" do
-            expect(subject).to eq pact_hash
-          end
-        end
-      end
-
-      describe "#pact_specification_version" do
-        subject { Content.from_hash(json) }
-        context "with pactSpecification.version" do
-          let(:json) do
-            {
-              "metadata" => {
-                "pactSpecification" => {
-                  "version" => "1"
-                }
-              }
-            }
-          end
-
-          its(:pact_specification_version) { is_expected.to eq "1" }
-        end
-
-        context "with pact-specification.version" do
-          let(:json) do
-            {
-              "metadata" => {
-                "pact-specification" => {
-                  "version" => "1"
-                }
-              }
-            }
-          end
-
-          its(:pact_specification_version) { is_expected.to eq "1" }
-        end
-
-        context "with pactSpecificationVersion" do
-          let(:json) do
-            {
-              "metadata" => {
-                "pactSpecificationVersion" => "1"
-              }
-            }
-          end
-
-          its(:pact_specification_version) { is_expected.to eq "1" }
-        end
-
-        context "with an array for content" do
-          let(:json) { [] }
-
-          its(:pact_specification_version) { is_expected.to eq nil }
-        end
-      end
-
-      describe "with_test_results" do
-        let(:test_results) do
-          {
-            "tests" => [
-              {
-                "interactionProviderState" => "ps1",
-                "interactionDescription" => "desc1"
-              },{
-                "interactionProviderState" => "ps1",
-                "interactionDescription" => "desc1"
-              }
-            ]
-          }
-        end
-
-        let(:pact_content) do
-          {
-            "interactions" => [
-              {
-               "providerState" => "ps1",
-               "description" => "desc1",
-              },
-              {
-               "providerState" => "ps2",
-               "description" => "desc2",
-              }
-            ]
-          }
-        end
-
-        subject { Content.from_hash(pact_content).with_test_results(test_results) }
-
-        let(:merged) do
-          {
-            "interactions" => [
-              {
-               "providerState" => "ps1",
-               "description" => "desc1",
-               "tests" => [
-                {
-                  "interactionProviderState" => "ps1",
-                  "interactionDescription" => "desc1",
-                },{
-                  "interactionProviderState" => "ps1",
-                  "interactionDescription" => "desc1",
-                }
-               ]
-              },{
-               "providerState" => "ps2",
-               "description" => "desc2",
-               "tests" => []
-              }
-            ]
-          }
-        end
-
-        let(:merged_with_empty_tests) do
-          {
-            "interactions" => [
-              {
-               "providerState" => "ps1",
-               "description" => "desc1",
-               "tests" => []
-              },{
-               "providerState" => "ps2",
-               "description" => "desc2",
-               "tests" => []
-              }
-            ]
-          }
-        end
-
-        it "merges the contents with the results" do
-          expect(subject.to_hash).to eq merged
-        end
-
-        it "returns interactions without test results" do
-          expect(subject.interactions_missing_test_results.count).to eq 1
-        end
-
-        context "with no interactions" do
-          let(:pact_content) { {} }
-
-          it "does not blow up" do
-            expect(subject.interactions_missing_test_results.count).to eq 0
-          end
-        end
-
-        context "with nil test results" do
-          let(:test_results) { nil }
-
-          it "does not blow up" do
-            expect(subject.to_hash).to eq merged_with_empty_tests
-          end
-
-          it "returns interactions without test results" do
-            expect(subject.interactions_missing_test_results.count).to eq 2
-          end
-        end
-
-        context "with nil tests" do
-          let(:test_results) { {} }
-
-          it "does not blow up" do
-            expect(subject.to_hash).to eq merged_with_empty_tests
-          end
-        end
-
-        context "with empty tests" do
-          let(:test_results) { { "tests" => [] } }
-
-          it "does not blow up" do
-            expect(subject.to_hash).to eq merged_with_empty_tests
-          end
-        end
-
-        context "with tests not an array" do
-          let(:test_results) { { "tests" => {} } }
-
-          it "does not blow up" do
-            expect(subject.to_hash).to eq merged_with_empty_tests
-          end
-        end
-
-        context "with tests an array of not hashes" do
-          let(:test_results) { { "tests" => [1] } }
-
-          it "does not blow up" do
-            expect(subject.to_hash).to eq merged_with_empty_tests
-          end
-        end
-
-        context "with the new format" do
-          let(:test_results) do
-            [
-              {
-                "interactionId" => "1",
-                "success "=> false
-              },{
-                "foo" => "bar"
-              }
-            ]
-          end
-
-          let(:pact_content) do
-            {
-              "interactions" => [
-                {
-                 "_id" => "1"
-                },
-                {
-                 "_id" => "2"
-                }
-              ]
-            }
-          end
-
-          let(:merged) do
-            {
-              "interactions" => [
-                {
-                 "_id" => "1",
-                 "tests" => [{
-                    "interactionId" => "1",
-                    "success "=> false
-                  }]
-                },{
-                 "_id" => "2",
-                 "tests" => []
-                }
-              ]
-            }
-          end
-
-          it "merges the tests into the pact content" do
-            expect(subject.to_hash).to eq merged
-          end
-        end
-      end
-
-      describe "interaction_ids" do
-        let(:interaction_1) do
-          {
-            _id: "1"
-          }
-        end
-
-        let(:interaction_2) do
-          {
-            _id: "2"
-          }
-        end
-
-        let(:interaction_3) do
-          {
-          }
-        end
-
-        let(:content_hash) do
-          {
-            interactions: [interaction_1, interaction_2, interaction_3]
-          }
-        end
-
-        subject { Content.from_json(content_hash.to_json) }
-
-        its(:interaction_ids) { is_expected.to eq ["1", "2"] }
-
-        context "when there are no interactions" do
-          let(:content_hash) { {} }
-
-          its(:interaction_ids) { is_expected.to eq [] }
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require "spec_helper"
-require "pact_broker/pacts/create_formatted_diff"
-require "pact_broker/pacts/repository"
-
-module PactBroker
-  module Pacts
-    describe CreateFormattedDiff do
-      describe ".call" do
-
-        let(:pact_content_version_1) do
-          hash = load_json_fixture("consumer-provider.json")
-          hash["interactions"].first["request"]["method"] = "post"
-          hash.to_json
-        end
-
-        let(:pact_content_version_2) { load_fixture("consumer-provider.json") }
-
-        subject { CreateFormattedDiff.call(pact_content_version_2, pact_content_version_1) }
-
-        it "returns the formatted diff" do
-          expect(subject).to include "interactions"
-          expect(subject).to match(/\-.*post/)
-          expect(subject).to match(/\+.*get/)
-          expect(subject).to_not include "Key"
-        end
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-require "spec_helper"
-require "pact_broker/pacts/diff"
-require "pact_broker/pacts/pact_params"
-
-module PactBroker
-  module Pacts
-    describe Diff do
-
-      describe "#process" do
-
-        let(:pact_content_version_1) do
-          hash = load_json_fixture("consumer-provider.json")
-          hash["interactions"].first["request"]["method"] = "post"
-          hash.to_json
-        end
-        let(:pact_content_version_2) { load_fixture("consumer-provider.json") }
-        let(:pact_content_version_3) { pact_content_version_2 }
-        let(:pact_content_version_4) do
-          hash = load_json_fixture("consumer-provider.json")
-          hash["interactions"].first["request"]["method"] = "delete"
-          hash.to_json
-        end
-
-        let(:pact_params) do
-          PactBroker::Pacts::PactParams.new(
-            consumer_name: "Consumer",
-            provider_name: "Provider",
-            consumer_version_number: "3"
-          )
-        end
-
-        before do
-          TestDataBuilder.new
-            .create_consumer("Consumer")
-            .create_provider("Provider")
-            .create_consumer_version("1")
-            .create_pact(json_content: pact_content_version_1)
-            .create_consumer_version("2")
-            .create_pact(json_content: pact_content_version_2)
-            .create_consumer_version("3")
-            .create_pact(json_content: pact_content_version_3)
-            .create_consumer_version("4")
-            .create_pact(json_content: pact_content_version_4)
-
-          allow(DateHelper).to receive(:local_date_in_words).and_return("a date")
-        end
-
-        subject { Diff.new.process(pact_params.merge(base_url: "http://example.org"), nil, raw: true) }
-
-        context "when a comparison version is specified" do
-          let(:comparison_pact_params) do
-            PactBroker::Pacts::PactParams.new(
-              consumer_name: "Consumer",
-              provider_name: "Provider",
-              consumer_version_number: "4"
-            ).merge(base_url: "http://example.org")
-          end
-
-          subject { Diff.new.process(pact_params.merge(base_url: "http://example.org"), comparison_pact_params) }
-
-          it "compares the two pacts" do
-            expect(subject).to include "Pact between Consumer (3) and Provider"
-            expect(subject).to include "Pact between Consumer (4) and Provider"
-          end
-
-          it "includes a link to the comparison pact", pending: true do
-            expect(subject).to include "comparision-pact-version:"
-          end
-        end
-
-        context "when there is a previous distinct version" do
-          it "indicates when the previous change was made" do
-            expect(subject).to include "The following changes were made less than a minute ago (a date)"
-          end
-
-          it "returns the formatted diff" do
-            expect(subject).to include "interactions"
-            expect(subject).to include "post"
-            expect(subject).to include "get"
-          end
-        end
-
-        context "when there is not a previous distinct version (this needs to be moved into the resource)" do
-          let(:pact_params) do
-            PactBroker::Pacts::PactParams.new(
-              consumer_name: "Consumer",
-              provider_name: "Provider",
-              consumer_version_number: "1"
-            )
-          end
-
-          it "returns a message indicating there was no previous distinct version found" do
-            expect(subject).to include("No previous distinct version was found")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-require "pact_broker/pacts/generate_interaction_sha"
-
-module PactBroker
-  module Pacts
-    describe GenerateInteractionSha do
-      describe ".call" do
-        let(:interaction_hash) do
-          {
-            "description" => "foo",
-            "providerStates" => [
-              "name" => "bar",
-              "params" => {
-                "wiffle" => "bar",
-                "meep" => "eek"
-              }
-            ]
-          }
-        end
-
-        let(:interaction_hash_with_different_key_order) do
-          {
-            "providerStates" => [
-              "name" => "bar",
-              "params" => {
-                "meep" => "eek",
-                "wiffle" => "bar"
-              }
-            ],
-            "description" => "foo"
-          }
-        end
-
-        subject { GenerateInteractionSha.call(interaction_hash) }
-
-        it "generates a SHA based on the sorted keys" do
-          expect(subject).to eq "57d06e151eca35083e4d6b585b4d4fab2e2ed6b7"
-        end
-
-        it "generates the same SHA if the keys are ordered differently" do
-          expect(subject).to eq GenerateInteractionSha.call(interaction_hash_with_different_key_order)
-        end
-      end
-    end
-  end
-end