journaled 2.0.0.alpha1 → 2.0.0.rc1

data/spec/models/journaled/actor_uri_provider_spec.rb

@@ -0,0 +1,41 @@
+require 'rails_helper'
+
+RSpec.describe Journaled::ActorUriProvider do
+  describe "#actor_uri" do
+    let(:request_store) { 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(RequestStore).to receive(:store).and_return(request_store)
+    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 })
+      expect(subject.actor_uri).to eq("my_fancy_gid")
+      expect(request_store).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

@@ -0,0 +1,276 @@
+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
+      }
+    )
+  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: {}
+      )
+    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)
+        }
+      )
+    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_app_name if model class doesn't respond to it" do
+      expect(subject.journaled_change_for("update", {}).journaled_app_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"
+        example.run
+        Journaled.default_app_name = orig_app_name
+      end
+
+      it "passes through default" do
+        expect(subject.journaled_change_for("update", {}).journaled_app_name).to eq("foo")
+      end
+    end
+
+    context "when model class defines journaled_app_name" do
+      before do
+        allow(model_class).to receive(:journaled_app_name).and_return("my_app")
+      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")
+      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: {}
+        )
+      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)
+          }
+        )
+      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

data/spec/models/journaled/delivery_spec.rb

@@ -0,0 +1,156 @@
+require 'rails_helper'
+
+RSpec.describe Journaled::Delivery do
+  let(:stream_name) { 'test_events' }
+  let(:partition_key) { 'fake_partition_key' }
+  let(:serialized_event) { '{"foo":"bar"}' }
+
+  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 }
+
+  describe '#perform' do
+    let!(:stubbed_request) do
+      stub_request(:post, 'https://kinesis.us-east-1.amazonaws.com').to_return(status: return_status_code, body: return_status_body)
+    end
+    let(:return_status_code) { 200 }
+    let(:return_status_body) { return_status_body_hash.to_json }
+    let(:return_status_body_hash) { { RecordId: '101' } }
+
+    let(:stubbed_body) do
+      {
+        'StreamName' => stream_name,
+        'Data' => Base64.encode64(serialized_event).strip,
+        'PartitionKey' => 'fake_partition_key'
+      }
+    end
+
+    before do
+      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
+      subject.perform
+
+      expect(stubbed_request.with(body: stubbed_body.to_json)).to have_been_requested.once
+    end
+
+    context 'when the stream name env var is NOT set' do
+      let(:stream_name) { nil }
+
+      it 'raises an KeyError error' do
+        expect { subject.perform }.to raise_error KeyError
+      end
+    end
+
+    context 'when Amazon responds with an InternalFailure' do
+      let(:return_status_code) { 500 }
+      let(:return_status_body_hash) { { __type: 'InternalFailure' } }
+
+      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
+        expect(stubbed_request).to have_been_requested.once
+      end
+    end
+
+    context 'when Amazon responds with a ServiceUnavailable' do
+      let(:return_status_code) { 503 }
+      let(:return_status_body_hash) { { __type: 'ServiceUnavailable' } }
+
+      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(stubbed_request).to have_been_requested.once
+        expect(Rails.logger).to have_received(:error).with(/\AKinesis Error/).once
+      end
+    end
+
+    context 'when we receive a 504 Gateway timeout' do
+      let(:return_status_code) { 504 }
+      let(:return_status_body) { nil }
+
+      it 'raises an error that subclasses Aws::Kinesis::Errors::ServiceError' do
+        expect { subject.perform }.to raise_error Aws::Kinesis::Errors::ServiceError
+        expect(stubbed_request).to have_been_requested.once
+      end
+    end
+
+    context 'when the IAM user does not have permission to put_record to the specified stream' do
+      let(:return_status_code) { 400 }
+      let(:return_status_body_hash) { { __type: 'AccessDeniedException' } }
+
+      it 'raises an AccessDeniedException error' do
+        expect { subject.perform }.to raise_error Aws::Kinesis::Errors::AccessDeniedException
+        expect(stubbed_request).to have_been_requested.once
+      end
+    end
+
+    context 'when the request timesout' do
+      let!(:stubbed_request) do
+        stub_request(:post, 'https://kinesis.us-east-1.amazonaws.com').to_timeout
+      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 - Networking Error occurred - Seahorse::Client::NetworkingError").once
+        expect { subject.perform }.to raise_error described_class::KinesisTemporaryFailure
+        expect(stubbed_request).to have_been_requested.once
+      end
+    end
+  end
+
+  describe "#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(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(ENV).to have_received(:fetch).with("MY_FUNKY_APP_NAME_JOURNALED_STREAM_NAME")
+      end
+    end
+  end
+
+  describe "#kinesis_client_config" do
+    it "is in us-east-1 by default" do
+      with_env(AWS_DEFAULT_REGION: nil) do
+        expect(subject.kinesis_client_config).to include(region: 'us-east-1')
+      end
+    end
+
+    it "respects AWS_DEFAULT_REGION env var" do
+      with_env(AWS_DEFAULT_REGION: 'us-west-2') do
+        expect(subject.kinesis_client_config).to include(region: 'us-west-2')
+      end
+    end
+
+    it "doesn't limit retry" do
+      expect(subject.kinesis_client_config).to include(retry_limit: 0)
+    end
+
+    it "provides no AWS credentials by default" do
+      with_env(RUBY_AWS_ACCESS_KEY_ID: nil, RUBY_AWS_SECRET_ACCESS_KEY: nil) do
+        expect(subject.kinesis_client_config).not_to have_key(:access_key_id)
+        expect(subject.kinesis_client_config).not_to have_key(:secret_access_key)
+      end
+    end
+
+    it "will use legacy credentials if specified" do
+      with_env(RUBY_AWS_ACCESS_KEY_ID: 'key_id', RUBY_AWS_SECRET_ACCESS_KEY: 'secret') do
+        expect(subject.kinesis_client_config).to include(access_key_id: 'key_id', secret_access_key: 'secret')
+      end
+    end
+  end
+end