pact_broker 1.0.0 → 1.1.0

data/public/stylesheets/relationships.css

@@ -15,4 +15,8 @@
   padding-left:10px;
 }
 
+.hack {
+  padding-right: 20px;
+}
+
 body { padding-top: 10px; }

data/spec/integration/endpoints/group.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "/groups/{pacticipant-name}" do
+
+  let(:app) { PactBroker::API }
+
+  describe "GET" do
+    before do
+      ProviderStateBuilder.new.create_pact_with_hierarchy "Consumer", "1.2.3", "Provider"
+      get "/groups/Consumer"
+    end
+
+    it "returns a success response" do
+      expect(last_response.status).to eq 200
+    end
+
+    it "returns a body" do
+      expect(last_response.body).to_not be_nil
+    end
+  end
+
+end

data/spec/lib/pact_broker/api/decorators/pact_decorator_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'pact_broker/api/decorators/pact_decorator'
+
+module PactBroker
+
+  module Api
+
+    module Decorators
+
+      describe PactDecorator do
+
+        let(:json_content) {
+          {
+            'consumer' => {'name' => 'Consumer'},
+            'provider' => {'name' => 'Provider'},
+            'interactions' => [],
+            'metadata' => {}
+          }.to_json
+        }
+
+        let(:base_url) { 'http://example.org' }
+        let(:created_at) { Time.new(2014, 3, 4) }
+        let(:updated_at) { Time.new(2014, 3, 5) }
+        let(:pact) { double('pact', json_content: json_content, created_at: created_at, updated_at: updated_at, consumer: consumer, provider: provider, consumer_version: consumer_version)}
+        let(:consumer) { instance_double(PactBroker::Models::Pacticipant, name: 'Consumer')}
+        let(:provider) { instance_double(PactBroker::Models::Pacticipant, name: 'Provider')}
+        let(:consumer_version) { instance_double(PactBroker::Models::Version, number: '1234')}
+
+        subject { JSON.parse PactDecorator.new(pact).to_json(base_url: base_url), symbolize_names: true}
+
+        describe "#to_json" do
+
+          it "includes the json_content" do
+            expect(subject[:consumer]).to eq name: 'Consumer'
+          end
+
+          it "includes the createdAt date" do
+            expect(subject[:createdAt]).to eq created_at.xmlschema
+          end
+
+          it "includes a link to the webhooks for this pact" do
+            expect(subject[:_links][:'pact-webhooks'][:href]).to eq "http://example.org/webhooks/provider/Provider/consumer/Consumer"
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/api/decorators/pacticipant_decorator_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'pact_broker/api/decorators/pacticipant_decorator'
+require 'pact_broker/models/pacticipant'
+
+module PactBroker
+
+  module Api
+
+    module Decorators
+
+      describe PacticipantRepresenter do
+
+        let(:created_at) { Time.new(2014, 3, 4) }
+        let(:updated_at) { Time.new(2014, 3, 5) }
+        let(:pacticipant) { PactBroker::Models::Pacticipant.new(name: 'Name', updated_at: updated_at, created_at: created_at)}
+
+        subject { JSON.parse PacticipantRepresenter.new(pacticipant).to_json, symbolize_names: true }
+
+        it "includes the createdAt timestamp" do
+          expect(subject[:createdAt]).to eq created_at.xmlschema
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/api/decorators/relationships_csv_decorator_spec.rb

@@ -11,15 +11,18 @@ module PactBroker
 
         let(:pact) { ProviderStateBuilder.new.create_pact_with_hierarchy "My Consumer", "1.0", "My Provider"}
         let(:pacts) { [pact]}
-        let(:line_1) { 'source,target,weight'}
-        let(:line_2) { 'My Consumer,My Provider,1' }
-        let(:expected_text) { [line_1, line_2].join("\n") + "\n" }
+
 
         subject { RelationshipsCsvDecorator.new(pacts) }
 
 
         describe "#to_csv" do
-          it "returns the relationships as CSV" do
+
+          let(:line_1) { '1,My Consumer,1,3158419,0,1,2,0,0,0,0,0,0,0,0'}
+          let(:line_2) { '2,My Provider,1,3158419,0,2,0,0,0,0,0,0,0,0,0' }
+          let(:expected_text) { [line_1, line_2].join("\n") + "\n" }
+
+          xit "returns the relationships as CSV" do
             expect(subject.to_csv).to eq expected_text
           end
         end

data/spec/lib/pact_broker/api/decorators/webhook_decorator_spec.rb

@@ -0,0 +1,121 @@
+require 'pact_broker/api/decorators/webhook_decorator'
+require 'pact_broker/models/webhook'
+
+module PactBroker
+  module Api
+    module Decorators
+      describe WebhookDecorator do
+
+        let(:headers) { {:'Content-Type' => 'application/json'} }
+        let(:request) do
+          {
+            method: 'POST',
+            url: 'http://example.org/hook',
+            headers: headers,
+            body: { some: 'body' }
+          }
+        end
+
+        let(:webhook_request) do
+          Models::WebhookRequest.new(request)
+        end
+
+        let(:consumer) { Models::Pacticipant.new(name: 'Consumer') }
+        let(:provider) { Models::Pacticipant.new(name: 'Provider') }
+
+        let(:webhook) do
+          Models::Webhook.new(
+            request: webhook_request,
+            uuid: 'some-uuid',
+            consumer: consumer,
+            provider: provider,
+            created_at: DateTime.now,
+            updated_at: DateTime.now)
+        end
+
+        subject { WebhookDecorator.new(webhook) }
+
+        describe "to_json" do
+
+          let(:parsed_json) { JSON.parse(subject.to_json(base_url: 'http://example.org'), symbolize_names: true)}
+
+          it "includes the request" do
+            expect(parsed_json[:request]).to eq request
+          end
+
+          it "includes an embedded consumer" do
+            expect(parsed_json[:_embedded][:consumer]).to eq ({
+                name: 'Consumer',
+                :_links => {
+                  :self => {
+                    :href=>"http://example.org/pacticipants/Consumer"
+                    }
+                  }
+                })
+          end
+
+          it "includes an embedded provider" do
+            expect(parsed_json[:_embedded][:provider]).to eq ({
+                name: 'Provider',
+                :_links => {
+                  :self => {
+                    :href=>"http://example.org/pacticipants/Provider"
+                    }
+                  }
+                })
+          end
+
+          it "includes a link to itself" do
+            expect(parsed_json[:_links][:self][:href]).to eq 'http://example.org/webhooks/some-uuid'
+            expect(parsed_json[:_links][:self][:title]).to_not be_nil
+          end
+
+          it "includes a link to its parent collection" do
+            expect(parsed_json[:_links][:'pact-webhooks'][:href]).to_not be_nil
+          end
+
+
+          it "includes a link to the webhooks resource" do
+            expect(parsed_json[:_links][:webhooks][:href]).to_not be_nil
+          end
+
+          it "includes a link to execute the webhook directly" do
+            expect(parsed_json[:_links][:execute][:href]).to eq 'http://example.org/webhooks/some-uuid/execute'
+          end
+
+          context "when the headers are empty" do
+            let(:headers) { nil }
+            it "does not include the headers" do
+              expect(parsed_json[:request]).to_not have_key :headers
+            end
+          end
+
+        end
+
+        describe "from_json" do
+          let(:hash) { { request: request } }
+          let(:json) { hash.to_json }
+          let(:webhook) { Models::Webhook.new }
+          let(:parsed_object) { subject.from_json(json) }
+
+          it "parses the request method" do
+            expect(parsed_object.request.method).to eq 'POST'
+          end
+
+          it "parses the request URL" do
+            expect(parsed_object.request.url).to eq 'http://example.org/hook'
+          end
+
+          it "parses the request headers" do
+            expect(parsed_object.request.headers).to eq 'Content-Type' => 'application/json'
+          end
+
+          it "parses the request body" do
+            expect(parsed_object.request.body).to eq 'some' => 'body'
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/api/decorators/webhook_execution_result_decorator_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'pact_broker/api/decorators/webhook_execution_result_decorator'
+
+module PactBroker
+  module Api
+    module Decorators
+      describe WebhookExecutionResultDecorator do
+
+        describe "to_json" do
+
+          let(:webhook_execution_result) { PactBroker::Models::WebhookExecutionResult.new(response, error)}
+          let(:headers) { { "Something" => ["blah", "thing"]} }
+          let(:response) { double('http_response', code: '200', body: response_body, to_hash: headers) }
+          let(:response_body) { 'body' }
+          let(:error) { nil }
+          let(:webhook) { instance_double(PactBroker::Models::Webhook, uuid: 'some-uuid')}
+          let(:json) {
+            WebhookExecutionResultDecorator.new(webhook_execution_result)
+            .to_json(base_url: 'http://example.org', webhook: webhook)
+          }
+
+          let(:subject) { JSON.parse(json, symbolize_names: true)}
+
+          it "includes a link to execute the webhook again" do
+            expect(subject[:_links][:'try-again'][:href]).to eq 'http://example.org/webhooks/some-uuid/execute'
+          end
+
+          it "includes a link to the webhook" do
+            expect(subject[:_links][:webhook][:href]).to eq 'http://example.org/webhooks/some-uuid'
+          end
+
+          context "when there is an error" do
+            let(:error) { double('error', message: 'message', backtrace: ['blah','blah']) }
+
+            it "includes the message" do
+              expect(subject[:error][:message]).to eq 'message'
+            end
+
+            it "includes the backtrace" do
+              expect(subject[:error][:backtrace]).to eq ['blah','blah']
+            end
+          end
+
+          context "when there is a response" do
+            it "includes the response code" do
+              expect(subject[:response][:status]).to eq 200
+            end
+
+            it "includes the response headers" do
+              expect(subject[:response][:headers]).to eq :'Something' => "blah, thing"
+            end
+            it "includes the response body" do
+              expect(subject[:response][:body]).to eq response_body
+            end
+
+            context "when the response body is JSON" do
+              let(:response_body_hash) { {some: 'json'} }
+              let(:response_body) { response_body_hash.to_json }
+              it "returns the response as JSON" do
+                expect(subject[:response][:body]).to eq response_body_hash
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/api/decorators/webhook_request_decorator_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'pact_broker/api/decorators/webhook_request_decorator'
+require 'json'
+
+module PactBroker
+  module Api
+    module Decorators
+      describe WebhookRequestDecorator do
+
+        let(:username) { 'username' }
+        let(:display_password) { '*****' }
+        let(:webhook_request) do
+          instance_double(
+            PactBroker::Models::WebhookRequest,
+            username: username,
+            display_password: display_password,
+            method: 'POST',
+            url: 'url',
+            body: 'body',
+            headers: {})
+        end
+
+        let(:json) { WebhookRequestDecorator.new(webhook_request).to_json }
+
+        subject { JSON.parse(json, symbolize_names: true)}
+
+        describe "to_json" do
+
+          it "includes the username" do
+            expect(subject[:username]).to eq username
+          end
+
+          it "includes the username starred out" do
+            expect(subject[:password]).to eq display_password
+          end
+
+          context "when there is no password" do
+
+            let(:display_password) { nil }
+
+            it "does not include a password key" do
+              expect(subject).to_not have_key(:password)
+            end
+          end
+        end
+
+        describe "from_json" do
+          let(:password) { 'password' }
+          let(:hash) do
+            {
+              username: username,
+              password: password,
+              method: 'POST',
+              url: 'url',
+              body: 'body',
+              headers: {}
+            }
+          end
+
+          let(:json) { hash.to_json }
+          let(:webhook_request) { PactBroker::Models::WebhookRequest.new }
+
+          subject { WebhookRequestDecorator.new(webhook_request).from_json(json) }
+
+          it "reads the username" do
+            expect(subject.username).to eq username
+          end
+
+          it "reads the password" do
+            expect(subject.password).to eq password
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/api/decorators/webhooks_decorator_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'pact_broker/api/decorators/webhooks_decorator'
+
+module PactBroker
+  module Api
+    module Decorators
+      describe WebhooksDecorator do
+
+        let(:webhook) do
+          instance_double(Models::Webhook, uuid: 'some-uuid', description: 'description', request_description: 'request description')
+        end
+        let(:base_url) { 'http://example.org' }
+        let(:resource_url) { 'http://example.org/webhooks' }
+
+        let(:decorator_context) do
+          DecoratorContext.new(base_url, resource_url, resource_title: 'Title')
+        end
+
+        let(:webhooks) { [webhook] }
+
+        describe "to_json" do
+
+          let(:json) { WebhooksDecorator.new(webhooks).to_json(decorator_context) }
+
+          subject { JSON.parse(json, symbolize_names: true) }
+
+          it "includes a link to itself with a title" do
+            expect(subject[:_links][:'pb:self'][:href]).to eq resource_url
+            expect(subject[:_links][:'pb:self'][:title]).to eq 'Title'
+          end
+
+          it "includes a list of links to the webhooks" do
+            expect(subject[:_links][:webhooks]).to be_instance_of(Array)
+            expect(subject[:_links][:webhooks].first).to eq title: 'description', name: 'request description', href: 'http://example.org/webhooks/some-uuid'
+          end
+
+          it "includes curies" do
+            expect(subject[:_links][:curies]).to eq [{:name=>"pb", :href=>"http://example.org/doc/webhooks"}]
+          end
+
+        end
+
+      end
+    end
+  end
+end