journaled 2.5.0 → 4.1.0

data/spec/dummy/config/database.yml

@@ -1,21 +1,6 @@
-default: &default
-  pool: 5
-  encoding: unicode
-
-postgresql:
-  default: &postgres_default
-    adapter: postgresql
-    url: <%= ENV['DATABASE_URL'] %>
-  test: &postgres_test
-    <<: *postgres_default
-    url: <%= ENV['DATABASE_URL'] || "postgresql://localhost:#{ENV.fetch('PGPORT', 5432)}/journaled_test" %>
-    database: journaled_test
-  development: &postgres_development
-    <<: *postgres_default
-    url: <%= ENV['DATABASE_URL'] || "postgresql://localhost:#{ENV.fetch('PGPORT', 5432)}/journaled_development" %>
-    database: journaled_development
-
 development:
-  <<: *postgres_development
+  adapter: sqlite3
+  database: ":memory:"
 test:
-  <<: *postgres_test
+  adapter: sqlite3
+  database: ":memory:"

data/spec/dummy/config/environments/development.rb

@@ -13,25 +13,12 @@ Rails.application.configure do
   config.consider_all_requests_local       = true
   config.action_controller.perform_caching = false
 
-  # Don't care if the mailer can't send.
-  config.action_mailer.raise_delivery_errors = false
-
   # Print deprecation notices to the Rails logger.
   config.active_support.deprecation = :log
 
   # Raise an error on page load if there are pending migrations.
   config.active_record.migration_error = :page_load
 
-  # Debug mode disables concatenation and preprocessing of assets.
-  # This option may cause significant delays in view rendering with a large
-  # number of complex assets.
-  config.assets.debug = true
-
-  # Adds additional error checking when serving assets at runtime.
-  # Checks for improperly declared sprockets dependencies.
-  # Raises helpful error messages.
-  config.assets.raise_runtime_errors = true
-
   # Raises error for missing translations
   # config.action_view.raise_on_missing_translations = true
 end

data/spec/dummy/config/environments/test.rb

@@ -26,14 +26,12 @@ Rails.application.configure do
   # Disable request forgery protection in test environment.
   config.action_controller.allow_forgery_protection = false
 
-  # Tell Action Mailer not to deliver emails to the real world.
-  # The :test delivery method accumulates sent emails in the
-  # ActionMailer::Base.deliveries array.
-  config.action_mailer.delivery_method = :test
-
   # Print deprecation notices to the stderr.
   config.active_support.deprecation = :stderr
 
   # Raises error for missing translations
   # config.action_view.raise_on_missing_translations = true
+
+  # Use ActiveJob test adapter
+  config.active_job.queue_adapter = :test
 end

data/spec/dummy/db/schema.rb

@@ -11,21 +11,8 @@
 # It's strongly recommended that you check this file into your version control system.
 
 ActiveRecord::Schema.define(version: 20180606205114) do
-  # These are extensions that must be enabled in order to support this database
-  enable_extension "plpgsql"
-
-  create_table "delayed_jobs", force: :cascade do |t|
-    t.integer "priority", default: 0, null: false
-    t.integer "attempts", default: 0, null: false
-    t.text "handler", null: false
-    t.text "last_error"
-    t.datetime "run_at"
-    t.datetime "locked_at"
-    t.datetime "failed_at"
-    t.string "locked_by"
-    t.string "queue"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-    t.index ["priority", "run_at"], name: "delayed_jobs_priority"
+  create_table "widgets", force: :cascade do |t|
+    t.string "name"
+    t.string "other_column"
   end
 end

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

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/concerns/journaled/actor_spec.rb

@@ -5,11 +5,10 @@ RSpec.describe Journaled::Actor do
   let(:user) { double("User") }
   let(:klass) do
     Class.new do
-      cattr_accessor :before_actions
-      self.before_actions = []
+      cattr_accessor(:before_actions) { [] }
 
-      def self.before_action(&hook)
-        before_actions << hook
+      def self.before_action(method_name, _opts)
+        before_actions << method_name
       end
 
       include Journaled::Actor
@@ -21,7 +20,7 @@ RSpec.describe Journaled::Actor do
       end
 
       def trigger_before_actions
-        before_actions.each { |proc| instance_eval(&proc) }
+        before_actions.each { |method_name| send(method_name) }
       end
     end
   end
@@ -33,7 +32,8 @@ RSpec.describe Journaled::Actor do
 
     allow(subject).to receive(:current_user).and_return(nil)
 
-    expect(RequestStore.store[:journaled_actor_proc].call).to eq nil
+    expect(Journaled::Current.journaled_actor_proc.call).to eq nil
+    expect(Journaled::Current.actor).to eq nil
   end
 
   it "Stores a thunk returning current_user if it is set when called" do
@@ -41,6 +41,7 @@ RSpec.describe Journaled::Actor do
 
     allow(subject).to receive(:current_user).and_return(user)
 
-    expect(RequestStore.store[:journaled_actor_proc].call).to eq user
+    expect(Journaled::Current.journaled_actor_proc.call).to eq user
+    expect(Journaled::Current.actor).to eq user
   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/actor_uri_provider_spec.rb

@@ -2,7 +2,7 @@ require 'rails_helper'
 
 RSpec.describe Journaled::ActorUriProvider do
   describe "#actor_uri" do
-    let(:request_store) { double(:[] => nil) }
+    let(:current_attributes) { double(:[] => nil) }
     let(:actor) { double(to_global_id: actor_gid) }
     let(:actor_gid) { double(to_s: "my_fancy_gid") }
     let(:program_name) { "/usr/local/bin/puma_or_something" }
@@ -17,13 +17,14 @@ RSpec.describe Journaled::ActorUriProvider do
     end
 
     before do
-      allow(RequestStore).to receive(:store).and_return(request_store)
+      allow(Journaled::Current.instance)
+        .to receive(:attributes).and_return(current_attributes)
     end
 
-    it "returns the global ID of the entity returned by RequestStore.store[:journaled_actor_proc].call if set" do
-      allow(request_store).to receive(:[]).and_return(-> { actor })
+    it "returns the global ID of the entity returned by Current.journaled_actor_proc.call if set" do
+      allow(current_attributes).to receive(:[]).and_return(-> { actor })
       expect(subject.actor_uri).to eq("my_fancy_gid")
-      expect(request_store).to have_received(:[]).with(:journaled_actor_proc)
+      expect(current_attributes).to have_received(:[]).with(:journaled_actor_proc)
     end
 
     context "when running in rake" do

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
 
@@ -88,8 +88,10 @@ RSpec.describe Journaled::Event do
 
     context 'when no additional attributes have been defined' do
       it 'returns the base attributes, and memoizes them after the first call' do
-        expect(sample_journaled_event.journaled_attributes).to eq id: fake_uuid, created_at: frozen_time, event_type: 'some_class_name'
-        expect(sample_journaled_event.journaled_attributes).to eq id: fake_uuid, created_at: frozen_time, event_type: 'some_class_name'
+        expect(sample_journaled_event.journaled_attributes)
+          .to eq id: fake_uuid, created_at: frozen_time, event_type: 'some_class_name'
+        expect(sample_journaled_event.journaled_attributes)
+          .to eq id: fake_uuid, created_at: frozen_time, event_type: 'some_class_name'
       end
     end
 
@@ -134,6 +136,80 @@ RSpec.describe Journaled::Event do
         )
       end
     end
+
+    context 'tagged: true' do
+      before do
+        sample_journaled_event_class.journal_attributes tagged: true
+      end
+
+      it 'adds a "tags" attribute' do
+        expect(sample_journaled_event.journaled_attributes).to include(tags: {})
+      end
+
+      context 'when tags are specified' do
+        around do |example|
+          Journaled.tag!(foo: 'bar')
+          Journaled.tagged(baz: 'bat') { example.run }
+        end
+
+        it 'adds them to the journaled attributes' do
+          expect(sample_journaled_event.journaled_attributes).to include(
+            tags: { foo: 'bar', baz: 'bat' },
+          )
+        end
+
+        context 'when even more tags are nested' do
+          it 'merges them in and then resets them' do
+            Journaled.tagged(oh_no: 'even more tags') do
+              expect(sample_journaled_event.journaled_attributes).to include(
+                tags: { foo: 'bar', baz: 'bat', oh_no: 'even more tags' },
+              )
+            end
+
+            allow(SecureRandom).to receive(:uuid).and_return(fake_uuid).once
+            expect(sample_journaled_event_class.new.journaled_attributes).to include(
+              tags: { foo: 'bar', baz: 'bat' },
+            )
+          end
+        end
+
+        context 'when custom event tags are also specified and merged' do
+          let(:sample_journaled_event_class) do
+            Class.new do
+              include Journaled::Event
+
+              def tags
+                super.merge(abc: '123')
+              end
+            end
+          end
+
+          it 'combines all tags' do
+            expect(sample_journaled_event.journaled_attributes).to include(
+              tags: { foo: 'bar', baz: 'bat', abc: '123' },
+            )
+          end
+        end
+
+        context 'when custom event tags are also specified but not merged' do
+          let(:sample_journaled_event_class) do
+            Class.new do
+              include Journaled::Event
+
+              def tags
+                { bananas: 'are great', but_not_actually: 'the best source of potassium' } # it's true
+              end
+            end
+          end
+
+          it 'adds them to the journaled attributes' do
+            expect(sample_journaled_event.journaled_attributes).to include(
+              tags: { bananas: 'are great', but_not_actually: 'the best source of potassium' },
+            )
+          end
+        end
+      end
+    end
   end
 
   describe '#journaled_enqueue_opts, .journaled_enqueue_opts' do