pact_broker 2.89.1 → 2.90.0

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

@@ -1,358 +0,0 @@
-require "pact_broker/api/contracts/pacts_for_verification_json_query_schema"
-
-module PactBroker
-  module Api
-    module Contracts
-      describe PactsForVerificationJSONQuerySchema do
-        before do
-          allow(PactBroker::Deployments::EnvironmentService).to receive(:find_by_name).and_return(environment)
-        end
-        let(:environment) { double("environment") }
-
-        let(:params) do
-          {
-            providerVersionTags: provider_version_tags,
-            consumerVersionSelectors: consumer_version_selectors
-          }
-        end
-
-        let(:provider_version_tags) { %w[master] }
-
-        let(:consumer_version_selectors) do
-          [{
-            tag: "master",
-            latest: true
-          }]
-        end
-
-        subject { PactsForVerificationJSONQuerySchema.(params) }
-
-        context "when the params are valid" do
-          it "has no errors" do
-            expect(subject).to eq({})
-          end
-        end
-
-        context "when the fallback tag is specified" do
-          context "when latest is specified" do
-            let(:consumer_version_selectors) do
-              [{
-                tag: "feat-x",
-                fallbackTag: "master",
-                latest: true
-              }]
-            end
-
-            it "has no errors" do
-              expect(subject).to eq({})
-            end
-          end
-
-          context "when latest is not specified" do
-            let(:consumer_version_selectors) do
-              [{
-                tag: "feat-x",
-                fallbackTag: "master"
-              }]
-            end
-
-            it "has an error" do
-              expect(subject[:consumerVersionSelectors].first).to match(/can only be set.*index 0/)
-            end
-
-            context "when there are multiple errors" do
-              let(:consumer_version_selectors) do
-                [{
-                  consumer: "",
-                  tag: "feat-x",
-                  fallbackTag: "master"
-                }]
-              end
-
-              it "merges the array" do
-                expect(subject[:consumerVersionSelectors].size).to be 2
-              end
-            end
-          end
-        end
-
-        context "when the latest version for a particular consumer is requested" do
-          let(:consumer_version_selectors) do
-            [{
-              consumer: "Foo",
-              latest: true
-            }]
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when the latest version for all is requested" do
-          let(:consumer_version_selectors) do
-            [{
-              latest: true
-            }]
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when providerVersionTags is not an array" do
-          let(:provider_version_tags) { true }
-
-          it { is_expected.to have_key(:providerVersionTags) }
-        end
-
-        context "when consumerVersionSelectors is not an array" do
-          let(:consumer_version_selectors) { true }
-
-          it { is_expected.to have_key(:consumerVersionSelectors) }
-        end
-
-        context "when the consumer_version_selector is empty" do
-          let(:consumer_version_selectors) do
-            [{}]
-          end
-
-          it "flattens the messages" do
-            expect(subject[:consumerVersionSelectors].first).to match(/must specify a value.*at index 0/)
-          end
-        end
-
-        context "when the consumerVersionSelectors is missing the latest" do
-          let(:consumer_version_selectors) do
-            [{
-              tag: "master"
-            }]
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when includeWipPactsSince key exists" do
-          let(:include_wip_pacts_since) { nil }
-          let(:params) do
-            {
-              includeWipPactsSince: include_wip_pacts_since
-            }
-          end
-
-          context "when it is nil" do
-            it { is_expected.to have_key(:includeWipPactsSince) }
-          end
-
-          context "when it is not a date" do
-            let(:include_wip_pacts_since) { "foo" }
-
-            it { is_expected.to have_key(:includeWipPactsSince) }
-          end
-
-          context "when it is a valid date" do
-            let(:include_wip_pacts_since) { "2013-02-13T20:04:45.000+11:00" }
-
-            it { is_expected.to_not have_key(:includeWipPactsSince) }
-          end
-        end
-
-        context "when a blank consumer name is specified" do
-          let(:consumer_version_selectors) do
-            [{
-              tag: "feat-x",
-              consumer: ""
-            }]
-          end
-
-          it "has an error" do
-            expect(subject[:consumerVersionSelectors].first).to include "blank"
-          end
-        end
-
-        context "when a consumer name is specified with a latest tag" do
-          let(:consumer_version_selectors) do
-            [{
-              latest: true,
-              tag: "feat-x",
-              consumer: "foo"
-            }]
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when deployed is specified" do
-          let(:consumer_version_selectors) do
-            [{
-              deployed: true
-            }]
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when released is specified" do
-          let(:consumer_version_selectors) do
-            [{
-              released: true
-            }]
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-
-        context "when the environment is specified" do
-          let(:consumer_version_selectors) do
-            [{
-              environment: "test"
-            }]
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when deployed with an environment is specified" do
-          let(:consumer_version_selectors) do
-            [{
-              environment: "feat",
-              deployed: true
-            }]
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when deployed=false with an environment is specified" do
-          let(:consumer_version_selectors) do
-            [{
-              environment: "feat",
-              deployed: false
-            }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to eq "deployed must be one of: true at index 0" }
-        end
-
-        context "when the environment is specified and deployed is nil" do
-          let(:consumer_version_selectors) do
-            [{
-              environment: "feat",
-              deployed: nil
-            }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to eq "deployed can't be blank at index 0" }
-        end
-
-        context "when deployed is nil" do
-          let(:consumer_version_selectors) do
-            [{
-              deployed: nil
-            }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to eq "deployed can't be blank at index 0" }
-        end
-
-        context "when latest=true and an environment is specified" do
-          let(:consumer_version_selectors) do
-            [{
-              environment: "feat",
-              latest: true
-            }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to eq "cannot specify the field latest with the field environment (at index 0)" }
-        end
-
-        context "when latest=true, tag and an environment and deployed are specified" do
-          let(:consumer_version_selectors) do
-            [{
-              environment: "feat",
-              latest: true,
-              tag: "foo",
-              deployed: true
-            }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to eq "cannot specify the fields latest/tag with the fields deployed/environment (at index 0)" }
-        end
-
-        context "when a tag and a branch are specified" do
-          let(:consumer_version_selectors) do
-            [{
-              branch: "foo",
-              tag: "foo",
-              latest: true
-            }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to eq "cannot specify both a tag and a branch (at index 0)" }
-        end
-
-        context "when a fallbackTag is specified without a tag" do
-          let(:consumer_version_selectors) do
-            [{
-              fallbackTag: "foo",
-              latest: true,
-              branch: "foo"
-            }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to eq "a tag must be specified when a fallbackTag is specified (at index 0)" }
-        end
-
-        context "when a fallbackBranch is specified without a branch" do
-          let(:consumer_version_selectors) do
-            [{
-              fallbackBranch: "foo",
-              tag: "foo"
-            }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to eq "a branch must be specified when a fallbackBranch is specified (at index 0)" }
-        end
-
-        context "when a branch is specified with no latest=true" do
-          let(:consumer_version_selectors) do
-            [{
-              branch: "foo"
-            }]
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when a branch is specified with latest=false" do
-          let(:consumer_version_selectors) do
-            [{
-              branch: "foo",
-              latest: false
-            }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to eq "cannot specify a branch with latest=false (at index 0)" }
-        end
-
-        context "when the environment does not exist" do
-          let(:environment) { nil }
-
-          let(:consumer_version_selectors) do
-            [{ environment: "prod" }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to eq "environment with name 'prod' does not exist at index 0" }
-        end
-
-        context "when matchingBranch is true, but the providerVersionBranch is not set" do
-          let(:consumer_version_selectors) do
-            [{
-              matchingBranch: true
-            }]
-          end
-
-          its([:consumerVersionSelectors, 0]) { is_expected.to include "the providerVersionBranch must be specified"}
-        end
-      end
-    end
-  end
-end

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

@@ -1,97 +0,0 @@
-require "pact_broker/api/contracts/pacts_for_verification_query_string_schema"
-
-module PactBroker
-  module Api
-    module Contracts
-      describe PactsForVerificationQueryStringSchema do
-        let(:params) do
-          {
-            provider_version_tags: provider_version_tags,
-            consumer_version_selectors: consumer_version_selectors
-          }
-        end
-
-        let(:provider_version_tags) { %w[master] }
-
-        let(:consumer_version_selectors) do
-          [{
-            tag: "master",
-            latest: "true"
-          }]
-        end
-
-        subject { PactsForVerificationQueryStringSchema.(params) }
-
-        context "when the params are valid" do
-          it "has no errors" do
-            expect(subject).to eq({})
-          end
-        end
-
-        context "when provider_version_tags is not an array" do
-          let(:provider_version_tags) { "foo" }
-
-          it { is_expected.to have_key(:provider_version_tags) }
-        end
-
-        context "when the consumer_version_selector is missing a tag" do
-          let(:consumer_version_selectors) do
-            [{}]
-          end
-
-          it "flattens the messages" do
-            expect(subject[:consumer_version_selectors].first).to eq "tag is missing at index 0"
-          end
-        end
-
-        context "when the consumer_version_selectors is missing the latest" do
-          let(:consumer_version_selectors) do
-            [{
-              tag: "master"
-            }]
-          end
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when include_wip_pacts_since key exists" do
-          let(:include_wip_pacts_since) { nil }
-          let(:params) do
-            {
-              include_wip_pacts_since: include_wip_pacts_since
-            }
-          end
-
-          context "when it is nil" do
-            it { is_expected.to have_key(:include_wip_pacts_since) }
-          end
-
-          context "when it is not a date" do
-            let(:include_wip_pacts_since) { "foo" }
-
-            it { is_expected.to have_key(:include_wip_pacts_since) }
-          end
-
-          context "when it is a valid date" do
-            let(:include_wip_pacts_since) { "2013-02-13T20:04:45.000+11:00" }
-
-            it { is_expected.to_not have_key(:include_wip_pacts_since) }
-          end
-        end
-
-        context "when a blank consumer name is specified" do
-          let(:consumer_version_selectors) do
-            [{
-              tag: "feat-x",
-              consumer: ""
-            }]
-          end
-
-          it "has an error" do
-            expect(subject[:consumer_version_selectors].first).to include "blank"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,127 +0,0 @@
-require "pact_broker/api/contracts/publish_contracts_schema"
-
-module PactBroker
-  module Api
-    module Contracts
-      describe PublishContractsSchema do
-        let(:params) do
-          {
-            :pacticipantName => pacticipant_name,
-            :pacticipantVersionNumber => version_number,
-            :tags => tags,
-            :branch => branch,
-            :buildUrl => build_url,
-            :contracts => [
-              {
-                :consumerName => consumer_name,
-                :providerName => "Bar",
-                :specification => "pact",
-                :contentType => content_type,
-                :content => encoded_contract,
-                :decodedContent => decoded_content,
-                :decodedParsedContent => decoded_parsed_content
-              }
-            ]
-          }
-        end
-
-        let(:pacticipant_name) { "Foo" }
-        let(:consumer_name) { pacticipant_name }
-        let(:version_number) { "34" }
-        let(:tags) { ["a", "b"] }
-        let(:branch) { "main" }
-        let(:build_url) { "http://ci/builds/1234" }
-        let(:contract_hash) { { "consumer" => { "name" => "Foo" }, "provider" => { "name" => "Bar" }, "interactions" => [] } }
-        let(:encoded_contract) { Base64.strict_encode64(contract_hash.to_json) }
-        let(:decoded_content) { contract_hash.to_json }
-        let(:decoded_parsed_content) { contract_hash }
-        let(:content_type) { "application/json" }
-
-        subject { PublishContractsSchema.call(params) }
-
-        context "with valid params" do
-          it { is_expected.to be_empty }
-        end
-
-        context "with an empty tag" do
-          let(:tags) { [""] }
-
-          its([:tags, 0]) { is_expected.to include "blank" }
-        end
-
-        context "with an empty build_url" do
-          let(:build_url) { "" }
-
-          it { is_expected.to be_empty }
-        end
-
-        context "with an invalid content type" do
-          let(:content_type) { "foo" }
-
-          its([:contracts, 0]) { is_expected.to include "one of" }
-        end
-
-        context "when the specification is pact and consumer name does not match the pacticipant name" do
-          let(:consumer_name) { "waffle" }
-
-          its([:contracts, 0]) { is_expected.to include "must match" }
-        end
-
-        context "when the decoded content is nil" do
-          let(:decoded_content) { nil }
-
-          its([:contracts, 0]) { is_expected.to include "Base64" }
-        end
-
-        context "when the decoded parsed content is nil" do
-          let(:decoded_parsed_content) { nil }
-
-          its([:contracts, 0]) { is_expected.to include "The content could not be parsed as application/json" }
-
-          context "when the content type is also nil" do
-            let(:content_type) { nil }
-
-            its([:contracts, 0]) { is_expected.to include "contentType can't be blank at index 0" }
-          end
-        end
-
-        context "when the consumer name in the content does not match the pacticipant name" do
-          let(:contract_hash) { { "consumer" => { "name" => "WRONG" }, "provider" => { "name" => "Bar" }, "interactions" => [] } }
-
-          its([:contracts, 0]) { is_expected.to include "consumer name in contract content ('WRONG') must match pacticipantName ('Foo') at index 0" }
-        end
-
-        context "when there is no consumer name in the content" do
-          let(:contract_hash) { {  } }
-
-          it { is_expected.to be_empty }
-        end
-
-        context "when the consumer name in the contract node does not match the pacticipant name" do
-          let(:consumer_name) { "WRONG" }
-
-          its([:contracts, 0]) { is_expected.to include "consumerName ('WRONG') must match pacticipantName ('Foo') at index 0" }
-        end
-
-        context "when the providerName in the contract node does not match the provider name in the contract content" do
-          let(:contract_hash) { { "consumer" => { "name" => "Foo" }, "provider" => { "name" => "WRONG" }, "interactions" => [] } }
-
-          its([:contracts, 0]) { is_expected.to include "provider name in contract content ('WRONG') must match providerName ('Bar') in contracts at index 0" }
-        end
-
-        context "when the consumer name is missing and there is a validation error with the content" do
-          let(:params) do
-            JSON.parse(File.read("spec/fixtures/invalid-publish-contract-body.json"), symbolize_names: true)
-          end
-
-          it "handles multiple errors" do
-            expect(subject[:contracts]).to include "consumerName is missing at index 0"
-            expect(subject[:contracts]).to include "providerName is missing at index 0"
-            expect(subject[:contracts]).to include "contentType is missing at index 0"
-            expect(subject[:contracts]).to include "specification is missing at index 0"
-          end
-        end
-      end
-    end
-  end
-end