journaled 4.0.0 → 4.3.0

data/lib/journaled/rspec.rb

@@ -16,3 +16,89 @@ RSpec::Matchers.define :journal_changes_to do |*attribute_names, as:|
     "expected #{model_class} not to journal changes to #{attribute_names.map(&:inspect).join(', ')} as #{as.inspect}"
   end
 end
+
+RSpec::Matchers.define_negated_matcher :not_journal_changes_to, :journal_changes_to
+
+RSpec::Matchers.define :journal_events_including do |*expected_events|
+  raise "Please specify at least one expected event. RSpec argument matchers are supported." if expected_events.empty?
+
+  attr_accessor :expected, :actual, :matches, :nonmatches
+
+  chain :with_schema_name, :expected_schema_name
+  chain :with_partition_key, :expected_partition_key
+  chain :with_stream_name, :expected_stream_name
+  chain :with_enqueue_opts, :expected_enqueue_opts
+  chain :with_priority, :expected_priority
+
+  def supports_block_expectations?
+    true
+  end
+
+  def hash_including_recursive(hash)
+    hash_including(
+      hash.transform_values { |v| v.is_a?(Hash) ? hash_including_recursive(v) : v },
+    )
+  end
+
+  match do |block|
+    expected_events = [expected_events.first].flatten(1) unless expected_events.length > 1
+
+    self.expected = expected_events.map { |e| { journaled_attributes: e } }
+    expected.each { |e| e.merge!(journaled_schema_name: expected_schema_name) } if expected_schema_name
+    expected.each { |e| e.merge!(journaled_partition_key: expected_partition_key) } if expected_partition_key
+    expected.each { |e| e.merge!(journaled_stream_name: expected_stream_name) } if expected_stream_name
+    expected.each { |e| e.merge!(journaled_enqueue_opts: expected_enqueue_opts) } if expected_enqueue_opts
+    expected.each { |e| e.merge!(priority: expected_priority) } if expected_priority
+    self.actual = []
+
+    callback = ->(_name, _started, _finished, _unique_id, payload) do
+      event = payload[:event]
+      a = { journaled_attributes: event.journaled_attributes }
+      a[:journaled_schema_name] = event.journaled_schema_name if expected_schema_name
+      a[:journaled_partition_key] = event.journaled_partition_key if expected_partition_key
+      a[:journaled_stream_name] = event.journaled_stream_name if expected_stream_name
+      a[:journaled_enqueue_opts] = event.journaled_enqueue_opts if expected_enqueue_opts
+      a[:priority] = payload[:priority] if expected_priority
+      actual << a
+    end
+
+    ActiveSupport::Notifications.subscribed(callback, 'journaled.event.enqueue', &block)
+
+    self.matches = actual.select do |a|
+      expected.any? { |e| values_match?(hash_including_recursive(e), a) }
+    end
+
+    self.nonmatches = actual - matches
+
+    exact_matches = matches.dup
+    matches.count == expected.count && expected.all? do |e|
+      match, index = exact_matches.each_with_index.find { |a, _| values_match?(hash_including_recursive(e), a) }
+      exact_matches.delete_at(index) if match
+    end && exact_matches.empty?
+  end
+
+  failure_message do
+    <<~MSG
+      Expected the code block to journal exactly one matching event per expected event.
+
+      Expected Events (#{expected.count}):
+      ===============================================================================
+        #{expected.map(&:to_json).join("\n ")}
+      ===============================================================================
+
+      Matching Events (#{matches.count}):
+      ===============================================================================
+        #{matches.map(&:to_json).join("\n ")}
+      ===============================================================================
+
+      Non-Matching Events (#{nonmatches.count}):
+      ===============================================================================
+        #{nonmatches.map(&:to_json).join("\n  ")}
+      ===============================================================================
+    MSG
+  end
+end
+
+RSpec::Matchers.alias_matcher :journal_event_including, :journal_events_including
+RSpec::Matchers.define_negated_matcher :not_journal_events_including, :journal_events_including
+RSpec::Matchers.define_negated_matcher :not_journal_event_including, :journal_event_including

data/lib/journaled/version.rb

@@ -1,3 +1,3 @@
 module Journaled
-  VERSION = "4.0.0".freeze
+  VERSION = "4.3.0".freeze
 end

data/lib/journaled.rb

@@ -1,9 +1,9 @@
 require "aws-sdk-kinesis"
 require "active_job"
 require "json-schema"
-require "request_store"
 
 require "journaled/engine"
+require "journaled/current"
 
 module Journaled
   SUPPORTED_QUEUE_ADAPTERS = %w(delayed delayed_job good_job que).freeze
@@ -20,7 +20,7 @@ module Journaled
   end
 
   def enabled?
-    !['0', 'false', false, 'f', ''].include?(ENV.fetch('JOURNALED_ENABLED', !development_or_test?))
+    ['0', 'false', false, 'f', ''].exclude?(ENV.fetch('JOURNALED_ENABLED', !development_or_test?))
   end
 
   def schema_providers
@@ -51,5 +51,17 @@ module Journaled
     end
   end
 
+  def self.tagged(**tags)
+    existing_tags = Current.tags
+    tag!(**tags)
+    yield
+  ensure
+    Current.tags = existing_tags
+  end
+
+  def self.tag!(**tags)
+    Current.tags = Current.tags.merge(tags)
+  end
+
   module_function :development_or_test?, :enabled?, :schema_providers, :commit_hash, :actor_uri, :detect_queue_adapter!
 end

data/spec/dummy/config.ru

@@ -1,4 +1,4 @@
 # This file is used by Rack-based servers to start the application.
 
-require ::File.expand_path('../config/environment', __FILE__)
+require ::File.expand_path('config/environment', __dir__)
 run Rails.application

data/spec/jobs/journaled/delivery_job_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe Journaled::DeliveryJob do
     end
 
     it 'makes requests to AWS to put the event on the Kinesis with the correct body' do
-      event = described_class.perform_now(args)
+      event = described_class.perform_now(**args)
 
       expect(event.shard_id).to eq '101'
       expect(event.sequence_number).to eq '101123'
@@ -60,7 +60,7 @@ RSpec.describe Journaled::DeliveryJob do
       end
 
       it 'initializes a Kinesis client with assume role credentials' do
-        described_class.perform_now(args)
+        described_class.perform_now(**args)
 
         expect(Aws::AssumeRoleCredentials).to have_received(:new).with(
           client: aws_sts_client,
@@ -74,7 +74,7 @@ RSpec.describe Journaled::DeliveryJob do
       let(:stream_name) { nil }
 
       it 'raises an KeyError error' do
-        expect { described_class.perform_now(args) }.to raise_error ArgumentError, 'missing keyword: stream_name'
+        expect { described_class.perform_now(**args) }.to raise_error ArgumentError, 'missing keyword: stream_name'
       end
     end
 
@@ -99,7 +99,7 @@ RSpec.describe Journaled::DeliveryJob do
       end
 
       it 'makes requests to AWS to put the event on the Kinesis with the correct body' do
-        event = described_class.perform_now(args)
+        event = described_class.perform_now(**args)
 
         expect(event.shard_id).to eq '101'
         expect(event.sequence_number).to eq '101123'
@@ -119,7 +119,7 @@ RSpec.describe Journaled::DeliveryJob do
       end
 
       it 'makes requests to AWS to put the event on the Kinesis with the correct body' do
-        event = described_class.perform_now(args)
+        event = described_class.perform_now(**args)
 
         expect(event.shard_id).to eq '101'
         expect(event.sequence_number).to eq '101123'
@@ -138,7 +138,7 @@ RSpec.describe Journaled::DeliveryJob 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 { described_class.perform_now(args) }.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(
           "Kinesis Error - Server Error occurred - Aws::Kinesis::Errors::InternalFailure",
         ).once
@@ -152,7 +152,7 @@ RSpec.describe Journaled::DeliveryJob 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 { described_class.perform_now(args) }.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
@@ -163,7 +163,7 @@ RSpec.describe Journaled::DeliveryJob do
       end
 
       it 'raises an error that subclasses Aws::Kinesis::Errors::ServiceError' do
-        expect { described_class.perform_now(args) }.to raise_error Aws::Kinesis::Errors::ServiceError
+        expect { described_class.perform_now(**args) }.to raise_error Aws::Kinesis::Errors::ServiceError
       end
     end
 
@@ -173,7 +173,7 @@ RSpec.describe Journaled::DeliveryJob do
       end
 
       it 'raises an AccessDeniedException error' do
-        expect { described_class.perform_now(args) }.to raise_error Aws::Kinesis::Errors::AccessDeniedException
+        expect { described_class.perform_now(**args) }.to raise_error Aws::Kinesis::Errors::AccessDeniedException
       end
     end
 
@@ -184,7 +184,7 @@ RSpec.describe Journaled::DeliveryJob 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 { described_class.perform_now(args) }.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(
           "Kinesis Error - Networking Error occurred - Seahorse::Client::NetworkingError",
         ).once

data/spec/lib/journaled_spec.rb

@@ -75,12 +75,10 @@ RSpec.describe Journaled do
       end
 
       around do |example|
-        begin
-          example.run
-        ensure
-          ActiveJob::Base.queue_adapter = :test
-          ActiveJob::Base.enable_test_adapter(ActiveJob::QueueAdapters::TestAdapter.new)
-        end
+        example.run
+      ensure
+        ActiveJob::Base.queue_adapter = :test
+        ActiveJob::Base.enable_test_adapter(ActiveJob::QueueAdapters::TestAdapter.new)
       end
 
       it 'does not raise an error' do

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 be_nil
+    expect(Journaled::Current.actor).to be_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/concerns/journaled/changes_spec.rb

@@ -44,7 +44,7 @@ RSpec.describe Journaled::Changes do
 
   subject { klass.new }
 
-  let(:change_writer) { double(Journaled::ChangeWriter, create: true, update: true, delete: true) }
+  let(:change_writer) { instance_double(Journaled::ChangeWriter, create: true, update: true, delete: true) }
 
   before do
     allow(Journaled::ChangeWriter).to receive(:new) do |opts|

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

@@ -139,7 +139,7 @@ RSpec.describe Journaled::ChangeWriter do
     end
 
     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)
+      expect(subject.journaled_change_for("update", {}).journaled_stream_name).to be_nil
     end
 
     context "with journaled default app name set" do

data/spec/models/journaled/event_spec.rb

@@ -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

data/spec/models/journaled/json_schema_model/validator_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe Journaled::JsonSchemaModel::Validator do
     let(:attributes_to_validate) do
       {
         some_string: some_string_value,
-        some_decimal: 0.1.to_d,
+        some_decimal: BigDecimal('0.1'),
         some_time: Time.zone.parse('2017-01-20 15:16:17 -05:00'),
         some_int: some_int_value,
         some_optional_string: some_optional_string_value,
@@ -66,7 +66,7 @@ RSpec.describe Journaled::JsonSchemaModel::Validator do
       context 'when all the required fields are provided' do
         context 'when all the fields are provided' do
           it 'is valid' do
-            expect(subject.validate!(json_to_validate)).to eq true
+            expect(subject.validate!(json_to_validate)).to be true
           end
         end
 
@@ -74,7 +74,7 @@ RSpec.describe Journaled::JsonSchemaModel::Validator do
           let(:attributes_to_validate) do
             {
               some_string: some_string_value,
-              some_decimal: 0.1.to_d,
+              some_decimal: BigDecimal('0.1'),
               some_time: Time.zone.parse('2017-01-20 15:16:17 -05:00'),
               some_int: some_int_value,
               some_nullable_field: some_nullable_field,
@@ -82,7 +82,7 @@ RSpec.describe Journaled::JsonSchemaModel::Validator do
           end
 
           it 'is valid' do
-            expect(subject.validate!(json_to_validate)).to eq true
+            expect(subject.validate!(json_to_validate)).to be true
           end
         end
 
@@ -90,7 +90,7 @@ RSpec.describe Journaled::JsonSchemaModel::Validator do
           let(:some_nullable_optional_field) { nil }
 
           it 'is valid' do
-            expect(subject.validate!(json_to_validate)).to eq true
+            expect(subject.validate!(json_to_validate)).to be true
           end
         end
 
@@ -107,7 +107,7 @@ RSpec.describe Journaled::JsonSchemaModel::Validator do
         let(:attributes_to_validate) do
           {
             some_string: some_string_value,
-            some_decimal: 0.1.to_d,
+            some_decimal: BigDecimal('0.1'),
             some_time: Time.zone.parse('2017-01-20 15:16:17 -05:00'),
           }
         end

data/spec/models/journaled/writer_spec.rb

@@ -1,11 +1,12 @@
 require 'rails_helper'
 
 RSpec.describe Journaled::Writer do
+  let(:event_class) { Class.new { include Journaled::Event } }
   subject { described_class.new journaled_event: journaled_event }
 
   describe '#initialize' do
     context 'when the Journaled Event does not implement all the necessary methods' do
-      let(:journaled_event) { double }
+      let(:journaled_event) { instance_double(event_class) }
 
       it 'raises on initialization' do
         expect { subject }.to raise_error RuntimeError, /An enqueued event must respond to/
@@ -14,7 +15,8 @@ RSpec.describe Journaled::Writer do
 
     context 'when the Journaled Event returns non-present values for some of the required methods' do
       let(:journaled_event) do
-        double(
+        instance_double(
+          event_class,
           journaled_schema_name: nil,
           journaled_attributes: {},
           journaled_partition_key: '',
@@ -30,7 +32,8 @@ RSpec.describe Journaled::Writer do
 
     context 'when the Journaled Event complies with the API' do
       let(:journaled_event) do
-        double(
+        instance_double(
+          event_class,
           journaled_schema_name: :fake_schema_name,
           journaled_attributes: { foo: :bar },
           journaled_partition_key: 'fake_partition_key',
@@ -71,12 +74,14 @@ RSpec.describe Journaled::Writer do
 
     let(:journaled_enqueue_opts) { {} }
     let(:journaled_event) do
-      double(
-        journaled_schema_name: :fake_schema_name,
+      instance_double(
+        event_class,
+        journaled_schema_name: 'fake_schema_name',
         journaled_attributes: journaled_event_attributes,
         journaled_partition_key: 'fake_partition_key',
         journaled_stream_name: 'my_app_events',
         journaled_enqueue_opts: journaled_enqueue_opts,
+        tagged?: false,
       )
     end
 
@@ -84,7 +89,9 @@ RSpec.describe Journaled::Writer 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 { subject.journal! }
+          .to raise_error(JSON::Schema::ValidationError)
+          .and not_journal_event_including(anything)
         expect(enqueued_jobs.count).to eq 0
       end
     end
@@ -94,7 +101,9 @@ RSpec.describe Journaled::Writer do
         let(:journaled_event_attributes) { { id: 'FAKE_UUID', event_type: 'fake_event', created_at: Time.zone.now, foo: 1 } }
 
         it 'raises an error and does not enqueue anything' do
-          expect { subject.journal! }.to raise_error JSON::Schema::ValidationError
+          expect { subject.journal! }
+            .to raise_error(JSON::Schema::ValidationError)
+            .and not_journal_event_including(anything)
           expect(enqueued_jobs.count).to eq 0
         end
       end
@@ -103,7 +112,13 @@ 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
-          expect { subject.journal! }.to change { enqueued_jobs.count }.from(0).to(1)
+          expect { subject.journal! }
+            .to change { enqueued_jobs.count }.from(0).to(1)
+            .and journal_event_including(journaled_event_attributes)
+            .with_schema_name('fake_schema_name')
+            .with_partition_key('fake_partition_key')
+            .with_stream_name('my_app_events')
+            .with_enqueue_opts({})
           expect(enqueued_jobs.first[:args].first).to include('stream_name' => 'my_app_events')
         end
 
@@ -118,11 +133,18 @@ RSpec.describe Journaled::Writer do
           it 'defaults to the global default' do
             expect { subject.journal! }.to change {
               if Rails::VERSION::MAJOR < 6
-                enqueued_jobs.select { |j| j[:job] == Journaled::DeliveryJob }.count
+                enqueued_jobs.count { |j| j[:job] == Journaled::DeliveryJob }
               else
-                enqueued_jobs.select { |j| j['job_class'] == 'Journaled::DeliveryJob' && j['priority'] == 999 }.count
+                enqueued_jobs.count { |j| j['job_class'] == 'Journaled::DeliveryJob' && j['priority'] == 999 }
               end
             }.from(0).to(1)
+              .and journal_event_including(journaled_event_attributes)
+              .with_schema_name('fake_schema_name')
+              .with_partition_key('fake_partition_key')
+              .with_stream_name('my_app_events')
+              .with_priority(999)
+              .and not_journal_event_including(anything)
+              .with_enqueue_opts(priority: 999) # with_enqueue_opts looks at event itself
           end
         end
 
@@ -132,14 +154,59 @@ RSpec.describe Journaled::Writer do
           it 'enqueues a Journaled::DeliveryJob with the given priority' do
             expect { subject.journal! }.to change {
               if Rails::VERSION::MAJOR < 6
-                enqueued_jobs.select { |j| j[:job] == Journaled::DeliveryJob }.count
+                enqueued_jobs.count { |j| j[:job] == Journaled::DeliveryJob }
               else
-                enqueued_jobs.select { |j| j['job_class'] == 'Journaled::DeliveryJob' && j['priority'] == 13 }.count
+                enqueued_jobs.count { |j| j['job_class'] == 'Journaled::DeliveryJob' && j['priority'] == 13 }
               end
             }.from(0).to(1)
+              .and journal_event_including(journaled_event_attributes)
+              .with_schema_name('fake_schema_name')
+              .with_partition_key('fake_partition_key')
+              .with_stream_name('my_app_events')
+              .with_priority(13)
+              .with_enqueue_opts(priority: 13)
           end
         end
       end
     end
+
+    context 'when the event is tagged' do
+      before do
+        allow(journaled_event).to receive(:tagged?).and_return(true)
+      end
+
+      context 'and the "tags" attribute is not present' do
+        let(:journaled_event_attributes) do
+          { id: 'FAKE_UUID', event_type: 'fake_event', created_at: Time.zone.now, foo: 'bar' }
+        end
+
+        it 'raises an error and does not enqueue anything' do
+          expect { subject.journal! }
+            .to not_journal_events_including(anything)
+            .and raise_error JSON::Schema::ValidationError
+          expect(enqueued_jobs.count).to eq 0
+        end
+      end
+
+      context 'and the "tags" attribute is present' do
+        let(:journaled_event_attributes) do
+          { id: 'FAKE_UUID', event_type: 'fake_event', created_at: Time.zone.now, foo: 'bar', tags: { baz: 'bat' } }
+        end
+
+        it 'creates a delivery with the app name passed through' do
+          expect { subject.journal! }
+            .to change { enqueued_jobs.count }.from(0).to(1)
+            .and journal_event_including(journaled_event_attributes)
+            .with_schema_name('fake_schema_name')
+            .with_partition_key('fake_partition_key')
+            .with_stream_name('my_app_events')
+            .with_enqueue_opts({})
+            .with_priority(Journaled.job_priority)
+            .and not_journal_event_including(anything)
+            .with_enqueue_opts(priority: Journaled.job_priority)
+          expect(enqueued_jobs.first[:args].first).to include('stream_name' => 'my_app_events')
+        end
+      end
+    end
   end
 end

data/spec/rails_helper.rb

@@ -7,7 +7,7 @@ require 'timecop'
 require 'webmock/rspec'
 require 'journaled/rspec'
 
-Dir[Rails.root.join('..', 'support', '**', '*.rb')].each { |f| require f }
+Dir[Rails.root.join('../support/**/*.rb')].sort.each { |f| require f }
 
 RSpec.configure do |config|
   config.use_transactional_fixtures = true