inst-jobs-statsd 2.2.0 → 3.0.2

data/spec/inst_jobs_statsd/jobs_tracker_spec.rb

@@ -1,30 +0,0 @@
-RSpec.describe InstJobsStatsd::JobsTracker do
-  describe '.track' do
-    it 'calls the block' do
-      @done_in_block = false
-      expect do
-        InstJobsStatsd::JobsTracker.track do
-          @done_in_block = true
-        end
-      end.to(change { @done_in_block })
-    end
-  end
-
-  describe '.initialize' do
-    it 'enables everything' do
-      expect(InstJobsStatsd::Stats::Counters::Create).to receive(:enable)
-      expect(InstJobsStatsd::Stats::Counters::Run).to receive(:enable)
-      expect(InstJobsStatsd::Stats::Counters::Complete).to receive(:enable)
-
-      expect(InstJobsStatsd::Stats::Periodic::Failed).to receive(:enable)
-      expect(InstJobsStatsd::Stats::Periodic::Queue).to receive(:enable)
-      expect(InstJobsStatsd::Stats::Periodic::Run).to receive(:enable)
-
-      expect(InstJobsStatsd::Stats::Timing::Failed).to receive(:enable)
-      expect(InstJobsStatsd::Stats::Timing::Perform).to receive(:enable)
-      expect(InstJobsStatsd::Stats::Timing::Pop).to receive(:enable)
-
-      InstJobsStatsd::JobsTracker.new
-    end
-  end
-end

data/spec/inst_jobs_statsd/naming_spec.rb

@@ -1,56 +0,0 @@
-RSpec.describe InstJobsStatsd::Naming do
-  describe '.qualified_names' do
-    subject { InstJobsStatsd::Naming.qualified_names(stat_name, job) }
-    let(:stat_name) { :wut }
-
-    context 'when no job is given' do
-      let(:job) { nil }
-      it { should eq ['delayedjob.wut'] }
-    end
-
-    context 'when job is given' do
-      let(:job) { build :job }
-      it { should include 'delayedjob.wut.tag.Test-Job.perform' }
-
-      context 'job tag is unusual' do
-        let(:job) { build :job, tag: 'periodic__Something_on_a_schedule' }
-        it { should include 'delayedjob.wut.tag.periodic__Something_on_a_schedule' }
-      end
-
-      context 'job tag is dynamic' do
-        let(:job) { build :job, tag: '<Class:0x00000004f575b8>#perform' }
-        it { should eq ['delayedjob.wut'] }
-      end
-    end
-
-    context 'with region tags' do
-      before do
-        @jobs_namespace = ENV['INST_JOBS_STATSD_NAMESPACE']
-        ENV['INST_JOBS_STATSD_NAMESPACE'] = 'region_name'
-      end
-
-      after do
-        ENV['INST_JOBS_STATSD_NAMESPACE'] = @jobs_namespace
-      end
-
-      let(:job) { build :job, tag: 'a_tag_name' }
-
-      it { should include 'delayedjob.wut' }
-      it { should include 'delayedjob.wut.tag.a_tag_name' }
-      it { should include 'delayedjob.wut.region_name' }
-      it { should include 'delayedjob.wut.region_name.tag.a_tag_name' }
-    end
-
-    describe '.dd_job_tags' do
-      it 'works' do
-        job = double(tag: 'Account.run_reports_later', shard: double(id: 101), strand: 'special')
-        expect(InstJobsStatsd::Naming.dd_job_tags(job)).to eq(tag: 'Account.run_reports_later', jobshard: 101)
-      end
-
-      it 'properly munges job tags' do
-        job = double(tag: 'Quizzes::Quiz#do_something', strand: nil)
-        expect(InstJobsStatsd::Naming.dd_job_tags(job)).to eq(tag: 'Quizzes-Quiz.do_something')
-      end
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/counters/complete_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Counters::Complete do
-  describe '.enable' do
-    it 'enables all the things' do
-      expect(InstJobsStatsd::Stats::Counters::Complete).to receive(:enable_complete_count)
-      InstJobsStatsd::Stats::Counters::Complete.enable
-    end
-  end
-
-  describe '.report_complete_count' do
-    let(:x) { Struct.new(:perform).new(true) }
-
-    before do
-      Delayed::Worker.lifecycle.reset!
-      InstJobsStatsd::Stats::Counters::Complete.enable
-
-      2.times { x.delay.perform }
-    end
-
-    it "increments the counter" do
-      expect(InstStatsd::Statsd).to receive(:count)
-        .twice.with(array_including(/\.complete$/), 1, 1, short_stat: anything, tags: {})
-      Delayed::Job.all.each do |job|
-        Delayed::Worker.lifecycle.run_callbacks(:perform, {}, job) {}
-      end
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/counters/create_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Counters::Create do
-  describe '.enable' do
-    it 'enables all the things' do
-      expect(InstJobsStatsd::Stats::Counters::Create).to receive(:enable_create_count)
-      InstJobsStatsd::Stats::Counters::Create.enable
-    end
-  end
-
-  describe '.report_create_count' do
-    let(:x) { Struct.new(:perform).new(true) }
-
-    before do
-      Delayed::Worker.lifecycle.reset!
-      InstJobsStatsd::Stats::Counters::Create.enable
-
-      2.times { x.delay.perform }
-    end
-
-    it "increments the counter" do
-      expect(InstStatsd::Statsd).to receive(:count)
-        .twice.with(array_including(/\.create$/), 1, 1, short_stat: anything, tags: {})
-      Delayed::Job.all.each do |job|
-        Delayed::Worker.lifecycle.run_callbacks(:create, job) {}
-      end
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/counters/run_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Counters::Run do
-  describe '.enable' do
-    it 'enables all the things' do
-      expect(InstJobsStatsd::Stats::Counters::Run).to receive(:enable_run_count)
-      InstJobsStatsd::Stats::Counters::Run.enable
-    end
-  end
-
-  describe '.report_run_count' do
-    let(:x) { Struct.new(:perform).new(true) }
-
-    before do
-      Delayed::Worker.lifecycle.reset!
-      InstJobsStatsd::Stats::Counters::Run.enable
-
-      2.times { x.delay.perform }
-    end
-
-    it do
-      expect(InstStatsd::Statsd).to receive(:count)
-        .twice.with(array_including(/\.run$/), 1, 1, short_stat: anything, tags: {})
-      Delayed::Job.all.each do |job|
-        Delayed::Worker.lifecycle.run_callbacks(:perform, {}, job) {}
-      end
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/periodic/failed_spec.rb

@@ -1,31 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Periodic::Failed do
-  before do
-    InstJobsStatsd::Stats::Periodic.instance_variable_set(:@instance, nil)
-  end
-
-  describe '.enable' do
-    it 'enables all the things' do
-      expect(InstJobsStatsd::Stats::Periodic::Failed).to receive(:enable_failed_depth)
-      InstJobsStatsd::Stats::Periodic::Failed.enable
-    end
-  end
-
-  describe '.report_failed_depth' do
-    let(:x) { Struct.new(:perform).new(true) }
-    let(:now) { Delayed::Job.db_time_now }
-
-    before do
-      InstJobsStatsd::Stats::Periodic.enable_callbacks
-      InstJobsStatsd::Stats::Periodic::Failed.enable_failed_depth
-
-      x.delay.perform
-      Delayed::Job.first.fail!
-    end
-
-    it do
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .with(array_including(/\.failed_depth$/), 1, 1, short_stat: anything, tags: {})
-      InstJobsStatsd::Stats::Periodic::Failed.report_failed_depth
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/periodic/queue_spec.rb

@@ -1,95 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Periodic::Queue do
-  before do
-    InstJobsStatsd::Stats::Periodic.instance_variable_set(:@instance, nil)
-  end
-
-  describe '.enable' do
-    it 'enables all the things' do
-      expect(InstJobsStatsd::Stats::Periodic::Queue).to receive(:enable_queue_depth)
-      expect(InstJobsStatsd::Stats::Periodic::Queue).to receive(:enable_queue_age)
-      InstJobsStatsd::Stats::Periodic::Queue.enable
-    end
-  end
-
-  describe '.report_queue_depth' do
-    let(:x) { Struct.new(:perform).new(true) }
-    let(:now) { Delayed::Job.db_time_now }
-
-    before do
-      InstJobsStatsd::Stats::Periodic::Queue.enable_queue_depth
-
-      x.delay.perform
-      Delayed::Job.first.update(locked_at: Delayed::Job.db_time_now, locked_by: 'test')
-
-      x.delay.perform
-      x.delay(run_at: now + 1.minute).perform
-      x.delay(run_at: now + 10.minutes).perform
-    end
-
-    it do
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .with(array_including(/\.queue_depth$/), 1, 1, short_stat: anything, tags: {})
-      InstJobsStatsd::Stats::Periodic::Queue.report_queue_depth
-    end
-
-    it do
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .with(array_including(/\.queue_depth$/), 2, 1, short_stat: anything, tags: {})
-      Timecop.freeze(2.minutes.from_now) do
-        InstJobsStatsd::Stats::Periodic::Queue.report_queue_depth
-      end
-    end
-
-    it do
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .with(array_including(/\.queue_depth$/), 3, 1, short_stat: anything, tags: {})
-      Timecop.freeze(20.minutes.from_now) do
-        InstJobsStatsd::Stats::Periodic::Queue.report_queue_depth
-      end
-    end
-  end
-
-  describe '.report_queue_age' do
-    let(:x) { Struct.new(:perform).new(true) }
-    let(:now) { Delayed::Job.db_time_now }
-
-    before do
-      InstJobsStatsd::Stats::Periodic::Queue.enable_queue_age
-
-      x.delay.perform
-      Delayed::Job.first.update(locked_at: Delayed::Job.db_time_now, locked_by: 'test')
-
-      x.delay.perform
-      x.delay(run_at: now + 1.minute).perform
-      x.delay(run_at: now + 10.minutes).perform
-    end
-
-    it do
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .ordered.with(array_including(/\.queue_age_total$/), number_near(0), 1, short_stat: anything, tags: {})
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .ordered.with(array_including(/\.queue_age_max$/), number_near(0), 1, short_stat: anything, tags: {})
-      InstJobsStatsd::Stats::Periodic::Queue.report_queue_age
-    end
-
-    it do
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .ordered.with(array_including(/\.queue_age_total$/), number_near(180), 1, short_stat: anything, tags: {})
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .ordered.with(array_including(/\.queue_age_max$/), number_near(120), 1, short_stat: anything, tags: {})
-      Timecop.freeze(2.minutes.from_now) do
-        InstJobsStatsd::Stats::Periodic::Queue.report_queue_age
-      end
-    end
-
-    it do
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .ordered.with(array_including(/\.queue_age_total$/), number_near(2940), 1, short_stat: anything, tags: {})
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .ordered.with(array_including(/\.queue_age_max$/), number_near(1200), 1, short_stat: anything, tags: {})
-      Timecop.freeze(20.minutes.from_now) do
-        InstJobsStatsd::Stats::Periodic::Queue.report_queue_age
-      end
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/periodic/run_spec.rb

@@ -1,53 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Periodic::Run do
-  before do
-    InstJobsStatsd::Stats::Periodic.instance_variable_set(:@instance, nil)
-  end
-
-  describe '.enable' do
-    it 'enables all the things' do
-      expect(InstJobsStatsd::Stats::Periodic::Run).to receive(:enable_run_depth)
-      expect(InstJobsStatsd::Stats::Periodic::Run).to receive(:enable_run_age)
-      InstJobsStatsd::Stats::Periodic::Run.enable
-    end
-  end
-
-  describe '.report_run_depth' do
-    let(:x) { Struct.new(:perform).new(true) }
-    let(:now) { Delayed::Job.db_time_now }
-
-    before do
-      InstJobsStatsd::Stats::Periodic::Run.enable_run_depth
-
-      x.delay.perform
-      x.delay.perform
-      Delayed::Job.first.update(locked_at: Delayed::Job.db_time_now, locked_by: 'test')
-    end
-
-    it do
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .with(array_including(/\.run_depth$/), 1, 1, short_stat: anything, tags: {})
-      InstJobsStatsd::Stats::Periodic::Run.report_run_depth
-    end
-  end
-
-  describe '.report_run_age' do
-    let(:x) { Struct.new(:perform).new(true) }
-    let(:now) { Delayed::Job.db_time_now }
-
-    before do
-      InstJobsStatsd::Stats::Periodic::Run.enable_run_age
-
-      x.delay.perform
-      x.delay.perform
-      Delayed::Job.first.update(locked_at: now, locked_by: 'test')
-    end
-
-    it do
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .ordered.with(array_including(/\.run_age_total$/), number_near(0), 1, short_stat: anything, tags: {})
-      expect(InstStatsd::Statsd).to receive(:gauge)
-        .ordered.with(array_including(/\.run_age_max$/), number_near(0), 1, short_stat: anything, tags: {})
-      InstJobsStatsd::Stats::Periodic::Run.report_run_age
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/periodic_spec.rb

@@ -1,63 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Periodic do
-  before(:each) do
-    Delayed::Worker.lifecycle.reset!
-    InstJobsStatsd::Stats::Periodic.instance_variable_set(:@instance, nil)
-  end
-
-  describe '.enable_callbacks' do
-    it 'only happens once' do
-      expect(InstJobsStatsd::Stats::Periodic::Callbacks).to receive(:new).once.and_call_original
-      2.times { InstJobsStatsd::Stats::Periodic.enable_callbacks }
-    end
-  end
-
-  describe '.add' do
-    it 'does nothing if not enabled' do
-      expect_any_instance_of(InstJobsStatsd::Stats::Periodic::Callbacks).not_to receive(:add)
-      InstJobsStatsd::Stats::Periodic.add(-> {})
-    end
-
-    it 'does something if enabled' do
-      expect_any_instance_of(InstJobsStatsd::Stats::Periodic::Callbacks)
-        .to receive(:add).and_call_original
-      InstJobsStatsd::Stats::Periodic.enable_callbacks
-      InstJobsStatsd::Stats::Periodic.add(-> {})
-    end
-  end
-
-  describe 'Callbacks' do
-    before(:each) do
-      InstJobsStatsd::Stats::Periodic.instance_variable_set(:@instance, nil)
-    end
-
-    it 'calls the procs at the interval' do
-      InstJobsStatsd::Stats::Periodic.enable_callbacks
-
-      @count = 0
-      InstJobsStatsd::Stats::Periodic.add(-> { @count += 1 })
-      InstJobsStatsd::Stats::Periodic.add(-> { @count += 2 })
-
-      Timecop.freeze(Delayed::Job.db_time_now + 60.seconds) do
-        Delayed::Worker.lifecycle.run_callbacks(:work_queue_pop, nil, nil) {}
-      end
-
-      expect(@count).to eq 3
-    end
-  end
-
-  describe 'Timer' do
-    before(:each) { @did_block = false }
-
-    it 'does not call the block too soon' do
-      t = InstJobsStatsd::Stats::Periodic::Timer.new(60)
-      expect { t.tick { @did_block = true } }.not_to(change { @did_block })
-    end
-
-    it 'calls the block after the interval elapses' do
-      t = InstJobsStatsd::Stats::Periodic::Timer.new(60)
-      Timecop.freeze(Delayed::Job.db_time_now + 60.seconds) do
-        expect { t.tick { @did_block = true } }.to(change { @did_block })
-      end
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/timing/failed_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Timing::Failed do
-  let(:worker) { build :worker }
-  let(:job) { build :job, run_at: 1.minute.ago }
-
-  before(:each) { Delayed::Worker.lifecycle.reset! }
-
-  describe '.enable' do
-    it 'enables all the things' do
-      expect(InstJobsStatsd::Stats::Timing::Failed).to receive(:enable_failure_timing)
-      InstJobsStatsd::Stats::Timing::Failed.enable
-    end
-  end
-
-  describe '.enable_failure_timing' do
-    it 'reports failure time' do
-      expect(InstStatsd::Statsd).to receive(:timing)
-        .once.with(array_including(/\.failed_after$/), any_args)
-      InstJobsStatsd::Stats::Timing::Failed.enable_failure_timing
-      Delayed::Worker.lifecycle.run_callbacks(
-        :error, worker, job, Exception.new('test')
-      ) { @in_block = true }
-      expect(@in_block).to be_truthy
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/timing/perform_spec.rb

@@ -1,35 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Timing::Perform do
-  let(:worker) { build :worker }
-  let(:job) { build :job, run_at: 1.minute.ago }
-
-  before(:each) { Delayed::Worker.lifecycle.reset! }
-
-  describe '.enable' do
-    it 'enables all the things' do
-      expect(InstJobsStatsd::Stats::Timing::Perform).to receive(:enable_batching)
-      expect(InstJobsStatsd::Stats::Timing::Perform).to receive(:enable_perform_timing)
-      InstJobsStatsd::Stats::Timing::Perform.enable
-    end
-  end
-
-  describe '.enable_batching' do
-    it 'does batching' do
-      expect(InstStatsd::Statsd).to receive(:batch).and_call_original
-      InstJobsStatsd::Stats::Timing::Perform.enable_batching
-      Delayed::Worker.lifecycle.run_callbacks(:perform, worker, job) { @in_block = true }
-      expect(@in_block).to be_truthy
-    end
-  end
-
-  describe '.enable_perform_timing' do
-    it 'reports queu and perform time' do
-      expect(InstStatsd::Statsd).to receive(:timing)
-        .once.ordered.with(array_including(/\.queue$/), any_args)
-      expect(InstStatsd::Statsd).to receive(:timing)
-        .once.ordered.with(array_including(/\.perform$/), any_args)
-      InstJobsStatsd::Stats::Timing::Perform.enable_perform_timing
-      Delayed::Worker.lifecycle.run_callbacks(:perform, worker, job) { @in_block = true }
-      expect(@in_block).to be_truthy
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/timing/pop_spec.rb

@@ -1,34 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Timing::Pop do
-  let(:worker) { build :worker }
-  let(:job) { build :job, run_at: 1.minute.ago }
-
-  before(:each) { Delayed::Worker.lifecycle.reset! }
-
-  describe '.enable' do
-    it 'enables all the things' do
-      expect(InstJobsStatsd::Stats::Timing::Pop).to receive(:enable_pop_timing)
-      expect(InstJobsStatsd::Stats::Timing::Pop).to receive(:enable_workqueue_pop_timing)
-      InstJobsStatsd::Stats::Timing::Pop.enable
-    end
-  end
-
-  describe '.enable_pop_timing' do
-    it 'reports pop time' do
-      expect(InstStatsd::Statsd).to receive(:timing)
-        .once.ordered.with(array_including(/\.pop$/), any_args)
-      InstJobsStatsd::Stats::Timing::Pop.enable_pop_timing
-      Delayed::Worker.lifecycle.run_callbacks(:pop, worker) { @in_block = true }
-      expect(@in_block).to be_truthy
-    end
-  end
-
-  describe '.enable_workqueue_pop_timing' do
-    it 'reports pop time' do
-      expect(InstStatsd::Statsd).to receive(:timing)
-        .once.ordered.with(array_including(/\.workqueuepop$/), any_args)
-      InstJobsStatsd::Stats::Timing::Pop.enable_workqueue_pop_timing
-      Delayed::Worker.lifecycle.run_callbacks(:work_queue_pop, worker, {}) { @in_block = true }
-      expect(@in_block).to be_truthy
-    end
-  end
-end

data/spec/inst_jobs_statsd/stats/timing_spec.rb

@@ -1,35 +0,0 @@
-RSpec.describe InstJobsStatsd::Stats::Timing do
-  let(:job) { build :job, run_at: 1.minute.ago }
-
-  describe 'report_tinming' do
-    context 'with a block' do
-      it 'reports the elapsed time' do
-        expect(InstStatsd::Statsd).to receive(:time)
-        InstJobsStatsd::Stats::Timing.report_timing('test', job: job) { sleep 0.001 }
-      end
-    end
-
-    context 'without a block' do
-      it 'reports the given time' do
-        expect(InstStatsd::Statsd).to receive(:timing)
-        InstJobsStatsd::Stats::Timing.report_timing('test', job: job, timing: 123)
-      end
-    end
-  end
-
-  describe 'report_job_timing_queued' do
-    it 'reports the stat' do
-      expect(InstStatsd::Statsd).to receive(:timing)
-        .with(array_including(/\.queue$/), any_args)
-      InstJobsStatsd::Stats::Timing.report_job_timing_queued(job)
-    end
-  end
-
-  describe 'report_job_timing_failed' do
-    it 'reports the stat' do
-      expect(InstStatsd::Statsd).to receive(:timing)
-        .with(array_including(/\.failed_after$/), any_args)
-      InstJobsStatsd::Stats::Timing.report_job_timing_failed(job)
-    end
-  end
-end

data/spec/inst_statsd/default_tracking_spec.rb

@@ -1,16 +0,0 @@
-RSpec.describe InstStatsd::DefaultTracking do
-  it 'includes methods defined in the base gem' do
-    expect(InstStatsd::DefaultTracking.respond_to?(:track_sql)).to be_truthy
-  end
-
-  describe 'track_job_stats' do
-    it 'defines :track_jobs' do
-      expect(InstStatsd::DefaultTracking.respond_to?(:track_jobs)).to be_truthy
-    end
-
-    it 'only does it once' do
-      expect(InstJobsStatsd::JobsTracker).to receive(:new).once.and_call_original
-      2.times { InstStatsd::DefaultTracking.track_jobs }
-    end
-  end
-end

data/spec/matchers.rb

@@ -1,3 +0,0 @@
-RSpec::Matchers.define :number_near do |target, max_delta = 0.5|
-  match { |actual| (actual - target).abs <= max_delta }
-end

data/spec/setup_test_db.rb

@@ -1,45 +0,0 @@
-# All the below is essentially copied from inst-jobs spec_helper.rb,
-# to create the test db, run migrations, etc
-ENV['TEST_ENV_NUMBER'] ||= '1'
-ENV['TEST_DB_HOST'] ||= 'localhost'
-ENV['TEST_DB_DATABASE'] ||= "inst-jobs-test-#{ENV['TEST_ENV_NUMBER']}"
-
-connection_config = {
-  adapter: :postgresql,
-  host: ENV['TEST_DB_HOST'].presence,
-  encoding: 'utf8',
-  username: ENV['TEST_DB_USERNAME'],
-  database: ENV['TEST_DB_DATABASE']
-}
-
-if ::Rails.version < '5'
-  class ActiveRecord::Migration
-    class << self
-      def [](_version); self; end
-    end
-  end
-end
-
-# create the test db if it does not exist, to help out wwtd
-ActiveRecord::Base.establish_connection(connection_config.merge(database: 'postgres'))
-begin
-  ActiveRecord::Base.connection.create_database(connection_config[:database])
-rescue ActiveRecord::StatementInvalid
-end
-ActiveRecord::Base.establish_connection(connection_config)
-# TODO reset db and migrate again, to test migrations
-
-# Apply the migrations from the inst-jobs gem
-inst_jobs_spec = Gem::Specification.find_by_name('inst-jobs')
-if ::Rails.version >= '6'
-  sm = ActiveRecord::Base.connection.schema_migration
-  migrations = ActiveRecord::MigrationContext.new(inst_jobs_spec.gem_dir + '/db/migrate', sm).migrations
-  ActiveRecord::Migrator.new(:up, migrations, sm).migrate
-  migrations = ActiveRecord::MigrationContext.new(inst_jobs_spec.gem_dir + '/spec/migrate', sm).migrations
-  ActiveRecord::Migrator.new(:up, migrations, sm).migrate
-else
-  ActiveRecord::Migrator.migrate(inst_jobs_spec.gem_dir + '/db/migrate')
-  ActiveRecord::Migrator.migrate(inst_jobs_spec.gem_dir + '/spec/migrate')
-end
-Delayed::Backend::ActiveRecord::Job.reset_column_information
-Delayed::Backend::ActiveRecord::Job::Failed.reset_column_information

data/spec/spec_helper.rb

@@ -1,61 +0,0 @@
-if /^2\.7/ =~ RUBY_VERSION && /60\./ =~ ENV['BUNDLE_GEMFILE'] # Limit coverage to one build
-  require 'simplecov'
-
-  SimpleCov.start do
-    add_filter 'lib/inst_jobs_statsd/version.rb'
-    add_filter 'spec'
-    track_files 'lib/**/*.rb'
-  end
-end
-
-require 'inst-jobs-statsd'
-require 'delayed/testing'
-
-require 'byebug'
-require 'database_cleaner'
-require 'factory_girl'
-require 'pry'
-require 'timecop'
-
-# No reason to add default sleep time to specs:
-Delayed::Settings.sleep_delay         = 0
-Delayed::Settings.sleep_delay_stagger = 0
-
-RSpec.configure do |config|
-  config.expect_with(:rspec) do |c|
-    c.syntax = %i[should expect]
-  end
-
-  config.include FactoryGirl::Syntax::Methods
-  config.before(:suite) do
-    FactoryGirl.find_definitions
-  end
-
-  config.before(:suite) do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.clean_with(:truncation)
-  end
-
-  config.before(:each) do |example|
-    DatabaseCleaner.strategy = (example.metadata[:sinatra] ? :truncation : :transaction)
-    DatabaseCleaner.start
-  end
-
-  config.after(:each) do
-    DatabaseCleaner.clean
-  end
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  config.order = :random
-  Kernel.srand config.seed
-end
-
-require_relative 'setup_test_db'
-
-Time.zone = 'UTC'
-Rails.logger = Logger.new(nil)
-
-require_relative 'matchers'