active_interaction 5.3.0 → 5.4.0

data/spec/active_interaction/i18n_spec.rb

@@ -1,111 +0,0 @@
-RSpec.describe ActiveInteraction do
-  context 'I18n.load_path' do
-    it 'contains localization file paths' do
-      expect(I18n.load_path)
-        .to include a_string_ending_with('active_interaction/locale/en.yml')
-    end
-  end
-end
-
-I18nInteraction = Class.new(TestInteraction) do
-  hash :a do
-    hash :x
-  end
-end
-
-TYPES = ActiveInteraction::Filter
-  .const_get(:CLASSES)
-  .keys
-  .map(&:to_s)
-
-RSpec.describe I18nInteraction do
-  include_context 'interactions'
-
-  shared_examples 'translation' do |locale|
-    around do |example|
-      old_locale = I18n.locale
-      I18n.locale = locale
-
-      example.run
-
-      I18n.locale = old_locale
-    end
-
-    context 'types' do
-      TYPES.each do |type|
-        it "has a translation for #{type}" do
-          key = "#{described_class.i18n_scope}.types.#{type}"
-          expect { I18n.translate(key, raise: true) }.to_not raise_error
-        end
-      end
-    end
-
-    context 'error messages' do
-      let(:translation) { I18n.translate(key, type: type, raise: true) }
-      let(:type) { I18n.translate("#{described_class.i18n_scope}.types.hash") }
-
-      shared_examples 'translations' do |key, value|
-        context key.inspect do
-          let(:key) { "#{described_class.i18n_scope}.errors.messages.#{key}" }
-
-          before { inputs[:a] = value }
-
-          it 'has a translation' do
-            expect { translation }.to_not raise_error
-          end
-
-          it 'returns the translation' do
-            expect(outcome.errors[:a]).to include translation
-          end
-        end
-      end
-
-      include_examples 'translations', :invalid_type, Object.new
-      include_examples 'translations', :missing, nil
-    end
-  end
-
-  context 'english' do
-    include_examples 'translation', :en
-  end
-
-  context 'brazilian portuguese' do
-    include_examples 'translation', :'pt-BR'
-  end
-
-  context 'french' do
-    include_examples 'translation', :fr
-  end
-
-  context 'italian' do
-    include_examples 'translation', :it
-  end
-
-  context 'hsilgne' do
-    # This must appear before including the translation examples so that the
-    # locale is available before it is assigned.
-    around do |example|
-      old_locals = I18n.config.available_locales
-      I18n.config.available_locales += [:hsilgne]
-
-      I18n.backend.store_translations('hsilgne',
-        active_interaction: {
-          errors: {
-            messages: {
-              invalid: 'is invalid'.reverse,
-              invalid_type: "%<type>s} #{'is not a valid'.reverse}",
-              missing: 'missing'.reverse
-            }
-          },
-          types: TYPES.each_with_object({}) { |e, a| a[e] = e.reverse }
-        }
-      )
-
-      example.run
-
-      I18n.config.available_locales = old_locals
-    end
-
-    include_examples 'translation', :hsilgne
-  end
-end

data/spec/active_interaction/inputs_spec.rb

@@ -1,264 +0,0 @@
-RSpec.describe ActiveInteraction::Inputs do
-  subject(:inputs) { described_class.new(args, base_class.new) }
-
-  let(:args) { {} }
-  let(:base_class) { ActiveInteraction::Base }
-
-  describe '.reserved?(name)' do
-    it 'returns true for anything starting with "_interaction_"' do
-      expect(described_class).to be_reserved('_interaction_')
-    end
-
-    it 'returns true for existing instance methods' do
-      (
-        (ActiveInteraction::Base.instance_methods - Object.instance_methods) +
-        (ActiveInteraction::Base.private_instance_methods - Object.private_instance_methods)
-      ).each do |method|
-        expect(described_class).to be_reserved(method)
-      end
-    end
-
-    it 'returns false for anything else' do
-      expect(described_class).to_not be_reserved(SecureRandom.hex)
-    end
-  end
-
-  describe '#normalized' do
-    let(:result) { inputs.normalized }
-
-    context 'with invalid inputs' do
-      let(:args) { nil }
-
-      it 'raises an error' do
-        expect { result }.to raise_error ArgumentError
-      end
-    end
-
-    context 'with non-hash inputs' do
-      let(:args) { [%i[k v]] }
-
-      it 'raises an error' do
-        expect { result }.to raise_error ArgumentError
-      end
-    end
-
-    context 'with ActiveInteraction::Inputs inputs' do
-      let(:args) { described_class.new({ key: :value }, base_class.new) }
-
-      it 'does not raise an error' do
-        expect { result }.to_not raise_error
-      end
-    end
-
-    context 'with ActionController::Parameters inputs' do
-      let(:args) { ::ActionController::Parameters.new }
-
-      it 'does not raise an error' do
-        expect { result }.to_not raise_error
-      end
-    end
-
-    context 'with simple inputs' do
-      before { args[:key] = :value }
-
-      it 'sends them straight through' do
-        expect(result).to eql args
-      end
-    end
-
-    context 'with groupable inputs' do
-      context 'without a matching simple input' do
-        before do
-          args.merge!(
-            'key(1i)' => :value1,
-            'key(2i)' => :value2
-          )
-        end
-
-        it 'groups the inputs into a GroupedInput' do
-          expect(result).to eq(
-            key: ActiveInteraction::GroupedInput.new(
-              '1' => :value1,
-              '2' => :value2
-            )
-          )
-        end
-      end
-
-      context 'with a matching simple input' do
-        before do
-          args.merge!(
-            'key(1i)' => :value1,
-            key: :value2
-          )
-        end
-
-        it 'groups the inputs into a GroupedInput' do
-          expect(result).to eq(
-            key: ActiveInteraction::GroupedInput.new(
-              '1' => :value1
-            )
-          )
-        end
-      end
-    end
-
-    context 'with a reserved name' do
-      before { args[:_interaction_key] = :value }
-
-      it 'skips the input' do
-        expect(result).to_not have_key(:_interaction_key)
-      end
-    end
-  end
-
-  describe '#given?' do
-    let(:base_class) do
-      Class.new(ActiveInteraction::Base) do
-        float :x,
-          default: nil
-
-        def execute; end
-      end
-    end
-
-    it 'is false when the input is not given' do
-      expect(inputs.given?(:x)).to be false
-    end
-
-    it 'is true when the input is nil' do
-      args[:x] = nil
-      expect(inputs.given?(:x)).to be true
-    end
-
-    it 'is true when the input is given' do
-      args[:x] = rand
-      expect(inputs.given?(:x)).to be true
-    end
-
-    it 'symbolizes its argument' do
-      args[:x] = rand
-      expect(inputs.given?('x')).to be true
-    end
-
-    it 'only tracks inputs with filters' do
-      args[:y] = rand
-      expect(inputs.given?(:y)).to be false
-    end
-
-    context 'nested hash values' do
-      let(:base_class) do
-        Class.new(ActiveInteraction::Base) do
-          hash :x, default: {} do
-            boolean :y,
-              default: true
-          end
-
-          def execute; end
-        end
-      end
-
-      it 'is true when the nested inputs symbols are given' do
-        described_class.class_exec do
-          def execute
-            given?(:x, :y)
-          end
-        end
-
-        args[:x] = { y: false }
-        expect(inputs.given?(:x, :y)).to be true
-      end
-
-      it 'is true when the nested inputs strings are given' do
-        args['x'] = { 'y' => false }
-        expect(inputs.given?(:x, :y)).to be true
-      end
-
-      it 'is false when the nested input is not given' do
-        args[:x] = {}
-        expect(inputs.given?(:x, :y)).to be false
-      end
-
-      it 'is false when the first input is not given' do
-        expect(inputs.given?(:x, :y)).to be false
-      end
-
-      it 'is false when the first input is nil' do
-        args[:x] = nil
-        expect(inputs.given?(:x, :y)).to be false
-      end
-
-      it 'returns false if you go too far' do
-        args[:x] = { y: true }
-        expect(inputs.given?(:x, :y, :z)).to be false
-      end
-    end
-
-    context 'nested array values' do
-      let(:base_class) do
-        Class.new(ActiveInteraction::Base) do
-          array :x do
-            hash do
-              boolean :y, default: true
-            end
-          end
-
-          def execute; end
-        end
-      end
-
-      context 'has a positive index' do
-        it 'returns true if found' do
-          args[:x] = [{ y: true }]
-          expect(inputs.given?(:x, 0, :y)).to be true
-        end
-
-        it 'returns false if not found' do
-          args[:x] = []
-          expect(inputs.given?(:x, 0, :y)).to be false
-        end
-      end
-
-      context 'has a negative index' do
-        it 'returns true if found' do
-          args[:x] = [{ y: true }]
-          expect(inputs.given?(:x, -1, :y)).to be true
-        end
-
-        it 'returns false if not found' do
-          args[:x] = []
-          expect(inputs.given?(:x, -1, :y)).to be false
-        end
-      end
-
-      it 'returns false if you go too far' do
-        args[:x] = [{}]
-        expect(inputs.given?(:x, 10, :y)).to be false
-      end
-    end
-
-    context 'multi-part date values' do
-      let(:base_class) do
-        Class.new(ActiveInteraction::Base) do
-          date :thing,
-            default: nil
-
-          def execute; end
-        end
-      end
-
-      it 'returns true when the input is given' do
-        args.merge!(
-          'thing(1i)' => '2020',
-          'thing(2i)' => '12',
-          'thing(3i)' => '31'
-        )
-        expect(inputs.given?(:thing)).to be true
-      end
-
-      it 'returns false if not found' do
-        expect(inputs.given?(:thing)).to be false
-      end
-    end
-  end
-end

data/spec/active_interaction/integration/array_interaction_spec.rb

@@ -1,87 +0,0 @@
-require 'active_record'
-require 'sqlite3'
-
-ActiveRecord::Base.establish_connection(
-  adapter: 'sqlite3',
-  database: ':memory:'
-)
-
-ActiveRecord::Schema.define do
-  create_table(:lists)
-  create_table(:elements) { |t| t.column(:list_id, :integer) }
-end
-
-class List < ActiveRecord::Base
-  has_many :elements
-end
-
-class Element < ActiveRecord::Base
-  belongs_to :list
-end
-
-ArrayInteraction = Class.new(TestInteraction) do
-  array :a do
-    array
-  end
-  array :b, default: [[]] do
-    array
-  end
-end
-
-RSpec.describe ArrayInteraction do
-  include_context 'interactions'
-  it_behaves_like 'an interaction', :array, -> { [] }
-  it_behaves_like 'an interaction', :array, -> { Element.where('1 = 1') }, ->(result) { result.to_a }
-  it_behaves_like 'an interaction', :array, -> { List.create!.elements }, ->(result) { result.to_a }
-
-  context 'with inputs[:a]' do
-    let(:a) { [[]] }
-
-    before { inputs[:a] = a }
-
-    it 'returns the correct value for :a' do
-      expect(result[:a]).to eql a
-    end
-
-    it 'returns the correct value for :b' do
-      expect(result[:b]).to eql [[]]
-    end
-
-    it 'does not raise an error with an invalid nested value' do
-      inputs[:a] = [false]
-      expect { outcome }.to_not raise_error
-    end
-  end
-
-  context 'with an invalid default' do
-    it 'raises an error' do
-      expect do
-        Class.new(ActiveInteraction::Base) do
-          array :a, default: Object.new
-        end
-      end.to raise_error ActiveInteraction::InvalidDefaultError
-    end
-  end
-
-  context 'with an invalid default as a proc' do
-    it 'does not raise an error' do
-      expect do
-        Class.new(ActiveInteraction::Base) do
-          array :a, default: -> { Object.new }
-        end
-      end.to_not raise_error
-    end
-  end
-
-  context 'with an invalid nested default' do
-    it 'raises an error' do
-      expect do
-        Class.new(ActiveInteraction::Base) do
-          array :a, default: [Object.new] do
-            array
-          end
-        end
-      end.to raise_error ActiveInteraction::InvalidDefaultError
-    end
-  end
-end

data/spec/active_interaction/integration/boolean_interaction_spec.rb

@@ -1,11 +0,0 @@
-BooleanInteraction = Class.new(TestInteraction) do
-  boolean :x
-end
-
-RSpec.describe BooleanInteraction do
-  it_behaves_like 'an interaction', :boolean, -> { [false, true].sample }
-
-  it 'responds to #x?' do
-    expect(described_class.new).to respond_to(:x?)
-  end
-end

data/spec/active_interaction/integration/date_interaction_spec.rb

@@ -1,3 +0,0 @@
-RSpec.describe 'DateInteraction' do
-  it_behaves_like 'an interaction', :date, -> { Date.today }
-end

data/spec/active_interaction/integration/date_time_interaction_spec.rb

@@ -1,3 +0,0 @@
-RSpec.describe 'DateTimeInteraction' do
-  it_behaves_like 'an interaction', :date_time, -> { DateTime.now }
-end

data/spec/active_interaction/integration/file_interaction_spec.rb

@@ -1,17 +0,0 @@
-require 'action_dispatch'
-
-FileInteraction = Class.new(TestInteraction) do
-  file :a
-end
-
-RSpec.describe FileInteraction do
-  include_context 'interactions'
-  it_behaves_like 'an interaction', :file, -> { File.open(__FILE__) }
-
-  it 'works with an uploaded file' do
-    file = File.open(__FILE__)
-    uploaded_file = ActionDispatch::Http::UploadedFile.new(tempfile: file)
-    inputs[:a] = uploaded_file
-    expect(outcome).to be_valid
-  end
-end

data/spec/active_interaction/integration/float_interaction_spec.rb

@@ -1,3 +0,0 @@
-RSpec.describe 'FloatInteraction' do
-  it_behaves_like 'an interaction', :float, -> { rand }
-end

data/spec/active_interaction/integration/hash_interaction_spec.rb

@@ -1,106 +0,0 @@
-HashInteraction = Class.new(TestInteraction) do
-  hash :a do
-    hash :x
-  end
-  hash :b, default: {} do
-    hash :x, default: {}
-  end
-end
-
-RSpec.describe HashInteraction do
-  include_context 'interactions'
-  it_behaves_like 'an interaction', :hash, -> { {} }
-
-  context 'with inputs[:a]' do
-    let(:a) { { x: {} } }
-
-    before { inputs[:a] = a }
-
-    it 'returns the correct value for :a' do
-      expect(result[:a]).to eql ActiveSupport::HashWithIndifferentAccess.new(a)
-    end
-
-    it 'returns the correct value for :b' do
-      expect(result[:b]).to eql('x' => {})
-    end
-
-    it 'does not raise an error with an invalid nested value' do
-      inputs[:a] = { x: false }
-      expect { outcome }.to_not raise_error
-    end
-  end
-
-  context 'with an invalid default' do
-    it 'raises an error' do
-      expect do
-        Class.new(ActiveInteraction::Base) do
-          hash :a, default: Object.new
-        end
-      end.to raise_error ActiveInteraction::InvalidDefaultError
-    end
-  end
-
-  context 'with an invalid default as a proc' do
-    it 'does not raise an error' do
-      expect do
-        Class.new(ActiveInteraction::Base) do
-          array :a, default: -> { Object.new }
-        end
-      end.to_not raise_error
-    end
-  end
-
-  context 'with an invalid nested default' do
-    it 'raises an error with a non-empty hash' do
-      expect do
-        Class.new(ActiveInteraction::Base) do
-          hash :a, default: { x: Object.new } do
-            hash :x
-          end
-        end
-      end.to raise_error ActiveInteraction::InvalidDefaultError
-    end
-
-    it 'raises an error' do
-      expect do
-        Class.new(ActiveInteraction::Base) do
-          hash :a, default: {} do
-            hash :x
-          end
-        end
-      end.to raise_error ActiveInteraction::InvalidDefaultError
-    end
-  end
-
-  context 'with a default' do
-    context 'with a lazy nested default' do
-      it 'raises an error' do
-        expect do
-          Class.new(ActiveInteraction::Base) do
-            hash :b, default: {} do
-              hash :x, default: -> { {} }
-            end
-          end
-        end.to raise_error ActiveInteraction::InvalidDefaultError
-      end
-    end
-  end
-
-  context 'with a lazy default' do
-    context 'with a lazy nested default' do
-      it 'returns the correct value' do
-        klass = Class.new(ActiveInteraction::Base) do
-          hash :b, default: -> { {} } do
-            hash :x, default: -> { {} }
-          end
-
-          def execute
-            b
-          end
-        end
-
-        expect(klass.run!).to eql('x' => {})
-      end
-    end
-  end
-end

data/spec/active_interaction/integration/integer_interaction_spec.rb

@@ -1,3 +0,0 @@
-RSpec.describe 'IntegerInteraction' do
-  it_behaves_like 'an interaction', :integer, -> { rand(1 << 16) }
-end

data/spec/active_interaction/integration/interface_interaction_spec.rb

@@ -1,18 +0,0 @@
-require 'json'
-require 'yaml'
-
-InterfaceInteraction = Class.new(TestInteraction) do
-  interface :anything, methods: []
-end
-
-RSpec.describe InterfaceInteraction do
-  include_context 'interactions'
-  it_behaves_like 'an interaction',
-    :interface,
-    -> { [JSON, YAML].sample },
-    methods: %i[dump load]
-
-  it 'succeeds when given nil' do
-    expect { result }.to_not raise_error
-  end
-end

data/spec/active_interaction/integration/object_interaction_spec.rb

@@ -1,12 +0,0 @@
-ObjectInteraction = Class.new(TestInteraction) do
-  object :object
-end
-
-RSpec.describe ObjectInteraction do
-  include_context 'interactions'
-  it_behaves_like 'an interaction', :object, -> { // }, class: Regexp
-
-  it 'succeeds when given nil' do
-    expect { result }.to_not raise_error
-  end
-end

data/spec/active_interaction/integration/record_integration_spec.rb

@@ -1,3 +0,0 @@
-RSpec.describe 'RecordIntegration' do
-  it_behaves_like 'an interaction', :record, -> { Encoding::US_ASCII }, class: Encoding
-end

data/spec/active_interaction/integration/string_interaction_spec.rb

@@ -1,3 +0,0 @@
-RSpec.describe 'StringInteraction' do
-  it_behaves_like 'an interaction', :string, -> { SecureRandom.hex }
-end

data/spec/active_interaction/integration/symbol_interaction_spec.rb

@@ -1,3 +0,0 @@
-RSpec.describe 'SymbolInteraction' do
-  it_behaves_like 'an interaction', :symbol, -> { SecureRandom.hex.to_sym }
-end