pact_broker 2.4.2 → 2.5.0

data/spec/lib/pact_broker/webhooks/status_spec.rb

@@ -0,0 +1,48 @@
+require 'pact_broker/webhooks/status'
+
+module PactBroker
+  module Webhooks
+    describe Status do
+      let(:webhooks) { [double('webhook')]}
+      let(:latest_triggered_webhooks) { [ triggered_webhook_1, triggered_webhook_2] }
+      let(:pact) { double('pact') }
+      let(:triggered_webhook_1) { double('triggered_webhook', status: status_1) }
+      let(:triggered_webhook_2) { double('triggered_webhook', status: status_2) }
+      let(:status_1) { TriggeredWebhook::STATUS_SUCCESS }
+      let(:status_2) { TriggeredWebhook::STATUS_SUCCESS }
+
+      subject { Status.new(pact, webhooks, latest_triggered_webhooks) }
+
+      context "when there are no webhooks configured" do
+        let(:webhooks) { [] }
+        its(:to_sym) { is_expected.to eq :none }
+      end
+
+      context "when there are webhooks, but no triggered webhooks" do
+        let(:latest_triggered_webhooks) { [] }
+        its(:to_sym) { is_expected.to eq :not_run }
+      end
+
+      context "when the most recent triggered webhooks are successful" do
+        its(:to_sym) { is_expected.to eq :success }
+      end
+
+      context "when one of the most recent executions is a failure" do
+        let(:status_1) { TriggeredWebhook::STATUS_FAILURE }
+        its(:to_sym) { is_expected.to eq :failure }
+      end
+
+      context "when one of the most recent executions is a failure and one is retrying" do
+        let(:status_1) { TriggeredWebhook::STATUS_FAILURE }
+        let(:status_2) { TriggeredWebhook::STATUS_RETRYING }
+        its(:to_sym) { is_expected.to eq :retrying }
+      end
+
+      context "when the most recent executions are failures" do
+        let(:status_1) { TriggeredWebhook::STATUS_FAILURE }
+        let(:status_2) { TriggeredWebhook::STATUS_FAILURE }
+        its(:to_sym) { is_expected.to eq :failure }
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/webhooks/triggered_webhook_spec.rb

@@ -0,0 +1,40 @@
+require 'pact_broker/webhooks/triggered_webhook'
+
+module PactBroker
+  module Webhooks
+    describe TriggeredWebhook do
+      let(:status) { TriggeredWebhook::STATUS_SUCCESS }
+
+      subject { TriggeredWebhook.new(status: status) }
+
+      describe "remaining_attempts" do
+        before do
+          PactBroker.configuration.webhook_retry_schedule = [1, 1, 1]
+          allow(subject).to receive(:webhook_executions).and_return([double('execution')])
+        end
+
+        its(:number_of_attempts_made) { is_expected.to eq 1 }
+
+        context "when its status is retrying" do
+          let(:status) { TriggeredWebhook::STATUS_RETRYING }
+          its(:number_of_attempts_remaining) { is_expected.to eq 3  }
+        end
+
+        context "when its status is not_run" do
+          let(:status) { TriggeredWebhook::STATUS_NOT_RUN }
+          its(:number_of_attempts_remaining) { is_expected.to eq 3  }
+        end
+
+        context "when its status is success" do
+          let(:status) { TriggeredWebhook::STATUS_SUCCESS }
+          its(:number_of_attempts_remaining) { is_expected.to eq 0}
+        end
+
+        context "when its status is failure" do
+          let(:status) { TriggeredWebhook::STATUS_FAILURE }
+          its(:number_of_attempts_remaining) { is_expected.to eq 0}
+        end
+      end
+    end
+  end
+end

data/spec/lib/rack/pact_broker/database_transaction_spec.rb

@@ -13,20 +13,21 @@ module Rack
         ::PactBroker::Database.truncate
       end
 
+      let(:headers) { {} }
+
       let(:api) do
-        ->(env) { ::PactBroker::Domain::Pacticipant.create(name: 'Foo'); [500, {}, []] }
+        ->(env) { ::PactBroker::Domain::Pacticipant.create(name: 'Foo'); [500, headers, []] }
       end
 
-      let(:api_with_transaction) do
+      let(:app) do
         ::Rack::PactBroker::DatabaseTransaction.new(api, ::PactBroker::DB.connection)
       end
 
       subject { self.send(http_method, "/") }
 
       context "for get requests" do
-        let(:app) { api_with_transaction }
-
         let(:http_method) { :get }
+
         it "does not use a transaction" do
           expect { subject }.to change { ::PactBroker::Domain::Pacticipant.count }.by(1)
         end
@@ -40,6 +41,15 @@ module Rack
           end
         end
       end
+
+      context "when there is an error but the resource sets the no rollback header" do
+        let(:headers) { {::PactBroker::DO_NOT_ROLLBACK => 'true'} }
+        let(:http_method) { :post }
+
+        it "does not roll back" do
+          expect { subject }.to change { ::PactBroker::Domain::Pacticipant.count }.by(1)
+        end
+      end
     end
   end
 end

data/spec/migrations/23_pact_versions_spec.rb

@@ -1,20 +1,5 @@
-require 'tasks/database'
-
-describe 'migrate to pact versions (migrate 22-31)', no_db_clean: :true do
-
-  def create table_name, params, id_column_name = :id
-    database[table_name].insert(params);
-    database[table_name].order(id_column_name).last
-  end
-
-  def clean table_name
-    database[table_name].delete rescue puts "Error cleaning #{table_name} #{$!}"
-  end
-
-  let(:database) { DB.connection_for_env 'test' }
-
+describe 'migrate to pact versions (migrate 22-31)', migration: true do
   before do
-    PactBroker::Database.drop_objects
     PactBroker::Database.migrate(22)
   end
 
@@ -29,22 +14,20 @@ describe 'migrate to pact versions (migrate 22-31)', no_db_clean: :true do
   let!(:pact_2) { create(:pacts, {version_id: consumer_version_2[:id], provider_id: provider[:id], pact_version_content_sha: '1234', created_at: now, updated_at: pact_updated_at}) }
 
 
-  let(:do_migration) do
-    PactBroker::Database.migrate(34)
-  end
+  subject { PactBroker::Database.migrate(34) }
 
   it "keeps the same number of pacts" do
-    do_migration
+    subject
     expect(database[:latest_pact_publications_by_consumer_versions].count).to eq 2
   end
 
   it "uses the old updated date for the new creation date" do
-    do_migration
+    subject
     expect(database[:latest_pact_publications_by_consumer_versions].order(:id).first[:created_at].to_datetime).to eq pact_updated_at
   end
 
   it "sets each revision number to 1" do
-    do_migration
+    subject
     expect(database[:latest_pact_publications_by_consumer_versions].order(:id).first[:revision_number]).to eq 1
     expect(database[:latest_pact_publications_by_consumer_versions].order(:id).last[:revision_number]).to eq 1
   end
@@ -56,7 +39,7 @@ describe 'migrate to pact versions (migrate 22-31)', no_db_clean: :true do
     old_all_pact.delete(:created_at)
     old_all_pact.delete(:created_at)
     old_all_pact[:pact_version_sha] = old_all_pact.delete(:pact_version_content_sha)
-    do_migration
+    subject
     database[:latest_pact_publications_by_consumer_versions]
     new_all_pact = database[:latest_pact_publications_by_consumer_versions].order(:id).first
     new_all_pact.delete(:created_at)
@@ -70,7 +53,7 @@ describe 'migrate to pact versions (migrate 22-31)', no_db_clean: :true do
     old_all_pact.delete(:updated_at)
     old_all_pact.delete(:created_at)
     old_all_pact[:pact_version_sha] = old_all_pact.delete(:pact_version_content_sha)
-    do_migration
+    subject
     new_all_pact = database[:latest_pact_publications_by_consumer_versions].order(:id).last
     new_all_pact.delete(:created_at)
     new_all_pact.delete(:revision_number)
@@ -79,15 +62,10 @@ describe 'migrate to pact versions (migrate 22-31)', no_db_clean: :true do
   end
 
   it "allows a new pact to be inserted with no duplicate ID error" do
-    do_migration
+    subject
 
     PactBroker::Pacts::Service.create_or_update_pact(
       consumer_id: consumer[:id], provider_id: provider[:id], consumer_version_number: '1.2.3', json_content: load_fixture('a_consumer-a_provider.json')
     )
   end
-
-  after do
-    PactBroker::Database.migrate
-    PactBroker::Database.truncate
-  end
 end

data/spec/migrations/24_populate_pact_contents_spec.rb

@@ -1,16 +1,5 @@
-require 'tasks/database'
-
-describe 'migrate to pact versions (migrate 22-24)', no_db_clean: :true do
-
-  def create table_name, params, id_column_name = :id
-    database[table_name].insert(params);
-    database[table_name].order(id_column_name).last
-  end
-
-  let(:database) { DB.connection_for_env 'test' }
-
+describe 'migrate to pact versions (migrate 22-24)', migration: true do
   before do
-    PactBroker::Database.drop_objects
     PactBroker::Database.migrate(22)
   end
 
@@ -24,17 +13,10 @@ describe 'migrate to pact versions (migrate 22-24)', no_db_clean: :true do
 
   let!(:pact_version_content_orphan) { create(:pact_version_contents, {content: {some: 'json'}.to_json, sha: '4567', created_at: now, updated_at: now}, :sha) }
 
-  let(:do_migration) do
-    PactBroker::Database.migrate(34)
-  end
+  subject { PactBroker::Database.migrate(34) }
 
   it "deletes orphan pact_versions" do
-    do_migration
+    subject
     expect(database[:pact_versions].count).to eq 1
   end
-
-  after do
-    PactBroker::Database.migrate
-    PactBroker::Database.truncate
-  end
 end

data/spec/migrations/34_latest_tagged_pacts_spec.rb

@@ -1,16 +1,5 @@
-require 'tasks/database'
-
-describe 'using pact publications (migrate 31-32)', no_db_clean: :true do
-
-  def create table_name, params, id_column_name = :id
-    database[table_name].insert(params);
-    database[table_name].order(id_column_name).last
-  end
-
-  let(:database) { DB.connection_for_env 'test' }
-
+describe 'using pact publications (migrate 31-32)', migration: true do
   before do
-    PactBroker::Database.drop_objects
     PactBroker::Database.migrate(34)
   end
 
@@ -92,9 +81,4 @@ describe 'using pact publications (migrate 31-32)', no_db_clean: :true do
       expect(database[:latest_tagged_pact_publications].order(:id).first).to_not have_key(:updated_at)
     end
   end
-
-  after do
-    PactBroker::Database.migrate
-    PactBroker::Database.truncate
-  end
 end

data/spec/migrations/34_pact_revisions_spec.rb

@@ -1,16 +1,5 @@
-require 'tasks/database'
-
-describe 'using pact publications (migrate 31-32)', no_db_clean: :true do
-
-  def create table_name, params, id_column_name = :id
-    database[table_name].insert(params);
-    database[table_name].order(id_column_name).last
-  end
-
-  let(:database) { DB.connection_for_env 'test' }
-
+describe 'using pact publications (migrate 31-32)', migration: true do
   before do
-    PactBroker::Database.drop_objects
     PactBroker::Database.migrate(33)
   end
 
@@ -30,28 +19,28 @@ describe 'using pact publications (migrate 31-32)', no_db_clean: :true do
   let!(:pact_version_content_2) { create(:pact_versions, {content: {some: 'json'}.to_json, sha: '4567', consumer_id: consumer_2[:id], provider_id: provider_2[:id], created_at: now}) }
   let!(:pact_version_3_revision_1) { create(:pact_publications, {consumer_version_id: consumer_version_3[:id], provider_id: provider_2[:id], pact_version_id: pact_version_content_2[:id], created_at: now, revision_number: 1}) }
 
-  let(:do_migration) do
+  subject do
     PactBroker::Database.migrate(34)
     database.schema(:latest_pact_publication_revision_numbers, reload: true)
   end
 
   describe "all_pact_publications" do
     it "has a row for every revision" do
-      do_migration
+      subject
       expect(database[:all_pact_publications].count).to eq 4
     end
   end
 
   describe "latest_pact_publications_by_consumer_versions" do
     it "has a row for every pact" do
-      do_migration
+      subject
       expect(database[:latest_pact_publications_by_consumer_versions].count).to eq 3
     end
   end
 
   describe "latest_pact_publication_revision_numbers" do
     it "contains the latest revision number for each consumer version" do
-      do_migration
+      subject
       expect(database[:latest_pact_publication_revision_numbers].where(
         provider_id: provider_1[:id], consumer_id: consumer_1[:id],
         consumer_version_order: 1, latest_revision_number: 1
@@ -72,7 +61,7 @@ describe 'using pact publications (migrate 31-32)', no_db_clean: :true do
 
   describe "latest_pact_consumer_version_orders" do
     it "contains the latest consumer version for each consumer/provider pair" do
-      do_migration
+      subject
       expect(database[:latest_pact_consumer_version_orders].count).to eq 2
       expect(database[:latest_pact_consumer_version_orders].where(
         provider_id: provider_1[:id], consumer_id: consumer_1[:id],
@@ -85,14 +74,9 @@ describe 'using pact publications (migrate 31-32)', no_db_clean: :true do
 
   describe "latest_pact_publications" do
     it "only contains the latest revision of the pact for the latest consumer version" do
-      do_migration
+      subject
       expect(database[:latest_pact_publications].count).to eq 2
       expect(database[:latest_pact_publications].where(provider_id: provider_1[:id], consumer_id: consumer_1[:id]).count).to eq 1
     end
   end
-
-  after do
-    PactBroker::Database.migrate
-    PactBroker::Database.truncate
-  end
 end

data/spec/migrations/41_migrate_execution_data_spec.rb

@@ -0,0 +1,109 @@
+describe 'creating triggered webhooks from webhook executions (migrate 36-41)', migration: true do
+  before do
+    PactBroker::Database.migrate(36)
+  end
+
+  let(:before_now) { DateTime.new(2016, 1, 1) }
+  let(:now) { DateTime.new(2018, 2, 2) }
+  let(:consumer) { create(:pacticipants, {name: 'Consumer', created_at: now, updated_at: now}) }
+  let(:provider) { create(:pacticipants, {name: 'Provider', created_at: now, updated_at: now}) }
+  let(:consumer_version) { create(:versions, {number: '1.2.3', order: 1, pacticipant_id: consumer[:id], created_at: now, updated_at: now}) }
+  let(:pact_version) { create(:pact_versions, {content: {some: 'json'}.to_json, sha: '1234', consumer_id: consumer[:id], provider_id: provider[:id], created_at: now}) }
+  let(:pact_publication) do
+    create(:pact_publications, {
+      consumer_version_id: consumer_version[:id],
+      provider_id: provider[:id],
+      revision_number: 1,
+      pact_version_id: pact_version[:id],
+      created_at: (now - 1)
+    })
+  end
+
+  let(:pact_publication_2) do
+    create(:pact_publications, {
+      consumer_version_id: consumer_version[:id],
+      provider_id: provider[:id],
+      revision_number: 2,
+      pact_version_id: pact_version[:id],
+      created_at: now
+    })
+  end
+  let(:pact_publication_3) do
+    create(:pact_publications, {
+      consumer_version_id: consumer_version[:id],
+      provider_id: provider[:id],
+      revision_number: 3,
+      pact_version_id: pact_version[:id],
+      created_at: (now + 1)
+    })
+  end
+  let(:webhook) do
+    create(:webhooks, {
+      uuid: '1234',
+      method: 'GET',
+      url: 'http://www.example.org',
+      consumer_id: consumer[:id],
+      provider_id: provider[:id],
+      is_json_request_body: false,
+      created_at: now
+    })
+  end
+  let(:webhook_execution) do
+    create(:webhook_executions, {
+      webhook_id: webhook[:id],
+      pact_publication_id: pact_publication[:id],
+      consumer_id: consumer[:id],
+      provider_id: provider[:id],
+      success: true,
+      logs: 'logs',
+      created_at: now
+    })
+  end
+
+  subject { PactBroker::Database.migrate(41) }
+
+  context "when a pact_publication can be found" do
+    before do
+      pact_publication
+      pact_publication_2
+      pact_publication_3
+      webhook_execution
+    end
+
+    it "creates a triggered webhook for each webhook execution" do
+      subject
+      expect(database[:triggered_webhooks].count).to eq 1
+      expect(database[:triggered_webhooks].first[:webhook_id]).to eq webhook[:id]
+      expect(database[:triggered_webhooks].first[:webhook_uuid]).to eq '1234'
+      expect(database[:triggered_webhooks].first[:consumer_id]).to eq consumer[:id]
+      expect(database[:triggered_webhooks].first[:provider_id]).to eq provider[:id]
+      expect(database[:triggered_webhooks].first[:pact_publication_id]).to eq pact_publication_2[:id]
+      expect(database[:triggered_webhooks].first[:status]).to eq 'success'
+      expect(database[:triggered_webhooks].first[:created_at]).to eq webhook[:created_at]
+      expect(database[:triggered_webhooks].first[:updated_at]).to eq webhook[:created_at]
+    end
+
+    it "nils out the unused foreign_keys on the webhook_execution" do
+      subject
+      expect(database[:webhook_executions].first[:webhook_id]).to be_nil
+      expect(database[:webhook_executions].first[:consumer_id]).to be_nil
+      expect(database[:webhook_executions].first[:provider_id]).to be_nil
+      expect(database[:webhook_executions].first[:pact_publication_id]).to be_nil
+    end
+
+    context "migrating backwards" do
+      it "deletes the triggered_webhooks again" do
+        subject
+        PactBroker::Database.migrate(40)
+        expect(database[:triggered_webhooks].count).to eq 0
+      end
+    end
+  end
+
+  context "when a pact_publication cannot be found" do
+    it "does not insert a triggered webhook" do
+      subject
+      expect(database[:triggered_webhooks].count).to eq 0
+    end
+  end
+end

data/spec/service_consumers/pact_helper.rb

@@ -1,6 +1,10 @@
 $: << File.expand_path("../../../", __FILE__)
 require 'pact/provider/rspec'
 require 'db'
+require 'tasks/database'
+require 'pact_broker/db'
+PactBroker::DB.connection = PactBroker::Database.database = DB::PACT_BROKER_DB
+
 require 'spec/support/database_cleaner'
 require 'pact_broker/api'
 
@@ -9,7 +13,7 @@ require_relative 'provider_states_for_pact_broker_client'
 Pact.service_provider "Pact Broker" do
 
   honours_pact_with "Pact Broker Client" do
-    pact_uri "https://raw.githubusercontent.com/bethesque/pact_broker-client/master/spec/pacts/pact_broker_client-pact_broker.json"
+    pact_uri "https://raw.githubusercontent.com/pact-foundation/pact_broker-client/master/spec/pacts/pact_broker_client-pact_broker.json"
   end
 
 end

data/spec/spec_helper.rb

@@ -5,10 +5,15 @@ ENV['RACK_ENV'] = 'test'
 RACK_ENV = 'test'
 
 $: << File.expand_path("../../", __FILE__)
-require 'rack/test'
+
 require 'db'
-require 'pact_broker/api'
 require 'tasks/database'
+require 'pact_broker/db'
+raise "Wrong environment!!! Don't run this script!! ENV['RACK_ENV'] is #{ENV['RACK_ENV']} and RACK_ENV is #{RACK_ENV}" if ENV['RACK_ENV'] != 'test' || RACK_ENV != 'test'
+PactBroker::DB.connection = PactBroker::Database.database = DB::PACT_BROKER_DB
+
+require 'rack/test'
+require 'pact_broker/api'
 require 'rspec/its'
 
 Dir.glob("./spec/support/**/*.rb") { |file| require file  }
@@ -16,21 +21,24 @@ Dir.glob("./spec/support/**/*.rb") { |file| require file  }
 I18n.config.enforce_available_locales = false
 
 RSpec.configure do | config |
-  config.before :suite do
-    raise "Wrong environment!!! Don't run this script!! ENV['RACK_ENV'] is #{ENV['RACK_ENV']} and RACK_ENV is #{RACK_ENV}" if ENV['RACK_ENV'] != 'test' || RACK_ENV != 'test'
-    PactBroker::DB.connection = PactBroker::Database.database = DB::PACT_BROKER_DB
-  end
-
   config.before :each do
     PactBroker.reset_configuration
+    require 'pact_broker/badges/service'
+    PactBroker::Badges::Service.clear_cache
   end
 
   config.include Rack::Test::Methods
+
   config.mock_with :rspec do |mocks|
     mocks.verify_partial_doubles = true
   end
 
+  config.define_derived_metadata do |meta|
+    meta[:aggregate_failures] = true unless meta.key?(:aggregate_failures)
+  end
+
   config.include FixtureHelpers
+  config.example_status_persistence_file_path = "./spec/examples.txt"
 
   def app
     PactBroker::API

data/spec/support/database_cleaner.rb

@@ -1,6 +1,10 @@
 require 'database_cleaner'
+require 'support/migration_helpers'
 
 RSpec.configure do |config|
+
+  config.include MigrationHelpers, migration: true
+
   config.before(:suite) do
     if defined?(::DB)
       DatabaseCleaner.strategy = :transaction
@@ -12,14 +16,23 @@ RSpec.configure do |config|
     end
   end
 
+  config.before :each, migration: true do
+    PactBroker::Database.drop_objects
+  end
+
+  config.after :each, migration: true do
+    PactBroker::Database.migrate
+    PactBroker::Database.truncate
+  end
+
   config.before(:each) do | example |
-    unless example.metadata[:no_db_clean]
+    unless example.metadata[:no_db_clean] || example.metadata[:migration]
       DatabaseCleaner.start if defined?(::DB)
     end
   end
 
   config.after(:each) do | example |
-    unless example.metadata[:no_db_clean]
+    unless example.metadata[:no_db_clean] || example.metadata[:migration]
       DatabaseCleaner.clean if defined?(::DB)
     end
   end

data/spec/support/migration_helpers.rb

@@ -0,0 +1,16 @@
+require 'tasks/database'
+
+module MigrationHelpers
+  def create table_name, params, id_column_name = :id
+    database[table_name].insert(params);
+    database[table_name].order(id_column_name).last
+  end
+
+  def clean table_name
+    database[table_name].delete rescue puts "Error cleaning #{table_name} #{$!}"
+  end
+
+  def database
+    @database ||= DB.connection_for_env 'test'
+  end
+end

data/spec/support/test_data_builder.rb

@@ -1,4 +1,5 @@
 require 'pact_broker/repositories'
+require 'pact_broker/services'
 require 'pact_broker/webhooks/repository'
 require 'pact_broker/webhooks/service'
 require 'pact_broker/domain/webhook_execution_result'
@@ -25,11 +26,16 @@ require 'ostruct'
 class TestDataBuilder
 
   include PactBroker::Repositories
+  include PactBroker::Services
 
   attr_reader :pacticipant
   attr_reader :consumer
   attr_reader :provider
+  attr_reader :consumer_version
+  attr_reader :pact
   attr_reader :webhook
+  attr_reader :webhook_execution
+  attr_reader :triggered_webhook
 
   def create_pricing_service
     @pricing_service_id = pacticipant_repository.create(:name => 'Pricing Service', :repository_url => 'git@git.realestate.com.au:business-systems/pricing-service').save(raise_on_save_failure: true).id
@@ -82,10 +88,11 @@ class TestDataBuilder
   end
 
   def create_pact_with_hierarchy consumer_name = "Consumer", consumer_version = "1.2.3", provider_name = "Provider", json_content = default_json_content
-    provider = PactBroker::Domain::Pacticipant.create(:name => provider_name)
-    consumer = PactBroker::Domain::Pacticipant.create(:name => consumer_name)
-    version = PactBroker::Domain::Version.create(:number => consumer_version, :pacticipant => consumer)
-    PactBroker::Pacts::Repository.new.create(version_id: version.id, consumer_id: consumer.id, provider_id: provider.id, json_content: json_content)
+    create_consumer consumer_name
+    create_provider provider_name
+    create_consumer_version consumer_version
+    create_pact json_content: json_content
+    self
   end
 
   def create_version_with_hierarchy pacticipant_name, pacticipant_version
@@ -156,15 +163,40 @@ class TestDataBuilder
   end
 
   def create_webhook params = {}
+    uuid = params[:uuid] || PactBroker::Webhooks::Service.next_uuid
     default_params = {method: 'POST', url: 'http://example.org', headers: {'Content-Type' => 'application/json'}}
     request = PactBroker::Domain::WebhookRequest.new(default_params.merge(params))
-    @webhook = PactBroker::Webhooks::Repository.new.create PactBroker::Webhooks::Service.next_uuid, PactBroker::Domain::Webhook.new(request: request), @consumer, @provider
+    @webhook = PactBroker::Webhooks::Repository.new.create uuid, PactBroker::Domain::Webhook.new(request: request), @consumer, @provider
+    self
+  end
+
+  def create_triggered_webhook params = {}
+    trigger_uuid = params[:trigger_uuid] || webhook_service.next_uuid
+    @triggered_webhook = webhook_repository.create_triggered_webhook trigger_uuid, @webhook, @pact, PactBroker::Webhooks::Service::PUBLICATION
+    @triggered_webhook.update(status: params[:status]) if params[:status]
+    set_created_at_if_set params[:created_at], :triggered_webhooks, {id: @triggered_webhook.id}
+    self
+  end
+
+  def create_webhook_execution params = {}
+    logs = params[:logs] || "logs"
+    webhook_execution_result = PactBroker::Domain::WebhookExecutionResult.new(OpenStruct.new(code: "200"), logs, nil)
+    @webhook_execution = PactBroker::Webhooks::Repository.new.create_execution @triggered_webhook, webhook_execution_result
+    created_at = params[:created_at] || @pact.created_at + Rational(1, 86400)
+    set_created_at_if_set created_at, :webhook_executions, {id: @webhook_execution.id}
+    @webhook_execution = PactBroker::Webhooks::Execution.find(id: @webhook_execution.id)
     self
   end
 
-  def create_webhook_execution
-    webhook_execution_result = PactBroker::Domain::WebhookExecutionResult.new(OpenStruct.new(code: "200"), "logs", nil)
-    @webhook_execution = PactBroker::Webhooks::Repository.new.create_execution @webhook, webhook_execution_result
+  def create_deprecated_webhook_execution params = {}
+    create_webhook_execution params
+    Sequel::Model.db[:webhook_executions].where(id: webhook_execution.id).update(
+      triggered_webhook_id: nil,
+      consumer_id: consumer.id,
+      provider_id: provider.id,
+      webhook_id: PactBroker::Webhooks::Webhook.find(uuid: webhook.uuid).id,
+      pact_publication_id: pact.id
+    )
     self
   end
 
@@ -189,7 +221,7 @@ class TestDataBuilder
 
   def set_created_at_if_set created_at, table_name, selector
     if created_at
-      Sequel::Model.db[table_name].where(selector.keys.first => selector.values.first).update(created_at: created_at.xmlschema)
+      Sequel::Model.db[table_name].where(selector.keys.first => selector.values.first).update(created_at: created_at)
     end
   end