active_interaction 5.1.0 → 5.5.0

data/spec/active_interaction/filters/time_filter_spec.rb

@@ -1,251 +0,0 @@
-require 'spec_helper'
-
-describe ActiveInteraction::TimeFilter, :filter do
-  include_context 'filters'
-  it_behaves_like 'a filter'
-
-  shared_context 'with format' do
-    let(:format) { '%d/%m/%Y %H:%M:%S %z' }
-
-    before do
-      options[:format] = format
-    end
-  end
-
-  describe '#initialize' do
-    context 'with a format' do
-      before { options[:format] = '%T' }
-
-      context 'with a time zone' do
-        before do
-          time_with_zone = double
-
-          time_zone = double
-          allow(time_zone).to receive(:at).and_return(time_with_zone)
-
-          allow(Time).to receive(:zone).and_return(time_zone)
-        end
-
-        it 'raises an error' do
-          expect do
-            filter
-          end.to raise_error(ActiveInteraction::InvalidFilterError)
-        end
-      end
-    end
-  end
-
-  describe '#process' do
-    let(:result) { filter.process(value, nil) }
-
-    context 'with a Time' do
-      let(:value) { Time.new }
-
-      it 'returns the Time' do
-        expect(result.value).to eql value
-      end
-    end
-
-    context 'with a String' do
-      let(:value) { '2011-12-13 14:15:16 +1718' }
-
-      it 'returns a Time' do
-        expect(result.value).to eql Time.parse(value)
-      end
-
-      context 'with a time zone' do
-        before do
-          klass = double
-          allow(klass).to receive(:parse).with(value).and_return(nil)
-
-          allow(filter).to receive(:matches?).and_return(false)
-          allow(filter).to receive(:klass).and_return(klass)
-        end
-
-        it 'indicates an error the string is not parsable' do
-          error = result.errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :invalid_type
-        end
-      end
-
-      context 'with format' do
-        include_context 'with format'
-
-        let(:value) { '13/12/2011 14:15:16 +1718' }
-
-        it 'returns a Time' do
-          expect(result.value).to eql Time.strptime(value, format)
-        end
-      end
-    end
-
-    context 'with an invalid String' do
-      let(:value) { 'invalid' }
-
-      it 'indicates an error' do
-        error = result.errors.first
-
-        expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-        expect(error.type).to be :invalid_type
-      end
-
-      context 'with format' do
-        include_context 'with format'
-
-        it 'indicates an error' do
-          error = result.errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :invalid_type
-        end
-      end
-    end
-
-    context 'with an implicit String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            '2011-12-13 14:15:16 +1718'
-          end
-        end.new
-      end
-
-      it 'returns a Time' do
-        expect(result.value).to eql Time.parse(value)
-      end
-    end
-
-    context 'with a blank String' do
-      let(:value) do
-        Class.new do
-          def to_str
-            ' '
-          end
-        end.new
-      end
-
-      context 'optional' do
-        include_context 'optional'
-
-        it 'returns the default' do
-          expect(result.value).to eql options[:default]
-        end
-      end
-
-      context 'required' do
-        include_context 'required'
-
-        it 'indicates an error' do
-          error = result.errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :missing
-        end
-      end
-    end
-
-    context 'with an Integer' do
-      let(:value) { rand(1 << 16) }
-
-      it 'returns the Time' do
-        expect(result.value).to eql Time.at(value)
-      end
-    end
-
-    context 'with an implicit Integer' do
-      let(:value) do
-        Class.new do
-          def to_int
-            @to_int ||= rand(1 << 16)
-          end
-        end.new
-      end
-
-      it 'returns the Time' do
-        expect(result.value).to eql Time.at(value)
-      end
-    end
-
-    context 'with a GroupedInput' do
-      let(:year) { 2012 }
-      let(:month) { 1 }
-      let(:day) { 2 }
-      let(:hour) { 3 }
-      let(:min) { 4 }
-      let(:sec) { 5 }
-      let(:value) do
-        ActiveInteraction::GroupedInput.new(
-          '1' => year.to_s,
-          '2' => month.to_s,
-          '3' => day.to_s,
-          '4' => hour.to_s,
-          '5' => min.to_s,
-          '6' => sec.to_s
-        )
-      end
-
-      it 'returns a Time' do
-        expect(
-          result.value
-        ).to eql Time.new(year, month, day, hour, min, sec)
-      end
-    end
-
-    context 'with an invalid GroupedInput' do
-      context 'empty' do
-        let(:value) { ActiveInteraction::GroupedInput.new }
-
-        it 'indicates an error' do
-          error = result.errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :invalid_type
-        end
-      end
-
-      context 'partial inputs' do
-        let(:value) do
-          ActiveInteraction::GroupedInput.new(
-            '2' => '1'
-          )
-        end
-
-        it 'indicates an error' do
-          error = result.errors.first
-
-          expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-          expect(error.type).to be :invalid_type
-        end
-      end
-    end
-  end
-
-  describe '#database_column_type' do
-    it 'returns :datetime' do
-      expect(filter.database_column_type).to be :datetime
-    end
-  end
-
-  describe '#default' do
-    context 'with a GroupedInput' do
-      before do
-        options[:default] = ActiveInteraction::GroupedInput.new(
-          '1' => '2012',
-          '2' => '1',
-          '3' => '2',
-          '4' => '3',
-          '5' => '4',
-          '6' => '5'
-        )
-      end
-
-      it 'raises an error' do
-        expect do
-          filter.default(nil)
-        end.to raise_error ActiveInteraction::InvalidDefaultError
-      end
-    end
-  end
-end

data/spec/active_interaction/grouped_input_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe ActiveInteraction::GroupedInput do
-  subject(:grouped_input) { described_class.new }
-
-  it 'subclasses OpenStruct' do
-    expect(grouped_input).to be_an OpenStruct
-  end
-
-  it 'responds to #[]' do
-    expect { grouped_input[:key] }.to_not raise_error
-  end
-
-  it 'responds to #[]=' do
-    expect { grouped_input[:key] = :value }.to_not raise_error
-  end
-end

data/spec/active_interaction/hash_input_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe ActiveInteraction::HashInput do
-  subject(:input) do
-    described_class.new(filter,
-      value: value,
-      error: error,
-      children: children
-    )
-  end
-
-  let(:filter) do
-    ActiveInteraction::HashFilter.new(:h, &block)
-  end
-  let(:block) { proc { integer :i } }
-  let(:value) { nil }
-  let(:error) { nil }
-  let(:children) { {} }
-
-  describe '#errors' do
-    context 'with no errors' do
-      it 'returns an empty array' do
-        expect(input.errors).to be_empty
-      end
-    end
-
-    context 'with an error on the hash' do
-      let(:error) { ActiveInteraction::Filter::Error.new(filter, :invalid_type) }
-
-      it 'returns one error in the array' do
-        expect(input.errors.size).to be 1
-
-        error = input.errors.first
-        expect(error.name).to be filter.name
-        expect(error.type).to be :invalid_type
-      end
-    end
-
-    context 'with children with errors' do
-      let(:child_i) do
-        filter = ActiveInteraction::IntegerFilter.new(:i)
-        ActiveInteraction::Input.new(filter,
-          value: nil,
-          error: ActiveInteraction::Filter::Error.new(filter, :missing)
-        )
-      end
-      let(:children) { { i: child_i } }
-
-      it 'returns the error' do
-        expect(input.errors.size).to be 1
-
-        error = input.errors.first
-        expect(error.name).to be :"#{filter.name}.i"
-        expect(error.type).to be :missing
-      end
-    end
-  end
-end

data/spec/active_interaction/i18n_spec.rb

@@ -1,113 +0,0 @@
-require 'spec_helper'
-
-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)
-
-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,266 +0,0 @@
-require 'spec_helper'
-
-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