diff --git a/Gemfile b/Gemfile index c8be050..bb87b8f 100644 --- a/Gemfile +++ b/Gemfile @@ -14,7 +14,6 @@ gem "minitest-mock" gem "minitest-stub-const" gem "mutant-minitest" gem "concurrent-ruby" -gem "pg-ephemeral" gem "syntax_tree" gem "activerecord" diff --git a/Gemfile.lock b/Gemfile.lock index 116d46d..ca1cf92 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -160,16 +160,9 @@ GEM parser (3.3.11.1) ast (~> 2.4.1) racc - pg (1.6.3) pg (1.6.3-aarch64-linux) pg (1.6.3-arm64-darwin) pg (1.6.3-x86_64-linux) - pg-ephemeral (0.5.1-aarch64-linux) - pg (~> 1.5) - pg-ephemeral (0.5.1-arm64-darwin) - pg (~> 1.5) - pg-ephemeral (0.5.1-x86_64-linux) - pg (~> 1.5) pp (0.6.3) prettyprint prettier_print (1.2.1) @@ -286,7 +279,6 @@ DEPENDENCIES minitest-mock minitest-stub-const mutant-minitest - pg-ephemeral rails rails_event_store rake @@ -348,13 +340,9 @@ CHECKSUMS nokogiri (1.19.3-arm64-darwin) sha256=71b9bd424b1b7abc18b05052a1a3cfd3627abdca62be280854cc411791357e42 nokogiri (1.19.3-x86_64-linux-gnu) sha256=2f5078620fe12e83669b5b17311b32532a8153d02eee7ad06948b926d6080976 parser (3.3.11.1) sha256=d17ace7aabe3e72c3cc94043714be27cc6f852f104d81aa284c2281aecc65d54 - pg (1.6.3) sha256=1388d0563e13d2758c1089e35e973a3249e955c659592d10e5b77c468f628a99 pg (1.6.3-aarch64-linux) sha256=0698ad563e02383c27510b76bf7d4cd2de19cd1d16a5013f375dd473e4be72ea pg (1.6.3-arm64-darwin) sha256=7240330b572e6355d7c75a7de535edb5dfcbd6295d9c7777df4d9dddfb8c0e5f pg (1.6.3-x86_64-linux) sha256=5d9e188c8f7a0295d162b7b88a768d8452a899977d44f3274d1946d67920ae8d - pg-ephemeral (0.5.1-aarch64-linux) sha256=109ede089c1a5ef2d5ef80e8a1a8d7e4741a827948a1e7c3ae44c37f27fe6dbe - pg-ephemeral (0.5.1-arm64-darwin) sha256=b254bacea36f1fd9b9690f95d141c16716684beccae7ffd0a23df4477b4cf512 - pg-ephemeral (0.5.1-x86_64-linux) sha256=4c7a867df7e88abd5d8a5e816b0f633043c181017ccc6cde90b4be2087361129 pp (0.6.3) sha256=2951d514450b93ccfeb1df7d021cae0da16e0a7f95ee1e2273719669d0ab9df6 prettier_print (1.2.1) sha256=a72838b5f23facff21f90a5423cdcdda19e4271092b41f4ea7f50b83929e6ff9 prettyprint (0.2.0) sha256=2bc9e15581a94742064a3cc8b0fb9d45aae3d03a1baa6ef80922627a0766f193 diff --git a/bin/pg-ephemeral b/bin/pg-ephemeral deleted file mode 100755 index 2242dfc..0000000 --- a/bin/pg-ephemeral +++ /dev/null @@ -1,16 +0,0 @@ -#!/usr/bin/env ruby -# frozen_string_literal: true - -# -# This file was generated by Bundler. -# -# The application 'pg-ephemeral' is installed as part of a gem, and -# this file is here to facilitate running it. -# - -ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__) - -require "rubygems" -require "bundler/setup" - -load Gem.bin_path("pg-ephemeral", "pg-ephemeral") diff --git a/database.toml b/database.toml deleted file mode 100644 index 4409cd8..0000000 --- a/database.toml +++ /dev/null @@ -1,53 +0,0 @@ -image = "18" - -[instances.main.seeds.schema] -type = "sql-file" -path = "db/schema/0.1.0.sql" - -[instances.concurrent-append-non-conflicting-tags.seeds.schema] -type = "sql-file" -path = "db/schema/0.1.0.sql" - -[instances.concurrent-append-non-conflicting-tags-seeded.seeds.schema] -type = "sql-file" -path = "db/schema/0.1.0.sql" - -[instances.concurrent-append-non-conflicting-tags-seeded.seeds.events] -type = "sql-file" -path = "db/seeds/concurrent_append_non_conflicting_tags_seeded.sql" - -[instances.append-no-fail-if.seeds.schema] -type = "sql-file" -path = "db/schema/0.1.0.sql" - -[instances.append-no-fail-if-ar.seeds.schema] -type = "sql-file" -path = "db/schema/0.1.0.sql" - -[instances.append-non-conflicting-tags.seeds.schema] -type = "sql-file" -path = "db/schema/0.1.0.sql" - -[instances.concurrent-append-no-fail-if.seeds.schema] -type = "sql-file" -path = "db/schema/0.1.0.sql" - -[instances.concurrent-append-no-fail-if-ar.seeds.schema] -type = "sql-file" -path = "db/schema/0.1.0.sql" - -[instances.concurrent-append-conflicting-tags.seeds.schema] -type = "sql-file" -path = "db/schema/0.1.0.sql" - -[instances.res-append-stream-any.seeds.schema] -type = "sql-file" -path = "db/seeds/res.sql" - -[instances.res-concurrent-append-non-conflicting-streams.seeds.schema] -type = "sql-file" -path = "db/seeds/res.sql" - -[instances.res-concurrent-append-conflicting-streams.seeds.schema] -type = "sql-file" -path = "db/seeds/res.sql" diff --git a/devenv.nix b/devenv.nix index 7897c08..5e399db 100644 --- a/devenv.nix +++ b/devenv.nix @@ -33,6 +33,37 @@ export MUTANT_SINCE="''${MUTANT_SINCE:-HEAD}" ''; + services.postgres = { + enable = true; + package = pkgs.postgresql_18; + initialDatabases = + let + en57 = name: { + inherit name; + schema = ./db/schema/0.1.0.sql; + }; + res = name: { + inherit name; + schema = ./db/seeds/res.sql; + }; + in + [ + (en57 "main") + (en57 "append-no-fail-if") + (en57 "append-no-fail-if-ar") + (en57 "append-non-conflicting-tags") + (en57 "concurrent-append-no-fail-if") + (en57 "concurrent-append-no-fail-if-ar") + (en57 "concurrent-append-conflicting-tags") + (en57 "concurrent-append-non-conflicting-tags") + (en57 "concurrent-append-non-conflicting-tags-seeded") + (res "res-append-stream-any") + (res "res-concurrent-append-non-conflicting-streams") + (res "res-concurrent-append-conflicting-streams") + (en57 "en57_regress") + ]; + }; + files = let commitSkill = '' @@ -159,23 +190,12 @@ pg_regress=${pkgs.postgresql_18.dev}/lib/pgxs/src/test/regress/pg_regress bindir=${pkgs.postgresql_18}/bin - workdir=$(mktemp -d) - datadir=$workdir/data - socketdir=$workdir/socket dbname=en57_regress - mkdir -p "$socketdir" - - cleanup() { - "$bindir/pg_ctl" -D "$datadir" -m immediate stop >/dev/null 2>&1 || true - rm -rf "$workdir" - } - trap cleanup EXIT - - "$bindir/initdb" -D "$datadir" -U postgres --auth=trust >/dev/null - "$bindir/pg_ctl" -D "$datadir" -w \ - -o "-k $socketdir -c listen_addresses='''" start >/dev/null - "$bindir/createdb" -h "$socketdir" -U postgres "$dbname" - "$bindir/psql" -h "$socketdir" -U postgres -d "$dbname" \ + user=''${PGUSER:-$(id -un)} + + "$bindir/dropdb" -h "$PGHOST" -U "$user" --if-exists "$dbname" + "$bindir/createdb" -h "$PGHOST" -U "$user" "$dbname" + "$bindir/psql" -h "$PGHOST" -U "$user" -d "$dbname" \ -v ON_ERROR_STOP=1 -q -f db/schema/0.1.0.sql rm -rf test/pg_regress/results @@ -183,8 +203,8 @@ "$pg_regress" \ --use-existing \ - --host="$socketdir" \ - --user=postgres \ + --host="$PGHOST" \ + --user="$user" \ --dbname="$dbname" \ --inputdir=test/pg_regress \ --outputdir=test/pg_regress/results \ diff --git a/lib/benchmark/concurrent_append_non_conflicting_tags.rb b/lib/benchmark/concurrent_append_non_conflicting_tags.rb index 2c2d687..7ee7a49 100644 --- a/lib/benchmark/concurrent_append_non_conflicting_tags.rb +++ b/lib/benchmark/concurrent_append_non_conflicting_tags.rb @@ -38,6 +38,14 @@ module En57 concurrent_append_non_conflicting_tags.with( database_instance: "concurrent-append-non-conflicting-tags-seeded", name: "10x100 concurrent append, non-conflicting tags (seeded)", + reset: + Scenario::RESET_EN57 + "; " + + File.read( + File.expand_path( + "../../db/seeds/concurrent_append_non_conflicting_tags_seeded.sql", + __dir__, + ), + ), ) end end diff --git a/lib/benchmark/res_append_stream_any.rb b/lib/benchmark/res_append_stream_any.rb index ccb95fd..33f36b1 100644 --- a/lib/benchmark/res_append_stream_any.rb +++ b/lib/benchmark/res_append_stream_any.rb @@ -8,6 +8,7 @@ module En57 runs: ->(runs) { runs * 10 }, concurrency: 1, batch_size: 100, + reset: Scenario::RESET_RES, ) do def setup(database_url) require "active_record" diff --git a/lib/benchmark/res_concurrent_append_conflicting_streams.rb b/lib/benchmark/res_concurrent_append_conflicting_streams.rb index 94b80ce..f59e122 100644 --- a/lib/benchmark/res_concurrent_append_conflicting_streams.rb +++ b/lib/benchmark/res_concurrent_append_conflicting_streams.rb @@ -7,6 +7,7 @@ module En57 name: "10x100 concurrent append, conflicting streams (RES)", concurrency: 10, batch_size: 100, + reset: Scenario::RESET_RES, ) do def setup(database_url) require "active_record" diff --git a/lib/benchmark/res_concurrent_append_non_conflicting_streams.rb b/lib/benchmark/res_concurrent_append_non_conflicting_streams.rb index 8899158..5f9167c 100644 --- a/lib/benchmark/res_concurrent_append_non_conflicting_streams.rb +++ b/lib/benchmark/res_concurrent_append_non_conflicting_streams.rb @@ -7,6 +7,7 @@ module En57 name: "10x100 concurrent append, non-conflicting streams (RES)", concurrency: 10, batch_size: 100, + reset: Scenario::RESET_RES, ) do def setup(database_url) require "active_record" diff --git a/lib/en57/benchmark.rb b/lib/en57/benchmark.rb index fca99f5..563b301 100644 --- a/lib/en57/benchmark.rb +++ b/lib/en57/benchmark.rb @@ -3,7 +3,7 @@ require "benchmark" require "concurrent-ruby" require "connection_pool" -require "pg_ephemeral" +require "pg" require "securerandom" require_relative "../en57" @@ -22,6 +22,8 @@ module En57 :retry_count, ) + Runnable = Data.define(:build, :reset) + class Table def format(results) return "" if results.empty? @@ -121,7 +123,19 @@ module En57 class Scenario Configuration = - Data.define(:database_instance, :name, :concurrency, :batch_size, :runs) + Data.define( + :database_instance, + :name, + :concurrency, + :batch_size, + :runs, + :reset, + ) + + RESET_EN57 = "TRUNCATE en57.tags, en57.events RESTART IDENTITY CASCADE" + RESET_RES = + "TRUNCATE event_store_events, event_store_events_in_streams " \ + "RESTART IDENTITY CASCADE" @definitions = [] @@ -133,6 +147,7 @@ module En57 concurrency: 1, batch_size: 100, runs: ->(runs) { runs }, + reset: RESET_EN57, &block ) register( @@ -142,6 +157,7 @@ module En57 concurrency:, batch_size:, runs:, + reset:, ), &block ) @@ -158,6 +174,8 @@ module En57 configuration.database_instance end + define_singleton_method(:reset) { configuration.reset } + define_singleton_method( :build, ) do |database_url:, warmup_runs:, runs:| @@ -243,9 +261,12 @@ module En57 .to_h do |scenario_class| [ scenario_class.database_instance, - ->(database_url, warmup_runs) do - scenario_class.build(database_url:, warmup_runs:, runs:) - end, + Runnable.new( + reset: scenario_class.reset, + build: ->(database_url, warmup_runs) do + scenario_class.build(database_url:, warmup_runs:, runs:) + end, + ), ] end end @@ -260,35 +281,45 @@ module En57 En57.configuration.append_retries = 100 results = - @scenarios.map do |instance_name, mk_scenario| - PgEphemeral.with_server(instance_name:) do |server| - samples = Concurrent::Array.new - retries = Concurrent::AtomicFixnum.new - - scenario = mk_scenario.call(server.url, 2) - scenario.run( - ->(&block) { samples << ::Benchmark.realtime { block.call } }, - -> { retries.increment }, - ) - measurement = Measurement.from(samples) - - Result.new( - name: scenario.name, - runs: scenario.runs, - mean: measurement.mean, - stddev: measurement.stddev, - min: measurement.min, - max: measurement.max, - median: measurement.median, - retry_count: retries.value, - ) - end + @scenarios.map do |instance_name, runnable| + database_url = "postgres:///#{instance_name}" + reset(database_url, runnable.reset) + + samples = Concurrent::Array.new + retries = Concurrent::AtomicFixnum.new + + scenario = runnable.build.call(database_url, 2) + scenario.run( + ->(&block) { samples << ::Benchmark.realtime { block.call } }, + -> { retries.increment }, + ) + measurement = Measurement.from(samples) + + Result.new( + name: scenario.name, + runs: scenario.runs, + mean: measurement.mean, + stddev: measurement.stddev, + min: measurement.min, + max: measurement.max, + median: measurement.median, + retry_count: retries.value, + ) end @formatter.format(results) ensure En57.configuration.append_retries = original_append_retries end + + private + + def reset(database_url, sql) + connection = PG.connect(database_url) + connection.exec(sql) + ensure + connection&.close + end end class CLI diff --git a/test/test_benchmark.rb b/test/test_benchmark.rb index 2521402..93e81c9 100644 --- a/test/test_benchmark.rb +++ b/test/test_benchmark.rb @@ -86,27 +86,26 @@ module En57 "formatted" end - server = Data.define(:url).new("postgres://example") mk_scenario = ->(name) do - ->(_database_url, _warmup_runs) do - Data - .define(:name, :runs, :retry_count) do - def run(measure, retries) - 3.times do - retries.call - measure.call { nil } + Runnable.new( + reset: "", + build: ->(_database_url, _warmup_runs) do + Data + .define(:name, :runs, :retry_count) do + def run(measure, retries) + 3.times do + retries.call + measure.call { nil } + end end end - end - .new(name, 1, 3) - end + .new(name, 1, 3) + end, + ) end output = - PgEphemeral.stub( - :with_server, - ->(instance_name:, &block) { block.call(server) }, - ) do + PG.stub(:connect, fake_pg_connection.method(:connect)) do Runner.new( formatter:, scenarios: { @@ -125,7 +124,6 @@ module En57 def test_runner_sets_append_retries_during_benchmark formatter = Object.new formatter.define_singleton_method(:format) { |_results| "formatted" } - server = Data.define(:url).new("postgres://example") append_retries = nil original_append_retries = En57.configuration.append_retries En57.configuration.append_retries = 7 @@ -145,14 +143,15 @@ module En57 end .new(->(value) { append_retries = value }) - PgEphemeral.stub( - :with_server, - ->(instance_name:, &block) { block.call(server) }, - ) do + PG.stub(:connect, fake_pg_connection.method(:connect)) do Runner.new( formatter:, scenarios: { - "instance" => ->(_database_url, _warmup_runs) { scenario }, + "instance" => + Runnable.new( + reset: "", + build: ->(_database_url, _warmup_runs) { scenario }, + ), }, ).run end @@ -169,7 +168,6 @@ module En57 formatter.define_singleton_method(:format) do |results| formatted_results = results end - server = Data.define(:url).new("postgres://example") samples = Class .new(Array) do @@ -189,16 +187,17 @@ module En57 end .new - PgEphemeral.stub( - :with_server, - ->(instance_name:, &block) { block.call(server) }, - ) do + PG.stub(:connect, fake_pg_connection.method(:connect)) do Concurrent::Array.stub(:new, samples) do ::Benchmark.stub(:realtime, ->(&block) { block.call || 0.1 }) do Runner.new( formatter:, scenarios: { - "instance" => ->(_database_url, _warmup_runs) { scenario }, + "instance" => + Runnable.new( + reset: "", + build: ->(_database_url, _warmup_runs) { scenario }, + ), }, ).run end @@ -208,15 +207,13 @@ module En57 assert_in_delta(1.1, formatted_results.fetch(0).mean) end - def test_runner_uses_scenario_instance_names_and_database_urls + def test_runner_resets_database_and_uses_instance_database_urls formatter = Object.new formatter.define_singleton_method(:format) { |_results| "formatted" } - server = Data.define(:url).new("postgres://example") - instance_names = [] database_urls = [] warmup_runs = [] measured_blocks = 0 - mk_scenario = ->(database_url, warmup_run_count) do + build = ->(database_url, warmup_run_count) do database_urls << database_url warmup_runs << warmup_run_count Class @@ -238,20 +235,46 @@ module En57 end end - PgEphemeral.stub( - :with_server, - ->(instance_name:, &block) do - instance_names << instance_name - block.call(server) - end, - ) do - Runner.new(formatter:, scenarios: { "instance" => mk_scenario }).run + connection = fake_pg_connection + PG.stub(:connect, connection.method(:connect)) do + Runner.new( + formatter:, + scenarios: { + "instance" => Runnable.new(reset: "RESET SQL", build:), + }, + ).run end - assert_equal(["instance"], instance_names) - assert_equal(["postgres://example"], database_urls) + assert_equal(["postgres:///instance"], database_urls) assert_equal([2], warmup_runs) assert_equal(3, measured_blocks) + assert_equal(["postgres:///instance"], connection.urls) + assert_equal(["RESET SQL"], connection.statements) + assert_equal(1, connection.closed) + end + + def test_runner_propagates_reset_connection_errors_without_masking + formatter = Object.new + formatter.define_singleton_method(:format) { |_results| "formatted" } + boom = Class.new(StandardError) + + error = + assert_raises(boom) do + PG.stub(:connect, ->(_url) { raise boom }) do + Runner.new( + formatter:, + scenarios: { + "instance" => + Runnable.new( + reset: "", + build: ->(_database_url, _warmup_runs) { nil }, + ), + }, + ).run + end + end + + assert_instance_of(boom, error) end def test_scenario_uses_noop_measure_for_warmup @@ -286,13 +309,9 @@ module En57 end end scenario = nil - server = Data.define(:url).new("postgres://example") durations = [0.1, 0.2] - PgEphemeral.stub( - :with_server, - ->(instance_name:, &block) { block.call(server) }, - ) do + PG.stub(:connect, fake_pg_connection.method(:connect)) do ::Benchmark.stub( :realtime, ->(&block) do @@ -303,9 +322,13 @@ module En57 Runner.new( formatter:, scenarios: { - "warmup" => ->(_database_url, warmup_runs) do - scenario = scenario_class.new(warmup_runs:) - end, + "warmup" => + Runnable.new( + reset: "", + build: ->(_database_url, warmup_runs) do + scenario = scenario_class.new(warmup_runs:) + end, + ), }, ).run end @@ -636,6 +659,7 @@ module En57 first_scenario = Class.new do def self.database_instance = "a-discovered" + def self.reset = "reset-a" def self.build(database_url:, warmup_runs:, runs:) [database_url, warmup_runs, runs] @@ -644,6 +668,7 @@ module En57 second_scenario = Class.new do def self.database_instance = "b-discovered" + def self.reset = "reset-b" def self.build(database_url:, warmup_runs:, runs:) [database_url, warmup_runs, runs] @@ -652,12 +677,11 @@ module En57 Scenario.stub(:definitions, [second_scenario, first_scenario]) do assert_equal(%w[a-discovered b-discovered], Runner.names) + runnable = Runner.scenarios(runs: 3).fetch("a-discovered") + assert_equal("reset-a", runnable.reset) assert_equal( ["postgres://example", 2, 3], - Runner - .scenarios(runs: 3) - .fetch("a-discovered") - .call("postgres://example", 2), + runnable.build.call("postgres://example", 2), ) end end @@ -666,11 +690,13 @@ module En57 first_scenario = Class.new do def self.database_instance = "first" + def self.reset = "" def self.build(...) = nil end second_scenario = Class.new do def self.database_instance = "second" + def self.reset = "" def self.build(...) = nil end @@ -688,6 +714,7 @@ module En57 scenario = Class.new do def self.database_instance = "scenario" + def self.reset = "" def self.build(database_url:, warmup_runs:, runs:) [database_url, warmup_runs, runs] @@ -700,6 +727,7 @@ module En57 .classic .instance_variable_get(:@scenarios) .fetch("scenario") + .build .call("postgres://example", 2) assert_equal(["postgres://example", 2, 50], scenario) @@ -804,6 +832,102 @@ module En57 assert_in_delta(0.35, measurement.median) end + + def test_reset_en57_truncates_event_and_tag_tables + assert_equal( + "TRUNCATE en57.tags, en57.events RESTART IDENTITY CASCADE", + Scenario::RESET_EN57, + ) + end + + def test_reset_res_truncates_event_store_tables + assert_equal( + "TRUNCATE event_store_events, event_store_events_in_streams " \ + "RESTART IDENTITY CASCADE", + Scenario::RESET_RES, + ) + end + + def test_scenario_define_defaults_reset_to_en57_truncate + original_definitions = Scenario.definitions.dup + scenario_class = + Scenario.define(database_instance: "reset-default", name: "Reset") + + assert_equal(Scenario::RESET_EN57, scenario_class.reset) + ensure + Scenario.definitions.replace(original_definitions) + end + + def test_scenario_define_accepts_custom_reset + original_definitions = Scenario.definitions.dup + scenario_class = + Scenario.define( + database_instance: "reset-custom", + name: "Reset", + reset: "TRUNCATE custom", + ) + + assert_equal("TRUNCATE custom", scenario_class.reset) + ensure + Scenario.definitions.replace(original_definitions) + end + + def test_seeded_scenario_reset_reloads_seed_after_truncate + seeded = + Scenario.definitions.find do + it.database_instance == + "concurrent-append-non-conflicting-tags-seeded" + end + + assert(seeded.reset.start_with?(Scenario::RESET_EN57)) + assert_includes(seeded.reset, "INSERT INTO en57.events") + end + + def test_res_scenarios_reset_with_res_truncate + res_scenarios = + Scenario.definitions.select do + it.database_instance.start_with?("res-") + end + + refute_empty(res_scenarios) + res_scenarios.each do |scenario| + assert_equal(Scenario::RESET_RES, scenario.reset) + end + end + + def test_scenario_with_overrides_reset + original_definitions = Scenario.definitions.dup + scenario_class = + Scenario.define(database_instance: "reset-base", name: "Base") + copy = scenario_class.with(database_instance: "reset-copy", reset: "X") + + assert_equal(Scenario::RESET_EN57, scenario_class.reset) + assert_equal("X", copy.reset) + ensure + Scenario.definitions.replace(original_definitions) + end + + def fake_pg_connection + Class + .new do + attr_reader :urls, :statements, :closed + + def initialize + @urls = [] + @statements = [] + @closed = 0 + end + + def connect(url) + @urls << url + self + end + + def exec(sql) = @statements << sql + def close = @closed += 1 + end + .new + end end class CLI::TestInitialize < Minitest::Test diff --git a/test/test_factories.rb b/test/test_factories.rb index cb2f92c..79c21cb 100644 --- a/test/test_factories.rb +++ b/test/test_factories.rb @@ -5,15 +5,15 @@ require "test_helper" module En57 class TestFactories < IntegrationTest def test_for_pg_round_trips_with_connection_uri - assert_round_trip EventStore.for_pg(SERVER.url) + assert_round_trip EventStore.for_pg(MAIN_URL) end def test_for_pooled_pg_round_trips_with_default_max_connections - assert_round_trip EventStore.for_pooled_pg(SERVER.url) + assert_round_trip EventStore.for_pooled_pg(MAIN_URL) end def test_for_pooled_pg_round_trips_with_custom_max_connections - assert_round_trip EventStore.for_pooled_pg(SERVER.url, max_connections: 1) + assert_round_trip EventStore.for_pooled_pg(MAIN_URL, max_connections: 1) end def test_for_active_record_round_trips_with_default_model @@ -34,7 +34,7 @@ module En57 CONNECTION.exec("CREATE TABLE public.events (id integer PRIMARY KEY)") CONNECTION.exec("CREATE TABLE public.tags (id integer PRIMARY KEY)") - assert_round_trip EventStore.for_pg(SERVER.url) + assert_round_trip EventStore.for_pg(MAIN_URL) ensure CONNECTION.exec("DROP TABLE IF EXISTS public.tags, public.events") end diff --git a/test/test_helper.rb b/test/test_helper.rb index 28c0048..1f8e11c 100644 --- a/test/test_helper.rb +++ b/test/test_helper.rb @@ -15,27 +15,26 @@ require "en57" # test dependencies require "securerandom" require "concurrent-ruby" -require "pg_ephemeral" module En57 class IntegrationTest < Minitest::Test - SERVER = PgEphemeral.start + MAIN_URL = "postgres:///main" - CONNECTION = PG.connect(SERVER.url) + CONNECTION = PG.connect(MAIN_URL) POOL_SIZE = 8 - PG_POOL = ConnectionPool.new(size: POOL_SIZE) { PG.connect(SERVER.url) } + PG_POOL = ConnectionPool.new(size: POOL_SIZE) { PG.connect(MAIN_URL) } SEQUEL_DB = Sequel.connect( - SERVER.url, + MAIN_URL, preconnect: :concurrently, max_connections: POOL_SIZE, ) AR_POOL = -> do - ActiveRecord::Base.establish_connection("#{SERVER.url}&pool=#{POOL_SIZE}") + ActiveRecord::Base.establish_connection("#{MAIN_URL}?pool=#{POOL_SIZE}") ActiveRecord::Base.connection_pool end.call @@ -55,7 +54,6 @@ module En57 SEQUEL_DB.disconnect PG_POOL.shutdown(&:close) CONNECTION.close - SERVER.shutdown end end end diff --git a/test/test_migrator.rb b/test/test_migrator.rb index db74e45..59cfb64 100644 --- a/test/test_migrator.rb +++ b/test/test_migrator.rb @@ -1,7 +1,6 @@ # frozen_string_literal: true require "test_helper" -require "uri" module En57 class TestMigrator < IntegrationTest @@ -119,11 +118,7 @@ module En57 ) end - def database_url(name) - uri = URI(SERVER.url) - uri.path = "/#{name}" - uri.to_s - end + def database_url(name) = "postgres:///#{name}" def schema_path(version) File.expand_path("../db/schema/#{version}.sql", __dir__)