pact_broker-client 1.14.1 → 1.15.0

data/spec/integration/can_i_deploy_spec.rb

@@ -1,6 +1,4 @@
-is_windows = !!RbConfig::CONFIG['host_os'] =~ /bccwin|cygwin|djgpp|mingw|mswin|wince/
-
-describe "pact-broker can-i-deploy", pending: is_windows do
+describe "pact-broker can-i-deploy", skip_windows: true do
   before(:all) do
     @pipe = IO.popen("bundle exec pact-stub-service spec/pacts/pact_broker_client-pact_broker.json -p 5000")
     sleep 2

data/spec/integration/create_version_tag_spec.rb

@@ -1,6 +1,4 @@
-is_windows = !!RbConfig::CONFIG['host_os'] =~ /bccwin|cygwin|djgpp|mingw|mswin|wince/
-
-describe "pact-broker create-version-tag", pending: is_windows do
+describe "pact-broker create-version-tag", skip_windows: true do
   before(:all) do
     @pipe = IO.popen("bundle exec pact-stub-service spec/pacts/pact_broker_client-pact_broker.json -p 5001")
     sleep 2

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

@@ -76,7 +76,7 @@ module PactBroker
 
       context "when a StandardError is raised" do
         before do
-          allow(Retry).to receive(:sleep).and_return(0)
+          allow(Retry).to receive(:until_true) { |&block| block.call }
           allow($stderr).to receive(:puts)
           allow(matrix_client).to receive(:get).and_raise(StandardError.new('error text'))
         end

data/spec/lib/pact_broker/client/cli/broker_create_webhook_spec.rb

@@ -0,0 +1,190 @@
+require 'pact_broker/client/cli/broker'
+require 'pact_broker/client/webhooks/create'
+
+module PactBroker
+  module Client
+    module CLI
+      describe Broker do
+        describe "create_webhook" do
+          before do
+            allow($stdout).to receive(:puts)
+            allow(PactBroker::Client::Webhooks::Create).to receive(:call).and_return(command_result)
+            broker.options = OpenStruct.new(options_hash)
+          end
+
+          let(:broker) { Broker.new }
+          let(:data) { 'data' }
+          let(:user) { "username:password" }
+          let(:command_result) { double('command result', success: success, message: 'message') }
+          let(:success) { true }
+          let(:header) { ["Foo: bar", "Bar: foo"] }
+
+          let(:options_hash) do
+            {
+              request: "POST",
+              header: header,
+              data: data,
+              user: user,
+              consumer: "consumer",
+              provider: "provider",
+              broker_base_url: "http://broker",
+              broker_username: "username",
+              broker_password: "password",
+              contract_content_changed: true,
+              verbose: true
+            }
+          end
+
+          let(:expected_params) do
+            {
+              http_method: "POST",
+              url: "http://webhook",
+              headers: { "Foo" => "bar", "Bar" => "foo"},
+              username: "username",
+              password: "password",
+              body: "data",
+              consumer: "consumer",
+              provider: "provider",
+              events: ["contract_content_changed"]
+            }.tap { |it| Pact::Fixture.add_fixture(:create_webhook_params, it) }
+          end
+
+          subject {  broker.create_webhook "http://webhook" }
+
+          it "calls PactBroker::Client::Webhooks::Create with the webhook params" do
+            expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
+              expect(params).to eq expected_params
+              command_result
+            end
+            subject
+          end
+
+          it "calls PactBroker::Client::Webhooks::Create with pact broker details" do
+            expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | _, broker_base_url, pact_broker_client_options |
+              expect(broker_base_url).to eq "http://broker"
+              expect(pact_broker_client_options).to eq(basic_auth: { username: "username", password: "password"}, verbose: true)
+              command_result
+            end
+            subject
+          end
+
+          context "when neither event type is selected" do
+            before do
+              options_hash.delete(:contract_content_changed)
+              broker.options = OpenStruct.new(options_hash)
+            end
+
+            it "raises an error" do
+              expect { subject }.to raise_error PactBroker::Client::Error, /You must select at least one/
+            end
+          end
+
+          context "with no basic auth" do
+            before do
+              options_hash.delete(:broker_username)
+              options_hash.delete(:broker_password)
+              broker.options = OpenStruct.new(options_hash)
+            end
+
+            it "calls Webhooks::Create without basic auth" do
+              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | _, _, pact_broker_client_options |
+                expect(pact_broker_client_options).to eq(verbose: true)
+                command_result
+              end
+              subject
+            end
+          end
+
+          context "when there are no headers specified" do
+            let(:header) { nil }
+
+            it "calls Webhooks::Create with an empty hash of headers" do
+              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
+                expect(params[:headers]).to eq({})
+                command_result
+              end
+              subject
+            end
+          end
+
+          context "when data is nil" do
+            let(:data) { nil }
+
+            it "alls Webhooks::Create with a nil body" do
+              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
+                expect(params[:body]).to be nil
+                command_result
+              end
+              subject
+            end
+          end
+
+          context "when a file reference is passed for the data" do
+            before do
+              FileUtils.mkdir_p "tmp"
+              File.open("tmp/body.json", "w") { |file| file << "file" }
+            end
+
+            let(:data) { "@tmp/body.json" }
+
+            it "reads the file and passes it in to the Webhooks::Create call" do
+              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
+                expect(params[:body]).to eq "file"
+                command_result
+              end
+              subject
+            end
+
+            context "when the file is not found" do
+
+              let(:data) { "@doesnotexist.json" }
+
+              it "raises a PactBroker::Client::Error" do
+                expect { subject }.to raise_error PactBroker::Client::Error, /Couldn't read data from file/
+              end
+            end
+
+            context "when successful" do
+              it "prints the message to stdout" do
+                expect($stdout).to receive(:puts).with('message')
+                subject
+              end
+            end
+
+            context "when not successful" do
+              let(:success) { false }
+
+              it "prints the message to stderr" do
+                expect($stdout).to receive(:puts).with('message')
+                begin
+                  subject
+                rescue SystemExit
+                end
+              end
+
+              it "exits with code 1" do
+                exited_with_error = false
+                begin
+                  subject
+                rescue SystemExit
+                  exited_with_error = true
+                end
+                expect(exited_with_error).to be true
+              end
+            end
+
+            context "when a PactBroker::Client::Error is raised" do
+              before do
+                allow(PactBroker::Client::Webhooks::Create).to receive(:call).and_raise(PactBroker::Client::Error, "foo")
+              end
+
+              it "raises a WebhookCreationError which does not show an ugly stack trace" do
+                expect { subject }.to raise_error(WebhookCreationError, /foo/)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+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)
+      end
+
+      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(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 "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 'fetch' do
+        context 'when the key exist' do
+          it 'returns fetched value' do
+            expect(subject.fetch('pb:provider')).to be do
+              {href: 'http://provider'}
+            end
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'pact_broker/client/hal/http_client'
+
+module PactBroker::Client
+  module Hal
+    describe HttpClient do
+      before do
+        allow(Retry).to receive(:until_true) { |&block| block.call }
+      end
+
+      subject { HttpClient.new(username: 'foo', password: 'bar') }
+
+      describe "get" do
+        let!(:request) do
+          stub_request(:get, "http://example.org/").
+            with(  headers: {
+              'Accept'=>'application/hal+json',
+              'Authorization'=>'Basic Zm9vOmJhcg=='
+              }).
+            to_return(status: 200, body: response_body, headers: {'Content-Type' => 'application/json'})
+        end
+
+        let(:response_body) { {some: 'json'}.to_json }
+        let(:do_get) { subject.get('http://example.org') }
+
+        it "performs a get request" do
+          do_get
+          expect(request).to have_been_made
+        end
+
+        context "with get params" do
+          let!(:request) do
+            stub_request(:get, "http://example.org/?foo=hello+world&bar=wiffle").
+              to_return(status: 200)
+          end
+
+          let(:do_get) { subject.get('http://example.org', { 'foo' => 'hello world', 'bar' => 'wiffle' }) }
+
+          it "correctly converts and encodes get params" do
+             do_get
+             expect(request).to have_been_made
+          end
+        end
+
+
+        it "retries on failure" do
+          expect(Retry).to receive(:until_true)
+          do_get
+        end
+
+        it "returns a response" do
+          expect(do_get.body).to eq({"some" => "json"})
+        end
+      end
+
+      describe "post" do
+        let!(:request) do
+          stub_request(:post, "http://example.org/").
+            with(  headers: {
+              'Accept'=>'application/hal+json',
+              'Authorization'=>'Basic Zm9vOmJhcg==',
+              'Content-Type'=>'application/json'
+              },
+              body: request_body).
+            to_return(status: 200, body: response_body, headers: {'Content-Type' => 'application/json'})
+        end
+
+        let(:request_body) { {some: 'data'}.to_json }
+        let(:response_body) { {some: 'json'}.to_json }
+
+        let(:do_post) { subject.post('http://example.org/', request_body) }
+
+        it "performs a post request" do
+          do_post
+          expect(request).to have_been_made
+        end
+
+        it "calls Retry.until_true" do
+          expect(Retry).to receive(:until_true)
+          do_post
+        end
+
+        it "returns a response" do
+          expect(do_post.body).to eq({"some" => "json"})
+        end
+
+        context "with custom headers" do
+          let!(:request) do
+            stub_request(:post, "http://example.org/").
+              with(  headers: {
+                'Accept'=>'foo'
+                }).
+              to_return(status: 200)
+          end
+
+          let(:do_post) { subject.post('http://example.org/', request_body, {"Accept" => "foo"} ) }
+
+          it "performs a post request with custom headers" do
+            do_post
+            expect(request).to have_been_made
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+require 'pact_broker/client/hal/link'
+require 'pact_broker/client/hal/entity'
+require 'pact_broker/client/hal/http_client'
+
+module PactBroker::Client
+  module Hal
+    describe Link do
+      let(:http_client) do
+        instance_double('PactBroker::Client::Hal::HttpClient', post: response)
+      end
+
+      let(:response) do
+        instance_double('PactBroker::Client::Hal::HttpClient::Response', success?: success, body: response_body)
+      end
+
+      let(:success) { true }
+
+      let(:entity) do
+        instance_double('PactBroker::Client::Hal::Entity')
+      end
+
+      let(:attrs) do
+        {
+          'href' => 'http://foo/{bar}',
+          'title' => 'title',
+          method: :post
+        }
+      end
+
+      let(:response_body) do
+        {
+          'some' => 'body'
+        }
+      end
+
+      subject { Link.new(attrs, http_client) }
+
+      before do
+        allow(PactBroker::Client::Hal::Entity).to receive(:new).and_return(entity)
+      end
+
+      describe "#run" do
+        let(:do_run) { subject.run('foo' => 'bar') }
+
+        it "executes the configured http request" do
+          expect(http_client).to receive(:post)
+          do_run
+        end
+
+        it "creates an Entity" do
+          expect(PactBroker::Client::Hal::Entity).to receive(:new).with(response_body, http_client, response)
+          do_run
+        end
+
+        it "returns an Entity" do
+          expect(do_run).to eq entity
+        end
+
+        context "when an error response is returned" do
+          before do
+            allow(PactBroker::Client::Hal::ErrorEntity).to receive(:new).and_return(entity)
+          end
+
+          let(:success) { false }
+
+          it "creates an ErrorEntity" do
+            expect(PactBroker::Client::Hal::ErrorEntity).to receive(:new).with(response_body, http_client, response)
+            do_run
+          end
+        end
+      end
+
+      describe "#get" do
+        before do
+          allow(http_client).to receive(:get).and_return(response)
+        end
+
+        let(:do_get) { subject.get({ 'foo' => 'bar' }) }
+
+        it "executes an HTTP Get request" do
+          expect(http_client).to receive(:get).with('http://foo/{bar}', { 'foo' => 'bar' }, {})
+          do_get
+        end
+      end
+
+      describe "#post" do
+        let(:do_post) { subject.post({ 'foo' => 'bar' }, { 'Accept' => 'foo' }) }
+
+        context "with custom headers" do
+          it "executes an HTTP Post request with the custom headers" do
+            expect(http_client).to receive(:post).with('http://foo/{bar}', '{"foo":"bar"}', { 'Accept' => 'foo' })
+            do_post
+          end
+        end
+      end
+
+      describe "#expand" do
+        it "returns a duplicate Link with the expanded href" do
+          expect(subject.expand(bar: 'wiffle').href).to eq "http://foo/wiffle"
+        end
+
+        it "returns a duplicate Link with the expanded href with URL escaping" do
+          expect(subject.expand(bar: 'wiffle meep').href).to eq "http://foo/wiffle%20meep"
+        end
+      end
+    end
+  end
+end