pact_broker 2.89.1 → 2.90.0

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

@@ -1,210 +0,0 @@
-require "pact_broker/api/decorators/webhook_decorator"
-require "pact_broker/domain/webhook"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe WebhookDecorator do
-        let(:description) { "Trigger build" }
-        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
-          Webhooks::WebhookRequestTemplate.new(request)
-        end
-
-        let(:consumer) { Domain::WebhookPacticipant.new(name: "Consumer") }
-        let(:provider) { Domain::WebhookPacticipant.new(name: "Provider") }
-        let(:event)    { Webhooks::WebhookEvent.new(name: "something_happened") }
-        let(:created_at) { DateTime.now }
-        let(:updated_at) { created_at + 1 }
-
-        let(:webhook) do
-          Domain::Webhook.new(
-            description: description,
-            request: webhook_request,
-            uuid: "some-uuid",
-            consumer: consumer,
-            provider: provider,
-            events: [event],
-            created_at: created_at,
-            updated_at: updated_at,
-            enabled: false
-          )
-        end
-
-        subject { WebhookDecorator.new(webhook) }
-
-        describe "to_json" do
-          let(:parsed_json) { JSON.parse(subject.to_json(user_options: { base_url: "http://example.org" }), symbolize_names: true) }
-
-          it "includes the description" do
-            expect(parsed_json[:description]).to eq "Trigger build"
-          end
-
-          it "includes the request" do
-            expect(parsed_json[:request]).to eq request
-          end
-
-          it "includes the consumer" do
-            expect(parsed_json[:consumer]).to eq name: "Consumer"
-          end
-
-          it "includes the provider" do
-            expect(parsed_json[:provider]).to eq name: "Provider"
-          end
-
-          it "includes a link to the consumer" do
-            expect(parsed_json[:_links][:'pb:consumer'][:name]).to eq "Consumer"
-            expect(parsed_json[:_links][:'pb:consumer'][:href]).to eq "http://example.org/pacticipants/Consumer"
-          end
-
-          it "includes a link to the provider" do
-            expect(parsed_json[:_links][:'pb:provider'][:name]).to eq "Provider"
-            expect(parsed_json[:_links][:'pb:provider'][:href]).to eq "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][:'pb:pact-webhooks'][:href]).to_not be_nil
-          end
-
-          it "includes a link to the webhooks resource" do
-            expect(parsed_json[:_links][:'pb:webhooks'][:href]).to_not be_nil
-          end
-
-          it "includes a link to execute the webhook directly" do
-            expect(parsed_json[:_links][:'pb:execute'][:href]).to eq "http://example.org/webhooks/some-uuid/execute"
-          end
-
-          it "includes the events" do
-            expect(parsed_json[:events].first).to eq name: "something_happened"
-          end
-
-          it "includes timestamps" do
-            expect(parsed_json[:createdAt]).to eq FormatDateTime.call(created_at)
-            expect(parsed_json[:updatedAt]).to eq FormatDateTime.call(updated_at)
-          end
-
-          it "includes the enabled flag" do
-            expect(parsed_json[:enabled]).to eq false
-          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
-
-          context "when there is no consumer" do
-            before do
-              webhook.consumer = nil
-            end
-
-            it "does not include the consumer relation" do
-              expect(parsed_json[:_links][:'pb:consumer']).to be nil
-            end
-
-            it "does not include the pact webhooks relation" do
-              expect(parsed_json[:_links][:'pb:pact-webhooks']).to be nil
-            end
-          end
-
-          context "when there is no provider" do
-            before do
-              webhook.provider = nil
-            end
-
-            it "does not include the provider relation" do
-              expect(parsed_json[:_links][:'pb:provider']).to be nil
-            end
-
-            it "does not include the pact webhooks relation" do
-              expect(parsed_json[:_links][:'pb:pact-webhooks']).to be nil
-            end
-          end
-
-          context "when the headers contain sensitve information" do
-            let(:headers) { { "Authorization" => "foo" } }
-            it "redacts them" do
-              expect(parsed_json[:request][:headers][:'Authorization']).to eq "**********"
-            end
-          end
-
-          context "when the description is empty" do
-            let(:description) { " " }
-
-            it "uses the scope description" do
-              expect(parsed_json[:description]).to match(/example.org/)
-            end
-          end
-        end
-
-        describe "from_json" do
-          let(:hash) { { request: request, events: [event] } }
-          let(:event) { {name: "something_happened"} }
-          let(:json) { hash.to_json }
-          let(:webhook) { Domain::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
-
-          it "parses the events" do
-            expect(parsed_object.events.size).to eq 1
-            expect(parsed_object.events.first.name).to eq "something_happened"
-          end
-
-          context "when no events are specified" do
-            let(:hash) { { request: request } }
-            let(:webhook) { Domain::Webhook.new }
-
-            it "defaults to a single contract_changed event for backwards compatibility" do
-              expect(parsed_object.events.size).to eq 1
-              expect(parsed_object.events.first.name).to eq PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME
-            end
-          end
-
-          context "when the decorated object has a consumer/provider but the incoming JSON does not" do
-            let(:webhook) do
-              Domain::Webhook.new(
-                consumer: Domain::WebhookPacticipant.new(name: "consumer"),
-                provider: Domain::WebhookPacticipant.new(name: "provider")
-              )
-            end
-
-            it "sets the consumer and provider to nil on the decorated object" do
-              expect(parsed_object.consumer).to be nil
-              expect(parsed_object.provider).to be nil
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,128 +0,0 @@
-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::Webhooks::WebhookExecutionResult.new(request, response, true, logs, error) }
-          let(:logs) { "logs" }
-          let(:headers) { { "Something" => ["blah", "thing"]} }
-          let(:request) do
-            req = Net::HTTP::Get.new("http://example.org?foo=bar")
-            req["Foo"] = ["bar", "wiffle"]
-            req.body = { foo: "bar" }.to_json
-            req
-          end
-          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::Domain::Webhook, uuid: uuid) }
-          let(:uuid) { "some-uuid" }
-          let(:show_response) { true }
-          let(:json) {
-            WebhookExecutionResultDecorator.new(webhook_execution_result)
-            .to_json(user_options: { resource_url: "http://resource-url", base_url: "http://example.org", webhook: webhook, show_response: show_response })
-          }
-
-          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://resource-url"
-          end
-
-          it "includes a success flag" do
-            expect(subject[:success]).to be true
-          end
-
-          it "includes the logs" do
-            expect(subject[:logs]).to eq logs
-          end
-
-          context "when there is a uuid" do
-            it "include a link to the webhook" do
-              expect(subject[:_links][:webhook][:href]).to eq "http://example.org/webhooks/some-uuid"
-            end
-          end
-
-          context "when there is a not uuid because this is an unsaved webhook" do
-            let(:uuid) { nil }
-
-            it "does not includes a link to the webhook" do
-              expect(subject[:_links]).to_not have_key(:webhook)
-            end
-          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
-          end
-
-          context "when there is a request" do
-            it "includes the request URL" do
-              expect(subject[:request][:url]).to eq "http://example.org?foo=bar"
-            end
-
-            it "includes the request headers" do
-              expect(subject[:request][:headers][:'foo']).to eq "bar, wiffle"
-            end
-
-            context "when the request body is JSON" do
-              it "includes the request body as JSON" do
-                expect(subject[:request][:body]).to include( foo: "bar" )
-              end
-            end
-
-            context "when the request body is not json" do
-              before do
-                request.body = "<xml></xml>"
-              end
-
-              it "includes the request body as a String" do
-                expect(subject[:request][:body]).to eq "<xml></xml>"
-              end
-            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
-
-          context "when show_response is false" do
-            let(:show_response) { false }
-
-            it "does not include the response" do
-              expect(subject).to_not have_key(:response)
-            end
-
-            it "includes a message about why the response is hidden" do
-              expect(subject[:message]).to match(/security purposes/)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/webhook_request_template_decorator"
-require "json"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe WebhookRequestTemplateDecorator do
-
-        let(:username) { "username" }
-        let(:display_password) { "*****" }
-        let(:webhook_request) do
-          instance_double(
-            PactBroker::Webhooks::WebhookRequestTemplate,
-            username: username,
-            display_password: display_password,
-            method: "POST",
-            url: "url",
-            body: "body",
-            redacted_headers: {
-              "foo" => "***"
-            })
-        end
-
-        let(:json) { WebhookRequestTemplateDecorator.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::Webhooks::WebhookRequestTemplate.new }
-
-          subject { WebhookRequestTemplateDecorator.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

@@ -1,48 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/webhooks_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe WebhooksDecorator do
-
-        let(:webhook) do
-          instance_double(Domain::Webhook,
-            uuid: "some-uuid",
-            display_description: "description",
-            scope_description: "scope 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(user_options: decorator_context) }
-
-          subject { JSON.parse(json, symbolize_names: true) }
-
-          it "includes a link to itself with a title" do
-            expect(subject[:_links][:self][:href]).to eq resource_url
-            expect(subject[:_links][:self][:title]).to eq "Title"
-          end
-
-          it "includes a list of links to the webhooks" do
-            expect(subject[:_links][:'pb:webhooks']).to be_instance_of(Array)
-            expect(subject[:_links][:'pb:webhooks'].first).to eq title: "scope description", name: "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-{rel}", templated: true}]
-          end
-        end
-      end
-    end
-  end
-end