journaled 4.3.0 → 5.0.0

data/spec/models/journaled/event_spec.rb

@@ -1,236 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Journaled::Event do
-  let(:sample_journaled_event_class_name) { 'SomeClassName' }
-  let(:sample_journaled_event_class) do
-    Class.new do
-      include Journaled::Event
-    end
-  end
-
-  before do
-    stub_const(sample_journaled_event_class_name, sample_journaled_event_class)
-  end
-
-  let(:sample_journaled_event) { sample_journaled_event_class.new }
-
-  describe '#journal!' do
-    let(:mock_journaled_writer) { instance_double(Journaled::Writer, journal!: nil) }
-
-    before do
-      allow(Journaled::Writer).to receive(:new).and_return(mock_journaled_writer)
-    end
-
-    context 'when no app job priority is set' do
-      it 'creates a Journaled::Writer with this event and journals it with the default priority' do
-        sample_journaled_event.journal!
-        expect(Journaled::Writer).to have_received(:new)
-          .with(journaled_event: sample_journaled_event)
-        expect(mock_journaled_writer).to have_received(:journal!)
-      end
-    end
-  end
-
-  describe '#journaled_schema_name' do
-    it 'returns the underscored version on the class name' do
-      expect(sample_journaled_event.journaled_schema_name).to eq 'some_class_name'
-    end
-
-    context 'when the class is modularized' do
-      let(:sample_journaled_event_class_name) { 'SomeModule::SomeClassName' }
-
-      it 'returns the underscored version on the class name' do
-        expect(sample_journaled_event.journaled_schema_name).to eq 'some_module/some_class_name'
-      end
-    end
-  end
-
-  describe '#event_type' do
-    it 'returns the underscored version on the class name' do
-      expect(sample_journaled_event.event_type).to eq 'some_class_name'
-    end
-
-    context 'when the class is modularized' do
-      let(:sample_journaled_event_class_name) { 'SomeModule::SomeClassName' }
-
-      it 'returns the underscored version on the class name, with slashes replaced with underscores' do
-        expect(sample_journaled_event.event_type).to eq 'some_module_some_class_name'
-      end
-    end
-  end
-
-  describe '#journaled_partition_key' do
-    it 'returns the #event_type' do
-      expect(sample_journaled_event.journaled_partition_key).to eq 'some_class_name'
-    end
-  end
-
-  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_stream_name).to be_nil
-    end
-
-    it 'returns the journaled default if set' do
-      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
-
-  describe '#journaled_attributes' do
-    let(:fake_uuid) { 'FAKE_UUID' }
-    let(:frozen_time) { Time.zone.parse('15/2/2017 13:00') }
-    before do
-      allow(SecureRandom).to receive(:uuid).and_return(fake_uuid).once
-    end
-    around do |example|
-      Timecop.freeze(frozen_time) { example.run }
-    end
-
-    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'
-      end
-    end
-
-    context 'when there are additional attributes specified, but not defined' do
-      let(:sample_journaled_event_class) do
-        Class.new do
-          include Journaled::Event
-
-          journal_attributes :foo
-        end
-      end
-
-      it 'raises a no method error' do
-        expect { sample_journaled_event.journaled_attributes }.to raise_error NoMethodError
-      end
-    end
-
-    context 'when there are additional attributes specified and defined' do
-      let(:sample_journaled_event_class) do
-        Class.new do
-          include Journaled::Event
-
-          journal_attributes :foo, :bar
-
-          def foo
-            'foo_return'
-          end
-
-          def bar
-            'bar_return'
-          end
-        end
-      end
-
-      it 'returns the specified attributes plus the base ones' do
-        expect(sample_journaled_event.journaled_attributes).to eq(
-          id: fake_uuid,
-          created_at: frozen_time,
-          event_type: 'some_class_name',
-          foo: 'foo_return',
-          bar: 'bar_return',
-        )
-      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
-    it 'defaults to an empty hash' do
-      expect(sample_journaled_event.journaled_enqueue_opts).to eq({})
-      expect(sample_journaled_event_class.journaled_enqueue_opts).to eq({})
-    end
-
-    context 'when there are custom opts provided' do
-      let(:sample_journaled_event_class) do
-        Class.new do
-          include Journaled::Event
-
-          journal_attributes :foo, enqueue_with: { priority: 34, foo: 'bar' }
-        end
-      end
-
-      it 'merges in the custom opts' do
-        expect(sample_journaled_event.journaled_enqueue_opts).to eq(priority: 34, foo: 'bar')
-        expect(sample_journaled_event_class.journaled_enqueue_opts).to eq(priority: 34, foo: 'bar')
-      end
-    end
-  end
-end

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

@@ -1,133 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Journaled::JsonSchemaModel::Validator do
-  subject { described_class.new schema_name }
-
-  describe '#validate!' do
-    let(:json_to_validate) { attributes_to_validate.to_json }
-    let(:attributes_to_validate) do
-      {
-        some_string: some_string_value,
-        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,
-        some_nullable_field: some_nullable_field,
-      }
-    end
-    let(:some_int_value) { 3 }
-    let(:some_string_value) { 'SOME_STRING' }
-    let(:some_optional_string_value) { 'SOME_OPTIONAL_STRING' }
-    let(:some_nullable_field) { 'VALUE' }
-
-    subject { described_class.new schema_name }
-
-    context 'when the schema name matches a schema in journaled' do
-      let(:schema_name) { :fake_json_schema_name }
-      let(:gem_path) { Journaled::Engine.root.join "journaled_schemas/#{schema_name}.json" }
-      let(:schema_path) { Rails.root.join "journaled_schemas", "#{schema_name}.json" }
-      let(:schema_file_contents) do
-        <<-JSON
-          {
-            "title": "Person",
-            "type": "object",
-            "properties": {
-              "some_string": {
-                "type": "string"
-              },
-              "some_decimal": {
-                "type": "string"
-              },
-              "some_time": {
-                "type": "string"
-              },
-              "some_int": {
-                "type": "integer"
-              },
-              "some_optional_string": {
-                "type": "string"
-              },
-              "some_nullable_field": {
-                "type": ["string", "null"]
-              }
-            },
-            "required": ["some_string", "some_decimal", "some_time", "some_int", "some_nullable_field"]
-          }
-        JSON
-      end
-
-      before do
-        allow(File).to receive(:exist?).and_call_original
-        allow(File).to receive(:exist?).with(gem_path).and_return(false)
-        allow(File).to receive(:exist?).with(schema_path).and_return(true)
-        allow(File).to receive(:read).with(schema_path).and_return(schema_file_contents)
-      end
-
-      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 be true
-          end
-        end
-
-        context 'when an optional field is missing' do
-          let(:attributes_to_validate) do
-            {
-              some_string: some_string_value,
-              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,
-            }
-          end
-
-          it 'is valid' do
-            expect(subject.validate!(json_to_validate)).to be true
-          end
-        end
-
-        context 'when a nullable field is nil' do
-          let(:some_nullable_optional_field) { nil }
-
-          it 'is valid' do
-            expect(subject.validate!(json_to_validate)).to be true
-          end
-        end
-
-        context 'but one of the required fields is of the wrong type' do
-          let(:some_int_value) { 'NOT_AN_INTEGER' }
-
-          it 'is NOT valid' do
-            expect { subject.validate! json_to_validate }.to raise_error JSON::Schema::ValidationError
-          end
-        end
-      end
-
-      context 'when not all the required fields are provided' do
-        let(:attributes_to_validate) do
-          {
-            some_string: some_string_value,
-            some_decimal: BigDecimal('0.1'),
-            some_time: Time.zone.parse('2017-01-20 15:16:17 -05:00'),
-          }
-        end
-
-        it 'is NOT valid' do
-          expect { subject.validate! json_to_validate }.to raise_error JSON::Schema::ValidationError
-        end
-      end
-    end
-
-    context 'when the schema name does not match a schema in journaled' do
-      let(:schema_name) { :nonexistent_avro_scehma }
-
-      before do
-        allow(File).to receive(:exist?).and_return(false)
-      end
-
-      it 'raises an error loading the schema' do
-        expect { subject.validate! json_to_validate }.to raise_error(/not found in any of Journaled::Engine.root,/)
-      end
-    end
-  end
-end

data/spec/models/journaled/writer_spec.rb

@@ -1,212 +0,0 @@
-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) { instance_double(event_class) }
-
-      it 'raises on initialization' do
-        expect { subject }.to raise_error RuntimeError, /An enqueued event must respond to/
-      end
-    end
-
-    context 'when the Journaled Event returns non-present values for some of the required methods' do
-      let(:journaled_event) do
-        instance_double(
-          event_class,
-          journaled_schema_name: nil,
-          journaled_attributes: {},
-          journaled_partition_key: '',
-          journaled_stream_name: nil,
-          journaled_enqueue_opts: {},
-        )
-      end
-
-      it 'raises on initialization' do
-        expect { subject }.to raise_error RuntimeError, /An enqueued event must have a non-nil response to/
-      end
-    end
-
-    context 'when the Journaled Event complies with the API' do
-      let(:journaled_event) do
-        instance_double(
-          event_class,
-          journaled_schema_name: :fake_schema_name,
-          journaled_attributes: { foo: :bar },
-          journaled_partition_key: 'fake_partition_key',
-          journaled_stream_name: nil,
-          journaled_enqueue_opts: {},
-        )
-      end
-
-      it 'does not raise on initialization' do
-        expect { subject }.not_to raise_error
-      end
-    end
-  end
-
-  describe '#journal!' do
-    let(:schema_path) { Journaled::Engine.root.join "journaled_schemas/fake_schema_name.json" }
-    let(:schema_file_contents) do
-      <<-JSON
-          {
-            "title": "Foo",
-            "type": "object",
-            "properties": {
-              "foo": {
-                "type": "string"
-              }
-            },
-            "required": ["foo"]
-          }
-      JSON
-    end
-
-    before do
-      allow(File).to receive(:exist?).and_call_original
-      allow(File).to receive(:exist?).with(schema_path).and_return(true)
-      allow(File).to receive(:read).and_call_original
-      allow(File).to receive(:read).with(schema_path).and_return(schema_file_contents)
-    end
-
-    let(:journaled_enqueue_opts) { {} }
-    let(:journaled_event) do
-      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
-
-    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)
-          .and not_journal_event_including(anything)
-        expect(enqueued_jobs.count).to eq 0
-      end
-    end
-
-    context 'when the event complies with the base_event schema' do
-      context 'when the specific json schema is NOT valid' 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)
-            .and not_journal_event_including(anything)
-          expect(enqueued_jobs.count).to eq 0
-        end
-      end
-
-      context 'when the specific json schema is also valid' 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)
-            .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
-
-        context 'when there is no job priority specified in the enqueue opts' do
-          around do |example|
-            old_priority = Journaled.job_priority
-            Journaled.job_priority = 999
-            example.run
-            Journaled.job_priority = old_priority
-          end
-
-          it 'defaults to the global default' do
-            expect { subject.journal! }.to change {
-              if Rails::VERSION::MAJOR < 6
-                enqueued_jobs.count { |j| j[:job] == Journaled::DeliveryJob }
-              else
-                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
-
-        context 'when there is a job priority specified in the enqueue opts' do
-          let(:journaled_enqueue_opts) { { priority: 13 } }
-
-          it 'enqueues a Journaled::DeliveryJob with the given priority' do
-            expect { subject.journal! }.to change {
-              if Rails::VERSION::MAJOR < 6
-                enqueued_jobs.count { |j| j[:job] == Journaled::DeliveryJob }
-              else
-                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

@@ -1,19 +0,0 @@
-# This file is copied to spec/ when you run 'rails generate rspec:install'
-ENV['RAILS_ENV'] ||= 'test'
-require 'spec_helper'
-require File.expand_path('../spec/dummy/config/environment', __dir__)
-require 'rspec/rails'
-require 'timecop'
-require 'webmock/rspec'
-require 'journaled/rspec'
-
-Dir[Rails.root.join('../support/**/*.rb')].sort.each { |f| require f }
-
-RSpec.configure do |config|
-  config.use_transactional_fixtures = true
-
-  config.infer_spec_type_from_file_location!
-
-  config.include ActiveJob::TestHelper
-  config.include EnvironmentSpecHelper
-end

data/spec/spec_helper.rb

@@ -1,24 +0,0 @@
-rails_env = ENV['RAILS_ENV'] ||= 'test'
-require 'uncruft'
-require File.expand_path('dummy/config/environment.rb', __dir__)
-
-Rails.application.config.active_record.sqlite3.represent_boolean_as_integer = true if Rails::VERSION::MAJOR < 6
-Rails.application.config.active_record.legacy_connection_handling = false if Rails::VERSION::MAJOR >= 7
-
-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__)
-end
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.order = :random
-end

data/spec/support/environment_spec_helper.rb

@@ -1,16 +0,0 @@
-module EnvironmentSpecHelper
-  def with_env(opts = {})
-    old = {}
-    opts.each do |k, v|
-      k = k.to_s
-      v = v.to_s unless v.nil?
-      old[k] = ENV[k]
-      ENV[k] = v
-    end
-    yield
-  ensure
-    old.each do |k, v|
-      ENV[k] = v
-    end
-  end
-end