journaled 4.1.0 → 5.0.0

data/spec/lib/journaled_spec.rb

@@ -1,91 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Journaled do
-  it "is enabled in production" do
-    allow(Rails).to receive(:env).and_return("production")
-    expect(described_class).to be_enabled
-  end
-
-  it "is disabled in development" do
-    allow(Rails).to receive(:env).and_return("development")
-    expect(described_class).not_to be_enabled
-  end
-
-  it "is disabled in test" do
-    allow(Rails).to receive(:env).and_return("test")
-    expect(described_class).not_to be_enabled
-  end
-
-  it "is enabled in whatevs" do
-    allow(Rails).to receive(:env).and_return("whatevs")
-    expect(described_class).to be_enabled
-  end
-
-  it "is enabled when explicitly enabled in development" do
-    with_env(JOURNALED_ENABLED: true) do
-      allow(Rails).to receive(:env).and_return("development")
-      expect(described_class).to be_enabled
-    end
-  end
-
-  it "is disabled when explicitly disabled in production" do
-    with_env(JOURNALED_ENABLED: false) do
-      allow(Rails).to receive(:env).and_return("production")
-      expect(described_class).not_to be_enabled
-    end
-  end
-
-  it "is disabled when explicitly disabled with empty string" do
-    with_env(JOURNALED_ENABLED: '') do
-      allow(Rails).to receive(:env).and_return("production")
-      expect(described_class).not_to be_enabled
-    end
-  end
-
-  describe "#actor_uri" do
-    it "delegates to ActorUriProvider" do
-      allow(Journaled::ActorUriProvider).to receive(:instance)
-        .and_return(instance_double(Journaled::ActorUriProvider, actor_uri: "my actor uri"))
-      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

@@ -1,47 +0,0 @@
-require 'rails_helper'
-
-# This is a controller mixin, but testing as a model spec!
-RSpec.describe Journaled::Actor do
-  let(:user) { double("User") }
-  let(:klass) do
-    Class.new do
-      cattr_accessor(:before_actions) { [] }
-
-      def self.before_action(method_name, _opts)
-        before_actions << method_name
-      end
-
-      include Journaled::Actor
-
-      self.journaled_actor = :current_user
-
-      def current_user
-        nil
-      end
-
-      def trigger_before_actions
-        before_actions.each { |method_name| send(method_name) }
-      end
-    end
-  end
-
-  subject { klass.new }
-
-  it "Stores a thunk returning nil if current_user returns nil" do
-    subject.trigger_before_actions
-
-    allow(subject).to receive(:current_user).and_return(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
-    subject.trigger_before_actions
-
-    allow(subject).to receive(:current_user).and_return(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

@@ -1,106 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Journaled::Changes do
-  let(:klass) do
-    Class.new do
-      cattr_accessor :after_create_hooks
-      self.after_create_hooks = []
-      cattr_accessor :after_save_hooks
-      self.after_save_hooks = []
-      cattr_accessor :after_destroy_hooks
-      self.after_destroy_hooks = []
-
-      def self.after_create(&hook)
-        after_create_hooks << hook
-      end
-
-      def self.after_save(opts, &hook)
-        # This is a back-door assertion to prevent regressions in the module's hook definition behavior
-        raise "expected `unless: :saved_change_to_id?`" unless opts[:unless] == :saved_change_to_id?
-
-        after_save_hooks << hook
-      end
-
-      def self.after_destroy(&hook)
-        after_destroy_hooks << hook
-      end
-
-      include Journaled::Changes
-      journal_changes_to :my_heart, as: :change_of_heart
-
-      def trigger_after_create_hooks
-        after_create_hooks.each { |proc| instance_eval(&proc) }
-      end
-
-      def trigger_after_save_hooks
-        after_save_hooks.each { |proc| instance_eval(&proc) }
-      end
-
-      def trigger_after_destroy_hooks
-        after_destroy_hooks.each { |proc| instance_eval(&proc) }
-      end
-    end
-  end
-
-  subject { klass.new }
-
-  let(:change_writer) { double(Journaled::ChangeWriter, create: true, update: true, delete: true) }
-
-  before do
-    allow(Journaled::ChangeWriter).to receive(:new) do |opts|
-      expect(opts[:model]).to eq(subject)
-      expect(opts[:change_definition].logical_operation).to eq(:change_of_heart)
-      change_writer
-    end
-  end
-
-  it "can be asserted on with our matcher" do
-    expect(klass).to journal_changes_to(:my_heart, as: :change_of_heart)
-
-    expect(klass).not_to journal_changes_to(:foobaloo, as: :an_event_to_remember)
-
-    expect {
-      expect(klass).to journal_changes_to(:foobaloo, as: :an_event_to_remember)
-    }.to raise_error(/> to journal changes to :foobaloo as :an_event_to_remember/)
-
-    expect {
-      expect(klass).not_to journal_changes_to(:my_heart, as: :change_of_heart)
-    }.to raise_error(/> not to journal changes to :my_heart as :change_of_heart/)
-  end
-
-  it "has a single change definition" do
-    expect(klass._journaled_change_definitions.length).to eq 1
-  end
-
-  it "journals create events on create" do
-    subject.trigger_after_create_hooks
-
-    expect(change_writer).to have_received(:create)
-    expect(Journaled::ChangeWriter).to have_received(:new)
-  end
-
-  it "journals update events on save" do
-    subject.trigger_after_save_hooks
-
-    expect(change_writer).to have_received(:update)
-    expect(Journaled::ChangeWriter).to have_received(:new)
-  end
-
-  it "journals delete events on destroy" do
-    subject.trigger_after_destroy_hooks
-
-    expect(change_writer).to have_received(:delete)
-    expect(Journaled::ChangeWriter).to have_received(:new)
-  end
-
-  context 'when DJ opts are provided' do
-    before do
-      klass.journal_changes_to :thing, as: :other_thing, enqueue_with: { asdf: 1, foo: 'bar' }
-    end
-
-    it 'sets them on the model' do
-      expect(klass.journaled_enqueue_opts).to eq(asdf: 1, foo: 'bar')
-      expect(klass.new.journaled_enqueue_opts).to eq(asdf: 1, foo: 'bar')
-    end
-  end
-end

data/spec/models/database_change_protection_spec.rb

@@ -1,109 +0,0 @@
-require 'rails_helper'
-
-if Rails::VERSION::MAJOR > 5 || (Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR >= 2)
-  # rubocop:disable Rails/SkipsModelValidations
-  RSpec.describe "Raw database change protection" do
-    let(:journaled_class) do
-      Class.new(ActiveRecord::Base) do
-        include Journaled::Changes
-
-        self.table_name = 'widgets'
-
-        journal_changes_to :name, as: :attempt
-      end
-    end
-
-    let(:journaled_class_with_no_journaled_columns) 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(name: nil) }.to raise_error(/aborted by Journaled/)
-        end
-
-        it "refuses on journaled columns passed as string" do
-          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(other_column: "") }.not_to raise_error
-        end
-
-        it "succeeds when forced on journaled columns" do
-          expect { journaled_class.update_all({ name: nil }, force: true) }.not_to raise_error
-        end
-      end
-
-      describe "#delete" do
-        it "refuses if journaled columns exist" do
-          expect { journaled_class.delete(1) }.to raise_error(/aborted by Journaled/)
-        end
-
-        it "succeeds if no journaled columns exist" do
-          expect { journaled_class_with_no_journaled_columns.delete(1) }.not_to raise_error
-        end
-
-        it "succeeds if journaled columns exist when forced" do
-          expect { journaled_class.delete(1, force: true) }.not_to raise_error
-        end
-      end
-
-      describe "#delete_all" do
-        it "refuses if journaled columns exist" do
-          expect { journaled_class.delete_all }.to raise_error(/aborted by Journaled/)
-        end
-
-        it "succeeds if no journaled columns exist" do
-          expect { journaled_class_with_no_journaled_columns.delete_all }.not_to raise_error
-        end
-
-        it "succeeds if journaled columns exist when forced" do
-          expect { journaled_class.delete_all(force: true) }.not_to raise_error
-        end
-      end
-    end
-
-    describe "an instance" do
-      subject { journaled_class.create!(name: 'foo') }
-
-      describe "#update_columns" do
-        it "refuses on journaled columns" do
-          expect { subject.update_columns(name: nil) }.to raise_error(/aborted by Journaled/)
-        end
-
-        it "succeeds on unjournaled columns" do
-          expect { subject.update_columns(other_column: "") }.not_to raise_error
-        end
-
-        it "succeeds when forced on journaled columns" do
-          expect { subject.update_columns({ name: nil }, force: true) }.not_to raise_error
-        end
-      end
-
-      describe "#delete" do
-        it "refuses if journaled columns exist" do
-          expect { subject.delete }.to raise_error(/aborted by Journaled/)
-        end
-
-        it "succeeds if no journaled columns exist" do
-          instance = journaled_class_with_no_journaled_columns.create!
-          expect { instance.delete }.not_to raise_error
-        end
-
-        it "succeeds if journaled columns exist when forced" do
-          expect { subject.delete(force: true) }.not_to raise_error
-        end
-      end
-    end
-  end
-  # rubocop:enable Rails/SkipsModelValidations
-end

data/spec/models/journaled/actor_uri_provider_spec.rb

@@ -1,42 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Journaled::ActorUriProvider do
-  describe "#actor_uri" do
-    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" }
-
-    subject { described_class.instance }
-
-    around do |example|
-      orig_program_name = $PROGRAM_NAME
-      $PROGRAM_NAME = program_name
-      example.run
-      $PROGRAM_NAME = orig_program_name
-    end
-
-    before do
-      allow(Journaled::Current.instance)
-        .to receive(:attributes).and_return(current_attributes)
-    end
-
-    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(current_attributes).to have_received(:[]).with(:journaled_actor_proc)
-    end
-
-    context "when running in rake" do
-      let(:program_name) { "rake" }
-      it "slurps up command line username if available" do
-        allow(Etc).to receive(:getlogin).and_return("my_unix_username")
-        expect(subject.actor_uri).to eq("gid://local/my_unix_username")
-      end
-    end
-
-    it "falls back to printing out a GID of bare app name" do
-      expect(subject.actor_uri).to eq("gid://dummy")
-    end
-  end
-end

data/spec/models/journaled/change_writer_spec.rb

@@ -1,281 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Journaled::ChangeWriter do
-  let(:model) do
-    now = Time.zone.now
-    double(
-      "Soldier",
-      id: 28_473,
-      class: model_class,
-      attributes: {
-        "name" => "bob",
-        "rank" => "first lieutenant",
-        "serial_number" => "foobar",
-        "last_sign_in_at" => now,
-      },
-      saved_changes: {
-        "name" => %w(bill bob),
-        "last_sign_in_at" => now,
-      },
-      journaled_enqueue_opts: {},
-    )
-  end
-
-  let(:model_class) do
-    double(
-      "SoldierClass",
-      table_name: "soldiers",
-      attribute_names: %w(id name rank serial_number last_sign_in_at),
-    )
-  end
-
-  let(:change_definition) do
-    Journaled::ChangeDefinition.new(
-      attribute_names: %i(name rank serial_number),
-      logical_operation: "identity_change",
-    )
-  end
-
-  let(:faulty_change_definition) do
-    Journaled::ChangeDefinition.new(
-      attribute_names: %i(name rank serial_number nonexistent_thingie),
-      logical_operation: "identity_change",
-    )
-  end
-
-  subject { described_class.new(model: model, change_definition: change_definition) }
-
-  it "fails to instantiate with an undefined attribute_name" do
-    expect { described_class.new(model: model, change_definition: faulty_change_definition) }.to raise_error(/\bnonexistent_thingie\n/)
-  end
-
-  describe "#relevant_attributes" do
-    let(:model) do
-      double(
-        "Soldier",
-        id: 28_473,
-        class: model_class,
-        attributes: {
-          "name" => "bill",
-          "rank" => "first lieutenant",
-          "serial_number" => "foobar",
-          "last_sign_in_at" => Time.zone.now,
-        },
-        saved_changes: {},
-        journaled_enqueue_opts: {},
-      )
-    end
-
-    it "returns all relevant attributes regardless of saved changes" do
-      expect(subject.relevant_attributes).to eq(
-        "name" => "bill",
-        "rank" => "first lieutenant",
-        "serial_number" => "foobar",
-      )
-    end
-  end
-
-  describe "#relevant_unperturbed_attributes" do
-    let(:model) do
-      double(
-        "Soldier",
-        id: 28_473,
-        class: model_class,
-        attributes: {
-          "name" => "bill",
-          "rank" => "first lieutenant",
-          "serial_number" => "foobar",
-          "last_sign_in_at" => Time.zone.now,
-        },
-        changes: {
-          "name" => %w(bob bill),
-        },
-        journaled_enqueue_opts: {},
-      )
-    end
-
-    it "returns the pre-change value of the attributes, regardless of whether they changed" do
-      expect(subject.relevant_unperturbed_attributes).to eq(
-        "name" => "bob",
-        "rank" => "first lieutenant",
-        "serial_number" => "foobar",
-      )
-    end
-  end
-
-  describe "#relevant_changed_attributes" do
-    it "returns only relevant changes" do
-      expect(subject.relevant_changed_attributes).to eq("name" => "bob")
-    end
-  end
-
-  describe "#actor_uri" do
-    it "delegates to ActorUriProvider" do
-      allow(Journaled::ActorUriProvider).to receive(:instance).and_return(double(actor_uri: "my actor uri"))
-      expect(Journaled.actor_uri).to eq "my actor uri"
-    end
-  end
-
-  describe "#journaled_change_for" do
-    it "stores passed changes serialized to json" do
-      expect(subject.journaled_change_for("update", "name" => "bob").changes).to eq('{"name":"bob"}')
-    end
-
-    it "stores the model's table_name" do
-      expect(subject.journaled_change_for("update", {}).table_name).to eq("soldiers")
-    end
-
-    it "converts the model's record_id to a string" do
-      expect(subject.journaled_change_for("update", {}).record_id).to eq("28473")
-    end
-
-    it "stuffs the database operation directly" do
-      expect(subject.journaled_change_for("update", {}).database_operation).to eq("update")
-      expect(subject.journaled_change_for("delete", {}).database_operation).to eq("delete")
-    end
-
-    it "includes logical_operation" do
-      expect(subject.journaled_change_for("update", {}).logical_operation).to eq("identity_change")
-    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)
-    end
-
-    context "with journaled default app name set" do
-      around do |example|
-        orig_app_name = Journaled.default_stream_name
-        Journaled.default_stream_name = "foo"
-        example.run
-        Journaled.default_stream_name = orig_app_name
-      end
-
-      it "passes through default" do
-        expect(subject.journaled_change_for("update", {}).journaled_stream_name).to eq("foo")
-      end
-    end
-
-    context "when model class defines journaled_stream_name" do
-      before do
-        allow(model_class).to receive(:journaled_stream_name).and_return("my_app_events")
-      end
-
-      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
-
-  context "with journaling stubbed" do
-    let(:journaled_change) { instance_double(Journaled::Change, journal!: true) }
-
-    before do
-      allow(Journaled::Change).to receive(:new).and_return(nil) # must be restubbed to work in context
-    end
-
-    describe "#create" do
-      let(:model) do
-        double(
-          "Soldier",
-          id: 28_473,
-          class: model_class,
-          attributes: {
-            "name" => "bill",
-            "rank" => "first lieutenant",
-            "serial_number" => "foobar",
-            "last_sign_in_at" => Time.zone.now,
-          },
-          saved_changes: {},
-          journaled_enqueue_opts: {},
-        )
-      end
-
-      it "always journals all relevant attributes, even if unchanged" do
-        allow(Journaled::Change).to receive(:new) do |opts|
-          expect(opts[:changes]).to eq '{"name":"bill","rank":"first lieutenant","serial_number":"foobar"}'
-          journaled_change
-        end
-
-        subject.create
-
-        expect(Journaled::Change).to have_received(:new)
-        expect(journaled_change).to have_received(:journal!)
-      end
-    end
-
-    describe "#update" do
-      it "journals only relevant changes" do
-        allow(Journaled::Change).to receive(:new) do |opts|
-          expect(opts[:changes]).to eq '{"name":"bob"}'
-          journaled_change
-        end
-
-        subject.update
-
-        expect(Journaled::Change).to have_received(:new)
-        expect(journaled_change).to have_received(:journal!)
-      end
-
-      context "with no changes" do
-        let(:model) do
-          double(
-            "Soldier",
-            id: 28_473,
-            class: model_class,
-            attributes: {
-              "name" => "bill",
-              "rank" => "first lieutenant",
-              "serial_number" => "foobar",
-              "last_sign_in_at" => Time.zone.now,
-            },
-            saved_changes: {},
-          )
-        end
-
-        it "doesn't journal" do
-          subject.update
-
-          expect(Journaled::Change).not_to have_received(:new)
-          expect(journaled_change).not_to have_received(:journal!)
-        end
-      end
-    end
-
-    describe "#delete" do
-      let(:model) do
-        now = Time.zone.now
-        double(
-          "Soldier",
-          id: 28_473,
-          class: model_class,
-          attributes: {
-            "name" => "bob",
-            "rank" => "first lieutenant",
-            "serial_number" => "foobar",
-            "last_sign_in_at" => now,
-          },
-          changes: {
-            "name" => %w(bill bob),
-          },
-          journaled_enqueue_opts: {},
-        )
-      end
-
-      it "journals the unperturbed values of all relevant attributes" do
-        allow(Journaled::Change).to receive(:new) do |opts|
-          expect(JSON.parse(opts[:changes])).to eq(
-            "name" => "bill",
-            "rank" => "first lieutenant",
-            "serial_number" => "foobar",
-          )
-          journaled_change
-        end
-
-        subject.delete
-
-        expect(Journaled::Change).to have_received(:new)
-        expect(journaled_change).to have_received(:journal!)
-      end
-    end
-  end
-end