active_interaction 5.1.0 → 5.5.0

data/spec/active_interaction/integration/array_interaction_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-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
-
-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,5 +0,0 @@
-require 'spec_helper'
-
-describe 'BooleanInteraction' do
-  it_behaves_like 'an interaction', :boolean, -> { [false, true].sample }
-end

data/spec/active_interaction/integration/date_interaction_spec.rb

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

data/spec/active_interaction/integration/date_time_interaction_spec.rb

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

data/spec/active_interaction/integration/file_interaction_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-require 'action_dispatch'
-
-FileInteraction = Class.new(TestInteraction) do
-  file :a
-end
-
-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,5 +0,0 @@
-require 'spec_helper'
-
-describe 'FloatInteraction' do
-  it_behaves_like 'an interaction', :float, -> { rand }
-end

data/spec/active_interaction/integration/hash_interaction_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-HashInteraction = Class.new(TestInteraction) do
-  hash :a do
-    hash :x
-  end
-  hash :b, default: {} do
-    hash :x, default: {}
-  end
-end
-
-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
-end

data/spec/active_interaction/integration/integer_interaction_spec.rb

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

data/spec/active_interaction/integration/interface_interaction_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-require 'json'
-require 'yaml'
-
-InterfaceInteraction = Class.new(TestInteraction) do
-  interface :anything, methods: []
-end
-
-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,14 +0,0 @@
-require 'spec_helper'
-
-ObjectInteraction = Class.new(TestInteraction) do
-  object :object
-end
-
-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,5 +0,0 @@
-require 'spec_helper'
-
-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,5 +0,0 @@
-require 'spec_helper'
-
-describe 'StringInteraction' do
-  it_behaves_like 'an interaction', :string, -> { SecureRandom.hex }
-end

data/spec/active_interaction/integration/symbol_interaction_spec.rb

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

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