pact_broker 2.77.0 → 2.80.0

data/spec/lib/pact_broker/api/resources/badge_spec.rb

@@ -1,6 +1,6 @@
-require 'pact_broker/api/resources/badge'
-require 'pact_broker/badges/service'
-require 'pact_broker/matrix/service'
+require "pact_broker/api/resources/badge"
+require "pact_broker/badges/service"
+require "pact_broker/matrix/service"
 
 module PactBroker
   module Api
@@ -19,12 +19,12 @@ module PactBroker
         end
 
         let(:pact) { instance_double("PactBroker::Domain::Pact", consumer: consumer, provider: provider, consumer_version_number: "2", revision_number: "1") }
-        let(:consumer) { double('consumer') }
-        let(:provider) { double('provider') }
+        let(:consumer) { double("consumer") }
+        let(:provider) { double("provider") }
         let(:verification) { double("verification", provider_version_number: "3", number: "7") }
         let(:pseudo_branch_verification_status) { instance_double("PactBroker::Verifications::PseudoBranchStatus", to_sym: :verified) }
 
-        subject { get path, params, {'HTTP_ACCEPT' => 'image/svg+xml'}; last_response }
+        subject { get path, params, {"HTTP_ACCEPT" => "image/svg+xml"}; last_response }
 
         context "when enable_public_badge_access is false and the request is not authenticated" do
           before do
@@ -92,7 +92,7 @@ module PactBroker
             end
 
             it "does not allow caching" do
-              expect(subject.headers['Cache-Control']).to eq 'no-cache'
+              expect(subject.headers["Cache-Control"]).to eq "no-cache"
             end
 
             it "returns the badge" do
@@ -116,22 +116,22 @@ module PactBroker
 
             it "returns a 301 redirect to the badge URL" do
               expect(subject.status).to eq 307
-              expect(subject.headers['Location']).to eq 'http://badge'
-              expect(subject.headers['Cache-Control']).to eq 'no-cache'
+              expect(subject.headers["Location"]).to eq "http://badge"
+              expect(subject.headers["Cache-Control"]).to eq "no-cache"
             end
           end
 
           context "when the label param is specified" do
-            let(:params) { {label: 'consumer'} }
+            let(:params) { {label: "consumer"} }
 
             it "creates a badge with the specified label" do
-              expect(PactBroker::Badges::Service).to receive(:pact_verification_badge).with(anything, 'consumer', anything, anything, {})
+              expect(PactBroker::Badges::Service).to receive(:pact_verification_badge).with(anything, "consumer", anything, anything, {})
               subject
             end
           end
 
           context "when the initials param is true" do
-            let(:params) { {initials: 'true'} }
+            let(:params) { {initials: "true"} }
 
             it "creates a badge with initials" do
               expect(PactBroker::Badges::Service).to receive(:pact_verification_badge).with(anything, anything, true, anything, {})
@@ -151,7 +151,7 @@ module PactBroker
             let(:path) { "/pacts/provider/provider/consumer/consumer/latest/prod/badge" }
 
             it "retrieves the latest verification for the pact's consumer and provider and specified tag" do
-              expect(PactBroker::Verifications::Service).to receive(:find_latest_verification_for).with(anything, anything, 'prod')
+              expect(PactBroker::Verifications::Service).to receive(:find_latest_verification_for).with(anything, anything, "prod")
               subject
             end
           end
@@ -163,14 +163,14 @@ module PactBroker
             end
 
             let(:path) { "/matrix/provider/provider/latest/master/consumer/consumer/latest/prod/badge" }
-            let(:row) { { consumer_name: 'consumer', provider_name: 'provider' } }
+            let(:row) { { consumer_name: "consumer", provider_name: "provider" } }
 
             context "when a pact is found" do
               it "looks up the verification" do
                 expect(PactBroker::Verifications::Service).to receive(:find_latest_verification_for_tags) do | consumer, provider, tag|
-                  expect(consumer.name).to eq 'consumer'
-                  expect(provider.name).to eq 'provider'
-                  expect(tag).to eq 'prod'
+                  expect(consumer.name).to eq "consumer"
+                  expect(provider.name).to eq "provider"
+                  expect(tag).to eq "prod"
                 end
                 subject
               end

data/spec/lib/pact_broker/api/resources/can_i_deploy_badge_spec.rb

@@ -1,4 +1,4 @@
-require 'pact_broker/api/resources/can_i_deploy_badge'
+require "pact_broker/api/resources/can_i_deploy_badge"
 
 module PactBroker
   module Api
@@ -11,7 +11,7 @@ module PactBroker
           allow_any_instance_of(described_class).to receive(:version_service).and_return(version_service)
           allow(badge_service).to receive(:can_i_deploy_badge_url).and_return("http://badge")
           allow(badge_service).to receive(:error_badge_url).and_return("http://error")
-          allow(matrix_service).to receive(:find).and_return(results)
+          allow(matrix_service).to receive(:can_i_deploy).and_return(results)
           allow(pacticipant_service).to receive(:find_pacticipant_by_name).and_return(pacticipant)
           allow(version_service).to receive(:find_by_pacticipant_name_and_latest_tag).and_return(version)
           allow(PactBroker.configuration).to receive(:show_backtrace_in_error_response?).and_return(false)
@@ -22,9 +22,9 @@ module PactBroker
         let(:badge_service) { class_double("PactBroker::Badges::Service").as_stubbed_const }
         let(:matrix_service) { class_double("PactBroker::Matrix::Service").as_stubbed_const }
         let(:version_service) { class_double("PactBroker::Version::Service").as_stubbed_const }
-        let(:results) { double('results', deployable?: true) }
-        let(:pacticipant) { double('pacticipant') }
-        let(:version) { double('version') }
+        let(:results) { double("results", deployable?: true) }
+        let(:pacticipant) { double("pacticipant") }
+        let(:version) { double("version") }
 
         let(:path) { "/pacticipants/Foo/latest-version/main/can-i-deploy/to/prod/badge"}
 
@@ -66,7 +66,7 @@ module PactBroker
 
         context "when there is an error" do
           before do
-            allow(matrix_service).to receive(:find).and_raise("foo error")
+            allow(matrix_service).to receive(:can_i_deploy).and_raise("foo error")
           end
 
           it "returns a redirect to a badge with an error message" do

data/spec/lib/pact_broker/api/resources/can_i_deploy_pacticipant_version_spec.rb

@@ -1,5 +1,5 @@
-require 'pact_broker/api/resources/can_i_deploy_pacticipant_version'
-require 'pact_broker/matrix/service'
+require "pact_broker/api/resources/can_i_deploy_pacticipant_version"
+require "pact_broker/matrix/service"
 
 module PactBroker
   module Api
@@ -8,21 +8,21 @@ module PactBroker
         include_context "stubbed services"
 
         before do
-          allow(PactBroker::Matrix::Service).to receive(:find).and_return([])
+          allow(PactBroker::Matrix::Service).to receive(:can_i_deploy).and_return([])
           allow(pacticipant_service).to receive(:find_pacticipant_by_name).and_return(pacticipant)
           allow(version_service).to receive(:find_by_pacticipant_name_and_latest_tag).and_return(version)
           allow(PactBroker::Api::Decorators::MatrixDecorator).to receive(:new).and_return(decorator)
         end
 
-        let(:pacticipant) { double('pacticipant') }
-        let(:version) { double('version') }
+        let(:pacticipant) { double("pacticipant") }
+        let(:version) { double("version") }
         let(:path) { "/pacticipants/Foo/latest-version/main/can-i-deploy/to/prod" }
         let(:json_response_body) { JSON.parse(subject.body, symbolize_names: true) }
-        let(:decorator) { double('decorator', to_json: 'response_body') }
-        let(:selectors) { double('selectors') }
-        let(:options) { double('options') }
+        let(:decorator) { double("decorator", to_json: "response_body") }
+        let(:selectors) { double("selectors") }
+        let(:options) { double("options") }
 
-        subject { get(path, nil, 'Content-Type' => 'application/hal+json') }
+        subject { get(path, nil, "Content-Type" => "application/hal+json") }
 
         it { is_expected.to be_a_hal_json_success_response }
       end

data/spec/lib/pact_broker/api/resources/can_i_deploy_spec.rb

@@ -1,4 +1,4 @@
-require 'pact_broker/api/resources/can_i_deploy'
+require "pact_broker/api/resources/can_i_deploy"
 
 module PactBroker
   module Api
@@ -8,14 +8,14 @@ module PactBroker
 
         before do
           allow(pacticipant_service).to receive(:find_pacticipant_by_name).and_return(pacticipant)
-          allow(matrix_service).to receive(:find).and_return(results)
+          allow(matrix_service).to receive(:can_i_deploy).and_return(results)
           allow_any_instance_of(described_class).to receive(:matrix_service).and_return(matrix_service)
           allow(PactBroker::Api::Decorators::MatrixDecorator).to receive(:new).and_return(decorator)
         end
 
-        let(:results) { double('results') }
-        let(:pacticipant) { double('pacticipant') }
-        let(:decorator) { instance_double('PactBroker::Api::Decorators::MatrixDecorator', to_json: 'response_body') }
+        let(:results) { double("results") }
+        let(:pacticipant) { double("pacticipant") }
+        let(:decorator) { instance_double("PactBroker::Api::Decorators::MatrixDecorator", to_json: "response_body") }
         let(:matrix_service) { class_double("PactBroker::Matrix::Service").as_stubbed_const }
 
         let(:query) do
@@ -26,7 +26,7 @@ module PactBroker
           }
         end
 
-        subject { get("/can-i-deploy", query, { 'HTTP_ACCEPT' => 'application/hal+json'}) }
+        subject { get("/can-i-deploy", query, { "HTTP_ACCEPT" => "application/hal+json"}) }
 
         context "with the wrong query" do
           let(:query) { {} }
@@ -42,7 +42,7 @@ module PactBroker
 
           it "returns a 400" do
             expect(subject.status).to eq 400
-            expect(JSON.parse(subject.body)["errors"]["pacticipant"].first).to match /Foo.*found/
+            expect(JSON.parse(subject.body)["errors"]["pacticipant"].first).to match(/Foo.*found/)
           end
         end
       end

data/spec/lib/pact_broker/api/resources/dashboard_spec.rb

@@ -1,4 +1,4 @@
-require 'pact_broker/api/resources/dashboard'
+require "pact_broker/api/resources/dashboard"
 
 module PactBroker
   module Api

data/spec/lib/pact_broker/api/resources/default_base_resource_approval_spec.rb

@@ -1,11 +1,10 @@
-require 'pact_broker/api/resources'
-
+require "pact_broker/api/resources"
 module PactBroker
   module Api
     module Resources
       RSpec.describe "modifiable resources (ones that require write access)" do
         let(:pact_broker_resource_classes) do
-          all_resources = ObjectSpace.each_object(::Class)
+          ObjectSpace.each_object(::Class)
             .select { |klass| klass < DefaultBaseResource }
             .select(&:name)
             .reject { |klass| klass.name.end_with?("BaseResource") }
@@ -14,8 +13,10 @@ module PactBroker
 
         it "specifies which pacticipant is the one relevant to the policy" do
           data = pact_broker_resource_classes.collect do | resource_class |
-            request = double('request', uri: URI("http://example.org")).as_null_object
-            response = double('response')
+            application_context = PactBroker::ApplicationContext.default_application_context
+            path_info = { pacticipant_name: "Foo", pacticipant_version_number: "1", application_context: application_context }
+            request = double("request", uri: URI("http://example.org"), path_info: path_info, body: "{}").as_null_object
+            response = double("response")
             resource = resource_class.new(request, response)
             modifiable = resource.allowed_methods.any?{ | method | %w{PATCH POST PUT DELETE}.include?(method) }
             # We only care about getting the right pacticipant for the policy if the
@@ -23,15 +24,15 @@ module PactBroker
             # Read only resources can be read by anybody - no point wasting time getting the right pacticipant
             if modifiable
               def resource.consumer
-                'consumer'
+                "consumer"
               end
 
               def resource.provider
-                'provider'
+                "provider"
               end
 
               def resource.pacticipant
-                'pacticipant'
+                "pacticipant"
               end
 
               def resource.resource_exists?
@@ -45,15 +46,15 @@ module PactBroker
               if resource.respond_to?(:policy_pacticipant)
                 resource_class_data[:resource_class_data] = resource.policy_pacticipant
               end
-                resource_class_data
+              resource_class_data
             else
               nil
             end
           end.compact
 
-          Approvals.verify({ resource_classes: data }, :name => 'modifiable_resources', format: :json)
+          Approvals.verify({ resource_classes: data }, :name => "modifiable_resources", format: :json)
         end
       end
     end
   end
-end
+end

data/spec/lib/pact_broker/api/resources/default_base_resource_spec.rb

@@ -1,5 +1,5 @@
-require 'pact_broker/api/resources/default_base_resource'
-require 'pact_broker/application_context'
+require "pact_broker/api/resources/default_base_resource"
+require "pact_broker/application_context"
 
 module PactBroker
   module Api
@@ -8,28 +8,28 @@ module PactBroker
         before do
           allow(env).to receive(:[]).with("pactbroker.base_url").and_return(nil)
         end
-        let(:request) { double('request', body: body, uri: uri, base_uri: URI("http://example.org/"), env: env, path_info: path_info).as_null_object }
+        let(:request) { double("request", body: body, uri: uri, base_uri: URI("http://example.org/"), env: env, path_info: path_info).as_null_object }
         let(:path_info) { { application_context: application_context, key1: "foo%20bar", key2: :value2, key3: 1.2 }}
         let(:application_context) { PactBroker::ApplicationContext.default_application_context }
-        let(:response) { double('response').as_null_object }
-        let(:uri) { URI('http://example.org/path?query') }
-        let(:body) { double('body', to_s: body_string) }
-        let(:body_string) { '' }
-        let(:env) { double('env').as_null_object }
+        let(:response) { double("response").as_null_object }
+        let(:uri) { URI("http://example.org/path?query") }
+        let(:body) { double("body", to_s: body_string) }
+        let(:body_string) { "" }
+        let(:env) { double("env").as_null_object }
 
         subject(:resource) { BaseResource.new(request, response) }
 
-        its(:resource_url) { is_expected.to eq 'http://example.org/path' }
+        its(:resource_url) { is_expected.to eq "http://example.org/path" }
 
         describe "identifier_from_path" do
           its(:identifier_from_path) { is_expected.to eq key1: "foo bar", key2: :value2, key3: 1.2 }
         end
 
         describe "params" do
-          let(:body_string) { { foo: 'bar' }.to_json }
+          let(:body_string) { { foo: "bar" }.to_json }
 
           context "when the body is invalid JSON" do
-            let(:body_string) { '{' }
+            let(:body_string) { "{" }
 
             it "raises an error" do
               expect { subject.params }.to raise_error InvalidJsonError
@@ -37,15 +37,15 @@ module PactBroker
           end
 
           context "when the body is empty and a default is provided" do
-            let(:body_string) { '' }
+            let(:body_string) { "" }
 
             it "returns the default" do
-              expect(subject.params(default: 'foo')).to eq 'foo'
+              expect(subject.params(default: "foo")).to eq "foo"
             end
           end
 
           context "when the body is empty and no default is provided" do
-            let(:body_string) { '' }
+            let(:body_string) { "" }
 
             it "raises an error" do
               expect { subject.params }.to raise_error InvalidJsonError
@@ -66,7 +66,7 @@ module PactBroker
 
           context "when symbolize_names is false" do
             it "does not symbolize the names" do
-              expect(subject.params(symbolize_names: false).keys).to eq ['foo']
+              expect(subject.params(symbolize_names: false).keys).to eq ["foo"]
             end
           end
         end
@@ -75,12 +75,12 @@ module PactBroker
           subject { options "/"; last_response }
 
           it "returns a list of allowed methods" do
-            expect(subject.headers['Access-Control-Allow-Methods']).to eq "GET, OPTIONS"
+            expect(subject.headers["Access-Control-Allow-Methods"]).to eq "GET, OPTIONS"
           end
         end
 
         describe "resource_url" do
-          let(:uri) { URI('http://example.org/path/?query') }
+          let(:uri) { URI("http://example.org/path/?query") }
 
           it "cleans the query and trailing slash" do
             expect(subject.resource_url).to eq "http://example.org/path"
@@ -147,7 +147,7 @@ module PactBroker
         describe "forbidden?" do
           context "with the resource_authorizer configured" do
             let(:application_context) { PactBroker::ApplicationContext.default_application_context(resource_authorizer: resource_authorizer) }
-            let(:resource_authorizer) { double('resource_authorizer', call: allowed) }
+            let(:resource_authorizer) { double("resource_authorizer", call: allowed) }
             let(:allowed) { true }
 
             it "calls the resource authorizer" do
@@ -181,21 +181,22 @@ module PactBroker
       ALL_RESOURCES = ObjectSpace.each_object(::Class)
         .select { |klass| klass < DefaultBaseResource }
         .select { |klass| !klass.name.end_with?("BaseResource") }
+        .sort_by(&:name)
 
       ALL_RESOURCES.each do | resource_class |
         describe resource_class do
           before do
             # stub out all path info params for pf
-            allow(path_info).to receive(:[]).and_return('1')
+            allow(path_info).to receive(:[]).and_return("1")
             allow(path_info).to receive(:[]).with(:application_context).and_return(application_context)
           end
           let(:application_context) { PactBroker::ApplicationContext.default_application_context(before_resource: before_resource, after_resource: after_resource) }
-          let(:request) { double('request', uri: URI("http://example.org"), path_info: path_info).as_null_object }
-          let(:path_info) { {} }
-          let(:response) { double('response').as_null_object }
+          let(:request) { double("request", uri: URI("http://example.org"), path_info: path_info, body: "{}").as_null_object }
+          let(:path_info) { { pacticipant_name: "foo", pacticipant_version_number: "1" } }
+          let(:response) { double("response").as_null_object }
           let(:resource) { resource_class.new(request, response) }
-          let(:before_resource) { double('before_resource', call: nil) }
-          let(:after_resource) { double('after_resource', call: nil) }
+          let(:before_resource) { double("before_resource", call: nil) }
+          let(:after_resource) { double("after_resource", call: nil) }
 
           it "includes OPTIONS in the list of allowed_methods" do
             expect(resource.allowed_methods).to include "OPTIONS"

data/spec/lib/pact_broker/api/resources/error_response_body_generator_spec.rb

@@ -1,4 +1,4 @@
-require 'pact_broker/api/resources/error_response_body_generator'
+require "pact_broker/api/resources/error_response_body_generator"
 
 module PactBroker
   module Api
@@ -8,13 +8,13 @@ module PactBroker
           before do
             allow(error).to receive(:backtrace).and_return(["backtrace"])
           end
-          let(:error) { StandardError.new('test error') }
+          let(:error) { StandardError.new("test error") }
           let(:error_reference) { "bYWfnyWPlf" }
 
           subject { JSON.parse(ErrorResponseBodyGenerator.call(error, error_reference)) }
 
           it "includes an error reference" do
-            expect(subject['error']).to  include 'reference' => "bYWfnyWPlf"
+            expect(subject["error"]).to include "reference" => "bYWfnyWPlf"
           end
 
           context "when show_backtrace_in_error_response? is true" do
@@ -23,14 +23,14 @@ module PactBroker
             end
 
             context "when the error is a PactBroker::Error or subclass" do
-              let(:error) { Class.new(PactBroker::Error).new('test error') }
+              let(:error) { Class.new(PactBroker::Error).new("test error") }
 
               it "uses the error message as the message" do
-                expect(subject['error']).to include 'message' => "test error"
+                expect(subject["error"]).to include "message" => "test error"
               end
 
               it "includes the backtrace in the error response" do
-                expect(subject['error']).to include ('backtrace')
+                expect(subject["error"]).to include("backtrace")
               end
             end
           end
@@ -41,24 +41,24 @@ module PactBroker
             end
 
             context "when the error is a PactBroker::Error or subclass" do
-              let(:error) { Class.new(PactBroker::Error).new('test error') }
+              let(:error) { Class.new(PactBroker::Error).new("test error") }
 
               it "uses the error message as the message" do
-                expect(subject['error']).to include 'message' => "test error"
+                expect(subject["error"]).to include "message" => "test error"
               end
 
               it "does not include the backtrace in the error response" do
-                expect(subject['error']).to_not include ('backtrace')
+                expect(subject["error"]).to_not include("backtrace")
               end
             end
 
             context "when the error is not a PactBroker::Error or subclass" do
               it "uses a hardcoded error message" do
-                expect(subject['error']['message']).to match /An error/
+                expect(subject["error"]["message"]).to match(/An error/)
               end
 
               it "does not include the backtrace in the error response" do
-                expect(subject['error']).to_not include ('backtrace')
+                expect(subject["error"]).to_not include("backtrace")
               end
             end
           end