journaled 2.0.0.alpha1 → 2.0.0.rc1

data/spec/models/journaled/event_spec.rb

@@ -0,0 +1,145 @@
+require 'rails_helper'
+
+RSpec.describe Journaled::Event do
+  let(:sample_journaled_event_class) do
+    SomeClassName = Class.new do
+      include Journaled::Event
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :SomeClassName) if defined?(SomeClassName)
+    Object.send(:remove_const, :SomeModule) if defined?(SomeModule)
+  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
+
+    it 'creates a Journaled::Writer with this event and journals it' 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
+
+  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) do
+        SomeModule = Module.new
+        SomeModule::SomeClassName = Class.new do
+          include Journaled::Event
+        end
+      end
+
+      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) do
+        SomeModule = Module.new
+        SomeModule::SomeClassName = Class.new do
+          include Journaled::Event
+        end
+      end
+
+      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_app_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
+    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")
+    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
+        SomeClassName = 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
+        SomeClassName = 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
+  end
+end

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

@@ -0,0 +1,133 @@
+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: 0.1.to_d,
+        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 eq true
+          end
+        end
+
+        context 'when an optional field is missing' do
+          let(:attributes_to_validate) do
+            {
+              some_string: some_string_value,
+              some_decimal: 0.1.to_d,
+              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 eq 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 eq 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: 0.1.to_d,
+            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

@@ -0,0 +1,129 @@
+require 'rails_helper'
+
+RSpec.describe Journaled::Writer do
+  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 }
+
+      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
+        double(
+          journaled_schema_name: nil,
+          journaled_attributes: {},
+          journaled_partition_key: '',
+          journaled_app_name: nil
+        )
+      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
+        double(
+          journaled_schema_name: :fake_schema_name,
+          journaled_attributes: { foo: :bar },
+          journaled_partition_key: 'fake_partition_key',
+          journaled_app_name: nil
+        )
+      end
+
+      it 'does not raise on initialization' do
+        expect { subject }.to_not 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_event) do
+      double(
+        journaled_schema_name: :fake_schema_name,
+        journaled_attributes: journaled_event_attributes,
+        journaled_partition_key: 'fake_partition_key',
+        journaled_app_name: 'my_app'
+      )
+    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
+      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
+          expect(Delayed::Job.where('handler like ?', '%Journaled::Delivery%').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
+          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'))
+        end
+
+        it 'enqueues a Journaled::Delivery object with the serialized journaled_event at the lowest priority' do
+          expect { subject.journal! }.to change {
+            Delayed::Job.where('handler like ?', '%Journaled::Delivery%').where(priority: Journaled::JobPriority::EVENTUAL).count
+          }.from(0).to(1)
+        end
+
+        context 'when the Writer was initialized with a priority' do
+          subject { described_class.new journaled_event: journaled_event, priority: Journaled::JobPriority::INTERACTIVE }
+
+          it 'enqueues the event at the given priority' do
+            expect { subject.journal! }.to change {
+              Delayed::Job.where('handler like ?', '%Journaled::Delivery%').where(priority: Journaled::JobPriority::INTERACTIVE).count
+            }.from(0).to(1)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,20 @@
+# 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'
+require 'pry-rails'
+
+Dir[Rails.root.join('..', 'support', '**', '*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+
+  config.infer_spec_type_from_file_location!
+
+  config.include DelayedJobSpecHelper
+  config.include EnvironmentSpecHelper
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+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|
+  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