mtk_framework 0.1.0

data/spec/active_interaction_concerns/loggable_spec.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+RSpec.describe MtkFramework::ActiveInteractionConcerns::Loggable do
+  let(:logger_output) { StringIO.new }
+  let(:logger) { Logger.new(logger_output) }
+
+  before do
+    allow(Rails).to receive(:logger).and_return(logger)
+  end
+
+  describe 'run' do
+    before do
+      application_interaction = Class.new(ActiveInteraction::Base) do
+        include MtkFramework::ActiveInteractionConcerns::Loggable
+        include MtkFramework::ActiveInteractionConcerns::Interruptable
+      end
+
+      stub_const('ApplicationInteraction', application_interaction)
+    end
+    context 'simple interaction' do
+      subject { DummyInteraction.run(params) }
+
+      before do
+        dummy_interaction = Class.new(ApplicationInteraction) do
+          integer :integer_param
+
+          validates :integer_param, numericality: { geater_than: 0 }
+
+          def execute
+            errors.add(:integer_param, :invalid) unless integer_param > 10
+          end
+        end
+
+        stub_const('DummyInteraction', dummy_interaction)
+      end
+
+      context 'type_check fails' do
+        let(:params) { {} }
+
+        it 'logs errors' do
+          expect(subject).not_to be_valid
+          expect(logger_output.string)
+            .to match %r{Interaction DummyInteraction failed: 'Integer param est obligatoire' called from: spec/active_interaction_concerns/loggable_spec\.rb} # rubocop:disable Layout/LineLength
+        end
+      end
+
+      context 'type_check succeeds' do
+        context 'validation fails' do
+          let(:params) { { integer_param: 0 } }
+
+          it 'logs errors' do
+            expect(subject).not_to be_valid
+            expect(logger_output.string)
+          end
+        end
+
+        context 'validation succeeds' do
+          context 'execution fails' do
+            let(:params) { { integer_param: 1 } }
+
+            it 'logs errors' do
+              expect(subject).not_to be_valid
+              expect(logger_output.string)
+              expect(logger_output.string)
+            end
+          end
+
+          context 'execution succeeds' do
+            let(:params) { { integer_param: 11 } }
+
+            it 'logs call' do
+              expect(subject).to be_valid
+              expect(logger_output.string)
+            end
+          end
+        end
+      end
+
+      context 'with compose' do
+        subject { DummyWithcompose.run(params) }
+
+        before do
+          dummy_with_compose = Class.new(ApplicationInteraction) do
+            integer :integer_param
+
+            def execute
+              compose(DummyInteraction, integer_param: integer_param)
+            end
+          end
+
+          stub_const('DummyWithcompose', dummy_with_compose)
+        end
+
+        context 'succeeds' do
+          let(:params) { { integer_param: 11 } }
+
+          it 'works' do
+            expect(subject).to be_valid
+            expect(logger_output.string)
+            expect(logger_output.string)
+              .to include 'Interaction DummyInteraction [{:integer_param=>11}] called from spec/active_interaction_concerns/loggable_spec.rb' # rubocop:disable Layout/LineLength
+          end
+        end
+
+        context 'compose execution fails' do
+          let(:params) { { integer_param: 0 } }
+
+          it 'logs failures for each interaction' do
+            expect(subject).not_to be_valid
+            expect(logger_output.string).to include 'Interaction DummyInteraction failed'
+          end
+        end
+      end
+    end
+
+    context 'interrupted' do
+      subject { DummyInterrupted.run }
+
+      before do
+        dummy_interaction = Class.new(ApplicationInteraction) do
+          def execute
+            interrupt_execute! :base, :invalid
+          end
+        end
+
+        stub_const('DummyInterrupted', dummy_interaction)
+      end
+
+      it 'works' do
+        expect(subject).not_to be_valid
+        expect(logger_output.string)
+          .to include 'Interaction DummyInterrupted [] called from spec/active_interaction_concerns/loggable_spec.rb' # rubocop:disable Layout/LineLength
+        expect(logger_output.string)
+          .to include "Interaction DummyInterrupted failed: 'est invalide' called from: spec/active_interaction_concerns/loggable_spec.rb" # rubocop:disable Layout/LineLength
+      end
+    end
+
+    context 'run! interrupted' do
+      subject { DummyInterrupted.run! }
+
+      before do
+        dummy_interaction = Class.new(ApplicationInteraction) do
+          def execute
+            interrupt_execute! :base, :invalid
+          end
+        end
+
+        stub_const('DummyInterrupted', dummy_interaction)
+      end
+
+      it 'works' do
+        expect { subject }.to raise_error ActiveInteraction::InvalidInteractionError, 'est invalide'
+        expect(logger_output.string)
+          .to include 'Interaction DummyInterrupted [] called from spec/active_interaction_concerns/loggable_spec.rb' # rubocop:disable Layout/LineLength
+        expect(logger_output.string)
+          .to include "Interaction DummyInterrupted failed: 'est invalide' called from: spec/active_interaction_concerns/loggable_spec.rb" # rubocop:disable Layout/LineLength
+      end
+    end
+
+    context 'filtering logs' do
+      subject { DummyInteraction.run(params) }
+
+      let(:params) do
+        {
+          password: 'super secret',
+          bank_account: {
+            name: 'name_value'
+          },
+          not_filtered: 'value'
+        }
+      end
+
+      before do
+        dummy_interaction = Class.new(ApplicationInteraction) do
+          string :password
+          hash :bank_account do
+            string :name
+          end
+          string :not_filtered
+
+          def execute; end
+        end
+
+        stub_const('DummyInteraction', dummy_interaction)
+      end
+
+      it 'logs call filtering params' do
+        expect(subject).to be_valid
+        x = logger_output.string
+        expect(logger_output.string)
+          .to include 'Interaction DummyInteraction [{:password=>"[FILTERED]", :bank_account=>{:name=>"[FILTERED]"}, :not_filtered=>"value"}] called from spec/active_interaction_concerns/loggable_spec.rb' # rubocop:disable Layout/LineLength
+      end
+    end
+  end
+end

data/spec/application_interaction_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# require_relative 'spec_helper'
+# require 'active_interaction'
+# require 'mtk_framework'
+# require 'pry'
+
+class ApplicationInteraction < ActiveInteraction::Base
+  include MtkFramework::ActiveInteractionConcerns::I18nable
+  include MtkFramework::ActiveInteractionConcerns::Interruptable
+  include MtkFramework::ActiveInteractionConcerns::Loggable
+  include MtkFramework::ActiveInteractionConcerns::Rescuable
+  include MtkFramework::ActiveInteractionConcerns::UpdatableObject
+end
+
+RSpec.describe ApplicationInteraction do
+end

data/spec/fake_app.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Dummy
+  class Application < Rails::Application
+    config.eager_load = false
+    config.root = ''
+    config.filter_parameters = ['password', 'bank_account.name']
+    config.i18n.default_locale = :fr
+  end
+end
+
+Rails.logger = Logger.new('/dev/null')
+
+Rails.application.initialize!

data/spec/gem_extensions/active_interaction/filters/tz_account_filter_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe ActiveInteraction::TzAccountFilter, :filter do # rubocop: disable RSpec/FilePath
+  it_behaves_like "a tz filter",
+                  valid: [Faker::Blockchain::Tezos.account],
+                  invalid: ["invalid", Faker::Blockchain::Tezos.secret_key]
+end

data/spec/gem_extensions/active_interaction/filters/tz_contract_address_filter_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe ActiveInteraction::TzContractAddressFilter, :filter do # rubocop: disable RSpec/FilePath
+  it_behaves_like "a tz filter",
+                  valid: [Faker::Blockchain::Tezos.contract],
+                  invalid: ["invalid", Faker::Blockchain::Tezos.secret_key]
+end

data/spec/gem_extensions/active_interaction/filters/tz_operation_filter_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe ActiveInteraction::TzOperationFilter, :filter do # rubocop: disable RSpec/FilePath
+  it_behaves_like "a tz filter",
+                  valid: [Faker::Blockchain::Tezos.operation],
+                  invalid: ["invalid", Faker::Blockchain::Tezos.secret_key]
+end

data/spec/gem_extensions/active_interaction/filters/tz_public_key_filter_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe ActiveInteraction::TzPublicKeyFilter, :filter do # rubocop: disable RSpec/FilePath
+  it_behaves_like "a tz filter",
+                  valid: [Faker::Blockchain::Tezos.public_key],
+                  invalid: ["invalid", Faker::Blockchain::Tezos.secret_key]
+end

data/spec/gem_extensions/active_interaction/filters/tz_secret_key_filter_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe ActiveInteraction::TzSecretKeyFilter, :filter do # rubocop: disable RSpec/FilePath
+  it_behaves_like "a tz filter",
+                  valid: [Faker::Blockchain::Tezos.secret_key],
+                  invalid: ["invalid", 10, Faker::Blockchain::Tezos.public_key]
+end

data/spec/gem_extensions/active_interaction/filters/tz_signature_filter_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe ActiveInteraction::TzSignatureFilter, :filter do # rubocop: disable RSpec/FilePath
+  it_behaves_like "a tz filter",
+                  valid: [Faker::Blockchain::Tezos.signature],
+                  invalid: ["invalid", 10, Faker::Blockchain::Tezos.public_key]
+end

data/spec/gem_extensions/active_interaction/filters_shared.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+RSpec.shared_context "filters" do
+  subject(:filter) { described_class.new(name, options, &block) }
+
+  let(:block) { nil }
+  let(:name) { SecureRandom.hex.to_sym }
+  let(:options) { {} }
+
+  shared_context "optional" do
+    before do
+      options[:default] = nil
+    end
+  end
+
+  shared_context "required" do
+    before do
+      options.delete(:default)
+    end
+  end
+end
+
+RSpec.shared_examples_for "a filter" do
+  include_context "filters"
+
+  describe ".factory" do
+    context "with an invalid slug" do
+      it "raises an error" do
+        expect do
+          described_class.factory(:invalid)
+        end.to raise_error ActiveInteraction::MissingFilterError
+      end
+    end
+
+    context "with a valid slug" do
+      it "returns a Filter" do
+        expect(
+          described_class.factory(described_class.slug)
+        ).to eql described_class
+      end
+    end
+  end
+
+  describe ".slug" do
+    it "returns a symbol" do
+      expect(described_class.slug).to be_a Symbol
+    end
+  end
+
+  describe "#cast" do
+    let(:value) { nil }
+    let(:result) { filter.send(:cast, value, nil) }
+
+    context "optional" do
+      include_context "optional"
+
+      it "returns nil" do
+        expect(result).to be_nil
+      end
+    end
+
+    context "required" do
+      include_context "required"
+
+      it "raises an error" do
+        expect { result }.to raise_error ActiveInteraction::MissingValueError
+      end
+
+      context "with an invalid default" do
+        let(:value) { Object.new }
+
+        it "raises an error" do
+          expect { result }.to raise_error ActiveInteraction::InvalidValueError
+        end
+      end
+    end
+
+    # BasicObject is missing a lot of methods
+    context "with a BasicObject" do
+      let(:value) { BasicObject.new }
+
+      it "raises an error" do
+        expect { result }.to raise_error ActiveInteraction::InvalidValueError
+      end
+    end
+  end
+
+  describe "#clean" do
+    let(:value) { nil }
+
+    context "optional" do
+      include_context "optional"
+
+      it "returns the default" do
+        expect(filter.clean(value, nil)).to eql options[:default]
+      end
+    end
+
+    context "required" do
+      include_context "required"
+
+      it "raises an error" do
+        expect do
+          filter.clean(value, nil)
+        end.to raise_error ActiveInteraction::MissingValueError
+      end
+
+      context "with an invalid value" do
+        let(:value) { Object.new }
+
+        it "raises an error" do
+          expect do
+            filter.clean(value, nil)
+          end.to raise_error ActiveInteraction::InvalidValueError
+        end
+      end
+    end
+
+    context "with an invalid default" do
+      before do
+        options[:default] = Object.new
+      end
+
+      it "raises an error" do
+        expect do
+          filter.clean(value, nil)
+        end.to raise_error ActiveInteraction::InvalidDefaultError
+      end
+    end
+  end
+
+  describe "#default" do
+    context "optional" do
+      include_context "optional"
+
+      it "returns the default" do
+        expect(filter.default(nil)).to eql options[:default]
+      end
+    end
+
+    context "required" do
+      include_context "required"
+
+      it "raises an error" do
+        expect do
+          filter.default(nil)
+        end.to raise_error ActiveInteraction::NoDefaultError
+      end
+    end
+
+    context "with an invalid default" do
+      before do
+        options[:default] = Object.new
+      end
+
+      it "raises an error" do
+        expect do
+          filter.default(nil)
+        end.to raise_error ActiveInteraction::InvalidDefaultError
+      end
+    end
+
+    context "with a callable default" do
+      include_context "optional"
+
+      before do
+        default = options[:default]
+        options[:default] = -> { default }
+      end
+
+      it "returns the default" do
+        expect(filter.default(nil)).to eql options[:default].call
+      end
+    end
+
+    context "with a callable default that takes an argument" do
+      include_context "optional"
+
+      it "returns the default" do
+        default = options[:default]
+
+        spec = self
+        filter # Necessary to bring into scope for lambda.
+        options[:default] = ->(this) do
+          spec.expect(this).to be filter
+          default
+        end
+
+        expect(filter.default(nil)).to be default
+      end
+    end
+  end
+
+  describe "#desc" do
+    it "returns nil" do
+      expect(filter.desc).to be_nil
+    end
+
+    context "with a description" do
+      let(:desc) { SecureRandom.hex }
+
+      before do
+        options[:desc] = desc
+      end
+
+      it "returns the description" do
+        expect(filter.desc).to eql desc
+      end
+    end
+  end
+
+  describe "#filters" do
+    it "returns Hash" do
+      expect(filter.filters).to be_a Hash
+    end
+  end
+
+  describe "#default?" do
+    context "optional" do
+      include_context "optional"
+
+      it "returns true" do
+        expect(filter).to be_default
+      end
+    end
+
+    context "required" do
+      include_context "required"
+
+      it "returns false" do
+        expect(filter).not_to be_default
+      end
+    end
+  end
+
+  describe "#name" do
+    it "returns the name" do
+      expect(filter.name).to eql name
+    end
+  end
+
+  describe "#options" do
+    it "returns the options" do
+      expect(filter.options).to eql options
+    end
+  end
+
+  describe "#database_column_type" do
+    it "returns a symbol" do
+      expect(filter.database_column_type).to be_a Symbol
+    end
+  end
+end