pact_broker 2.80.0 → 2.81.0

data/spec/features/publish_verification_results_and_version_spec.rb

@@ -0,0 +1,70 @@
+require "pact_broker/domain/verification"
+
+describe "Publishing a pact verification and provider version" do
+  let(:path) { "/pacts/provider/Provider/consumer/Consumer/pact-version/#{pact.pact_version_sha}/verification-results" }
+  let(:verification_content) { load_fixture("verification.json") }
+  let(:parsed_response_body) { JSON.parse(subject.body) }
+  let(:pact) { td.pact }
+  let(:rack_env) do
+    {
+      "CONTENT_TYPE" => "application/json",
+      "HTTP_ACCEPT" => "application/hal+json",
+      "pactbroker.database_connector" => lambda { |&block| block.call }
+    }
+  end
+
+  subject { post(path, verification_content, rack_env)  }
+
+  before do
+    td.create_provider("Provider")
+      .create_consumer("Consumer")
+      .create_consumer_version("1.0.0")
+      .create_pact
+      .create_consumer_version("1.2.3")
+      .create_pact
+      .revise_pact
+  end
+
+  it "Responds with a 201 Created" do
+    expect(subject.status).to be 201
+  end
+
+  it "saves new verification" do
+    expect { subject }.to change { PactBroker::Domain::Verification.count }.by(1)
+  end
+
+  it "saves the verification against the correct pact" do
+    subject
+    expect(PactBroker::Domain::Verification.order(:id).last.pact_version_sha).to eq pact.pact_version_sha
+  end
+
+  it "saves the test results" do
+    subject
+    expect(PactBroker::Domain::Verification.order(:id).last.test_results).to eq("some" => "results")
+  end
+
+  it "returns a link to itself that can be followed" do
+    get_verification_link = parsed_response_body["_links"]["self"]["href"]
+    get get_verification_link, nil, { "HTTP_ACCEPT" => "application/hal+json" }
+    expect(last_response.status).to be 200
+    expect(JSON.parse(subject.body)).to include JSON.parse(verification_content)
+  end
+
+  context "with a webhook configured", job: true do
+    before do
+      td.create_webhook(
+        method: "POST",
+        url: "http://example.org",
+        events: [{ name: PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED }]
+      )
+    end
+    let!(:request) do
+      stub_request(:post, "http://example.org").to_return(:status => 200)
+    end
+
+    it "executes the webhook" do
+      subject
+      expect(request).to have_been_made
+    end
+  end
+end

data/spec/fixtures/approvals/get_provider_pacts_for_verification.approved.json

@@ -22,7 +22,7 @@
     "status": 200,
     "headers": {
       "Content-Type": "application/hal+json;charset=utf-8",
-      "Content-Length": "815"
+      "Content-Length": "808"
     },
     "body": {
       "_embedded": {
@@ -39,7 +39,7 @@
             },
             "_links": {
               "self": {
-                "href": "http://example.org/pacts/provider/Provider/consumer/Consumer%202/pact-version/0f22f551a422b027066db7635cad8bd8a59ac869/metadata/c1tdW3RdPXByb2Qmc1tdW2xdPXRydWUmc1tdW2N2bl09NC41LjY",
+                "href": "http://example.org/pacts/provider/Provider/consumer/Consumer%202/pact-version/0f22f551a422b027066db7635cad8bd8a59ac869/metadata/c1tdW3RdPXByb2Qmc1tdW2xdPXRydWUmc1tdW2N2XT0y",
                 "name": "Pact between Consumer 2 (4.5.6) and Provider"
               }
             }

data/spec/lib/pact_broker/api/contracts/verifiable_pacts_json_query_schema_combinations_spec.rb

@@ -5,6 +5,7 @@ module PactBroker
     module Contracts
       describe VerifiablePactsJSONQuerySchema do
         ALL_PROPERTIES = {
+          mainBranch: true,
           tag: "tag",
           branch: "branch",
           latest: true,
@@ -13,10 +14,12 @@ module PactBroker
           environment: "environment",
           deployed: true,
           released: true,
+          deployedOrReleased: true,
           consumer: "consumer"
         }
 
         VALID_KEY_COMBINATIONS = [
+          [:mainBranch],
           [:tag],
           [:tag, :latest],
           [:tag, :latest, :fallbackTag],
@@ -29,12 +32,18 @@ module PactBroker
           [:environment, :released],
           [:deployed],
           [:released],
+          [:deployedOrReleased],
+          [:environment, :deployedOrReleased]
         ]
 
         VALID_KEY_COMBINATIONS.each do | valid_key_combination |
           selector = ALL_PROPERTIES.slice(*valid_key_combination)
 
           describe "with #{selector}" do
+            before do
+              allow(PactBroker::Deployments::EnvironmentService).to receive(:find_by_name).and_return(double("environment"))
+            end
+
             it "is valid" do
               params = { consumerVersionSelectors: [selector] }
               expect(VerifiablePactsJSONQuerySchema.(params)).to be_empty

data/spec/lib/pact_broker/api/contracts/verifiable_pacts_json_query_schema_spec.rb

@@ -4,6 +4,11 @@ module PactBroker
   module Api
     module Contracts
       describe VerifiablePactsJSONQuerySchema do
+        before do
+          allow(PactBroker::Deployments::EnvironmentService).to receive(:find_by_name).and_return(environment)
+        end
+        let(:environment) { double("environment") }
+
         let(:params) do
           {
             providerVersionTags: provider_version_tags,
@@ -327,6 +332,16 @@ module PactBroker
 
           its([:consumerVersionSelectors, 0]) { is_expected.to eq "cannot specify a branch with latest=false (at index 0)" }
         end
+
+        context "when the environment does not exist" do
+          let(:environment) { nil }
+
+          let(:consumer_version_selectors) do
+            [{ environment: "prod" }]
+          end
+
+          its([:consumerVersionSelectors, 0]) { is_expected.to eq "environment with name 'prod' does not exist at index 0" }
+        end
       end
     end
   end

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

@@ -113,6 +113,18 @@ module PactBroker
               expect(subject.consumer_version_selectors.first.currently_deployed).to be true
             end
           end
+
+          context "when deployedOrReleased is set to true" do
+            let(:consumer_version_selectors) do
+              [{ "deployedOrReleased" => true }]
+            end
+
+            it "creates two selectors - one for deployed and one for released" do
+              expect(subject.consumer_version_selectors.size).to eq 2
+              expect(subject.consumer_version_selectors.first).to eq PactBroker::Pacts::Selector.for_currently_deployed
+              expect(subject.consumer_version_selectors.last).to eq PactBroker::Pacts::Selector.for_currently_supported
+            end
+          end
         end
 
         context "when parsing query string params" do

data/spec/lib/pact_broker/api/resources/dashboard_spec.rb

@@ -3,12 +3,33 @@ require "pact_broker/api/resources/dashboard"
 module PactBroker
   module Api
     module Resources
-
       describe Dashboard do
+        before do
+          td.create_pact_with_verification("Foo1", "1", "Bar", "2")
+            .create_pact_with_verification("Foo2", "1", "Bar", "2")
+            .create_pact_with_verification("Foo3", "1", "Bar", "2")
+            .create_pact_with_verification("Foo4", "1", "Bar", "2")
+        end
+
+        let(:response_body_hash) { JSON.parse(subject.body) }
 
         let(:path) { "/dashboard" }
-        subject { get path; last_response }
 
+        subject { get(path) }
+
+        it { is_expected.to be_a_hal_json_success_response }
+
+        it "returns a list of items" do
+          expect(response_body_hash["items"]).to be_a(Array)
+        end
+
+        context "with pagination" do
+          subject { get(path, { pageNumber: 1, pageSize: 1 }) }
+
+          it "only returns the items for the page" do
+            expect(response_body_hash["items"].size).to eq 1
+          end
+        end
       end
     end
   end

data/spec/lib/pact_broker/api/resources/latest_provider_pacts_spec.rb

@@ -5,7 +5,7 @@ module PactBroker
     module Resources
       describe LatestProviderPacts do
         before do
-          allow(PactBroker::Pacts::Service).to receive(:find_latest_pact_versions_for_provider).and_return(pacts)
+          allow(PactBroker::Pacts::Service).to receive(:find_latest_pacts_for_provider).and_return(pacts)
           allow(PactBroker::Api::Decorators::ProviderPactsDecorator).to receive(:new).and_return(decorator)
           allow_any_instance_of(LatestProviderPacts).to receive(:resource_exists?).and_return(provider)
         end
@@ -19,7 +19,7 @@ module PactBroker
 
         context "with no tag" do
           it "finds the pacts" do
-            expect(PactBroker::Pacts::Service).to receive(:find_latest_pact_versions_for_provider).with("Bar", tag: nil)
+            expect(PactBroker::Pacts::Service).to receive(:find_latest_pacts_for_provider).with("Bar", tag: nil)
             subject
           end
 
@@ -35,7 +35,7 @@ module PactBroker
           let(:path) { "/pacts/provider/Bar/latest/prod" }
 
           it "finds the pacts with a tag" do
-            expect(PactBroker::Pacts::Service).to receive(:find_latest_pact_versions_for_provider).with("Bar", tag: "prod")
+            expect(PactBroker::Pacts::Service).to receive(:find_latest_pacts_for_provider).with("Bar", tag: "prod")
             subject
           end
 

data/spec/lib/pact_broker/api/resources/provider_pacts_spec.rb

@@ -5,7 +5,7 @@ module PactBroker
     module Resources
       describe ProviderPacts do
         before do
-          allow(PactBroker::Pacts::Service).to receive(:find_latest_pact_versions_for_provider).and_return(pacts)
+          allow(PactBroker::Pacts::Service).to receive(:find_latest_pacts_for_provider).and_return(pacts)
           allow(PactBroker::Api::Decorators::ProviderPactsDecorator).to receive(:new).and_return(decorator)
           allow(PactBroker::Pacticipants::Service).to receive(:find_pacticipant_by_name).and_return(provider)
         end

data/spec/lib/pact_broker/api/resources/tag_spec.rb

@@ -1,13 +1,9 @@
-require "spec_helper"
 require "pact_broker/api/resources/tag"
 
 module PactBroker
   module Api
-
     module Resources
-
       describe Tag do
-
         let(:tag) { double("PactBroker::Domain::Tag") }
         let(:tag_decorator) { instance_double("PactBroker::Api::Decorators::TagDecorator", :to_json => tag_json) }
         let(:tag_json) { {"some" => "tag"}.to_json }
@@ -40,7 +36,6 @@ module PactBroker
           end
 
           context "when the tag doesn't exist" do
-
             let(:tag) { nil }
 
             it "returns a 404 Not Found" do
@@ -87,7 +82,6 @@ module PactBroker
               subject
               expect(last_response).to be_successful
             end
-
           end
 
           context "when the tag does not exist" do
@@ -101,15 +95,16 @@ module PactBroker
         end
 
         describe "PUT" do
-
-          let(:tag_url) { "http://example.org/tag/url"}
-
           before do
             allow_any_instance_of(PactBroker::Api::Resources::Tag).to receive(:tag_url).and_return(tag_url)
             allow(Tags::Service).to receive(:find).and_return(tag)
             allow(PactBroker::Api::Decorators::TagDecorator).to receive(:new).and_return(tag_decorator)
+            allow_any_instance_of(described_class).to receive(:create_deployed_versions_for_tags?).and_return(create_deployed_versions_for_tags)
           end
 
+          let(:tag_url) { "http://example.org/tag/url"}
+          let(:create_deployed_versions_for_tags) { false }
+
           subject { put("/pacticipants/Condor/versions/1.3.0/tags/prod", nil, "CONTENT_LENGTH" => "0", "CONTENT_TYPE" => "application/json") }
 
           it "returns a success response" do
@@ -118,7 +113,6 @@ module PactBroker
           end
 
           context "when the tag already exists" do
-
             it "returns a 200" do
               subject
               expect(last_response.status).to be 200
@@ -153,13 +147,45 @@ module PactBroker
               subject
               expect(last_response.body).to eq tag_json
             end
-
           end
 
-        end
+          context "when create_deployed_versions_for_tags is true" do
+            before do
+              allow_any_instance_of(described_class).to receive(:environment_service).and_return(environment_service)
+              allow_any_instance_of(described_class).to receive(:deployed_version_service).and_return(deployed_version_service)
+              allow(environment_service).to receive(:find_by_name).and_return(environment)
+              allow(deployed_version_service).to receive(:next_uuid).and_return("uuid")
+              allow(tag).to receive(:version).and_return(version)
+            end
+            let(:environment_service) { class_double("PactBroker::Environments::Service").as_stubbed_const }
+            let(:deployed_version_service) { class_double("PactBroker::Deployments::DeployedVersionService").as_stubbed_const }
+            let(:environment) { nil }
+            let(:create_deployed_versions_for_tags) { true }
+            let(:version) { double("version") }
+
+            it "looks for a matching environment" do
+              expect(environment_service).to receive(:find_by_name).with("prod")
+              subject
+            end
 
-      end
+            context "when the tag name matches an existing environment" do
+              let(:environment) { double("environment") }
 
+              it "creates a deployed version" do
+                expect(deployed_version_service).to receive(:find_or_create).with(anything, version, environment, nil)
+                subject
+              end
+            end
+
+            context "when the tag name does not match an existing environment" do
+              it "does not create a deployed version" do
+                expect_any_instance_of(described_class).to_not receive(:deployed_version_service)
+                subject
+              end
+            end
+          end
+        end
+      end
     end
   end
 end

data/spec/lib/pact_broker/db/data_migrations/set_interactions_counts_spec.rb

@@ -0,0 +1,38 @@
+require "pact_broker/db/data_migrations/set_interactions_counts"
+
+module PactBroker
+  module DB
+    module DataMigrations
+      describe SetInteractionsCounts do
+        describe ".call" do
+          before do
+            td.create_consumer("Foo")
+              .create_provider("Bar")
+              .create_consumer_version("1")
+              .create_pact(json_content: { interactions: [1, 2] }.to_json )
+              .create_consumer_version("2")
+              .create_pact(json_content: { interactions: [1, 2, 3] }.to_json )
+              .create_provider("Bop")
+              .create_pact(json_content: { messages: [1] }.to_json )
+            PactBroker::Pacts::PactVersion.dataset.update(interactions_count: nil, messages_count: nil)
+          end
+
+          subject { SetInteractionsCounts.call(PactBroker::Pacts::PactVersion.db) }
+
+          it "sets the interactions and messages counts" do
+            subject
+            pact_versions = PactBroker::Pacts::PactVersion.order(:id).all
+            expect(pact_versions[0].interactions_count).to eq nil
+            expect(pact_versions[0].messages_count).to eq nil
+
+            expect(pact_versions[1].interactions_count).to eq 3
+            expect(pact_versions[1].messages_count).to eq 0
+
+            expect(pact_versions[2].interactions_count).to eq 0
+            expect(pact_versions[2].messages_count).to eq 1
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/deployments/deployed_version_service_spec.rb

@@ -0,0 +1,42 @@
+require "pact_broker/deployments/deployed_version_service"
+
+module PactBroker
+  module Deployments
+    describe DeployedVersionService do
+      describe ".create" do
+        before do
+          td.create_environment("test")
+            .create_consumer("foo")
+            .create_consumer_version("1")
+        end
+
+        let(:version) { td.and_return(:consumer_version) }
+        let(:environment) { td.and_return(:environment) }
+
+        context "when the version is already currently deployed" do
+          it "returns the existing deployed version object" do
+            deployed_version_1 = DeployedVersionService.find_or_create("1234", version, environment, nil)
+            deployed_version_2 = DeployedVersionService.find_or_create("4321", version, environment, nil)
+            expect(deployed_version_1.uuid).to eq deployed_version_2.uuid
+          end
+        end
+
+        context "when the version was previously deployed, but there was another version deployed in the meantime" do
+          before do
+            td.create_consumer_version("2")
+          end
+
+          let(:version_1) { PactBroker::Domain::Version.order(:id).first }
+          let(:version_2) { PactBroker::Domain::Version.order(:id).last }
+
+          it "returns a new deployed version object" do
+            deployed_version_1 = DeployedVersionService.find_or_create("1234", version_1, environment, nil)
+            DeployedVersionService.find_or_create("4321", version_2, environment, nil)
+            deployed_version_3 = DeployedVersionService.find_or_create("4545", version_1, environment, nil)
+            expect(deployed_version_1.uuid).to_not eq deployed_version_3.uuid
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,23 @@ module PactBroker
 
   module Domain
     describe Verification do
+      describe "latest_by_pact_version" do
+        before do
+          td.create_pact_with_hierarchy("Foo", "10", "Bar")
+            .create_verification(provider_version: "3", number: 1)
+            .create_verification(provider_version: "4", number: 2)
+            .create_pact_with_hierarchy("Foo2", "10", "Bar2")
+            .create_verification(provider_version: "30", number: 1)
+            .create_verification(provider_version: "31", number: 2)
+        end
+
+        subject { Verification.latest_by_pact_version.order(:id).all }
+
+        it "returns the latest by pact version" do
+          expect(subject.size).to eq 2
+          expect(subject.collect(&:provider_version_number).sort).to eq ["31", "4"]
+        end
+      end
       describe "latest_verifications_for_all_consumer_version_tags" do
         before do
           td.create_pact_with_verification_and_tags("Foo", "1", ["fmain"], "Bar", "2")