pact_broker 2.89.1 → 2.93.0

data/spec/lib/pact/doc/interaction_view_model_spec.rb

@@ -1,232 +0,0 @@
-require "pact/doc/interaction_view_model"
-
-module Pact
-  module Doc
-    describe InteractionViewModel do
-      let(:consumer_contract) { Pact::ConsumerContract.from_uri "./spec/support/interaction_view_model.json" }
-      let(:interaction_with_request_with_body_and_headers) { consumer_contract.find_interaction description: "a request with a body and headers" }
-      let(:interaction_with_request_without_body_and_headers) { consumer_contract.find_interaction description: "a request with an empty body and empty headers" }
-      let(:interaction_with_response_with_body_and_headers) { consumer_contract.find_interaction description: "a response with a body and headers" }
-      let(:interaction_with_response_without_body_and_headers) { consumer_contract.find_interaction description: "a response with an empty body and empty headers" }
-      let(:interaction) { consumer_contract.interactions.first }
-
-      subject { InteractionViewModel.new interaction, consumer_contract}
-
-      describe "id" do
-        context "with HTML characters in the description" do
-          before do
-            interaction.description = "an alligator with > 100 legs exists"
-            interaction.provider_state = "a thing exists"
-          end
-
-          it "escapes the HTML characters" do
-            expect(subject.id).to eq "an_alligator_with_>_100_legs_exists_given_a_thing_exists"
-          end
-        end
-      end
-
-      describe "consumer_name" do
-        context "with markdown characters in the name" do
-          it "escapes the markdown characters" do
-            expect(subject.consumer_name).to eq "a\\*consumer"
-          end
-        end
-      end
-
-      describe "provider_name" do
-        context "with markdown characters in the name" do
-          it "escapes the markdown characters" do
-            expect(subject.provider_name).to eq "a\\_provider"
-          end
-        end
-      end
-
-      describe "request" do
-        let(:interaction) { interaction_with_request_with_body_and_headers }
-
-        it "includes the method" do
-          expect(subject.request).to include('"method"')
-          expect(subject.request).to include('"get"')
-        end
-
-        it "includes the body" do
-          expect(subject.request).to include('"body"')
-          expect(subject.request).to include('"a body"')
-        end
-
-        it "includes the headers" do
-          expect(subject.request).to include('"headers"')
-          expect(subject.request).to include('"a header"')
-        end
-
-        it "includes the query" do
-          expect(subject.request).to include('"query"')
-          expect(subject.request).to include('"some=thing"')
-        end
-
-        it "includes the path" do
-          expect(subject.request).to include('"path"')
-          expect(subject.request).to include('"/path"')
-        end
-
-        it "renders the keys in a meaningful order" do
-          expect(subject.request).to match(/"method".*"path".*"query".*"headers".*"body"/m)
-        end
-
-        context "when the body hash is empty" do
-          let(:interaction) { interaction_with_request_without_body_and_headers }
-
-          it "includes the body" do
-            expect(subject.request).to include("body")
-          end
-        end
-        context "when the headers hash is empty" do
-          let(:interaction) { interaction_with_request_without_body_and_headers }
-
-          it "does not include the headers" do
-            expect(subject.request).to_not include("headers")
-          end
-        end
-
-        context "when a Pact::Term is present" do
-          let(:consumer_contract) { Pact::ConsumerContract.from_uri "./spec/support/interaction_view_model_with_terms.json"}
-          let(:interaction) { consumer_contract.interactions.first }
-
-          it "uses the generated value" do
-            expect(subject.request).to_not include("Term")
-            expect(subject.request).to include("sunny")
-          end
-        end
-      end
-
-      describe "response" do
-        let(:interaction) { interaction_with_response_with_body_and_headers }
-
-        it "includes the status" do
-          expect(subject.response).to include('"status"')
-        end
-
-        it "includes the body" do
-          expect(subject.response).to include('"body"')
-          expect(subject.response).to include('"a body"')
-        end
-        it "includes the headers" do
-          expect(subject.response).to include('"headers"')
-          expect(subject.response).to include('"a header"')
-        end
-
-        it "renders the keys in a meaningful order" do
-          expect(subject.response).to match(/"status".*"headers".*"body"/m)
-        end
-
-        context "when the body hash is empty" do
-          let(:interaction) { interaction_with_response_without_body_and_headers }
-
-          it "does not include the body" do
-            expect(subject.response).to_not include("body")
-          end
-        end
-
-        context "when the headers hash is empty" do
-          let(:interaction) { interaction_with_response_without_body_and_headers }
-
-          it "does not include the headers" do
-            expect(subject.response).to_not include("headers")
-          end
-        end
-
-        context "when a Pact::Term is present" do
-          let(:consumer_contract) { Pact::ConsumerContract.from_uri "./spec/support/interaction_view_model_with_terms.json"}
-          let(:interaction) { consumer_contract.interactions.first }
-
-          it "uses the generated value" do
-            expect(subject.response).to_not include("Term")
-            expect(subject.response).to include("rainy")
-          end
-        end
-      end
-
-      describe "description" do
-        context "with a nil description" do
-          let(:interaction) do
-            interaction_with_request_with_body_and_headers.description = nil
-            interaction_with_request_with_body_and_headers
-          end
-
-          it "does not blow up" do
-            expect(subject.description(true)).to eq ""
-            expect(subject.description(false)).to eq ""
-          end
-        end
-
-        context "with markdown characters in the name" do
-          let(:interaction) do
-            interaction_with_request_with_body_and_headers.description = "a *description"
-            interaction_with_request_with_body_and_headers
-          end
-          it "escapes the markdown characters" do
-            expect(subject.description).to eq "a \\*description"
-          end
-        end
-      end
-
-      describe "provider_state" do
-        context "with markdown characters in the name" do
-          let(:interaction) do
-            interaction_with_request_with_body_and_headers.provider_state = "a *provider state"
-            interaction_with_request_with_body_and_headers
-          end
-          it "escapes the markdown characters" do
-            expect(subject.provider_state).to eq "a \\*provider state"
-          end
-        end
-      end
-
-      describe "formatted_provider_states" do
-        let(:consumer_contract) { Pact::ConsumerContract.from_uri "./spec/support/markdown_pact.json" }
-        let(:interaction) { consumer_contract.interactions.first }
-
-        context "when no provider state" do
-          let(:interaction) { consumer_contract.interactions.last }
-
-          it "returns an empty string" do
-            expect(subject.formatted_provider_states).to eq ""
-          end
-        end
-
-        context "when marking provider states in bold" do
-          it "formats the provider state in bold" do
-            expect(subject.formatted_provider_states mark_bold: true).to eq "**alligators exist**"
-          end
-        end
-        
-        context "when not marking provider states in bold" do
-          it "formats the provider state without bold" do
-            expect(subject.formatted_provider_states).to eq "alligators exist"
-          end
-        end
-
-        context "when using v3 specification" do
-          let(:consumer_contract) { Pact::ConsumerContract.from_uri "./spec/support/markdown_pact_v3.json" }
-          let(:interaction) { consumer_contract.interactions.first }
-
-          context "when marking provider states in bold" do
-            it "formats the provider states in bold" do
-              expected_result = "**alligators exist** and **the city of Tel Aviv has a zoo** " \
-                                "and **the zoo keeps record of its alligator population**"
-              expect(subject.formatted_provider_states mark_bold: true).to eq expected_result
-            end
-          end
-
-          context "when not marking provider states in bold" do
-            it "formats the provider states without bold" do
-              expected_result = "alligators exist and the city of Tel Aviv has a zoo " \
-                                "and the zoo keeps record of its alligator population"
-              expect(subject.formatted_provider_states).to eq expected_result
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/doc/markdown/consumer_contract_renderer_spec.rb

@@ -1,71 +0,0 @@
-require "spec_helper"
-require "pact/doc/markdown/consumer_contract_renderer"
-require "pact/support"
-
-module Pact
-  module Doc
-    module Markdown
-      describe ConsumerContractRenderer do
-        let(:consumer_contract) { Pact::ConsumerContract.from_uri "./spec/support/markdown_pact.json" }
-        let(:expected_output) { File.read("./spec/support/generated_markdown.md", external_encoding: Encoding::UTF_8) }
-
-        subject { ConsumerContractRenderer.new(consumer_contract) }
-
-        describe "#call" do
-          context "when using V3 specification" do
-            context "when an interaction has multiple provider states" do
-              let(:consumer_contract) { Pact::ConsumerContract.from_uri "./spec/support/markdown_pact_v3.json" }
-
-              it "displays all provider states in the interaction title" do
-                expect(subject.call).to include "Given **alligators exist** and **the city of Tel Aviv has a zoo** " \
-                                                "and **the zoo keeps record of its alligator population**, upon receiving"
-              end
-            end
-          end
-
-          context "with markdown characters in the pacticipant names" do
-            let(:consumer_contract) { Pact::ConsumerContract.from_uri "./spec/support/markdown_pact_with_markdown_chars_in_names.json" }
-
-            it "escapes the markdown characters" do
-              expect(subject.call).to include "# A pact between Some\\*Consumer\\*App and Some\\_Provider\\_App"
-              expect(subject.call).to include "### Requests from Some\\*Consumer\\*App to Some\\_Provider\\_App"
-            end
-          end
-
-          context "with ruby's default external encoding is not UTF-8" do
-            around do |example|
-              back = nil
-              WarningSilencer.enable { back, Encoding.default_external = Encoding.default_external, Encoding::ASCII_8BIT }
-              example.run
-              WarningSilencer.enable { Encoding.default_external = back }
-            end
-
-            it "renders the interactions" do
-              expect(subject.call).to eq(expected_output)
-            end
-          end
-
-          it "renders the interactions" do
-            expect(subject.call).to eq(expected_output)
-          end
-
-          context "when the pact fields have html embedded in them" do
-            let(:consumer_contract) { Pact::ConsumerContract.from_uri "./spec/support/markdown_pact_with_html.json" }
-
-            its(:title) { is_expected.to include "<h1>Consumer</h1>" }
-            its(:title) { is_expected.to include "<h1>Provider</h1>" }
-
-            its(:summaries_title) { is_expected.to include "<h1>Consumer</h1>" }
-            its(:summaries_title) { is_expected.to include "<h1>Provider</h1>" }
-
-            its(:summaries) { is_expected.to include "<h1>alligators</h1>" }
-            its(:summaries) { is_expected.to_not include "<h1>alligators</h1>" }
-
-            its(:full_interactions) { is_expected.to include "&lt;h1&gt;alligators&lt;/h1&gt;" }
-            its(:full_interactions) { is_expected.to_not include "<h1>alligators</h1>" }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact/doc/markdown/index_renderer_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-require "pact/doc/markdown/index_renderer"
-
-module Pact
-  module Doc
-    module Markdown
-      describe IndexRenderer do
-
-        let(:consumer_name) { "Some Consumer" }
-        let(:docs) {  {"Some Provider" => "Some Provider.md", "Some other provider" => "Some other provider.md"} }
-        let(:subject) { IndexRenderer.new(consumer_name, docs) }
-        let(:expected_content) { File.read("./spec/support/generated_index.md")}
-
-        describe "#call" do
-          it "renders the index" do
-            expect(subject.call).to eq expected_content
-          end
-        end
-
-        describe ".call" do
-          it "renders the index" do
-            expect(IndexRenderer.call(consumer_name, docs) ).to eq expected_content
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/contracts/environment_schema_spec.rb

@@ -1,91 +0,0 @@
-require "pact_broker/api/contracts/environment_schema"
-
-module PactBroker
-  module Api
-    module Contracts
-      describe EnvironmentSchema do
-        before do
-          allow(PactBroker::Deployments::EnvironmentService).to receive(:find_by_name).and_return(existing_environment)
-        end
-        let(:existing_environment) { nil }
-        let(:name) { "test" }
-
-        let(:params) do
-          {
-            uuid: "1234",
-            name: name,
-            displayName: "Test",
-            production: false,
-            contacts: contacts
-          }
-        end
-
-        let(:contacts) do
-          [{
-            name: "Foo",
-            details: { email: "foo@bar.com" }
-          }]
-        end
-
-        subject { EnvironmentSchema.call(params) }
-
-        context "with valid params" do
-          it { is_expected.to be_empty }
-        end
-
-        context "with a name with a new line" do
-          let(:name) { "test 1" }
-
-          it { is_expected.to_not be_empty }
-        end
-
-        context "with empty params" do
-          let(:params) { {} }
-
-          it { is_expected.to_not be_empty }
-        end
-
-        context "when there is another environment with the same name but a different uuid" do
-          let(:existing_environment) { instance_double("PactBroker::Deployments::Environment", uuid: "5678")}
-
-          its([:name]) { is_expected.to eq ["Another environment with name 'test' already exists."] }
-        end
-
-        context "when there is another environment with the same name and same uuid" do
-          let(:existing_environment) { instance_double("PactBroker::Deployments::Environment", uuid: "1234")}
-
-          it { is_expected.to be_empty }
-        end
-
-        context "with a blank displayName" do
-          before do
-            params[:displayName] = ""
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "with no owner name" do
-          let(:contacts) do
-            [{
-              details: { email: "foo@bar.com" }
-            }]
-          end
-
-          its([:contacts, 0]) { is_expected.to eq "name is missing at index 0" }
-        end
-
-        context "with string contact details" do
-          let(:contacts) do
-            [{
-              name: "foo",
-              details: "foo"
-            }]
-          end
-
-          its([:contacts, 0]) { is_expected.to eq "details must be a hash at index 0" }
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/contracts/pacticipant_schema_spec.rb

@@ -1,46 +0,0 @@
-require "pact_broker/api/contracts/pacticipant_schema"
-
-module PactBroker
-  module Api
-    module Contracts
-      describe PacticipantSchema do
-        let(:params) do
-          {
-            name: "pact-broker",
-            displayName: "Pact Broker",
-            mainBranch: main_branch,
-            repositoryUrl: "https://github.com/pact-foundation/pact_broker",
-            repositoryName: "pact_broker",
-            repositoryNamespace: "pact-foundation"
-          }
-        end
-
-        let(:main_branch) { "main" }
-
-        subject { PacticipantSchema.call(params) }
-
-        context "with valid params" do
-          it { is_expected.to be_empty }
-        end
-
-        context "with empty params" do
-          let(:params) do
-            {
-              repositoryUrl: "",
-              repositoryName: "",
-              repositoryNamespace: ""
-            }
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "with branch names that contain spaces" do
-          let(:main_branch) { "main foo" }
-
-          its([:mainBranch, 0]) { is_expected.to include "cannot contain spaces" }
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/contracts/pacts_for_verification_json_query_schema_combinations_spec.rb

@@ -1,87 +0,0 @@
-require "pact_broker/api/contracts/pacts_for_verification_json_query_schema"
-
-module PactBroker
-  module Api
-    module Contracts
-      describe PactsForVerificationJSONQuerySchema do
-        ALL_PROPERTIES = {
-          mainBranch: true,
-          matchingBranch: true,
-          tag: "tag",
-          branch: "branch",
-          latest: true,
-          fallbackTag: "fallbackTag",
-          fallbackBranch: "fallbackBranch",
-          environment: "environment",
-          deployed: true,
-          released: true,
-          deployedOrReleased: true,
-          consumer: "consumer"
-        }
-
-        VALID_KEY_COMBINATIONS = [
-          [:mainBranch],
-          [:matchingBranch],
-          [:tag],
-          [:tag, :latest],
-          [:tag, :latest, :fallbackTag],
-          [:branch],
-          [:branch, :latest],
-          [:branch, :latest, :fallbackBranch],
-          [:branch, :fallbackBranch],
-          [:environment],
-          [:environment, :deployed],
-          [:environment, :released],
-          [:deployed],
-          [:released],
-          [:deployedOrReleased],
-          [:environment, :deployedOrReleased]
-        ]
-
-        VALID_KEY_COMBINATIONS.each do | valid_key_combination |
-          selector = ALL_PROPERTIES.slice(*valid_key_combination)
-
-          describe "with #{selector}" do
-            before do
-              allow(PactBroker::Deployments::EnvironmentService).to receive(:find_by_name).and_return(double("environment"))
-            end
-
-            it "is valid" do
-              params = { consumerVersionSelectors: [selector], providerVersionBranch: "main" }
-              expect(PactsForVerificationJSONQuerySchema.(params)).to be_empty
-            end
-
-            extra_keys = ALL_PROPERTIES.keys - valid_key_combination - [:consumer]
-            extra_keys.each do | extra_key |
-              selector_with_extra_key = selector.merge(extra_key => ALL_PROPERTIES[extra_key])
-              expect_to_be_valid = !!VALID_KEY_COMBINATIONS.find{ | k | k.sort == selector_with_extra_key.keys.sort }
-              params = { consumerVersionSelectors: [selector_with_extra_key], providerVersionBranch: "main"  }
-
-              describe "with #{selector_with_extra_key}" do
-                if expect_to_be_valid
-                  it "is valid" do
-                    expect(PactsForVerificationJSONQuerySchema.(params)).to be_empty
-                  end
-                else
-                  it "is not valid" do
-                    expect(PactsForVerificationJSONQuerySchema.(params)).to_not be_empty
-                  end
-                end
-              end
-
-              selector_with_consumer = selector.merge(consumer: ALL_PROPERTIES[:consumer])
-
-              describe "with #{selector_with_consumer}" do
-                it "is valid" do
-                  params = { consumerVersionSelectors: [selector_with_consumer], providerVersionBranch: "main" }
-
-                  expect(PactsForVerificationJSONQuerySchema.(params).empty?).to be true
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end