journaled 2.4.0 → 4.0.0

data/spec/{models/journaled/delivery_spec.rb → jobs/journaled/delivery_job_spec.rb}

@@ -1,16 +1,11 @@
 require 'rails_helper'
 
-RSpec.describe Journaled::Delivery do
+RSpec.describe Journaled::DeliveryJob do
   let(:stream_name) { 'test_events' }
   let(:partition_key) { 'fake_partition_key' }
   let(:serialized_event) { '{"foo":"bar"}' }
   let(:kinesis_client) { Aws::Kinesis::Client.new(stub_responses: true) }
-
-  around do |example|
-    with_env(JOURNALED_STREAM_NAME: stream_name) { example.run }
-  end
-
-  subject { described_class.new serialized_event: serialized_event, partition_key: partition_key, app_name: nil }
+  let(:args) { { serialized_event: serialized_event, partition_key: partition_key, stream_name: stream_name } }
 
   describe '#perform' do
     let(:return_status_body) { { shard_id: '101', sequence_number: '101123' } }
@@ -20,15 +15,21 @@ RSpec.describe Journaled::Delivery do
       allow(Aws::AssumeRoleCredentials).to receive(:new).and_call_original
       allow(Aws::Kinesis::Client).to receive(:new).and_return kinesis_client
       kinesis_client.stub_responses(:put_record, return_status_body)
+      allow(kinesis_client).to receive(:put_record).and_call_original
 
       allow(Journaled).to receive(:enabled?).and_return(true)
     end
 
     it 'makes requests to AWS to put the event on the Kinesis with the correct body' do
-      event = subject.perform
+      event = described_class.perform_now(args)
 
       expect(event.shard_id).to eq '101'
       expect(event.sequence_number).to eq '101123'
+      expect(kinesis_client).to have_received(:put_record).with(
+        stream_name: 'test_events',
+        data: '{"foo":"bar"}',
+        partition_key: 'fake_partition_key',
+      )
     end
 
     context 'when JOURNALED_IAM_ROLE_ARN is defined' do
@@ -59,7 +60,7 @@ RSpec.describe Journaled::Delivery do
       end
 
       it 'initializes a Kinesis client with assume role credentials' do
-        subject.perform
+        described_class.perform_now(args)
 
         expect(Aws::AssumeRoleCredentials).to have_received(:new).with(
           client: aws_sts_client,
@@ -69,11 +70,64 @@ RSpec.describe Journaled::Delivery do
       end
     end
 
-    context 'when the stream name env var is NOT set' do
+    context 'when the stream name is not set' do
       let(:stream_name) { nil }
 
       it 'raises an KeyError error' do
-        expect { subject.perform }.to raise_error KeyError
+        expect { described_class.perform_now(args) }.to raise_error ArgumentError, 'missing keyword: stream_name'
+      end
+    end
+
+    unless Gem::Version.new(Journaled::VERSION) < Gem::Version.new('5.0.0')
+      raise <<~MSG
+        Hey! I see that you're bumping the version to 5.0!
+
+        This is a reminder to:
+        - remove the `app_name` argument (and related logic) from `Journaled::DeliveryJob`,
+        - remove the following app_name test contexts, and
+        - make `stream_name` a required kwarg
+
+        Thanks!
+      MSG
+    end
+
+    context 'when the legacy app_name argument is present but nil' do
+      let(:args) { { serialized_event: serialized_event, partition_key: partition_key, app_name: nil } }
+
+      around do |example|
+        with_env(JOURNALED_STREAM_NAME: 'legacy_stream_name') { example.run }
+      end
+
+      it 'makes requests to AWS to put the event on the Kinesis with the correct body' do
+        event = described_class.perform_now(args)
+
+        expect(event.shard_id).to eq '101'
+        expect(event.sequence_number).to eq '101123'
+        expect(kinesis_client).to have_received(:put_record).with(
+          stream_name: 'legacy_stream_name',
+          data: '{"foo":"bar"}',
+          partition_key: 'fake_partition_key',
+        )
+      end
+    end
+
+    context 'when the legacy app_name argument is present and has a value' do
+      let(:args) { { serialized_event: serialized_event, partition_key: partition_key, app_name: 'pied_piper' } }
+
+      around do |example|
+        with_env(PIED_PIPER_JOURNALED_STREAM_NAME: 'pied_piper_events') { example.run }
+      end
+
+      it 'makes requests to AWS to put the event on the Kinesis with the correct body' do
+        event = described_class.perform_now(args)
+
+        expect(event.shard_id).to eq '101'
+        expect(event.sequence_number).to eq '101123'
+        expect(kinesis_client).to have_received(:put_record).with(
+          stream_name: 'pied_piper_events',
+          data: '{"foo":"bar"}',
+          partition_key: 'fake_partition_key',
+        )
       end
     end
 
@@ -83,8 +137,11 @@ RSpec.describe Journaled::Delivery do
       end
 
       it 'catches the error and re-raises a subclass of NotTrulyExceptionalError and logs about the failure' do
-        expect(Rails.logger).to receive(:error).with("Kinesis Error - Server Error occurred - Aws::Kinesis::Errors::InternalFailure").once
-        expect { subject.perform }.to raise_error described_class::KinesisTemporaryFailure
+        allow(Rails.logger).to receive(:error)
+        expect { described_class.perform_now(args) }.to raise_error described_class::KinesisTemporaryFailure
+        expect(Rails.logger).to have_received(:error).with(
+          "Kinesis Error - Server Error occurred - Aws::Kinesis::Errors::InternalFailure",
+        ).once
       end
     end
 
@@ -95,7 +152,7 @@ RSpec.describe Journaled::Delivery do
 
       it 'catches the error and re-raises a subclass of NotTrulyExceptionalError and logs about the failure' do
         allow(Rails.logger).to receive(:error)
-        expect { subject.perform }.to raise_error described_class::KinesisTemporaryFailure
+        expect { described_class.perform_now(args) }.to raise_error described_class::KinesisTemporaryFailure
         expect(Rails.logger).to have_received(:error).with(/\AKinesis Error/).once
       end
     end
@@ -106,7 +163,7 @@ RSpec.describe Journaled::Delivery do
       end
 
       it 'raises an error that subclasses Aws::Kinesis::Errors::ServiceError' do
-        expect { subject.perform }.to raise_error Aws::Kinesis::Errors::ServiceError
+        expect { described_class.perform_now(args) }.to raise_error Aws::Kinesis::Errors::ServiceError
       end
     end
 
@@ -116,7 +173,7 @@ RSpec.describe Journaled::Delivery do
       end
 
       it 'raises an AccessDeniedException error' do
-        expect { subject.perform }.to raise_error Aws::Kinesis::Errors::AccessDeniedException
+        expect { described_class.perform_now(args) }.to raise_error Aws::Kinesis::Errors::AccessDeniedException
       end
     end
 
@@ -126,31 +183,28 @@ RSpec.describe Journaled::Delivery do
       end
 
       it 'catches the error and re-raises a subclass of NotTrulyExceptionalError and logs about the failure' do
-        expect(Rails.logger).to receive(:error).with(
+        allow(Rails.logger).to receive(:error)
+        expect { described_class.perform_now(args) }.to raise_error described_class::KinesisTemporaryFailure
+        expect(Rails.logger).to have_received(:error).with(
           "Kinesis Error - Networking Error occurred - Seahorse::Client::NetworkingError",
         ).once
-        expect { subject.perform }.to raise_error described_class::KinesisTemporaryFailure
       end
     end
   end
 
-  describe "#stream_name" do
+  describe ".legacy_computed_stream_name" do
     context "when app_name is unspecified" do
-      subject { described_class.new serialized_event: serialized_event, partition_key: partition_key, app_name: nil }
-
       it "is fetched from a prefixed ENV var if specified" do
         allow(ENV).to receive(:fetch).and_return("expected_stream_name")
-        expect(subject.stream_name).to eq("expected_stream_name")
+        expect(described_class.legacy_computed_stream_name(app_name: nil)).to eq("expected_stream_name")
         expect(ENV).to have_received(:fetch).with("JOURNALED_STREAM_NAME")
       end
     end
 
     context "when app_name is specified" do
-      subject { described_class.new serialized_event: serialized_event, partition_key: partition_key, app_name: "my_funky_app_name" }
-
       it "is fetched from a prefixed ENV var if specified" do
         allow(ENV).to receive(:fetch).and_return("expected_stream_name")
-        expect(subject.stream_name).to eq("expected_stream_name")
+        expect(described_class.legacy_computed_stream_name(app_name: "my_funky_app_name")).to eq("expected_stream_name")
         expect(ENV).to have_received(:fetch).with("MY_FUNKY_APP_NAME_JOURNALED_STREAM_NAME")
       end
     end
@@ -191,7 +245,7 @@ RSpec.describe Journaled::Delivery do
     end
 
     it "will set http_open_timeout by default" do
-      expect(subject.kinesis_client_config).to include(http_open_timeout: 15)
+      expect(subject.kinesis_client_config).to include(http_open_timeout: 2)
     end
 
     it "will set http_read_timeout by default" do
@@ -207,8 +261,8 @@ RSpec.describe Journaled::Delivery do
 
     context "when Journaled.http_open_timeout is specified" do
       it "will set http_open_timeout by specified value" do
-        allow(Journaled).to receive(:http_open_timeout).and_return(2)
-        expect(subject.kinesis_client_config).to include(http_open_timeout: 2)
+        allow(Journaled).to receive(:http_open_timeout).and_return(1)
+        expect(subject.kinesis_client_config).to include(http_open_timeout: 1)
       end
     end
 

data/spec/lib/journaled_spec.rb

@@ -49,4 +49,43 @@ RSpec.describe Journaled do
       expect(described_class.actor_uri).to eq "my actor uri"
     end
   end
+
+  describe '.detect_queue_adapter!' do
+    it 'raises an error unless the queue adapter is DB-backed' do
+      expect { described_class.detect_queue_adapter! }.to raise_error <<~MSG
+        Journaled has detected an unsupported ActiveJob queue adapter: `:test`
+
+        Journaled jobs must be enqueued transactionally to your primary database.
+
+        Please install the appropriate gems and set `queue_adapter` to one of the following:
+        - `:delayed`
+        - `:delayed_job`
+        - `:good_job`
+        - `:que`
+
+        Read more at https://github.com/Betterment/journaled
+      MSG
+    end
+
+    context 'when the queue adapter is supported' do
+      before do
+        stub_const("ActiveJob::QueueAdapters::DelayedAdapter", Class.new)
+        ActiveJob::Base.disable_test_adapter
+        ActiveJob::Base.queue_adapter = :delayed
+      end
+
+      around do |example|
+        begin
+          example.run
+        ensure
+          ActiveJob::Base.queue_adapter = :test
+          ActiveJob::Base.enable_test_adapter(ActiveJob::QueueAdapters::TestAdapter.new)
+        end
+      end
+
+      it 'does not raise an error' do
+        expect { described_class.detect_queue_adapter! }.not_to raise_error
+      end
+    end
+  end
 end

data/spec/models/database_change_protection_spec.rb

@@ -4,38 +4,42 @@ if Rails::VERSION::MAJOR > 5 || (Rails::VERSION::MAJOR == 5 && Rails::VERSION::M
   # rubocop:disable Rails/SkipsModelValidations
   RSpec.describe "Raw database change protection" do
     let(:journaled_class) do
-      Class.new(Delayed::Job) do
+      Class.new(ActiveRecord::Base) do
         include Journaled::Changes
 
-        journal_changes_to :locked_at, as: :attempt
+        self.table_name = 'widgets'
+
+        journal_changes_to :name, as: :attempt
       end
     end
 
     let(:journaled_class_with_no_journaled_columns) do
-      Class.new(Delayed::Job) do
+      Class.new(ActiveRecord::Base) do
         include Journaled::Changes
+
+        self.table_name = 'widgets'
       end
     end
 
     describe "the relation" do
       describe "#update_all" do
         it "refuses on journaled columns passed as hash" do
-          expect { journaled_class.update_all(locked_at: nil) }.to raise_error(/aborted by Journaled/)
+          expect { journaled_class.update_all(name: nil) }.to raise_error(/aborted by Journaled/)
         end
 
         it "refuses on journaled columns passed as string" do
-          expect { journaled_class.update_all("\"locked_at\" = NULL") }.to raise_error(/aborted by Journaled/)
-          expect { journaled_class.update_all("locked_at = null") }.to raise_error(/aborted by Journaled/)
-          expect { journaled_class.update_all("delayed_jobs.locked_at = null") }.to raise_error(/aborted by Journaled/)
-          expect { journaled_class.update_all("last_error = 'locked_at'") }.not_to raise_error
+          expect { journaled_class.update_all("\"name\" = NULL") }.to raise_error(/aborted by Journaled/)
+          expect { journaled_class.update_all("name = null") }.to raise_error(/aborted by Journaled/)
+          expect { journaled_class.update_all("widgets.name = null") }.to raise_error(/aborted by Journaled/)
+          expect { journaled_class.update_all("other_column = 'name'") }.not_to raise_error
         end
 
         it "succeeds on unjournaled columns" do
-          expect { journaled_class.update_all(handler: "") }.not_to raise_error
+          expect { journaled_class.update_all(other_column: "") }.not_to raise_error
         end
 
         it "succeeds when forced on journaled columns" do
-          expect { journaled_class.update_all({ locked_at: nil }, force: true) }.not_to raise_error
+          expect { journaled_class.update_all({ name: nil }, force: true) }.not_to raise_error
         end
       end
 
@@ -69,29 +73,19 @@ if Rails::VERSION::MAJOR > 5 || (Rails::VERSION::MAJOR == 5 && Rails::VERSION::M
     end
 
     describe "an instance" do
-      let(:job) do
-        module TestJob
-          def perform
-            "foo"
-          end
-
-          module_function :perform
-        end
-      end
-
-      subject { journaled_class.enqueue(job) }
+      subject { journaled_class.create!(name: 'foo') }
 
       describe "#update_columns" do
         it "refuses on journaled columns" do
-          expect { subject.update_columns(locked_at: nil) }.to raise_error(/aborted by Journaled/)
+          expect { subject.update_columns(name: nil) }.to raise_error(/aborted by Journaled/)
         end
 
         it "succeeds on unjournaled columns" do
-          expect { subject.update_columns(handler: "") }.not_to raise_error
+          expect { subject.update_columns(other_column: "") }.not_to raise_error
         end
 
         it "succeeds when forced on journaled columns" do
-          expect { subject.update_columns({ locked_at: nil }, force: true) }.not_to raise_error
+          expect { subject.update_columns({ name: nil }, force: true) }.not_to raise_error
         end
       end
 
@@ -101,7 +95,7 @@ if Rails::VERSION::MAJOR > 5 || (Rails::VERSION::MAJOR == 5 && Rails::VERSION::M
         end
 
         it "succeeds if no journaled columns exist" do
-          instance = journaled_class_with_no_journaled_columns.enqueue(job)
+          instance = journaled_class_with_no_journaled_columns.create!
           expect { instance.delete }.not_to raise_error
         end
 

data/spec/models/journaled/change_writer_spec.rb

@@ -138,30 +138,30 @@ RSpec.describe Journaled::ChangeWriter do
       expect(subject.journaled_change_for("update", {}).logical_operation).to eq("identity_change")
     end
 
-    it "doesn't set journaled_app_name if model class doesn't respond to it" do
-      expect(subject.journaled_change_for("update", {}).journaled_app_name).to eq(nil)
+    it "doesn't set journaled_stream_name if model class doesn't respond to it" do
+      expect(subject.journaled_change_for("update", {}).journaled_stream_name).to eq(nil)
     end
 
     context "with journaled default app name set" do
       around do |example|
-        orig_app_name = Journaled.default_app_name
-        Journaled.default_app_name = "foo"
+        orig_app_name = Journaled.default_stream_name
+        Journaled.default_stream_name = "foo"
         example.run
-        Journaled.default_app_name = orig_app_name
+        Journaled.default_stream_name = orig_app_name
       end
 
       it "passes through default" do
-        expect(subject.journaled_change_for("update", {}).journaled_app_name).to eq("foo")
+        expect(subject.journaled_change_for("update", {}).journaled_stream_name).to eq("foo")
       end
     end
 
-    context "when model class defines journaled_app_name" do
+    context "when model class defines journaled_stream_name" do
       before do
-        allow(model_class).to receive(:journaled_app_name).and_return("my_app")
+        allow(model_class).to receive(:journaled_stream_name).and_return("my_app_events")
       end
 
-      it "sets journaled_app_name if model_class responds to it" do
-        expect(subject.journaled_change_for("update", {}).journaled_app_name).to eq("my_app")
+      it "sets journaled_stream_name if model_class responds to it" do
+        expect(subject.journaled_change_for("update", {}).journaled_stream_name).to eq("my_app_events")
       end
     end
   end

data/spec/models/journaled/event_spec.rb

@@ -65,14 +65,14 @@ RSpec.describe Journaled::Event do
     end
   end
 
-  describe '#journaled_app_name' do
+  describe '#journaled_stream_name' do
     it 'returns nil in the base class so it can be set explicitly in apps spanning multiple app domains' do
-      expect(sample_journaled_event.journaled_app_name).to be_nil
+      expect(sample_journaled_event.journaled_stream_name).to be_nil
     end
 
     it 'returns the journaled default if set' do
-      allow(Journaled).to receive(:default_app_name).and_return("my_app")
-      expect(sample_journaled_event.journaled_app_name).to eq("my_app")
+      allow(Journaled).to receive(:default_stream_name).and_return("my_app_events")
+      expect(sample_journaled_event.journaled_stream_name).to eq("my_app_events")
     end
   end
 

data/spec/models/journaled/writer_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe Journaled::Writer do
           journaled_schema_name: nil,
           journaled_attributes: {},
           journaled_partition_key: '',
-          journaled_app_name: nil,
+          journaled_stream_name: nil,
           journaled_enqueue_opts: {},
         )
       end
@@ -34,7 +34,7 @@ RSpec.describe Journaled::Writer do
           journaled_schema_name: :fake_schema_name,
           journaled_attributes: { foo: :bar },
           journaled_partition_key: 'fake_partition_key',
-          journaled_app_name: nil,
+          journaled_stream_name: nil,
           journaled_enqueue_opts: {},
         )
       end
@@ -75,21 +75,17 @@ RSpec.describe Journaled::Writer do
         journaled_schema_name: :fake_schema_name,
         journaled_attributes: journaled_event_attributes,
         journaled_partition_key: 'fake_partition_key',
-        journaled_app_name: 'my_app',
+        journaled_stream_name: 'my_app_events',
         journaled_enqueue_opts: journaled_enqueue_opts,
       )
     end
 
-    around do |example|
-      with_jobs_delayed { example.run }
-    end
-
     context 'when the journaled event does NOT comply with the base_event schema' do
       let(:journaled_event_attributes) { { foo: 1 } }
 
       it 'raises an error and does not enqueue anything' do
         expect { subject.journal! }.to raise_error JSON::Schema::ValidationError
-        expect(Delayed::Job.where('handler like ?', '%Journaled::Delivery%').count).to eq 0
+        expect(enqueued_jobs.count).to eq 0
       end
     end
 
@@ -99,7 +95,7 @@ RSpec.describe Journaled::Writer do
 
         it 'raises an error and does not enqueue anything' do
           expect { subject.journal! }.to raise_error JSON::Schema::ValidationError
-          expect(Delayed::Job.where('handler like ?', '%Journaled::Delivery%').count).to eq 0
+          expect(enqueued_jobs.count).to eq 0
         end
       end
 
@@ -107,9 +103,8 @@ RSpec.describe Journaled::Writer do
         let(:journaled_event_attributes) { { id: 'FAKE_UUID', event_type: 'fake_event', created_at: Time.zone.now, foo: :bar } }
 
         it 'creates a delivery with the app name passed through' do
-          allow(Journaled::Delivery).to receive(:new).and_call_original
-          subject.journal!
-          expect(Journaled::Delivery).to have_received(:new).with(hash_including(app_name: 'my_app'))
+          expect { subject.journal! }.to change { enqueued_jobs.count }.from(0).to(1)
+          expect(enqueued_jobs.first[:args].first).to include('stream_name' => 'my_app_events')
         end
 
         context 'when there is no job priority specified in the enqueue opts' do
@@ -122,7 +117,11 @@ RSpec.describe Journaled::Writer do
 
           it 'defaults to the global default' do
             expect { subject.journal! }.to change {
-              Delayed::Job.where('handler like ?', '%Journaled::Delivery%').where(priority: 999).count
+              if Rails::VERSION::MAJOR < 6
+                enqueued_jobs.select { |j| j[:job] == Journaled::DeliveryJob }.count
+              else
+                enqueued_jobs.select { |j| j['job_class'] == 'Journaled::DeliveryJob' && j['priority'] == 999 }.count
+              end
             }.from(0).to(1)
           end
         end
@@ -130,9 +129,13 @@ RSpec.describe Journaled::Writer do
         context 'when there is a job priority specified in the enqueue opts' do
           let(:journaled_enqueue_opts) { { priority: 13 } }
 
-          it 'enqueues a Journaled::Delivery object with the given priority' do
+          it 'enqueues a Journaled::DeliveryJob with the given priority' do
             expect { subject.journal! }.to change {
-              Delayed::Job.where('handler like ?', '%Journaled::Delivery%').where(priority: 13).count
+              if Rails::VERSION::MAJOR < 6
+                enqueued_jobs.select { |j| j[:job] == Journaled::DeliveryJob }.count
+              else
+                enqueued_jobs.select { |j| j['job_class'] == 'Journaled::DeliveryJob' && j['priority'] == 13 }.count
+              end
             }.from(0).to(1)
           end
         end

data/spec/rails_helper.rb

@@ -6,7 +6,6 @@ require 'rspec/rails'
 require 'timecop'
 require 'webmock/rspec'
 require 'journaled/rspec'
-require 'pry-rails'
 
 Dir[Rails.root.join('..', 'support', '**', '*.rb')].each { |f| require f }
 
@@ -15,6 +14,6 @@ RSpec.configure do |config|
 
   config.infer_spec_type_from_file_location!
 
-  config.include DelayedJobSpecHelper
+  config.include ActiveJob::TestHelper
   config.include EnvironmentSpecHelper
 end

data/spec/spec_helper.rb

@@ -1,9 +1,7 @@
-require 'delayed_job_active_record'
 rails_env = ENV['RAILS_ENV'] ||= 'test'
-db_adapter = ENV['DB_ADAPTER'] ||= 'postgresql'
 require File.expand_path('dummy/config/environment.rb', __dir__)
 
-Rails.configuration.database_configuration[db_adapter][rails_env].tap do |c|
+Rails.configuration.database_configuration[rails_env].tap do |c|
   ActiveRecord::Tasks::DatabaseTasks.create(c)
   ActiveRecord::Base.establish_connection(c)
   load File.expand_path('dummy/db/schema.rb', __dir__)