pact_broker 2.75.0 → 2.78.0

data/lib/pact_broker/repositories/helpers.rb

@@ -43,6 +43,10 @@ module PactBroker
         select(Sequel[model.table_name].*)
       end
 
+      def select_append_all_qualified
+        select_append(Sequel[model.table_name].*)
+      end
+
       def select_for_subquery column
         if mysql? #stoopid mysql doesn't allow you to modify datasets with subqueries
           column_name = column.respond_to?(:alias) ? column.alias : column

data/lib/pact_broker/services.rb

@@ -73,6 +73,10 @@ module PactBroker
       get(:metrics_service)
     end
 
+    def environment_service
+      get(:environment_service)
+    end
+
     def register_default_services
       register_service(:index_service) do
         require 'pact_broker/index/service'
@@ -148,6 +152,11 @@ module PactBroker
         require 'pact_broker/webhooks/trigger_service'
         Webhooks::TriggerService
       end
+
+      register_service(:environment_service) do
+        require 'pact_broker/deployments/environment_service'
+        Deployments::EnvironmentService
+      end
     end
   end
 end

data/lib/pact_broker/tags/eager_loaders.rb

@@ -0,0 +1,47 @@
+module PactBroker
+  module Tags
+    module EagerLoaders
+      class HeadTag
+        def self.call(eo, **_other)
+          initialize_association(eo[:rows])
+          populate_associations(eo[:rows])
+        end
+
+        def self.initialize_association(tags)
+          tags.each{|tag| tag.associations[:head_tag] = nil }
+        end
+
+        def self.populate_associations(tags)
+          group_by_pacticipant_id(tags).each do | pacticipant_id, tags |
+            populate_associations_by_pacticipant(pacticipant_id, tags)
+          end
+        end
+
+        def self.group_by_pacticipant_id(tags)
+          tags.to_a.group_by(&:pacticipant_id)
+        end
+
+        def self.populate_associations_by_pacticipant(pacticipant_id, tags)
+          latest_tags_for_tags = latest_tags_for_pacticipant_id(
+            pacticipant_id,
+            tags.collect(&:name).uniq.compact,
+            tags.first.class
+          )
+          self.populate_tags(tags, latest_tags_for_tags)
+        end
+
+        def self.populate_tags(tags, latest_tags_for_tags)
+          tags.each do | tag |
+            tag.associations[:head_tag] = latest_tags_for_tags[[tag.pacticipant_id, tag.name]]
+          end
+        end
+
+        def self.latest_tags_for_pacticipant_id(pacticipant_id, tag_names, tag_class)
+          tag_class.latest_tags_for_pacticipant_ids_and_tag_names(pacticipant_id, tag_names).each_with_object({}) do | tag, hash |
+            hash[[tag.pacticipant_id, tag.name]] = tag
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/tags/repository.rb

@@ -10,7 +10,9 @@ module PactBroker
       def create args
         params = {
           name: args.fetch(:name),
-          version_id: args.fetch(:version).id
+          version_id: args.fetch(:version).id,
+          version_order: args.fetch(:version).order,
+          pacticipant_id: args.fetch(:version).pacticipant_id
         }
         Domain::Tag.new(params).insert_ignore
       end

data/lib/pact_broker/tags/service.rb

@@ -1,12 +1,9 @@
 require 'pact_broker/repositories'
 
 module PactBroker
-
   module Tags
     module Service
-
       extend self
-
       extend PactBroker::Repositories
 
       def create args

data/lib/pact_broker/tags/tag_with_latest_flag.rb

@@ -4,6 +4,7 @@ require 'pact_broker/repositories/helpers'
 module PactBroker
   module Tags
     # The tag associated with the latest verification for a given tag
+    # TODO remove this class now we have eager loaders for head_tag
     class TagWithLatestFlag < Sequel::Model(:tags_with_latest_flag)
       associate(:many_to_one, :version, :class => "PactBroker::Domain::Version", :key => :version_id, :primary_key => :id)
 

data/lib/pact_broker/test/http_test_data_builder.rb

@@ -8,9 +8,9 @@ module PactBroker
   module Test
     class HttpTestDataBuilder
 
-      attr_reader :client, :last_consumer_name, :last_provider_name, :last_consumer_version_number, :last_provider_version_number
+      attr_reader :client, :last_consumer_name, :last_provider_name, :last_consumer_version_number, :last_provider_version_number, :last_provider_version_tag, :last_provider_version_branch
 
-      def initialize(pact_broker_base_url, auth)
+      def initialize(pact_broker_base_url, auth = {})
         @client = Faraday.new(url: pact_broker_base_url) do |faraday|
           faraday.request :json
           faraday.response :json, :content_type => /\bjson$/
@@ -24,8 +24,8 @@ module PactBroker
         end
       end
 
-      def sleep
-        Kernel.sleep 0.5
+      def sleep(seconds = 0.5)
+        Kernel.sleep(seconds)
         self
       end
 
@@ -42,10 +42,17 @@ module PactBroker
 
       def create_tag(pacticipant:, version:, tag:)
         puts "Creating tag '#{tag}' for #{pacticipant} version #{version}"
-        client.put("/pacticipants/#{encode(pacticipant)}/versions/#{encode(version)}/tags/#{encode(tag)}", {}).tap { |response| check_for_error(response) }
+        client.put("pacticipants/#{encode(pacticipant)}/versions/#{encode(version)}/tags/#{encode(tag)}", {}).tap { |response| check_for_error(response) }
         self
       end
 
+      def create_version(pacticipant:, version:, branch:)
+        request_body = {
+          branch: branch
+        }
+        client.put("pacticipants/#{encode(pacticipant)}/versions/#{encode(version)}", request_body).tap { |response| check_for_error(response) }
+      end
+
       def deploy_to_prod(pacticipant:, version:)
         puts "Deploying #{pacticipant} version #{version} to prod"
         create_tag(pacticipant: pacticipant, version: version, tag: "prod")
@@ -55,16 +62,18 @@ module PactBroker
 
       def create_pacticipant(name)
         puts "Creating pacticipant with name #{name}"
-        client.post("/pacticipants", { name: name}).tap { |response| check_for_error(response) }
+        client.post("pacticipants", { name: name}).tap { |response| check_for_error(response) }
         separate
         self
       end
 
-      def publish_pact(consumer: last_consumer_name, consumer_version:, provider: last_provider_name, content_id:, tag:)
+      def publish_pact(consumer: last_consumer_name, consumer_version:, provider: last_provider_name, content_id:, tag: nil, branch: nil)
         @last_consumer_name = consumer
         @last_provider_name = provider
         @last_consumer_version_number = consumer_version
 
+        create_version(pacticipant: consumer, version: consumer_version, branch: branch) if branch
+
         [*tag].each do | tag |
           create_tag(pacticipant: consumer, version: consumer_version, tag: tag)
         end
@@ -72,24 +81,27 @@ module PactBroker
 
         content = generate_content(consumer, provider, content_id)
         puts "Publishing pact for consumer #{consumer} version #{consumer_version} and provider #{provider}"
-        pact_path = "/pacts/provider/#{encode(provider)}/consumer/#{encode(consumer)}/version/#{encode(consumer_version)}"
+        pact_path = "pacts/provider/#{encode(provider)}/consumer/#{encode(consumer)}/version/#{encode(consumer_version)}"
         @publish_pact_response = client.put(pact_path, content).tap { |response| check_for_error(response) }
         separate
         self
       end
 
-      def get_pacts_for_verification(provider: last_provider_name, provider_version_tag: , consumer_version_selectors:, enable_pending: false, include_wip_pacts_since: nil)
+      def get_pacts_for_verification(provider: last_provider_name, provider_version_tag: nil, provider_version_branch: nil, consumer_version_selectors:, enable_pending: false, include_wip_pacts_since: nil)
         @last_provider_name = provider
+        @last_provider_version_tag = provider_version_tag
+        @last_provder_version_branch = provider_version_branch
         puts "Fetching pacts for verification for #{provider}"
-        body = {
+        request_body = {
           providerVersionTags: [*provider_version_tag],
+          providerVersionBranch: provider_version_branch,
           consumerVersionSelectors: consumer_version_selectors,
           includePendingStatus: enable_pending,
           includeWipPactsSince: include_wip_pacts_since
         }.compact
-        puts body.to_yaml
+        puts request_body.to_yaml
         puts ""
-        @pacts_for_verification_response = client.post("/pacts/provider/#{encode(provider)}/for-verification", body).tap { |response| check_for_error(response) }
+        @pacts_for_verification_response = client.post("pacts/provider/#{encode(provider)}/for-verification", request_body).tap { |response| check_for_error(response) }
 
         print_pacts_for_verification
         separate
@@ -111,28 +123,26 @@ module PactBroker
         self
       end
 
-      def verify_pact(index: 0, success:, provider: last_provider_name, provider_version_tag: , provider_version: )
+      def verify_latest_pact_for_tag(success: true, provider: last_provider_name, consumer: last_consumer_name, consumer_version_tag: , provider_version:, provider_version_tag: nil)
         @last_provider_name = provider
+        @last_consumer_name = consumer
+
+        url_of_pact_to_verify = "pacts/provider/#{encode(provider)}/consumer/#{encode(consumer)}/latest/#{encode(consumer_version_tag)}"
+        publish_verification_results(url_of_pact_to_verify, provider, provider_version, provider_version_tag, success)
+        separate
+        self
+      end
+
+      def verify_pact(index: 0, success:, provider: last_provider_name, provider_version_tag: last_provider_version_tag, provider_version_branch: last_provider_version_branch, provider_version: )
+        @last_provider_name = provider
+        @last_provider_version_tag = provider_version_tag
+        @last_provider_version_branch = provider_version_branch
+
         pact_to_verify = @pacts_for_verification_response.body["_embedded"]["pacts"][index]
         raise "No pact found to verify at index #{index}" unless pact_to_verify
         url_of_pact_to_verify = pact_to_verify["_links"]["self"]["href"]
 
-        [*provider_version_tag].each do | tag |
-          create_tag(pacticipant: provider, version: provider_version, tag: tag)
-        end
-        puts "" if [*provider_version_tag].any?
-
-        pact_response = client.get(url_of_pact_to_verify).tap { |response| check_for_error(response) }
-        verification_results_url = pact_response.body["_links"]["pb:publish-verification-results"]["href"]
-
-        results = {
-          success: success,
-          testResults: [],
-          providerApplicationVersion: provider_version
-        }
-        puts "Publishing verification"
-        puts results.to_yaml
-        response = client.post(verification_results_url, results.to_json).tap { |response| check_for_error(response) }
+        publish_verification_results(url_of_pact_to_verify, provider, provider_version, provider_version_tag, success)
         separate
         self
       end
@@ -150,7 +160,37 @@ module PactBroker
             "url" => url
           }
         }
-        path = "/webhooks/#{uuid}"
+        path = "webhooks/#{uuid}"
+        response = client.put(path, request_body.to_json).tap { |response| check_for_error(response) }
+        separate
+        self
+      end
+
+      def create_global_webhook_for_verification_published(uuid: nil, url: "https://postman-echo.com/post")
+        puts "Creating global webhook for contract changed event with uuid #{uuid}"
+        uuid ||= SecureRandom.uuid
+        request_body = {
+          "description" => "A webhook for all consumers and providers",
+          "events" => [{
+            "name" => "contract_published"
+          },{
+            "name" => "provider_verification_published"
+          }],
+          "request" => {
+            "method" => "POST",
+            "url" => url,
+            "headers" => { "Content-Type" => "application/json"},
+            "body" => {
+              "eventName" => "${pactbroker.eventName}",
+              "consumerVersionNumber" => "${pactbroker.consumerVersionNumber}",
+              "consumerVersionTags" => "${pactbroker.consumerVersionTags}",
+              "githubVerificationStatus" => "${pactbroker.githubVerificationStatus}",
+              "providerVersionNumber" => "${pactbroker.providerVersionNumber}",
+              "providerVersionTags" => "${pactbroker.providerVersionTags}"
+            }
+          }
+        }
+        path = "webhooks/#{uuid}"
         response = client.put(path, request_body.to_json).tap { |response| check_for_error(response) }
         separate
         self
@@ -158,7 +198,7 @@ module PactBroker
 
       def delete_webhook(uuid:)
         puts "Deleting webhook with uuid #{uuid}"
-        path = "/webhooks/#{uuid}"
+        path = "webhooks/#{uuid}"
         response = client.delete(path).tap { |response| check_for_error(response) }
         separate
         self
@@ -170,24 +210,29 @@ module PactBroker
       end
 
       def can_i_deploy(pacticipant:, version:, to:)
-        can_i_deploy_response = client.get("/can-i-deploy", { pacticipant: pacticipant, version: version, to: to} ).tap { |response| check_for_error(response) }
+        can_i_deploy_response = client.get("can-i-deploy", { pacticipant: pacticipant, version: version, to: to} ).tap { |response| check_for_error(response) }
         can = !!(can_i_deploy_response.body['summary'] || {})['deployable']
         puts "can-i-deploy #{pacticipant} version #{version} to #{to}: #{can ? 'yes' : 'no'}"
-        puts (can_i_deploy_response.body['summary'] || can_i_deploy_response.body).to_yaml
+        summary = can_i_deploy_response.body['summary']
+        verification_result_urls = (can_i_deploy_response.body['matrix'] || []).collect do | row |
+          row.dig("verificationResult", "_links", "self", "href")
+        end.compact
+        summary.merge!("verification_result_urls" => verification_result_urls)
+        puts summary.to_yaml
         separate
         self
       end
 
       def delete_integration(consumer:, provider:)
         puts "Deleting all data for the integration between #{consumer} and #{provider}"
-        client.delete("/integrations/provider/#{encode(provider)}/consumer/#{encode(consumer)}").tap { |response| check_for_error(response) }
+        client.delete("integrations/provider/#{encode(provider)}/consumer/#{encode(consumer)}").tap { |response| check_for_error(response) }
         separate
         self
       end
 
       def delete_pacticipant(name)
         puts "Deleting pacticipant #{name}"
-        @publish_pact_response = client.delete("/pacticipants/#{encode(name)}").tap { |response| check_for_error(response) }
+        @publish_pact_response = client.delete("pacticipants/#{encode(name)}").tap { |response| check_for_error(response) }
         separate
         self
       end
@@ -215,6 +260,27 @@ module PactBroker
         }
       end
 
+      private
+
+      def publish_verification_results(url_of_pact_to_verify, provider, provider_version, provider_version_tag, success)
+        [*provider_version_tag].each do | tag |
+          create_tag(pacticipant: provider, version: provider_version, tag: tag)
+        end
+        puts "" if [*provider_version_tag].any?
+
+        pact_response = client.get(url_of_pact_to_verify).tap { |response| check_for_error(response) }
+        verification_results_url = pact_response.body["_links"]["pb:publish-verification-results"]["href"]
+
+        results = {
+          success: success,
+          testResults: [],
+          providerApplicationVersion: provider_version
+        }
+        puts "Publishing verification"
+        puts results.to_yaml
+        response = client.post(verification_results_url, results.to_json).tap { |response| check_for_error(response) }
+      end
+
       def encode string
         ERB::Util.url_encode(string)
       end

data/lib/pact_broker/test/test_data_builder.rb

@@ -24,6 +24,7 @@ require 'pact_broker/tags/repository'
 require 'pact_broker/webhooks/repository'
 require 'pact_broker/certificates/certificate'
 require 'pact_broker/matrix/row'
+require 'pact_broker/deployments/environment_service'
 require 'ostruct'
 
 module PactBroker
@@ -45,6 +46,7 @@ module PactBroker
       attr_reader :webhook
       attr_reader :webhook_execution
       attr_reader :triggered_webhook
+      attr_reader :environment
 
       def initialize(params = {})
         @now = DateTime.now
@@ -159,18 +161,29 @@ module PactBroker
       def create_consumer_version version_number = "1.0.#{model_counter}", params = {}
         params.delete(:comment)
         tag_names = [params.delete(:tag_names), params.delete(:tag_name)].flatten.compact
-        @consumer_version = PactBroker::Domain::Version.create(:number => version_number, :pacticipant => @consumer)
+        @consumer_version = PactBroker::Domain::Version.create(
+          number: version_number,
+          pacticipant: @consumer,
+          branch: params[:branch],
+          build_url: params[:build_url]
+        )
         set_created_at_if_set params[:created_at], :versions, { id: @consumer_version.id }
         tag_names.each do | tag_name |
-          PactBroker::Domain::Tag.create(name: tag_name, version: @consumer_version)
+          tag = PactBroker::Domain::Tag.create(name: tag_name, version: consumer_version)
+          set_created_at_if_set(params[:created_at], :tags, { name: tag.name, version_id: consumer_version.id })
         end
         self
       end
 
       def create_provider_version version_number = "1.0.#{model_counter}", params = {}
         params.delete(:comment)
+        tag_names = [params.delete(:tag_names), params.delete(:tag_name)].flatten.compact
         @version = PactBroker::Domain::Version.create(:number => version_number, :pacticipant => @provider)
         @provider_version = @version
+        tag_names.each do | tag_name |
+          tag = PactBroker::Domain::Tag.create(name: tag_name, version: provider_version)
+          set_created_at_if_set(params[:created_at], :tags, { name: tag.name, version_id: provider_version.id })
+        end
         self
       end
 
@@ -186,7 +199,7 @@ module PactBroker
 
       def create_tag tag_name, params = {}
         params.delete(:comment)
-        @tag = PactBroker::Domain::Tag.create(name: tag_name, version: @version)
+        @tag = PactBroker::Domain::Tag.create(name: tag_name, version: @version, version_order: @version.order, pacticipant_id: @version.pacticipant_id)
         set_created_at_if_set params[:created_at], :tags, { name: @tag.name, version_id: @tag.version_id }
         self
       end
@@ -339,6 +352,7 @@ module PactBroker
 
       def create_verification parameters = {}
         parameters.delete(:comment)
+        branch = parameters.delete(:branch)
         tag_names = [parameters.delete(:tag_names), parameters.delete(:tag_name)].flatten.compact
         provider_version_number = parameters[:provider_version] || '4.5.6'
         default_parameters = { success: true, number: 1, test_results: {some: 'results'}, wip: false }
@@ -348,6 +362,7 @@ module PactBroker
         verification = PactBroker::Domain::Verification.new(parameters)
         @verification = PactBroker::Verifications::Repository.new.create(verification, provider_version_number, @pact)
         @provider_version = PactBroker::Domain::Version.where(pacticipant_id: @provider.id, number: provider_version_number).single_record
+        @provider_version.update(branch: branch) if branch
 
         set_created_at_if_set(parameters[:created_at], :verifications, id: @verification.id)
         set_created_at_if_set(parameters[:created_at], :versions, id: @provider_version.id)
@@ -368,6 +383,18 @@ module PactBroker
         self
       end
 
+      def create_environment(name, params = {})
+        uuid = params[:uuid] || PactBroker::Deployments::EnvironmentService.next_uuid
+        production = params[:production] || false
+        @environment = PactBroker::Deployments::EnvironmentService.create(uuid, PactBroker::Deployments::Environment.new(params.merge(name: name, production: production)))
+        set_created_at_if_set(params[:created_at], :environments, id: environment.id)
+        self
+      end
+
+      def create_deployment(_)
+        self
+      end
+
       def create_everything_for_an_integration
         create_pact_with_verification("Foo", "1", "Bar", "2")
           .create_label("label")
@@ -378,6 +405,26 @@ module PactBroker
           .create_webhook_execution
       end
 
+      def find_pacticipant(name)
+        PactBroker::Domain::Pacticipant.where(name: name).single_record
+      end
+
+      def find_version(pacticipant_name, version_number)
+        PactBroker::Domain::Version.for(pacticipant_name, version_number)
+      end
+
+      def find_pact(consumer_name, consumer_version_number, provider_name)
+        pact_repository.find_pact(consumer_name, consumer_version_number, provider_name)
+      end
+
+      def find_pact_publication(consumer_name, consumer_version_number, provider_name)
+        PactBroker::Pacts::PactPublication
+          .remove_overridden_revisions
+          .where(provider: find_pacticipant(provider_name))
+          .where(consumer_version: find_version(consumer_name, consumer_version_number))
+          .single_record
+      end
+
       def model_counter
         @@model_counter ||= 0
         @@model_counter += 1