pact_broker 2.19.1 → 2.19.2

data/script/run-with-ssl.rb

@@ -0,0 +1,44 @@
+if __FILE__ == $0
+  require 'pact_broker'
+
+  DATABASE_CREDENTIALS = {adapter: "sqlite", database: "pact_broker_ssl_database.sqlite3", :encoding => 'utf8'}
+
+  app = PactBroker::App.new do | config |
+    config.logger = ::Logger.new($stdout)
+    config.logger.level = ::Logger::DEBUG
+    config.database_connection = Sequel.connect(DATABASE_CREDENTIALS)
+  end
+
+  SSL_KEY = 'spec/fixtures/certificates/key.pem'
+  SSL_CERT = 'spec/fixtures/certificates/cert.pem'
+
+  trap(:INT) do
+    @server.shutdown
+    exit
+  end
+
+  def webrick_opts port
+    certificate = OpenSSL::X509::Certificate.new(File.read(SSL_CERT))
+    cert_name = certificate.subject.to_a.collect{|a| a[0..1] }
+    {
+      Port: port,
+      Host: "0.0.0.0",
+      AccessLog: [],
+      SSLCertificate: certificate,
+      SSLPrivateKey: OpenSSL::PKey::RSA.new(File.read(SSL_KEY)),
+      SSLEnable: true,
+      SSLCertName: cert_name
+    }
+  end
+
+  require 'webrick'
+  require 'webrick/https'
+  require 'rack'
+  require 'rack/handler/webrick'
+
+  opts = webrick_opts(4444)
+
+  Rack::Handler::WEBrick.run(app, opts) do |server|
+    @server = server
+  end
+end

data/spec/features/base_equality_only_on_content_that_affects_verification_results_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe "base_equality_only_on_content_that_affects_verification_results" do
+  let(:td) { TestDataBuilder.new }
+  let(:json_content_1) { load_fixture('foo-bar.json') }
+  let(:json_content_2) do
+    pact_hash = load_json_fixture('foo-bar.json')
+    pact_hash['interactions'] = pact_hash['interactions'].reverse
+    pact_hash.to_json
+  end
+  let(:base_equality_only_on_content_that_affects_verification_results) { true }
+
+  before do
+    PactBroker.configuration.base_equality_only_on_content_that_affects_verification_results = base_equality_only_on_content_that_affects_verification_results
+    td.create_pact_with_hierarchy("Foo", "1", "Bar", json_content_1)
+      .create_verification(provider_version: "5")
+      .create_consumer_version("2")
+      .create_pact(json_content: json_content_2)
+  end
+
+  context "when a pact is published with a different order of interactions to a previous version, but which is otherwise the same" do
+    context "when base_equality_only_on_content_that_affects_verification_results is true" do
+      it "applies the verifications from the previous version" do
+        expect(PactBroker::Matrix::Row.all).to contain_hash(consumer_version_number: "2", provider_version_number: "5")
+      end
+    end
+
+    context "when base_equality_only_on_content_that_affects_verification_results is false" do
+      let(:base_equality_only_on_content_that_affects_verification_results) { false }
+
+      it "does not apply the verifications from the previous version" do
+        expect(PactBroker::Matrix::Row.all).to_not contain_hash(consumer_version_number: "2", provider_version_number: "5")
+      end
+    end
+  end
+end

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

@@ -30,7 +30,11 @@ module PactBroker
             expect(subject[:_links][:webhook][:href]).to eq 'http://example.org/webhooks/some-uuid'
           end
 
-          context "when there is an error" do
+          it "includes a message about the response being redacted" do
+            expect(subject[:message]).to match /redacted/
+          end
+
+          context "when there is an error", pending: "temporarily disabled" do
             let(:error) { double('error', message: 'message', backtrace: ['blah','blah']) }
 
             it "includes the message" do
@@ -42,7 +46,7 @@ module PactBroker
             end
           end
 
-          context "when there is a response" do
+          context "when there is a response", pending: "temporarily disabled" do
             it "includes the response code" do
               expect(subject[:response][:status]).to eq 200
             end

data/spec/lib/pact_broker/domain/webhook_request_spec.rb

@@ -8,6 +8,9 @@ module PactBroker
       before do
         allow(PactBroker::Api::PactBrokerUrls).to receive(:pact_url).and_return('http://example.org/pact-url')
         allow(PactBroker.configuration).to receive(:base_url).and_return('http://example.org')
+        allow(PactBroker.logger).to receive(:info).and_call_original
+        allow(PactBroker.logger).to receive(:debug).and_call_original
+        allow(PactBroker.logger).to receive(:warn).and_call_original
       end
 
       let(:username) { nil }
@@ -121,6 +124,14 @@ module PactBroker
           subject.execute(pact, options)
         end
 
+        it "does not write the response body to the exeuction log for security purposes" do
+          expect(logs).to_not include "An error"
+        end
+
+        it "logs a message about why there is no response information" do
+          expect(logs).to include "Webhook response has been redacted temporarily for security purposes"
+        end
+
         describe "execution logs" do
 
           it "logs the request method and path" do
@@ -143,12 +154,12 @@ module PactBroker
             expect(logs).to include "HTTP/1.0 200"
           end
 
-          it "logs the response headers" do
-            expect(logs).to include "Content-Type: text/foo, blah"
+          it "does not log the response headers" do
+            expect(logs).to_not include "Content-Type: text/foo, blah"
           end
 
-          it "logs the response body" do
-            expect(logs).to include "respbod"
+          it "does not log the response body" do
+            expect(logs).to_not include "respbod"
           end
 
           context "when the response code is a success" do
@@ -280,7 +291,7 @@ module PactBroker
           end
         end
 
-        context "when the response body contains a non UTF-8 character" do
+        context "when the response body contains a non UTF-8 character", pending: "execution logs disabled temporarily for security purposes" do
           let!(:http_request) do
             stub_request(:post, "http://example.org/hook").
               to_return(:status => 200, :body => "This has some \xC2 invalid chars")

data/spec/lib/pact_broker/matrix/aggregated_row_spec.rb

@@ -0,0 +1,79 @@
+require 'pact_broker/matrix/aggregated_row'
+
+module PactBroker
+  module Matrix
+    describe AggregatedRow do
+      describe "latest_verification" do
+        let(:row_1) do
+          instance_double('PactBroker::Matrix::HeadRow',
+            consumer_name: "Foo",
+            provider_name: "Bar",
+            verification: verification_1,
+            latest_verification_for_consumer_version_tag: tag_verification_1,
+            consumer_version_tag_name: consumer_version_tag_name_1)
+        end
+        let(:row_2) do
+          instance_double('PactBroker::Matrix::HeadRow',
+            verification: verification_2,
+            latest_verification_for_consumer_version_tag: tag_verification_2,
+            consumer_version_tag_name: consumer_version_tag_name_2)
+        end
+        let(:verification_1) { instance_double('PactBroker::Domain::Verification', id: 1) }
+        let(:verification_2) { instance_double('PactBroker::Domain::Verification', id: 2) }
+        let(:tag_verification_1) { instance_double('PactBroker::Domain::Verification', id: 3) }
+        let(:tag_verification_2) { instance_double('PactBroker::Domain::Verification', id: 4) }
+        let(:consumer_version_tag_name_1) { 'master' }
+        let(:consumer_version_tag_name_2) { 'prod' }
+        let(:rows) { [row_1, row_2] }
+        let(:aggregated_row) { AggregatedRow.new(rows) }
+
+        subject { aggregated_row.latest_verification }
+
+        context "when the rows have verifications" do
+          it "returns the verification with the largest id" do
+            expect(subject).to be verification_2
+          end
+        end
+
+        context "when the rows do not have verifications, but there are a previous verifications for a pacts with the same tag" do
+          let(:verification_1) { nil }
+          let(:verification_2) { nil }
+
+          it "returns the verification for the previous pact that has the largest id" do
+            expect(subject).to be tag_verification_2
+          end
+        end
+
+        context "when there is no verification for any of the rows or any of the pacts with the same tag" do
+          let(:verification_1) { nil }
+          let(:verification_2) { nil }
+          let(:tag_verification_1) { nil }
+          let(:tag_verification_2) { nil }
+
+          context "when one of the rows is the overall latest" do
+            let(:consumer_version_tag_name_1) { nil }
+            let(:overall_latest_verification) { instance_double('PactBroker::Domain::Verification', id: 1) }
+            before do
+              allow(row_1).to receive(:latest_verification_for_consumer_and_provider).and_return(overall_latest_verification)
+            end
+
+            it "looks up the overall latest verification" do
+              expect(row_1).to receive(:latest_verification_for_consumer_and_provider)
+              subject
+            end
+
+            it "returns the overall latest verification" do
+              expect(subject).to be overall_latest_verification
+            end
+          end
+
+          context "when none of the rows is not the overall latest (they are all the latest with a tag)" do
+            it "returns nil" do
+              expect(subject).to be nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/matrix/head_row_spec.rb

@@ -3,6 +3,61 @@ require 'pact_broker/matrix/head_row'
 module PactBroker
   module Matrix
     describe HeadRow do
+      let(:td) { TestDataBuilder.new }
+
+      describe "latest_verification_for_consumer_version_tag" do
+        context "when the pact with a given tag has been verified" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_consumer_version_tag("prod")
+              .create_verification(provider_version: "10")
+              .create_consumer_version("2", comment: "latest prod version for Foo")
+              .create_consumer_version_tag("prod")
+              .create_pact
+              .create_verification(provider_version: "11")
+              .create_verification(provider_version: "12", number: 2)
+              .create_consumer("Wiffle")
+              .create_consumer_version("30", comment: "latest prod version for Wiffle")
+              .create_consumer_version_tag("prod")
+              .create_pact
+              .create_verification(provider_version: "12")
+              .create_provider("Meep")
+              .create_pact
+              .create_verification(provider_version: "40")
+          end
+
+          subject { HeadRow.eager(:consumer_version_tags).eager(:latest_verification_for_consumer_version_tag).order(:pact_publication_id, :verification_id).exclude(consumer_version_tag_name: nil).all }
+
+          it "returns its most recent verification" do
+            cols = [:consumer_name, :consumer_version_number, :consumer_version_tag_name, :provider_name, :provider_version_number]
+            rows = subject.collect{ | row | cols.collect{ | col | row[col]} }
+
+            expect(subject.size).to eq 3
+            expect(rows).to include ["Foo", "2", "prod", "Bar", "12"]
+            expect(rows).to include ["Wiffle", "30", "prod", "Bar", "12"]
+            expect(rows).to include ["Wiffle", "30", "prod", "Meep", "40"]
+          end
+        end
+
+        context "when the most recent pact with a given tag has not been verified, but a previous version with the same tag has" do
+          before do
+            td.create_pact_with_hierarchy("Foo", "1", "Bar")
+              .create_consumer_version_tag("prod")
+              .create_verification(provider_version: "10")
+              .create_verification(provider_version: "11", number: 2, comment: "this is the latest verification for a pact with cv tag prod")
+              .create_consumer_version("2")
+              .create_consumer_version_tag("prod")
+              .create_pact
+          end
+
+          subject { HeadRow.eager(:consumer_version_tags).eager(:latest_verification_for_consumer_version_tag).order(:pact_publication_id).all }
+
+          it "returns the most recent verification for the previous version with the same tag" do
+            expect(subject.last.verification_id).to be nil # this pact version has not been verified directly
+            expect(subject.last.latest_verification_for_consumer_version_tag.provider_version.number).to eq "11"
+          end
+        end
+      end
       describe "refresh", migration: true do
         before do
           PactBroker::Database.migrate

data/spec/lib/pact_broker/matrix/row_spec.rb

@@ -3,14 +3,34 @@ require 'pact_broker/matrix/row'
 module PactBroker
   module Matrix
     describe Row do
-      describe "refresh", migration: true do
+      let(:td) { TestDataBuilder.new }
+
+      describe "latest_verification_for_consumer_and_provider" do
         before do
-          PactBroker::Database.migrate
+          td.create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_verification(provider_version: "9")
+            .create_consumer_version("2")
+            .create_consumer_version_tag("prod")
+            .create_pact
+            .create_verification(provider_version: "10")
+            .create_consumer("Wiffle")
+            .create_consumer_version("4")
+            .create_pact
+            .create_verification(provider_version: "11")
+        end
+
+        subject { Row.where(consumer_name: "Foo", provider_name: "Bar").all.collect(&:latest_verification_for_consumer_and_provider) }
+
+        it "returns the latest verification for the consumer and provider" do
+          expect(subject.collect(&:provider_version_number)).to eq ["10", "10"]
         end
+      end
 
+      describe "refresh", migration: true do
         let(:td) { TestDataBuilder.new(auto_refresh_matrix: false) }
 
         before do
+          PactBroker::Database.migrate
           td.create_pact_with_hierarchy("Foo", "1", "Bar")
         end
 

data/spec/lib/pact_broker/pacts/content_spec.rb

@@ -0,0 +1,166 @@
+require 'pact_broker/pacts/content'
+
+module PactBroker
+  module Pacts
+    describe Content do
+      describe "content_that_affects_verification_results" do
+
+        subject { Content.from_hash(pact_hash).content_that_affects_verification_results }
+
+        context "with messages" do
+          let(:pact_hash) do
+            {
+              'ignored' => 'foo',
+              'messages' => [1],
+              'metadata' => {
+                'pactSpecification' => {
+                  'version' => '1'
+                }
+              }
+            }
+          end
+
+          let(:expected_content) do
+            {
+              'messages' => [1],
+              'pact_specification_version' => '1'
+            }
+          end
+
+          it "extracts the messages and pact_specification_version" do
+            expect(subject).to eq expected_content
+          end
+        end
+
+        context "with interactions" do
+          let(:pact_hash) do
+            {
+              'ignored' => 'foo',
+              'interactions' => [1],
+              'metadata' => {
+                'pactSpecification' => {
+                  'version' => '1'
+                }
+              }
+            }
+          end
+
+          let(:expected_content) do
+            {
+              'interactions' => [1],
+              'pact_specification_version' => '1'
+            }
+          end
+
+          it "extracts the interactions and pact_specification_version" do
+            expect(subject).to eq expected_content
+          end
+        end
+
+        context "with both messages and interactions, even though this should never happen" do
+          let(:pact_hash) do
+            {
+              'ignored' => 'foo',
+              'interactions' => [1],
+              'messages' => [2],
+              'metadata' => {
+                'pactSpecification' => {
+                  'version' => '1'
+                }
+              }
+            }
+          end
+
+          let(:expected_content) do
+            {
+              'interactions' => [1],
+              'messages' => [2],
+              'pact_specification_version' => '1'
+            }
+          end
+
+          it "extracts the interactions and pact_specification_version" do
+            expect(subject).to eq expected_content
+          end
+        end
+
+        context "with neither messages nor interactions" do
+          let(:pact_hash) do
+            {
+              'ignored' => 'foo',
+              'foo' => [1],
+              'metadata' => {
+                'pactSpecification' => {
+                  'version' => '1'
+                }
+              }
+            }
+          end
+
+          it "returns the entire hash" do
+            expect(subject).to eq pact_hash
+          end
+        end
+
+        context "when somebody publishes an array as the top level element" do
+          let(:pact_hash) do
+            [{ "foo" => "bar" }]
+          end
+
+          it "returns the entire document" do
+            expect(subject).to eq pact_hash
+          end
+        end
+      end
+
+      describe "#pact_specification_version" do
+        subject { Content.from_hash(json) }
+        context 'with pactSpecification.version' do
+          let(:json) do
+            {
+              'metadata' => {
+                'pactSpecification' => {
+                  'version' => '1'
+                }
+              }
+            }
+          end
+
+          its(:pact_specification_version) { is_expected.to eq '1' }
+        end
+
+        context 'with pact-specification.version' do
+          let(:json) do
+            {
+              'metadata' => {
+                'pact-specification' => {
+                  'version' => '1'
+                }
+              }
+            }
+          end
+
+          its(:pact_specification_version) { is_expected.to eq '1' }
+        end
+
+        context 'with pactSpecificationVersion' do
+          let(:json) do
+            {
+              'metadata' => {
+                'pactSpecificationVersion' => '1'
+              }
+            }
+          end
+
+          its(:pact_specification_version) { is_expected.to eq '1' }
+        end
+
+        context 'with an array for content' do
+          let(:json) { [] }
+
+          its(:pact_specification_version) { is_expected.to eq nil }
+        end
+      end
+    end
+  end
+end