active_interaction 5.2.0 → 5.4.0

data/spec/active_interaction/integration/time_interaction_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-TimeWithZone = Class.new do
-  attr_reader :time
-
-  def initialize(time)
-    @time = time
-  end
-
-  def ==(other)
-    !other.nil? && time == other.time
-  end
-
-  def at(*args)
-    TimeWithZone.new(Time.at(*args) + 1)
-  end
-
-  def parse(*args)
-    TimeWithZone.new(Time.parse(*args) + 1)
-  rescue ArgumentError
-    nil
-  end
-end
-
-TimeInteraction = Class.new(TestInteraction) do
-  time :a
-end
-
-describe TimeInteraction do
-  include_context 'interactions'
-  it_behaves_like 'an interaction', :time, -> { Time.now }
-
-  context 'with a time zone' do
-    let(:a) { nil }
-
-    before do
-      inputs[:a] = a
-
-      allow(Time).to receive(:zone).and_return(TimeWithZone.new(0))
-    end
-
-    context 'with an integer' do
-      let(:a) { rand(1 << 16) }
-
-      it 'returns the correct value' do
-        expect(result[:a]).to eq TimeWithZone.new(0).at(a)
-      end
-    end
-
-    context 'with a string' do
-      let(:a) { '2011-12-13T14:15:16Z' }
-
-      it 'returns the correct value' do
-        expect(result[:a]).to eq TimeWithZone.new(0).parse(a)
-      end
-    end
-
-    context 'with an invalid String' do
-      let(:a) { 'invalid' }
-
-      it 'is invalid' do
-        expect(outcome).to be_invalid
-      end
-    end
-
-    context 'with a Time' do
-      let(:a) { Time.now }
-
-      it 'returns the correct value' do
-        expect(result[:a]).to eql a
-      end
-    end
-
-    context 'with a TimeZone' do
-      let(:a) { TimeWithZone.new(Time.now) }
-
-      it 'returns the correct value' do
-        expect(result[:a]).to eql a
-      end
-
-      it 'handles time zone changes' do
-        outcome
-        allow(Time).to receive(:zone).and_return(nil)
-        expect(described_class.run(inputs)).to be_invalid
-      end
-    end
-  end
-end

data/spec/active_interaction/modules/validation_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe ActiveInteraction::Validation do
-  describe '.validate(context, filters, inputs)' do
-    let(:inputs) { {} }
-    let(:filter) { ActiveInteraction::Filter.new(:name, {}) }
-    let(:interaction) do
-      name = filter.name
-      klass = Class.new(ActiveInteraction::Base) { attr_writer(name) }
-      klass.filters[name] = filter
-      klass.new
-    end
-    let(:result) do
-      described_class.validate(interaction, interaction.class.filters, inputs)
-    end
-
-    context 'no filters are given' do
-      let(:interaction) { Class.new(ActiveInteraction::Base).new }
-
-      it 'returns no errors' do
-        expect(result).to eql []
-      end
-    end
-
-    context 'filter returns no errors' do
-      let(:inputs) { { name: 1 } }
-
-      before do
-        allow(filter).to receive(:process).and_return(ActiveInteraction::Input.new(filter, value: 1))
-      end
-
-      it 'returns no errors' do
-        expect(result).to eql []
-      end
-    end
-
-    context 'filter returns with errors' do
-      before do
-        allow(filter).to receive(:process).and_return(ActiveInteraction::Input.new(filter, error: exception))
-      end
-
-      context 'Filter::Error' do
-        let(:filter) { ActiveInteraction::ArrayFilter.new(:name, [1.0, 'a']) { float } }
-
-        let(:exception) { ActiveInteraction::Filter::Error.new(filter, :invalid_type) }
-
-        it 'returns an :invalid_type error' do
-          type = I18n.translate(
-            "#{ActiveInteraction::Base.i18n_scope}.types.#{filter.class.slug}"
-          )
-
-          expect(result).to eql [[filter.name, :invalid_type, { type: type }]]
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,20 +0,0 @@
-require 'i18n'
-I18n.config.enforce_available_locales = true if I18n.config.respond_to?(:enforce_available_locales)
-
-require 'active_interaction'
-require 'active_record'
-
-Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
-
-RSpec.configure do |config|
-  config.run_all_when_everything_filtered = true
-  config.filter_run_including :focus
-
-  config.before(:suite) do
-    if ActiveRecord.respond_to?(:index_nested_attribute_errors)
-      ActiveRecord.index_nested_attribute_errors = false
-    else
-      ActiveRecord::Base.index_nested_attribute_errors = false
-    end
-  end
-end

data/spec/support/concerns.rb

@@ -1,13 +0,0 @@
-shared_context 'concerns' do |concern|
-  subject(:instance) { klass.new }
-
-  let(:klass) do
-    Class.new do
-      include concern
-
-      def self.name
-        SecureRandom.hex
-      end
-    end
-  end
-end

data/spec/support/filters.rb

@@ -1,227 +0,0 @@
-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
-
-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 '#process' do
-    let(:value) { nil }
-
-    context 'optional' do
-      include_context 'optional'
-
-      it 'returns the default' do
-        expect(filter.process(value, nil).value).to eql options[:default]
-      end
-    end
-
-    context 'required' do
-      include_context 'required'
-
-      it 'indicates an error' do
-        error = filter.process(value, nil).errors.first
-
-        expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-        expect(error.type).to be :missing
-      end
-
-      context 'with an invalid value' do
-        let(:value) { Object.new }
-
-        it 'indicates an error' do
-          error = filter.process(value, nil).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 invalid default' do
-      before do
-        options[:default] = Object.new
-      end
-
-      it 'raises an error' do
-        expect do
-          filter.process(value, nil)
-        end.to raise_error ActiveInteraction::InvalidDefaultError
-      end
-    end
-
-    # BasicObject is missing a lot of methods
-    context 'with a BasicObject' do
-      let(:value) { BasicObject.new }
-
-      it 'indicates an error' do
-        error = filter.process(value, nil).errors.first
-
-        expect(error).to be_an_instance_of ActiveInteraction::Filter::Error
-        expect(error.type).to be :invalid_type
-      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] = lambda do |this|
-          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).to_not 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

data/spec/support/interactions.rb

@@ -1,124 +0,0 @@
-TestInteraction = Class.new(ActiveInteraction::Base) do
-  def self.name
-    SecureRandom.hex
-  end
-
-  def execute
-    inputs
-  end
-end
-
-shared_context 'interactions' do
-  let(:inputs) { {} }
-  let(:outcome) { described_class.run(inputs) }
-  let(:result) { outcome.result }
-end
-
-shared_examples_for 'an interaction' do |type, generator, adjust_output = nil, **filter_options|
-  include_context 'interactions'
-
-  let(:described_class) do
-    Class.new(TestInteraction) do
-      public_send(type, :required, filter_options)
-      public_send(type, :optional,
-        filter_options.merge(
-          default: nil
-        )
-      )
-      public_send(type, :default,
-        filter_options.merge(
-          default: generator.call
-        )
-      )
-      public_send(type, :defaults1, :defaults2,
-        filter_options.merge(
-          default: generator.call
-        )
-      )
-      public_send(type, :defaults3,
-        filter_options.merge(
-          default: -> { required }
-        )
-      )
-    end
-  end
-
-  context 'with an invalid lazy default' do
-    let(:described_class) do
-      Class.new(TestInteraction) do
-        public_send(type, :default,
-          filter_options.merge(default: -> { Object.new })
-        )
-      end
-    end
-
-    it 'raises an error' do
-      expect { outcome }.to raise_error ActiveInteraction::InvalidDefaultError
-    end
-  end
-
-  context 'without required inputs' do
-    it 'is invalid' do
-      expect(outcome).to be_invalid
-    end
-  end
-
-  context 'with inputs[:required]' do
-    let(:required) { generator.call }
-
-    before { inputs[:required] = required }
-
-    it 'is valid' do
-      expect(outcome).to be_valid
-    end
-
-    it 'returns the correct value for :required' do
-      expect(result[:required]).to eql(adjust_output ? adjust_output.call(required) : required)
-    end
-
-    it 'returns nil for :optional' do
-      expect(result[:optional]).to be_nil
-    end
-
-    it 'does not return nil for :default' do
-      expect(result[:default]).to_not be_nil
-    end
-
-    it 'does not return nil for :default when given nil' do
-      inputs[:default] = nil
-      expect(result[:default]).to_not be_nil
-    end
-
-    it 'does not return nil for :defaults1' do
-      expect(result[:defaults1]).to_not be_nil
-    end
-
-    it 'does not return nil for :defaults2' do
-      expect(result[:defaults2]).to_not be_nil
-    end
-
-    it 'evaluates :defaults3 in the interaction binding' do
-      expect(result[:defaults3]).to eql result[:required]
-    end
-
-    context 'with inputs[:optional]' do
-      let(:optional) { generator.call }
-
-      before { inputs[:optional] = optional }
-
-      it 'returns the correct value for :optional' do
-        expect(result[:optional]).to eql(adjust_output ? adjust_output.call(optional) : optional)
-      end
-    end
-
-    context 'with inputs[:default]' do
-      let(:default) { generator.call }
-
-      before { inputs[:default] = default }
-
-      it 'returns the correct value for :default' do
-        expect(result[:default]).to eql(adjust_output ? adjust_output.call(default) : default)
-      end
-    end
-  end
-end