pact_broker 2.89.1 → 2.90.0

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

@@ -1,133 +0,0 @@
-require "pact_broker/api/contracts/put_pact_params_contract"
-
-module PactBroker
-  module Api
-    module Contracts
-      describe PutPactParamsContract do
-        before do
-          allow(PactBroker.configuration).to receive(:order_versions_by_date).and_return(order_versions_by_date)
-        end
-
-        let(:json_content) { {"some" => "json" }.to_json }
-        let(:pact_params) { Pacts::PactParams.new(attributes) }
-        let(:order_versions_by_date) { false }
-
-        let(:valid_attributes) do
-          {
-            consumer_name: "consumer",
-            provider_name: "provider",
-            consumer_version_number: "1.2.3",
-            json_content: json_content,
-            consumer_name_in_pact: "consumer",
-            provider_name_in_pact: "provider"
-          }
-        end
-
-        subject { PutPactParamsContract.new(pact_params) }
-
-        describe "errors" do
-          let(:attributes) { valid_attributes }
-
-          before do
-            subject.validate(attributes)
-          end
-
-          context "with valid params" do
-
-            it "is empty" do
-              expect(subject.errors).to be_empty
-            end
-          end
-
-          context "with a nil consumer version number" do
-            let(:attributes) do
-              valid_attributes.merge(consumer_version_number: nil)
-            end
-
-            it "returns an error" do
-              expect(subject.errors[:consumer_version_number]).to include("can't be blank")
-            end
-          end
-
-          context "with an empty consumer version number" do
-            let(:attributes) do
-              valid_attributes.merge(consumer_version_number: "")
-            end
-
-            it "returns an error" do
-              expect(subject.errors[:consumer_version_number]).to include("can't be blank")
-            end
-          end
-
-          context "with an invalid version number" do
-            let(:attributes) do
-              valid_attributes.merge(consumer_version_number: "blah")
-            end
-
-            it "returns an error" do
-              expect(subject.errors[:consumer_version_number]).to include(/Consumer version number 'blah' cannot be parsed to a version number/)
-            end
-          end
-
-          context "when order_versions_by_date is true" do
-            let(:order_versions_by_date) { true }
-
-            context "with an invalid version number" do
-              let(:attributes) do
-                valid_attributes.merge(consumer_version_number: "blah")
-              end
-
-              it "does not return an error" do
-                expect(subject.errors[:consumer_version_number]).to be_empty
-              end
-            end
-          end
-
-          context "with a consumer name in the pact that does not match the consumer name in the path" do
-            let(:attributes) do
-              valid_attributes.merge(consumer_name: "another consumer")
-            end
-
-            it "returns an error" do
-              expect(subject.errors[:'consumer.name']).to include("does not match consumer name in path ('another consumer').")
-            end
-          end
-
-          context "with a provider name in the pact that does not match the provider name in the path" do
-            let(:attributes) do
-              valid_attributes.merge(provider_name: "another provider")
-            end
-
-            it "returns an error" do
-              expect(subject.errors[:'provider.name']).to include("does not match provider name in path ('another provider').")
-            end
-          end
-
-          context "when the consumer name in the pact is not present" do
-            let(:attributes) do
-              valid_attributes.tap do | atts |
-                atts.delete(:consumer_name_in_pact)
-              end
-            end
-
-            it "returns no error because I don't want to stop a different CDC from being published" do
-              expect(subject.errors).to be_empty
-            end
-          end
-
-          context "when the provider name in the pact is not present" do
-            let(:attributes) do
-              valid_attributes.tap do | atts |
-                atts.delete(:provider_name_in_pact)
-              end
-            end
-
-            it "returns no error because I don't want to stop a different CDC from being published" do
-              expect(subject.errors).to be_empty
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,112 +0,0 @@
-require "pact_broker/api/contracts/verification_contract"
-require "pact_broker/api/decorators/verification_decorator"
-require "pact_broker/domain/verification"
-
-module PactBroker
-  module Api
-    module Contracts
-      describe VerificationContract do
-
-        subject { VerificationContract.new(verification) }
-        let(:verification) { PactBroker::Domain::Verification.new }
-        let(:valid_params) { {success: success, providerApplicationVersion: provider_version, buildUrl: build_url} }
-        let(:params) { valid_params }
-
-        let(:success) { true }
-        let(:provider_version) { "4.5.6" }
-        let(:build_url) { "http://foo" }
-        let(:order_versions_by_date) { false }
-
-        def modify hash, options
-          hash.delete(options.fetch(:without))
-          hash
-        end
-
-        describe "errors" do
-
-          before do
-            allow(PactBroker.configuration).to receive(:order_versions_by_date).and_return(order_versions_by_date)
-            subject.validate(params)
-          end
-
-          context "with valid fields" do
-            its(:errors) { is_expected.to be_empty }
-          end
-
-          context "with no success property" do
-            let(:success) { nil }
-
-            it "has an error" do
-              expect(subject.errors[:success]).to include(match("blank"))
-            end
-          end
-
-          context "when success is a non-boolean string" do
-            let(:success) { "foo" }
-            it "has an error" do
-              expect(subject.errors[:success]).to include(match("boolean"))
-            end
-          end
-
-          context "when buildUrl is not a URL" do
-            let(:build_url) { "foo bar" }
-            it "has an error" do
-              expect(subject.errors[:build_url]).to include(match("URL"))
-            end
-          end
-
-          context "when buildUrl is nil" do
-            let(:build_url) { nil }
-            its(:errors) { is_expected.to be_empty }
-          end
-
-          context "when the buildURL is not present" do
-            let(:params) { modify valid_params, without: :buildUrl }
-            its(:errors) { is_expected.to be_empty }
-          end
-
-          context "when the buildURL is not stringable" do
-            let(:build_url) { {} }
-
-            it "has an error" do
-              expect(subject.errors[:build_url]).to include(match("URL"))
-            end
-          end
-
-          context "when the providerApplicationVersion is not present" do
-            let(:params) { modify valid_params, without: :providerApplicationVersion }
-            it "has an error" do
-              expect(subject.errors[:provider_version]).to include(match("can't be blank"))
-            end
-          end
-
-          context "when the providerApplicationVersion is blank" do
-            let(:provider_version) { " " }
-            it "has an error" do
-              expect(subject.errors[:provider_version]).to include(match("can't be blank"))
-            end
-          end
-
-          context "when order_versions_by_date is true" do
-            let(:order_versions_by_date) { true }
-
-            context "when the providerApplicationVersion is not a semantic version" do
-              let(:provider_version) { "#" }
-              its(:errors) { is_expected.to be_empty }
-            end
-          end
-
-          context "when order_versions_by_date is false" do
-            context "when the providerApplicationVersion is not a semantic version" do
-              let(:provider_version) { "#" }
-
-              it "has an error" do
-                expect(subject.errors[:provider_version]).to include(match("#.*cannot be parsed"))
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,379 +0,0 @@
-require "pact_broker/api/contracts/webhook_contract"
-require "pact_broker/api/decorators/webhook_decorator"
-
-module PactBroker
-  module Api
-    module Contracts
-      describe WebhookContract do
-        let(:json) { load_fixture "webhook_valid_with_pacticipants.json" }
-        let(:hash) { JSON.parse(json) }
-        let(:webhook) { PactBroker::Api::Decorators::WebhookDecorator.new(Domain::Webhook.new).from_json(json) }
-        let(:subject) { WebhookContract.new(webhook) }
-        let(:matching_hosts) { ["foo"] }
-        let(:consumer) { double("consumer") }
-        let(:provider) { double("provider") }
-
-        def valid_webhook_with
-          hash = load_json_fixture "webhook_valid_with_pacticipants.json"
-          yield hash
-          hash.to_json
-        end
-
-        describe "errors" do
-          before do
-            PactBroker.configuration.webhook_http_method_whitelist = webhook_http_method_whitelist
-            PactBroker.configuration.webhook_host_whitelist = webhook_host_whitelist
-            allow(PactBroker::Webhooks::CheckHostWhitelist).to receive(:call).and_return(whitelist_matches)
-            allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).with("Foo").and_return(consumer)
-            allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).with("Bar").and_return(provider)
-            subject.validate(hash)
-          end
-
-          let(:webhook_http_method_whitelist) { ["POST"] }
-          let(:whitelist_matches) { ["foo"] }
-          let(:webhook_host_whitelist) { [] }
-
-          context "with valid fields" do
-            it "is empty" do
-              expect(subject.errors).to be_empty
-            end
-          end
-
-          context "with a nil consumer name" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["consumer"]["name"] = nil
-              end
-            end
-
-            it "contains an error" do
-              expect(subject.errors[:'consumer.name']).to eq ["can't be blank"]
-            end
-          end
-
-          context "with no consumer name key" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["consumer"].delete("name")
-              end
-            end
-
-            # I'd prefer this to be "is missing". Isn't the whole point of dry validation
-            # that you can distingush between keys being missing and values being missing? FFS.
-            it "contains an error" do
-              expect(subject.errors[:'consumer.name']).to eq ["can't be blank"]
-            end
-          end
-
-          context "with no consumer" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash.delete("consumer")
-              end
-            end
-
-            it "contains no errors" do
-              expect(subject.errors).to be_empty
-            end
-          end
-
-          context "with a consumer name that doesn't match any existing consumer" do
-            let(:consumer) { nil }
-
-            it "contains no errors" do
-              expect(subject.errors[:'consumer.name']).to eq ["does not match an existing pacticipant"]
-            end
-          end
-
-          context "with a consumer label" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["consumer"].delete("name")
-                hash["consumer"]["label"] = "my_label"
-              end
-            end
-
-            it "contains no errors" do
-              expect(subject.errors).to be_empty
-            end
-          end
-
-          context "with a consumer label and name provided" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["consumer"]["label"] = "my_label"
-              end
-            end
-
-            it "contains consumer.label error" do
-              expect(subject.errors.messages).to eq({:'consumer.label' => ["cannot be provided"]})
-            end
-          end
-
-          context "with a nil provider name" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["provider"]["name"] = nil
-              end
-            end
-
-            it "contains an error" do
-              expect(subject.errors[:'provider.name']).to eq ["can't be blank"]
-            end
-          end
-
-          context "with no provider name key" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["provider"].delete("name")
-              end
-            end
-
-            # I'd prefer this to be "is missing". Isn't the whole point of dry validation
-            # that you can distingush between keys being missing and values being missing? FFS.
-            it "contains an error" do
-              expect(subject.errors[:'provider.name']).to eq ["can't be blank"]
-            end
-          end
-
-          context "with no provider" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash.delete("provider")
-              end
-            end
-
-            it "contains no errors" do
-              expect(subject.errors).to be_empty
-            end
-          end
-
-          context "with a provider name that doesn't match any existing provider" do
-            let(:provider) { nil }
-
-            it "contains no errors" do
-              expect(subject.errors[:'provider.name']).to eq ["does not match an existing pacticipant"]
-            end
-          end
-
-          context "with provider label" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["provider"].delete("name")
-                hash["provider"]["label"] = "my_label"
-              end
-            end
-
-            it "contains no errors" do
-              expect(subject.errors).to be_empty
-            end
-          end
-
-          context "with a provider label and name" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["provider"]["label"] = "my_label"
-              end
-            end
-
-            it "contains provider.label error" do
-              expect(subject.errors.messages).to eq({:'provider.label' => ["cannot be provided"]})
-            end
-          end
-
-          context "with no request defined" do
-            let(:json) { {}.to_json }
-
-            it "contains an error for missing request" do
-              expect(subject.errors[:request]).to eq ["can't be blank"]
-            end
-          end
-
-          context "with no events defined" do
-            let(:json) { {}.to_json }
-
-            it "does not contain an error for missing event, as it will be defaulted" do
-              expect(subject.errors.messages[:events]).to be nil
-            end
-          end
-
-          context "with empty events" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["events"] = []
-              end
-            end
-
-            it "contains an error for missing request" do
-              expect(subject.errors[:events]).to eq ["size cannot be less than 1"]
-            end
-          end
-
-          context "with an event with an invalid name" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["events"].first["name"] = "foo"
-              end
-            end
-
-            it "contains an error" do
-              expect(subject.errors[:'events.name'].first).to include "must be one of"
-            end
-          end
-
-          context "with no method" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["request"].delete("method")
-              end
-            end
-
-            it "contains an error for missing method" do
-              expect(subject.errors[:"request.http_method"]).to include "can't be blank"
-            end
-          end
-
-          context "with an invalid method" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["request"]["method"] = "blah"
-              end
-            end
-
-            it "contains an error for invalid method" do
-              expect(subject.errors[:"request.http_method"]).to include "is not a recognised HTTP method"
-            end
-          end
-
-          context "with an invalid scheme" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["request"]["url"] = "ftp://foo"
-              end
-            end
-
-            it "contains an error for the URL" do
-              expect(subject.errors[:"request.url"]).to include "scheme must be https. See /doc/webhooks#whitelist for more information."
-            end
-          end
-
-          context "with an HTTP method that is not whitelisted" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["request"]["method"] = "DELETE"
-              end
-            end
-
-            context "when there is only one allowed HTTP method" do
-              it "contains an error for invalid method" do
-                expect(subject.errors[:"request.http_method"]).to include "must be POST. See /doc/webhooks#whitelist for more information."
-              end
-            end
-
-            context "when there is more than one allowed HTTP method", pending: "need to work out how to dynamically create this message" do
-              let(:webhook_http_method_whitelist) { ["POST", "GET"] }
-
-              it "contains an error for invalid method" do
-                expect(subject.errors[:"request.http_method"]).to include "must be one of POST, GET"
-              end
-            end
-          end
-
-          context "when the host whitelist is empty" do
-            it "does not attempt to validate the host" do
-              expect(PactBroker::Webhooks::CheckHostWhitelist).to_not have_received(:call)
-            end
-          end
-
-          context "when the host whitelist is populated" do
-            let(:webhook_host_whitelist) { [/foo/, "bar"] }
-
-            it "validates the host" do
-              expect(PactBroker::Webhooks::CheckHostWhitelist).to have_received(:call).with("some.url", webhook_host_whitelist)
-            end
-
-            context "when the host does not match the whitelist" do
-              let(:whitelist_matches) { [] }
-
-              it "contains an error", pending: "need to work out how to do dynamic messages" do
-                expect(subject.errors[:"request.url"]).to include "host must be in the whitelist /foo/, \"bar\" . See /doc/webhooks#whitelist for more information."
-              end
-            end
-          end
-
-          context "with no URL" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["request"].delete("url")
-              end
-            end
-
-            it "contains an error for missing URL" do
-              expect(subject.errors[:"request.url"]).to include "can't be blank"
-            end
-          end
-
-          context "with an invalid URL" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["request"]["url"] = "bl ah"
-              end
-            end
-
-            it "contains an error for invalid URL" do
-              expect(subject.errors[:"request.url"]).to eq ["is not a valid URL eg. http://example.org"]
-            end
-          end
-
-          context "with an URL missing a scheme" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["request"]["url"] = "blah"
-              end
-            end
-
-            it "contains an error for invalid URL" do
-              expect(subject.errors[:"request.url"]).to eq ["is not a valid URL eg. http://example.org"]
-            end
-          end
-
-          context "with a URL that has templated parameters in it" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["request"]["url"] = "https://foo/commits/${pactbroker.consumerVersionNumber}"
-              end
-            end
-
-            it "is empty" do
-              expect(subject.errors).to be_empty
-            end
-          end
-
-          context "with a URL that has templated parameters in the host" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["request"]["url"] = "https://${pactbroker.consumerVersionNumber}/commits"
-              end
-            end
-
-            it "contains an error" do
-              expect(subject.errors[:"request.url"]).to eq ["cannot have a template parameter in the host"]
-            end
-          end
-
-          context "when enabled is not a boolean", pending: "I can't work out why this doesn't work" do
-            let(:json) do
-              valid_webhook_with do |hash|
-                hash["enabled"] = "foo"
-              end
-            end
-
-            it "contains an error" do
-              expect(subject.errors[:enabled]).to eq ["cannot have a template parameter in the host"]
-            end
-          end
-        end
-      end
-    end
-  end
-end