pact_broker-client 1.75.3 → 1.75.4

data/spec/lib/pact_broker/client/environments/update_environment_spec.rb

@@ -1,167 +0,0 @@
-require 'pact_broker/client/environments/update_environment'
-
-module PactBroker
-  module Client
-    module Environments
-      describe UpdateEnvironment do
-        before do
-          allow_any_instance_of(PactBroker::Client::Hal::HttpClient).to receive(:sleep)
-          allow_any_instance_of(PactBroker::Client::Hal::HttpClient).to receive(:default_max_tries).and_return(1)
-        end
-
-        let(:params) do
-          {
-            uuid: uuid,
-            name: "new name",
-            display_name: "new display name",
-            production: false
-          }
-        end
-        let(:options) do
-          {
-            output: output,
-            verbose: verbose
-          }
-        end
-        let(:uuid) { "a9aa4c22-66bb-45d3-ba4c-4916ac8b48c5" }
-        let(:pact_broker_base_url) { "http://example.org" }
-        let(:pact_broker_client_options) { { pact_broker_base_url: pact_broker_base_url } }
-        let(:response_headers) { { "Content-Type" => "application/hal+json"} }
-        let(:output) { "text" }
-        let(:verbose) { false }
-
-        before do
-          stub_request(:get, "http://example.org/").to_return(status: 200, body: index_response_body, headers: response_headers)
-          stub_request(:get, "http://example.org/environments/#{uuid}").to_return(status: get_environment_response_status, body: get_environment_response_body, headers: response_headers)
-          stub_request(:put, "http://example.org/environments/#{uuid}").to_return(status: put_response_status, body: put_environment_response_body, headers: response_headers)
-        end
-        let(:put_response_status) { 200 }
-        let(:get_environment_response_status) { 200 }
-        let(:put_request_body) do
-          {
-            name: "new name",
-            displayName: "new display name",
-            production: false
-          }.to_json
-        end
-
-        let(:index_response_body) do
-          {
-            "_links" => {
-              "pb:environments" => {},
-              "pb:environment" => {
-                "href" => "http://example.org/environments/{uuid}"
-              }
-            }
-          }.to_json
-        end
-
-        let(:get_environment_response_body) do
-          {
-            name: "existing name",
-            displayName: "existing display name",
-            production: true
-          }.to_json
-        end
-
-        let(:put_environment_response_body) do
-          JSON.parse(get_environment_response_body).merge("updatedAt" => "2021-05-28T13:34:54+10:00").to_json
-        end
-
-        subject { UpdateEnvironment.call(params, options, pact_broker_client_options) }
-
-        it "updates the environment" do
-          request = stub_request(:put, "http://example.org/environments/#{uuid}").with(body: put_request_body)
-          subject
-          expect(request).to have_been_made
-        end
-
-        context "when update is successful" do
-          its(:success) { is_expected.to be true }
-          its(:message) { is_expected.to include "Updated new name environment in the Pact Broker" }
-
-          context "when output is json" do
-            let(:output) { "json" }
-
-            its(:message) { is_expected.to eq put_environment_response_body }
-          end
-        end
-
-        context "when environments are not supported" do
-          let(:index_response_body) { "{}" }
-
-          its(:success) { is_expected.to be false }
-          its(:message) { is_expected.to include "does not support environments" }
-        end
-
-        context "when a StandardError occurs" do
-          before do
-            allow_any_instance_of(described_class).to receive(:do_call).and_raise(StandardError.new("Foo"))
-          end
-
-          its(:success) { is_expected.to be false }
-          its(:message) { is_expected.to include "StandardError - Foo" }
-
-          context "when verbose is on" do
-            let(:verbose) { true }
-
-            it "includes the message and class and backtrace in the error" do
-              expect(subject.message.split("\n").size).to be > 2
-            end
-          end
-
-          context "when output is json" do
-            let(:output) { "json" }
-
-            it "includes the message and class in the error" do
-              message_hash = JSON.parse(subject.message)
-              expect(message_hash).to eq "error" => { "message" => "Foo", "class" => "StandardError" }
-            end
-
-            context "when verbose is on" do
-              let(:verbose) { true }
-
-              it "includes the message and class and backtrace in the error" do
-                message_hash = JSON.parse(subject.message)
-                expect(message_hash["error"]["backtrace"]).to be_a(Array)
-              end
-            end
-          end
-        end
-
-        context "when the environment does not exist" do
-          let(:get_environment_response_status) { 404 }
-          let(:get_environment_response_body) { "" }
-          let(:put_environment_response_body) { "" }
-
-          its(:success) { is_expected.to be false }
-          its(:message) { is_expected.to include get_environment_response_body }
-
-          context "when output is json" do
-            let(:output) { "json" }
-
-            its(:message) { is_expected.to eq "{}" }
-          end
-        end
-
-        context "when update is unsuccessful" do
-          let(:put_response_status) { 400 }
-          let(:put_environment_response_body) do
-            {
-              "some" => "error"
-            }.to_json
-          end
-
-          its(:success) { is_expected.to be false }
-          its(:message) { is_expected.to include put_environment_response_body }
-
-          context "when output is json" do
-            let(:output) { "json" }
-
-            its(:message) { is_expected.to eq put_environment_response_body }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/generate_display_name_spec.rb

@@ -1,39 +0,0 @@
-require 'pact_broker/client/generate_display_name'
-
-module PactBroker
-  module Client
-    describe GenerateDisplayName do
-      describe ".call" do
-        TEST_CASES = {
-          "foo" => "Foo",
-          "MyService" => "My Service",
-          "my-service" => "My Service",
-          "my_service" => "My Service",
-          "my service" => "My Service",
-          "ABCService" => "ABC Service",
-          "A4Service" => "A4 Service",
-          "SNSPactEventConsumer" => "SNS Pact Event Consumer",
-          "AWSSummiteerWeb" => "AWS Summiteer Web",
-          "Beer-Consumer" => "Beer Consumer",
-          "foo.pretend-consumer" => "Foo Pretend Consumer",
-          "Client-XX" => "Client XX",
-          "providerJSWorkshop" => "Provider JS Workshop",
-          "e2e Provider Example" => "E2e Provider Example",
-          "MP - Our Provider" => "MP - Our Provider",
-          "PoC - Pact-broker-consumer" => "PoC - Pact Broker Consumer",
-          "QB-DATABASE Service" => "QB DATABASE Service",
-          "Support Species App (Provider)" => "Support Species App (Provider)",
-          9 => "9",
-          "" => "",
-          nil => nil
-        }
-
-        TEST_CASES.each do | name, expected_display_name |
-          it "converts #{name.inspect} to #{expected_display_name.inspect}" do
-            expect(GenerateDisplayName.call(name)).to eq expected_display_name
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/git_spec.rb

@@ -1,159 +0,0 @@
-require 'pact_broker/client/git'
-
-module PactBroker
-  module Client
-    module Git
-      describe ".branch" do
-        before do
-          allow(ENV).to receive(:[]).and_call_original
-          Git::BRANCH_ENV_VAR_NAMES.each do | env_var_name|
-            allow(ENV).to receive(:[]).with(env_var_name).and_return(nil)
-          end
-          allow(Git).to receive(:execute_git_command).and_return(" origin/HEAD \n origin/foo")
-        end
-
-        let(:raise_exception) { true }
-
-        subject { Git.branch(raise_error: raise_exception) }
-
-        shared_examples_for "when raise_error is false" do
-          context "when raise_error is false" do
-            let(:raise_exception) { false }
-
-            it { is_expected.to be nil }
-          end
-        end
-
-        context "when there is a known environment variable for the branch" do
-          before do
-            allow(ENV).to receive(:[]).with("BUILDKITE_BRANCH").and_return("")
-            allow(ENV).to receive(:[]).with("TRAVIS_BRANCH").and_return("foo")
-          end
-
-          it "returns the value of the environment variable" do
-            expect(subject).to eq "foo"
-          end
-        end
-
-        context "when the branch starts with refs/heads/" do
-          before do
-            allow(ENV).to receive(:[]).with("GITHUB_REF").and_return("refs/heads/feature-x")
-          end
-
-          it "trims off the refs/heads/" do
-            expect(subject).to eq "feature-x"
-          end
-        end
-
-        context "when there is one environment variable ending with _BRANCH" do
-          before do
-            allow(ENV).to receive(:keys).and_return(%w{FOO_BRANCH BAR_BRANCH BLAH})
-            allow(ENV).to receive(:[]).with("FOO_BRANCH").and_return("")
-            allow(ENV).to receive(:[]).with("BAR_BRANCH").and_return("meep")
-          end
-
-          it "returns the value of that environment variable" do
-            expect(subject).to eq "meep"
-          end
-        end
-
-        context "when there is more than one environment variable ending with _BRANCH" do
-          it "attempts to execute a git command to determine the value" do
-            expect(Git).to receive(:execute_git_command)
-            expect(subject).to_not be_empty
-          end
-        end
-
-        context "when there is no known environment variable for the branch", skip_ci: true do
-          it "attempts to execute a git command to determine the value" do
-            expect(Git).to receive(:execute_git_command)
-            expect(subject).to_not be_empty
-          end
-        end
-
-        context "when one git branch name is returned (apart from HEAD)" do
-          before do
-            allow(Git).to receive(:execute_git_command).and_return(" origin/HEAD \n origin/foo")
-          end
-
-          it "returns the branch" do
-            expect(subject).to eq "foo"
-          end
-        end
-
-        context "when two git branch names are returned (apart from HEAD)" do
-          before do
-            allow(Git).to receive(:execute_git_command).and_return(" origin/HEAD \n origin/foo \n origin/bar")
-          end
-
-          it "raises an error" do
-            expect { subject }.to raise_error PactBroker::Client::Error, /returned multiple branches: foo, bar/
-          end
-
-          include_examples "when raise_error is false"
-        end
-
-
-        context "when the git branch name comes back as an empty string" do
-          before do
-            allow(Git).to receive(:execute_git_command).and_return(" origin/HEAD")
-          end
-
-          it "raises an error" do
-            expect { subject }.to raise_error PactBroker::Client::Error, /didn't return anything/
-          end
-
-          include_examples "when raise_error is false"
-        end
-
-        context "when there is an error executing the git command" do
-          before do
-            allow(Git).to receive(:execute_git_command).and_raise("some error")
-          end
-
-          it "raises an error" do
-            expect { subject }.to raise_error PactBroker::Client::Error, /some error/
-          end
-
-          include_examples "when raise_error is false"
-        end
-      end
-
-      describe ".build_url" do
-        before do
-          allow(ENV).to receive(:[]).and_call_original
-        end
-
-        subject { Git.build_url }
-
-        context "when nothing is set" do
-          before do
-            allow(ENV).to receive(:[]).and_return(nil)
-          end
-
-          it { is_expected.to eq nil }
-        end
-
-        context "when BUILDKITE_BUILD_URL is set" do
-          before do
-            allow(ENV).to receive(:[]).and_return(nil)
-            allow(ENV).to receive(:[]).with("BUILDKITE_BUILD_URL").and_return("http://build")
-          end
-
-          it { is_expected.to eq "http://build" }
-        end
-
-        context "when the Github Actions env vars are set" do
-          before do
-            allow(ENV).to receive(:[]).and_return(nil)
-            allow(ENV).to receive(:[]).with("GITHUB_SERVER_URL").and_return("https://github.com")
-            allow(ENV).to receive(:[]).with("GITHUB_REPOSITORY").and_return("org/repo")
-            allow(ENV).to receive(:[]).with("GITHUB_RUN_ID").and_return("1")
-          end
-
-          it { is_expected.to eq "https://github.com/org/repo/actions/runs/1" }
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/hal/authorization_header_redactor_spec.rb

@@ -1,17 +0,0 @@
-require 'pact_broker/client/hal/authorization_header_redactor'
-
-module PactBroker
-  module Client
-    module Hal
-      describe AuthorizationHeaderRedactor do
-        let(:stream) { StringIO.new }
-        let(:stream_redactor) { AuthorizationHeaderRedactor.new(stream) }
-
-        it "redacts the authorizaton header" do
-          stream_redactor << "\\r\\nAuthorization: Bearer TOKEN\\r\\n"
-          expect(stream.string).to eq "\\r\\nAuthorization: [redacted]\\r\\n"
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/hal/entity_spec.rb

@@ -1,149 +0,0 @@
-require 'pact_broker/client/hal/entity'
-require 'pact_broker/client/hal/http_client'
-
-module PactBroker::Client
-  module Hal
-    describe Entity do
-      let(:http_client) do
-        instance_double('Pact::Hal::HttpClient', post: provider_response)
-      end
-
-      let(:provider_response) do
-        double('response', body: provider_hash, success?: true, status: status)
-      end
-      let(:status) { 200 }
-
-      let(:provider_hash) do
-        {
-          "name" => "Provider"
-        }
-      end
-
-      let(:pact_hash) do
-        {
-          "name" => "a name",
-
-          "_links" => {
-            "pb:provider" => {
-              "href" => "http://provider"
-            },
-            "pb:version-tag" => {
-              "href" => "http://provider/version/{version}/tag/{tag}"
-            }
-          }
-        }
-      end
-
-      subject(:entity) { Entity.new("http://pact", pact_hash, http_client) }
-
-      it "delegates to the properties in the data" do
-        expect(subject.name).to eq "a name"
-      end
-
-      describe "post" do
-        let(:post_provider) { entity.post("pb:provider", {'some' => 'data'} ) }
-
-        it "executes an http request" do
-          expect(http_client).to receive(:post).with("http://provider", '{"some":"data"}', {})
-          post_provider
-        end
-
-        it "returns the entity for the relation" do
-          expect(post_provider).to be_a(Entity)
-        end
-
-        context "with template params" do
-          let(:post_provider) { entity._link("pb:version-tag").expand(version: "1", tag: "prod").post({'some' => 'data'} ) }
-
-          it "posts to the expanded URL" do
-            expect(http_client).to receive(:post).with("http://provider/version/1/tag/prod", '{"some":"data"}', {})
-            post_provider
-          end
-        end
-      end
-
-      describe "assert_success!" do
-        context "when the response is successful" do
-          it "returns the entity" do
-            expect(entity.assert_success!).to be entity
-          end
-        end
-
-        context "when the response is not successful and there is no response" do
-          subject(:entity) { ErrorEntity.new("http://pact", pact_hash, http_client) }
-
-          it "raises an error" do
-            expect { entity.assert_success! }.to raise_error ErrorResponseReturned, "Error making request to http://pact status="
-          end
-        end
-
-        context "when the response is not successful and there is a response" do
-          let(:response) { double('response', status: 200, raw_body: "body") }
-
-          subject(:entity) { ErrorEntity.new("http://pact", pact_hash, http_client, response) }
-
-          it "raises an error" do
-            expect { entity.assert_success! }.to raise_error ErrorResponseReturned, "Error making request to http://pact status=200 body"
-          end
-        end
-      end
-
-      describe "can?" do
-        context "when the relation exists" do
-          it "returns true" do
-            expect(subject.can?('pb:provider')).to be true
-          end
-        end
-
-        context "when the relation does not exist" do
-          it "returns false" do
-            expect(subject.can?('pb:consumer')).to be false
-          end
-        end
-      end
-
-      describe "_link!" do
-        context 'when the key exists' do
-          it 'returns a Link' do
-            expect(subject._link!('pb:provider')).to be_a(Link)
-            expect(subject._link!('pb:provider').href).to eq 'http://provider'
-          end
-        end
-
-        context 'when the key does not exist' do
-          it 'raises an error' do
-            expect { subject._link!('foo') }.to raise_error RelationNotFoundError, /Could not find relation 'foo' in resource at http:\/\/pact/
-          end
-        end
-      end
-
-      describe 'fetch' do
-        context 'when the key exists' do
-          it 'returns fetched value' do
-            expect(subject.fetch('pb:provider')).to eq("href" => 'http://provider')
-          end
-        end
-
-        context "when the key doesn't not exist" do
-          it 'returns nil' do
-            expect(subject.fetch('i-dont-exist')).to be nil
-          end
-        end
-
-        context "when a fallback key is provided" do
-          context "when the fallback value exists" do
-            it "returns the fallback value" do
-              expect(subject.fetch('i-dont-exist', 'pb:provider')).to eq("href" => 'http://provider')
-            end
-          end
-
-          context "when the fallback value does not exist" do
-            it "returns nil" do
-              expect(subject.fetch('i-dont-exist', 'i-also-dont-exist')).to be nil
-            end
-          end
-        end
-      end
-    end
-  end
-end