pact_broker 2.89.1 → 2.90.0

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

@@ -1,51 +0,0 @@
-require "pact_broker/api/resources/can_i_deploy"
-
-module PactBroker
-  module Api
-    module Resources
-      describe CanIDeploy do
-        include_context "stubbed services"
-
-        before do
-          allow(pacticipant_service).to receive(:find_pacticipant_by_name).and_return(pacticipant)
-          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(:matrix_service) { class_double("PactBroker::Matrix::Service").as_stubbed_const }
-
-        let(:query) do
-          {
-            pacticipant: "Foo",
-            version: "1.2.3",
-            to: "prod"
-          }
-        end
-
-        subject { get("/can-i-deploy", query, { "HTTP_ACCEPT" => "application/hal+json"}) }
-
-        context "with the wrong query" do
-          let(:query) { {} }
-
-          it "returns a 400" do
-            expect(subject.status).to eq 400
-            expect(JSON.parse(subject.body)["errors"]["pacticipant"].first).to_not be_empty
-          end
-        end
-
-        context "when the pacticipant does not exist" do
-          let(:pacticipant) { nil }
-
-          it "returns a 400" do
-            expect(subject.status).to eq 400
-            expect(JSON.parse(subject.body)["errors"]["pacticipant"].first).to match(/Foo.*found/)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require "pact_broker/api/resources/dashboard"
-
-module PactBroker
-  module Api
-    module Resources
-      describe Dashboard do
-        before do
-          td.create_pact_with_verification("Foo1", "1", "Bar", "2")
-            .create_pact_with_verification("Foo2", "1", "Bar", "2")
-            .create_pact_with_verification("Foo3", "1", "Bar", "2")
-            .create_pact_with_verification("Foo4", "1", "Bar", "2")
-        end
-
-        let(:response_body_hash) { JSON.parse(subject.body) }
-
-        let(:path) { "/dashboard" }
-
-        subject { get(path) }
-
-        it { is_expected.to be_a_hal_json_success_response }
-
-        it "returns a list of items" do
-          expect(response_body_hash["items"]).to be_a(Array)
-        end
-
-        context "with pagination" do
-          subject { get(path, { pageNumber: 1, pageSize: 1 }) }
-
-          it "only returns the items for the page" do
-            expect(response_body_hash["items"].size).to eq 1
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-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
-          ObjectSpace.each_object(::Class)
-            .select { |klass| klass < DefaultBaseResource }
-            .select(&:name)
-            .reject { |klass| klass.name.end_with?("BaseResource") }
-            .sort_by(&:name)
-        end
-
-        it "specifies which pacticipant is the one relevant to the policy" do
-          data = pact_broker_resource_classes.collect do | resource_class |
-            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
-            # resource itself can be modified.
-            # Read only resources can be read by anybody - no point wasting time getting the right pacticipant
-            if modifiable
-              def resource.consumer
-                "consumer"
-              end
-
-              def resource.provider
-                "provider"
-              end
-
-              def resource.pacticipant
-                "pacticipant"
-              end
-
-              def resource.resource_exists?
-                true
-              end
-
-              resource_class_data = {
-                resource_class_name: resource.class.name,
-              }
-
-              if resource.respond_to?(:policy_pacticipant)
-                resource_class_data[:resource_class_data] = resource.policy_pacticipant
-              end
-              resource_class_data
-            else
-              nil
-            end
-          end.compact
-
-          Approvals.verify({ resource_classes: data }, :name => "modifiable_resources", format: :json)
-        end
-      end
-    end
-  end
-end

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

@@ -1,224 +0,0 @@
-require "pact_broker/api/resources/default_base_resource"
-require "pact_broker/application_context"
-
-module PactBroker
-  module Api
-    module Resources
-      describe DefaultBaseResource do
-        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(: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 }
-
-        subject(:resource) { BaseResource.new(request, response) }
-
-        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 }
-
-          context "when the body is invalid JSON" do
-            let(:body_string) { "{" }
-
-            it "raises an error" do
-              expect { subject.params }.to raise_error InvalidJsonError
-            end
-          end
-
-          context "when the body is empty and a default is provided" do
-            let(:body_string) { "" }
-
-            it "returns the default" do
-              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) { "" }
-
-            it "raises an error" do
-              expect { subject.params }.to raise_error InvalidJsonError
-            end
-          end
-
-          context "when symbolize_names is not set" do
-            it "symbolizes the names" do
-              expect(subject.params.keys).to eq [:foo]
-            end
-          end
-
-          context "when symbolize_names is true" do
-            it "symbolizes the names" do
-              expect(subject.params(symbolize_names: true).keys).to eq [:foo]
-            end
-          end
-
-          context "when symbolize_names is false" do
-            it "does not symbolize the names" do
-              expect(subject.params(symbolize_names: false).keys).to eq ["foo"]
-            end
-          end
-        end
-
-        describe "options" do
-          subject { options "/"; last_response }
-
-          it "returns a list of allowed methods" do
-            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") }
-
-          it "cleans the query and trailing slash" do
-            expect(subject.resource_url).to eq "http://example.org/path"
-          end
-        end
-
-        describe "base_url" do
-          before do
-            allow(env).to receive(:[]).with("pactbroker.base_url").and_return("http://rack")
-          end
-
-          context "when pactbroker.base_url is set on the env" do
-            it "uses that" do
-              expect(subject.base_url).to eq "http://rack"
-            end
-          end
-
-          context "when the rack env value is not set" do
-            before do
-              allow(env).to receive(:[]).with("pactbroker.base_url").and_return(nil)
-            end
-
-            it "returns the base URL from the request" do
-              expect(subject.base_url).to eq "http://example.org"
-            end
-          end
-        end
-
-        describe "decorator_options" do
-          before do
-            allow(env).to receive(:[]).with("QUERY_STRING").and_return("foo=bar")
-          end
-
-          context "with no overrides" do
-            it "returns the default decorator options" do
-              expect(subject.decorator_options).to eq(
-                user_options: {
-                  base_url: "http://example.org",
-                  resource_url: "http://example.org/path",
-                  env: env,
-                  resource_title: nil,
-                  query_string: "foo=bar"
-                }
-              )
-            end
-          end
-
-          context "with overrides" do
-            it "returns the default decorator options" do
-              expect(subject.decorator_options(resource_title: "foo", something: "else")).to eq(
-                user_options: {
-                  base_url: "http://example.org",
-                  resource_url: "http://example.org/path",
-                  env: env,
-                  resource_title: "foo",
-                  something: "else",
-                  query_string: "foo=bar"
-                }
-              )
-            end
-          end
-        end
-
-        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(:allowed) { true }
-
-            it "calls the resource authorizer" do
-              expect(resource_authorizer).to receive(:call).with(resource)
-              resource.forbidden?
-            end
-
-            context "when the authorizer returns true" do
-              it "returns false" do
-                expect(resource.forbidden?).to eq false
-              end
-            end
-
-            context "when the authorizer returns false" do
-              let(:allowed) { false }
-
-              it "returns true" do
-                expect(resource.forbidden?).to eq true
-              end
-            end
-          end
-        end
-
-        context "with no resource_authorizer configured" do
-          it "returns false" do
-            expect(resource.forbidden?).to eq false
-          end
-        end
-      end
-
-      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(:[]).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, 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) }
-
-          it "includes OPTIONS in the list of allowed_methods" do
-            expect(resource.allowed_methods).to include "OPTIONS"
-          end
-
-          it "calls super in its constructor" do
-            expect(application_context.before_resource).to receive(:call)
-            expect(PactBroker.configuration.before_resource).to receive(:call)
-            resource
-          end
-
-          it "calls super in finish_request" do
-            expect(application_context.after_resource).to receive(:call)
-            expect(PactBroker.configuration.after_resource).to receive(:call)
-            resource.finish_request
-          end
-
-          it "has a policy_name method" do
-            expect(resource).to respond_to(:policy_name)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-require "pact_broker/api/resources/error_response_body_generator"
-
-module PactBroker
-  module Api
-    module Resources
-      describe ErrorResponseBodyGenerator do
-        describe ".call" do
-          before do
-            allow(error).to receive(:backtrace).and_return(["backtrace"])
-          end
-          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"
-          end
-
-          context "when show_backtrace_in_error_response? is true" do
-            before do
-              allow(PactBroker.configuration).to receive(:show_backtrace_in_error_response?).and_return(true)
-            end
-
-            context "when the error is a PactBroker::Error or subclass" do
-              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"
-              end
-
-              it "includes the backtrace in the error response" do
-                expect(subject["error"]).to include("backtrace")
-              end
-            end
-          end
-
-          context "when show_backtrace_in_error_response? is false" do
-            before do
-              allow(PactBroker.configuration).to receive(:show_backtrace_in_error_response?).and_return(false)
-            end
-
-            context "when the error is a PactBroker::Error or subclass" do
-              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"
-              end
-
-              it "does not include the backtrace in the error response" do
-                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/)
-              end
-
-              it "does not include the backtrace in the error response" do
-                expect(subject["error"]).to_not include("backtrace")
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/resources/group"
-require "pact_broker/groups/service"
-require "rack/test"
-
-module PactBroker::Api
-  module Resources
-    describe Group do
-      include Rack::Test::Methods
-
-      let(:app) { PactBroker::API }
-
-      describe "GET" do
-        let(:group) { double("group") }
-        let(:decorator) { instance_double(PactBroker::Api::Decorators::RelationshipsCsvDecorator) }
-        let(:csv) { "csv" }
-        let(:pacticipant) { double("pacticipant")}
-
-        before do
-          allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).and_return(pacticipant)
-          allow(PactBroker::Groups::Service).to receive(:find_group_containing).and_return(group)
-          allow(PactBroker::Api::Decorators::RelationshipsCsvDecorator).to receive(:new).and_return(decorator)
-          allow(decorator).to receive(:to_csv).and_return(csv)
-        end
-
-        subject { get "/groups/Some%20Service", "", {"HTTP_X_My_App_Version" => "2"} }
-
-        context "when the pacticipant exists" do
-
-          it "looks up the pacticipant by name" do
-            expect(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).with("Some Service")
-            subject
-          end
-
-          it "finds the group containing the pacticipant" do
-            expect(PactBroker::Groups::Service).to receive(:find_group_containing).with(pacticipant)
-            subject
-          end
-
-          it "creates a CSV from the group" do
-            expect(PactBroker::Api::Decorators::RelationshipsCsvDecorator).to receive(:new).with(group)
-            subject
-          end
-
-          it "returns a 200 response" do
-            subject
-            expect(last_response.status).to eq 200
-          end
-
-          it "returns a CSV content type" do
-            subject
-            expect(last_response.headers["Content-Type"]).to eq "text/csv;charset=utf-8"
-          end
-
-          it "returns a CSV of pacticipants that are in the same group as the given pacticipant" do
-            subject
-            expect(last_response.body).to eq csv
-          end
-        end
-
-        context "when the pacticipant does not exist" do
-          let(:pacticipant) { nil }
-
-          it "returns a 404 response" do
-            subject
-            expect(last_response.status).to eq 404
-          end
-        end
-
-        context "when there is no group because the pacticipant isn't integrated with any other pacticipants" do
-          let(:group) { nil }
-
-          it "returns an empty body" do
-            expect(subject.status).to eq 200
-            expect(last_response.headers["Content-Type"]).to eq "text/csv;charset=utf-8"
-            expect(subject.body).to eq ""
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/resources/latest_pact"
-require "rack/test"
-
-module PactBroker::Api
-  module Resources
-    describe LatestPact do
-      include Rack::Test::Methods
-      describe "GET" do
-        context "Accept: text/html" do
-
-          let(:path) { "/pacts/provider/provider_name/consumer/consumer_name/latest/prod" }
-          let(:json_content) { "json_content" }
-          let(:pact) { double("pact", json_content: json_content, consumer_version_number: "1") }
-          let(:html) { "html" }
-          let(:pact_id_params) { {provider_name: "provider_name", consumer_name: "consumer_name"} }
-          let(:html_options) { { base_url: "http://example.org", badge_url: "http://example.org#{path}/badge.svg" } }
-          let(:metadata) { double("metadata") }
-          let(:accept) { "text/html" }
-
-          before do
-            allow(PactBroker::Pacts::Service).to receive(:find_latest_pact).and_return(pact)
-            allow(PactBroker.configuration.html_pact_renderer).to receive(:call).and_return(html)
-            allow_any_instance_of(LatestPact).to receive(:ui_base_url).and_return("http://example.org")
-          end
-
-          subject { get(path, nil, "HTTP_ACCEPT" => accept) }
-
-          it "find the pact" do
-            expect(PactBroker::Pacts::Service).to receive(:find_latest_pact).with(hash_including(pact_id_params))
-            subject
-          end
-
-          it "uses the configured HTML renderer" do
-            expect(PactBroker.configuration.html_pact_renderer).to receive(:call).with(pact, hash_including(html_options))
-            subject
-          end
-
-
-          it "returns a HTML body" do
-            subject
-            expect(last_response.body).to eq html
-          end
-
-          it "returns a content type of HTML" do
-            subject
-            expect(last_response.headers["Content-Type"]).to eq "text/html;charset=utf-8"
-          end
-
-          context "when Accept is application/hal+json" do
-            let(:accept) { "application/hal+json" }
-            let(:decorator) { instance_double(PactBroker::Api::Decorators::PactDecorator, to_json: pact_json)}
-            let(:pact_json) { { some: "json" }.to_json }
-
-            before do
-              allow(PactBroker::Api::Decorators::PactDecorator).to receive(:new).and_return(decorator)
-              allow(PactBroker::Pacts::Metadata).to receive(:build_metadata_for_latest_pact).and_return(metadata)
-              allow_any_instance_of(LatestPact).to receive(:encode_metadata).and_return("encoded metadata")
-            end
-
-            it "builds the metadata" do
-              expect(PactBroker::Pacts::Metadata).to receive(:build_metadata_for_latest_pact).with(pact, hash_including(tag: "prod"))
-              subject
-            end
-
-            it "encodes the metadata" do
-              expect_any_instance_of(LatestPact).to receive(:encode_metadata).with(metadata)
-              subject
-            end
-
-            it "renders the pact in JSON" do
-              expect(decorator).to receive(:to_json).with(user_options: hash_including(metadata: "encoded metadata"))
-              expect(subject.body).to eq pact_json
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require "pact_broker/api/resources/latest_provider_pacts"
-
-module PactBroker
-  module Api
-    module Resources
-      describe LatestProviderPacts do
-        before do
-          allow(PactBroker::Pacts::Service).to receive(:find_latest_pacts_for_provider).and_return(pacts)
-          allow(PactBroker::Api::Decorators::ProviderPactsDecorator).to receive(:new).and_return(decorator)
-          allow_any_instance_of(LatestProviderPacts).to receive(:resource_exists?).and_return(provider)
-        end
-
-        let(:provider) { double("provider") }
-        let(:pacts) { double("pacts") }
-        let(:path) { "/pacts/provider/Bar/latest" }
-        let(:decorator) { instance_double("PactBroker::Api::Decorators::ProviderPactsDecorator") }
-
-        subject { get path; last_response }
-
-        context "with no tag" do
-          it "finds the pacts" do
-            expect(PactBroker::Pacts::Service).to receive(:find_latest_pacts_for_provider).with("Bar", tag: nil)
-            subject
-          end
-
-          it "sets the correct resource title" do
-            expect(decorator).to receive(:to_json) do | options |
-              expect(options[:user_options][:title]).to eq "Latest pact versions for the provider Bar"
-            end
-            subject
-          end
-        end
-
-        context "with a tag" do
-          let(:path) { "/pacts/provider/Bar/latest/prod" }
-
-          it "finds the pacts with a tag" do
-            expect(PactBroker::Pacts::Service).to receive(:find_latest_pacts_for_provider).with("Bar", tag: "prod")
-            subject
-          end
-
-          it "sets the correct resource title" do
-            expect(decorator).to receive(:to_json) do | options |
-              expect(options[:user_options][:title]).to eq "Latest pact versions for the provider Bar with consumer version tag 'prod'"
-            end
-            subject
-          end
-        end
-      end
-    end
-  end
-end