pact_broker 2.89.1 → 2.90.0

data/spec/support/shared_examples_for_responses.rb

@@ -1,96 +0,0 @@
-shared_examples_for "a JSON 404 response" do
-  it "returns a 404 Not Found" do
-    subject
-    expect(last_response.status).to eq 404
-  end
-end
-
-shared_examples_for "a 200 JSON response" do
-
-end
-
-require "rspec/expectations"
-
-RSpec::Matchers.define :be_a_hal_json_success_response do
-  match do | actual |
-    expect(actual.status).to be 200
-    expect(actual.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-  end
-
-  failure_message do
-    "Expected successful json response, got #{actual.status} #{actual.headers['Content-Type']} with body #{actual.body}"
-  end
-end
-
-RSpec::Matchers.define :be_a_hal_json_created_response do
-  match do | actual |
-    expect(actual.status).to be 201
-    expect(actual.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-  end
-
-  failure_message do
-    "Expected creation successful json response, got #{actual.status} #{actual.headers['Content-Type']} with body #{actual.body}"
-  end
-end
-
-RSpec::Matchers.define :be_a_json_response do
-  match do | actual |
-    expect(actual.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-  end
-end
-
-RSpec::Matchers.define :be_a_json_error_response do | message |
-  match do | actual |
-    expect(actual.status).to be 400
-    expect(actual.headers["Content-Type"]).to eq "application/hal+json;charset=utf-8"
-    expect(actual.body).to include message
-  end
-end
-
-RSpec::Matchers.define :be_a_404_response do
-  match do | actual |
-    expect(actual.status).to be 404
-  end
-end
-
-RSpec::Matchers.define :include_hashes_matching do |expected_array_of_hashes|
-  match do |array_of_hashes|
-    expected_array_of_hashes.each do | expected |
-      expect(array_of_hashes).to include_hash_matching(expected)
-    end
-
-    expect(array_of_hashes.size).to eq expected_array_of_hashes.size
-  end
-
-  def slice actual, keys
-    keys.each_with_object({}) { |k, hash| hash[k] = actual[k] if actual.has_key?(k) }
-  end
-end
-
-RSpec::Matchers.define :include_hash_matching do |expected|
-  match do |array_of_hashes|
-    @array_of_hashes = array_of_hashes
-    array_of_hashes.any? { |actual| slice(actual, expected.keys) == expected }
-  end
-
-  failure_message do
-    "expected #{@array_of_hashes.inspect} to include #{expected.inspect}"
-  end
-
-  def slice actual, keys
-    keys.each_with_object({}) do |k, hash|
-      if (actual.respond_to?(:has_key?) && actual.has_key?(k))
-        hash[k] = actual[k]
-      elsif actual.respond_to?(k)
-        hash[k] = actual.send(k)
-      end
-    end
-  end
-end
-
-RSpec::Matchers.define :be_a_pact_never_verified_for_consumer do | expected_consumer_name |
-  match do | actual_reason |
-    expect(actual_reason).to be_a(PactBroker::Matrix::PactNotEverVerifiedByProvider)
-    expect(actual_reason.consumer_selector.pacticipant_name).to eq expected_consumer_name
-  end
-end

data/spec/support/simplecov.rb

@@ -1,23 +0,0 @@
-require "simplecov"
-
-SimpleCov.minimum_coverage 90
-
-if ENV["SIMPLECOV_COMMAND_NAME"]
-  SimpleCov.command_name ENV["SIMPLECOV_COMMAND_NAME"]
-  case ENV["SIMPLECOV_COMMAND_NAME"]
-  when "spec:quick"
-    SimpleCov.minimum_coverage 92
-  when "spec:slow"
-    SimpleCov.minimum_coverage 92
-  when "pact:verify"
-    SimpleCov.minimum_coverage 62
-  end
-end
-
-SimpleCov.start do
-  add_filter "/db/"
-  add_filter "/example/"
-  add_filter "/spec/"
-  add_filter "/tasks/"
-  add_filter "/script/"
-end

data/spec/support/ssl_pact_broker_server.rb

@@ -1,46 +0,0 @@
-if __FILE__ == $0
-
-  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 "pact_broker"
-
-  DATABASE_CREDENTIALS = { adapter: "sqlite", database: "/tmp/pact_broker_ssl_database.sqlite3", :encoding => "utf8" }
-
-  app = PactBroker::App.new do | config |
-    config.logger = ::Logger.new($stdout)
-    config.logger.level = ::Logger::INFO
-    config.auto_migrate_db = true
-    config.database_connection = Sequel.connect(DATABASE_CREDENTIALS.merge(:logger => PactBroker::DB::LogQuietener.new(Logger.new(StringIO.new))))
-  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/support/ssl_webhook_server.rb

@@ -1,39 +0,0 @@
-if __FILE__ == $0
-
-  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] }
-    logger_stream = ENV["DEBUG"] ? $stderr : StringIO.new
-    {
-      Port: port,
-      Host: "0.0.0.0",
-      AccessLog: [],
-      Logger: WEBrick::Log.new(logger_stream,WEBrick::Log::INFO),
-      SSLCertificate: certificate,
-      SSLPrivateKey: OpenSSL::PKey::RSA.new(File.read(SSL_KEY)),
-      SSLEnable: true,
-      SSLCertName: cert_name
-    }
-  end
-
-  app = ->(_env) { puts "hello"; [200, {}, ["Hello world" + "\n"]] }
-
-  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/support/test_data_builder.rb

@@ -1,3 +0,0 @@
-require "pact_broker/test/test_data_builder"
-
-TestDataBuilder = PactBroker::Test::TestDataBuilder

data/spec/support/verification_job.rb

@@ -1,37 +0,0 @@
-require "sucker_punch"
-require "faraday"
-require "pact_broker/logging"
-
-
-# Publishes verification results, as if they were triggered by a CI job
-module PactBroker
-  class VerificationJob
-    include SuckerPunch::Job
-    include PactBroker::Logging
-
-    def perform data
-      pact_url = data.fetch(:pactUrl)
-      pact = Faraday.get(pact_url, nil, { "Accept" => "application/hal+json"}).body
-      pact_hash = JSON.parse(pact)
-
-      headers = {
-        "Content-Type" => "application/json",
-        "Accept" => "application/hal+json"
-      }
-
-      provider_version = "1.2.#{(rand * 1000).to_i}"
-      provider_url = pact_hash["_links"]["pb:provider"]["href"]
-      Faraday.put("#{provider_url}/versions/#{provider_version}/tags/dev", nil, headers)
-
-      verification_url = pact_hash["_links"]["pb:publish-verification-results"]["href"]
-      body = {
-        success: true,
-        providerApplicationVersion: provider_version
-      }
-
-      Faraday.post(verification_url, body.to_json, headers)
-      sleep 3
-      Faraday.put("#{provider_url}/versions/#{provider_version}/tags/prod", nil, headers)
-    end
-  end
-end

data/spec/support/warning_silencer.rb

@@ -1,10 +0,0 @@
-module WarningSilencer
-  extend self
-
-  def enable
-    old, $VERBOSE = $VERBOSE, nil
-    yield
-  ensure
-    $VERBOSE = old
-  end
-end

data/spec/support/webhook_endpoint_middleware.rb

@@ -1,22 +0,0 @@
-module PactBroker
-  class WebhookEndpointMiddleware
-    def initialize app
-      @app = app
-    end
-
-    def call(env)
-      if env["PATH_INFO"] == "/pact-changed-webhook"
-        body = env["rack.input"].read
-        puts body
-        PactBroker::VerificationJob.perform_in(2, JSON.parse(body, symbolize_names: true))
-        [200, {}, ["Pact changed webhook executed"]]
-      elsif env["PATH_INFO"] == "/verification-published-webhook"
-        body = env["rack.input"].read
-        puts body
-        [200, {}, ["Verification webhook executed"]]
-      else
-        @app.call(env)
-      end
-    end
-  end
-end

data/tasks/audit.rake

@@ -1,6 +0,0 @@
-begin
-  require "bundler/audit/task"
-  Bundler::Audit::Task.new
-rescue LoadError
-  # in production
-end

data/tasks/database/annotate.rb

@@ -1,48 +0,0 @@
-require "sequel/annotate"
-
-module PactBroker
-  class Annotate
-    def self.call
-      annotation_configuration.each_pair do | klass, path |
-        begin
-          puts "Annotating #{klass}"
-          sa = Sequel::Annotate.new(klass)
-          sa.annotate(path)
-        rescue StandardError => e
-          puts "Error annnotating #{klass} - #{e.message}\n#{e.backtrace.join("\n")}"
-        end
-      end
-    end
-
-    def self.annotation_configuration
-      sequel_domain_classes.each_with_object({}) do | klass, configs |
-        file_path = file_path_for_class(klass)
-        if File.exist?(file_path)
-          if klass.db.table_exists?(klass.table_name)
-            configs[klass] = file_path
-          else
-            puts "Skipping annotation for #{klass} as the configured table_name '#{klass.table_name}' is not a real table"
-          end
-        else
-          puts "Skipping annotation for #{klass} as the generated file path #{file_path} does not exist"
-        end
-      end
-    end
-
-    def self.sequel_domain_classes
-
-      Dir.chdir("lib") { Dir.glob("**/*.rb") }.sort.each do | path |
-        require path
-      end
-
-      ObjectSpace
-        .each_object(::Class).select {|klass| klass < ::Sequel::Model }
-        .select{ |klass| klass.name && klass.name.start_with?("PactBroker::") }
-        .sort{ | c1, c2| c1.name <=> c2.name }
-    end
-
-    def self.file_path_for_class klass
-      "lib/" + klass.name.gsub("::", "/").gsub(/([a-z])([A-Z])/) {|match| match[0] + "_" + match[1].downcase }.downcase + ".rb"
-    end
-  end
-end

data/tasks/database/table_dependency_calculator.rb

@@ -1,8 +0,0 @@
-require "pact_broker/db/table_dependency_calculator"
-
-module PactBroker
-  module Database
-    # For backwards compatibility
-    TableDependencyCalculator = PactBroker::DB::TableDependencyCalculator
-  end
-end

data/tasks/database.rb

@@ -1,161 +0,0 @@
-require "pact_broker/project_root"
-require "pact_broker/db/migrate"
-require "pact_broker/db/version"
-require "pact_broker/db"
-require "sequel"
-require "yaml"
-require_relative "database/table_dependency_calculator"
-
-Sequel.extension :migration
-
-module PactBroker
-  module Database
-
-    extend self
-
-    def migrate target = nil
-      opts = target ? { target: target } : {}
-      PactBroker::DB::Migrate.call(database, opts)
-    end
-
-    def version
-      PactBroker::DB::Version.call(database)
-    end
-
-    def delete_database_file
-      ensure_not_production
-      FileUtils.rm_rf(database_file_path) if sqlite?
-    end
-
-    def ensure_database_dir_exists
-      ensure_not_production
-      FileUtils.mkdir_p(File.dirname(database_file_path)) if sqlite?
-    end
-
-    def drop_objects
-      drop_views
-      drop_tables
-      drop_sequences
-    end
-
-    def drop_tables
-      ordered_tables.each do | table_name |
-        database.drop_table(table_name, cascade: psql?)
-      end
-      database.drop_table(:schema_migrations) if database.table_exists?(:schema_migrations)
-    end
-
-    def drop_views
-      database.views.each do | view_name |
-        begin
-          # checking for existance using table_exists? doesn't work in sqlite
-          database.drop_view(view_name, cascade: psql?)
-        rescue Sequel::DatabaseError => e
-          # Cascade will have deleted some views already with pg
-          raise e unless e.cause.class.name == "PG::UndefinedTable"
-        end
-      end
-    end
-
-    def drop_sequences
-      if psql?
-        database.run("DROP SEQUENCE verification_number_sequence")
-        database.run("DROP SEQUENCE version_order_sequence")
-      end
-    end
-
-    def create
-      if psql?
-        system('psql postgres -c "create database pact_broker"')
-        system('psql postgres -c "CREATE USER pact_broker WITH PASSWORD \'pact_broker\'"')
-        system('psql postgres -c "GRANT ALL PRIVILEGES ON DATABASE pact_broker to pact_broker"')
-      elsif sqlite?
-        ensure_database_dir_exists
-      else
-        raise "Unknown database adapter #{adapter}"
-      end
-    end
-
-    def recreate
-      drop_tables
-      create
-    end
-
-    def truncate
-      ordered_tables.each do | table_name |
-        if database.table_exists?(table_name)
-          begin
-            database[table_name].delete
-          rescue SQLite3::ConstraintException => e
-            puts "Could not delete the following records from #{table_name}: #{database[table_name].select_all}"
-            raise e
-          end
-        end
-      end
-    end
-
-    def database= database
-      @@database = database
-    end
-
-    def database
-      @@database ||= begin
-        require "db"
-        ::DB.connection_for_env env
-      end
-    end
-
-    def wait_for_database
-      tries = 0
-      begin
-        database
-      rescue StandardError => e
-        tries += 1
-        sleep 1
-        retry if tries < 10
-        raise e
-      end
-    end
-
-    private
-
-    def ordered_tables
-      TableDependencyCalculator.call(database)
-    end
-
-    def ensure_not_production
-      raise "Cannot delete production database using this task" if env == "production"
-    end
-
-    def psql?
-      adapter == "postgres"
-    end
-
-    def sqlite?
-      adapter == "sqlite"
-    end
-
-    def migrations_dir
-      PactBroker.project_root.join("db","migrations")
-    end
-
-    def database_file_path
-      configuration_for_env(env)["database"]
-    end
-
-    def adapter
-      configuration_for_env(env)["adapter"]
-    end
-
-    def configuration_for_env env
-      database_yml = PactBroker.project_root.join("config","database.yml")
-      config = YAML.load(ERB.new(File.read(database_yml)).result)
-      adapter = ENV.fetch("DATABASE_ADAPTER","default")
-      config.fetch(env)[adapter]
-    end
-
-    def env
-      ENV.fetch("RACK_ENV")
-    end
-  end
-end

data/tasks/db.rake

@@ -1,147 +0,0 @@
-require "pact_broker/tasks"
-
-namespace :bundler do
-  task :setup do
-    require "rubygems"
-    require "bundler/setup"
-  end
-end
-
-namespace :db do
-
-  task :spec do
-    Bundler.with_clean_env do
-      # todo check for ruby version
-      system("cd db/test/backwards_compatibility && bundle exec rake db:check_backwards_compatibility")
-      success = $?.exitstatus == 0
-      exit(1) unless success
-    end
-  end
-
-  task :env => ["bundler:setup"] do
-    # Require RACK_ENV to be set for tasks that will be called in production
-    raise "Please specify RACK_ENV" unless ENV["RACK_ENV"]
-    require File.dirname(__FILE__) + "/database.rb"
-  end
-
-  task :create do
-    Rake::Task["db:create:#{ENV.fetch('DATABASE_ADAPTER', 'default')}"].invoke
-  end
-
-  namespace :create do
-    task :default do
-    end
-
-    task :postgres do
-      puts `psql postgres -c "CREATE DATABASE pact_broker;"`
-      puts `psql postgres -c "GRANT ALL PRIVILEGES ON DATABASE pact_broker TO pact_broker;"`
-    end
-
-    task :mysql do
-      puts `mysql -h localhost -u root -e "CREATE DATABASE IF NOT EXISTS pact_broker"`
-      puts `mysql -h localhost -u root -e "GRANT ALL PRIVILEGES ON pact_broker.* TO 'pact_broker'@'localhost' identified by 'pact_broker';"`
-    end
-  end
-
-  task :drop do
-    Rake::Task["db:drop:#{ENV.fetch('DATABASE_ADAPTER', 'default')}"].invoke
-  end
-
-  namespace :drop do
-    desc 'Delete the dev/test database - uses RACK_ENV, defaulting to "development"'
-    task :default => "db:env" do
-      PactBroker::Database.delete_database_file
-    end
-
-    task :postgres do
-      puts `psql postgres -c "drop DATABASE pact_broker;"`
-    end
-
-    task :mysql do
-      puts `mysql -h localhost -u root -e "DROP DATABASE IF EXISTS pact_broker"`
-    end
-  end
-
-  desc "Print current schema version"
-  task :version => "db:env" do
-    puts "Schema Version: #{PactBroker::Database.version}"
-  end
-
-  desc "Migrate the Database"
-  task :migrate, [:target] => "db:env" do |_t, args|
-    target = args[:target] ? args[:target].to_i : nil
-    PactBroker::Database.migrate(target)
-  end
-
-  desc "Rollback database to specified version"
-  task :rollback, [:target] => "db:env" do |_t, args|
-    args.with_defaults(target: 0)
-    PactBroker::Database.migrate(args[:target].to_i)
-  end
-
-  desc 'Prepare the test database for running specs - RACK_ENV will be hardcoded to "test"'
-  task "prepare:test" => ["db:set_test_env","db:prepare_dir","db:delete","db:migrate"]
-
-  desc 'Reset the database (rollback then migrate) - uses RACK_ENV, defaulting to "development"'
-  task :reset => ["db:rollback", "db:migrate"]
-
-  desc 'Delete the dev/test database - uses RACK_ENV, defaulting to "development"'
-  task "delete" => "db:env" do
-    PactBroker::Database.delete_database_file
-  end
-
-  # Private: Ensure the dev/test database directory exists
-  task "prepare_dir" => "db:env" do
-    PactBroker::Database.ensure_database_dir_exists
-  end
-
-  desc "Annotate the Sequel domain classes with schema information.
-  Start the postgres db with script/docker/db-start.sh first and run
-  INSTALL_PG=true bundle exec rake db:annotate
-  "
-  task :annotate do
-    begin
-      raise "Need to set INSTALL_PG=true" unless ENV["INSTALL_PG"] == "true"
-      ENV["RACK_ENV"] = "test"
-      ENV["DATABASE_ADAPTER"] = "docker_postgres"
-      load "tasks/database.rb"
-      PactBroker::Database.wait_for_database
-      PactBroker::Database.migrate
-      load "tasks/database/annotate.rb"
-      require "pact_broker/db"
-      PactBroker::Annotate.call
-    end
-  end
-
-  task "docker:start" do
-    load "tasks/docker_database.rb"
-    DockerDatabase.start(name: "postgres-for-pact-broker", port: "5433")
-  end
-
-  task "docker:stop" do
-    load "tasks/docker_database.rb"
-    DockerDatabase.stop_and_remove("postgres-for-pact-broker")
-  end
-
-  # task :create => 'db:env' do
-  #   PactBroker::Database.create
-  # end
-
-  # Private
-  task :set_test_env do
-    ENV["RACK_ENV"] = "test"
-  end
-
-  task :set_postgres_database_adapter do
-    ENV["DATABASE_ADAPTER"] = "postgres"
-  end
-
-  # Private
-  task "env:nonprod" => ["bundler:setup"] do
-    # Allow default RACK_ENV to be set when not in production
-    RACK_ENV = ENV["RACK_ENV"] ||= "development"
-  end
-end
-
-task "db:env" => "db:env:nonprod"
-task "db:migrate" => "db:prepare_dir"