active_interaction 3.7.1 → 4.0.0

data/spec/active_interaction/filters/interface_filter_spec.rb

@@ -1,47 +1,420 @@
-# coding: utf-8
-
 require 'spec_helper'
-require 'json'
-require 'yaml'
+
+module InterfaceModule; end
+
+class InterfaceClass; end # rubocop:disable Lint/EmptyClass
 
 describe ActiveInteraction::InterfaceFilter, :filter do
   include_context 'filters'
-  it_behaves_like 'a filter'
-
-  before { options[:methods] = %i[dump load] }
+  it_behaves_like 'a filter' do
+    let(:name) { :interface_module }
+  end
 
   describe '#cast' do
-    let(:result) { filter.cast(value, nil) }
+    let(:result) { filter.send(:cast, value, nil) }
 
-    context 'with a BasicObject' do
-      let(:value) { BasicObject.new }
+    context 'with an implicit constant name' do
+      context 'passed an instance' do
+        context 'with the module included' do
+          let(:name) { :interface_module }
+          let(:value) do
+            Class.new do
+              include InterfaceModule
+            end.new
+          end
 
-      it 'raises an error' do
-        expect { result }.to raise_error ActiveInteraction::InvalidValueError
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'with the class inherited from' do
+          let(:name) { :interface_class }
+          let(:value) do
+            Class.new(InterfaceClass) {}.new # rubocop:disable Lint/EmptyBlock
+          end
+
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'that is extended by the ancestor' do
+          let(:name) { :interface_module }
+          let(:value) do
+            Class.new {}.new.extend(InterfaceModule) # rubocop:disable Lint/EmptyBlock
+          end
+
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'that does not match' do
+          let(:name) { :interface_module }
+          let(:value) { Class.new }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+
+        context 'with the class itself' do
+          let(:name) { :interface_class }
+          let(:value) do
+            InterfaceClass.new
+          end
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+      end
+
+      context 'passed a class' do
+        context 'with the class inherited from' do
+          let(:name) { :interface_class }
+          let(:value) do
+            Class.new(InterfaceClass) {} # rubocop:disable Lint/EmptyBlock
+          end
+
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'that is extended by the ancestor' do
+          let(:name) { :interface_module }
+          let(:value) do
+            Class.new do
+              extend InterfaceModule
+            end
+          end
+
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'that does not match' do
+          let(:name) { :interface_class }
+          let(:value) { Class }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+
+        context 'with the class itself' do
+          let(:name) { :interface_class }
+          let(:value) { InterfaceClass }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+      end
+
+      context 'passed a module' do
+        context 'that is extended by the ancestor' do
+          let(:name) { :interface_module }
+          let(:value) do
+            Module.new do
+              extend InterfaceModule
+            end
+          end
+
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'that does not match' do
+          let(:name) { :interface_module }
+          let(:value) { Module.new }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+
+        context 'with the module itself' do
+          let(:name) { :interface_module }
+          let(:value) { InterfaceModule }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+      end
+
+      context 'given an invalid name' do
+        let(:name) { :invalid }
+        let(:value) { Object }
+
+        it 'raises an error' do
+          expect do
+            result
+          end.to raise_error ActiveInteraction::InvalidNameError
+        end
       end
     end
 
-    context 'with an Object' do
-      let(:value) { Object.new }
+    context 'with a constant given' do
+      context 'passed an instance' do
+        context 'with the module included' do
+          before { options.merge!(from: :interface_module) }
+          let(:value) do
+            Class.new do
+              include InterfaceModule
+            end.new
+          end
 
-      it 'raises an error' do
-        expect { result }.to raise_error ActiveInteraction::InvalidValueError
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'with the class inherited from' do
+          before { options.merge!(from: :interface_class) }
+          let(:value) do
+            Class.new(InterfaceClass) {}.new # rubocop:disable Lint/EmptyBlock
+          end
+
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'that is extended by the ancestor' do
+          before { options.merge!(from: :interface_module) }
+          let(:value) do
+            Class.new {}.new.extend(InterfaceModule) # rubocop:disable Lint/EmptyBlock
+          end
+
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'that does not match' do
+          let(:name) { :interface_class }
+          let(:value) { Class.new }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+
+        context 'with the class itself' do
+          let(:name) { :interface_class }
+          let(:value) { InterfaceClass.new }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+      end
+
+      context 'passed a class' do
+        context 'with the class inherited from' do
+          before { options.merge!(from: :interface_class) }
+          let(:value) do
+            Class.new(InterfaceClass) {} # rubocop:disable Lint/EmptyBlock
+          end
+
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'that is extended by the ancestor' do
+          before { options.merge!(from: :interface_module) }
+          let(:value) do
+            Class.new do
+              extend InterfaceModule
+            end
+          end
+
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'that does not match' do
+          let(:name) { :interface_class }
+          let(:value) { Class }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+
+        context 'with the class itself' do
+          let(:name) { :interface_class }
+          let(:value) { InterfaceClass }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+      end
+
+      context 'passed a module' do
+        context 'that is extended by the ancestor' do
+          before { options.merge!(from: :interface_module) }
+          let(:value) do
+            Module.new do
+              extend InterfaceModule
+            end
+          end
+
+          it 'returns a the value' do
+            expect(result).to eql value
+          end
+        end
+
+        context 'that does not match' do
+          let(:name) { :interface_module }
+          let(:value) { Module.new }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+
+        context 'with the module itself' do
+          let(:name) { :interface_module }
+          let(:value) { InterfaceModule }
+
+          it 'raises an error' do
+            expect do
+              result
+            end.to raise_error ActiveInteraction::InvalidValueError
+          end
+        end
+      end
+
+      context 'given an invalid name' do
+        before { options.merge!(from: :invalid) }
+        let(:value) { Object }
+
+        it 'raises an error' do
+          expect do
+            result
+          end.to raise_error ActiveInteraction::InvalidNameError
+        end
       end
     end
 
-    context 'with JSON' do
-      let(:value) { JSON }
+    context 'with methods passed' do
+      before { options[:methods] = %i[dump load] }
+
+      context 'passed an valid instance' do
+        let(:value) do
+          Class.new do
+            def dump; end
 
-      it 'returns an Array' do
-        expect(result).to eql value
+            def load; end
+          end.new
+        end
+
+        it 'returns a the value' do
+          expect(result).to eql value
+        end
+      end
+
+      context 'passed an invalid instance' do
+        let(:value) { Class.new }
+
+        it 'raises an error' do
+          expect do
+            result
+          end.to raise_error ActiveInteraction::InvalidValueError
+        end
+      end
+
+      context 'passed a class' do
+        let(:value) do
+          Class.new do
+            def self.dump; end
+
+            def self.load; end
+          end
+        end
+
+        it 'returns a the value' do
+          expect(result).to eql value
+        end
+      end
+
+      context 'passed an invalid class' do
+        let(:value) { Class }
+
+        it 'raises an error' do
+          expect do
+            result
+          end.to raise_error ActiveInteraction::InvalidValueError
+        end
+      end
+
+      context 'passed a module' do
+        let(:value) do
+          Module.new do
+            def self.dump; end
+
+            def self.load; end
+          end
+        end
+
+        it 'returns a the value' do
+          expect(result).to eql value
+        end
+      end
+
+      context 'passed an invalid module' do
+        let(:value) { Module.new }
+
+        it 'raises an error' do
+          expect do
+            result
+          end.to raise_error ActiveInteraction::InvalidValueError
+        end
       end
     end
 
-    context 'with YAML' do
-      let(:value) { YAML }
+    context 'with from and methods passed' do
+      before do
+        options[:from] = :module
+        options[:methods] = %i[dump load]
+      end
 
-      it 'returns an Hash' do
-        expect(result).to eql value
+      it 'raises an error' do
+        expect do
+          filter
+        end.to raise_error ActiveInteraction::InvalidFilterError
       end
     end
   end

data/spec/active_interaction/filters/object_filter_spec.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require 'spec_helper'
 
 class ObjectThing
@@ -11,7 +9,8 @@ class ObjectThing
     raise 'error'
   end
 end
-class ObjectThings; end
+
+class ObjectThings; end # rubocop:disable Lint/EmptyClass
 BackupObjectThing = ObjectThing
 
 describe ActiveInteraction::ObjectFilter, :filter do
@@ -24,86 +23,51 @@ describe ActiveInteraction::ObjectFilter, :filter do
 
   describe '#cast' do
     let(:value) { ObjectThing.new }
-    let(:result) { filter.cast(value, nil) }
+    let(:result) { filter.send(:cast, value, nil) }
 
-    context 'with class as a Class' do
+    context 'with an instance of the class' do
       it 'returns the instance' do
         expect(result).to eql value
       end
 
+      context 'with an instance that is a subclass' do
+        let(:subclass) { Class.new(ObjectThing) }
+        let(:value) { subclass.new }
+
+        it 'returns the instance' do
+          expect(result).to eql value
+        end
+      end
+
       it 'handles reconstantizing' do
         expect(result).to eql value
 
         Object.send(:remove_const, :ObjectThing)
-        ObjectThing = BackupObjectThing
+        ObjectThing = BackupObjectThing # rubocop:disable Lint/ConstantDefinitionInBlock
         value = ObjectThing.new
 
-        expect(filter.cast(value, nil)).to eql value
+        expect(filter.send(:cast, value, nil)).to eql value
       end
 
       it 'handles reconstantizing subclasses' do
         filter
 
         Object.send(:remove_const, :ObjectThing)
-        ObjectThing = BackupObjectThing
-        class SubObjectThing < ObjectThing; end
+        ObjectThing = BackupObjectThing # rubocop:disable Lint/ConstantDefinitionInBlock
+        class SubObjectThing < ObjectThing; end # rubocop:disable Lint/ConstantDefinitionInBlock
         value = SubObjectThing.new
 
-        expect(filter.cast(value, nil)).to eql value
+        expect(filter.send(:cast, value, nil)).to eql value
       end
 
       context 'without the class available' do
         before { Object.send(:remove_const, :ObjectThing) }
-        after { ObjectThing = BackupObjectThing }
+        after { ObjectThing = BackupObjectThing } # rubocop:disable Lint/ConstantDefinitionInBlock
 
         it 'does not raise an error on initialization' do
           expect { filter }.to_not raise_error
         end
       end
-
-      context 'with bidirectional class comparisons' do
-        let(:case_equality) { false }
-        let(:class_equality) { false }
-
-        before do
-          allow(ObjectThing).to receive(:===).and_return(case_equality)
-          allow(value).to receive(:is_a?).and_return(class_equality)
-        end
-
-        context 'without case or class equality' do
-          it 'raises an error' do
-            expect do
-              result
-            end.to raise_error ActiveInteraction::InvalidValueError
-          end
-        end
-
-        context 'with case equality' do
-          let(:case_equality) { true }
-
-          it 'returns the instance' do
-            expect(result).to eql value
-          end
-        end
-
-        context 'with class equality' do
-          let(:class_equality) { true }
-
-          it 'returns the instance' do
-            expect(result).to eql value
-          end
-        end
-      end
-    end
-
-    context 'with class as a superclass' do
-      before do
-        options[:class] = ObjectThing.superclass
-      end
-
-      it 'returns the instance' do
-        expect(result).to eql value
-      end
     end
 
     context 'with class as a String' do
@@ -134,7 +98,7 @@ describe ActiveInteraction::ObjectFilter, :filter do
       it 'raises an error' do
         expect do
           result
-        end.to raise_error ActiveInteraction::InvalidClassError
+        end.to raise_error ActiveInteraction::InvalidNameError
       end
     end
 
@@ -161,7 +125,7 @@ describe ActiveInteraction::ObjectFilter, :filter do
         end
       end
 
-      context 'with a object of the correct class' do
+      context 'with an object of the correct class' do
         let(:value) { ObjectThing.new }
 
         it 'does not call the converter' do
@@ -170,7 +134,7 @@ describe ActiveInteraction::ObjectFilter, :filter do
         end
       end
 
-      context 'with a object is a subclass' do
+      context 'with an object that is a subclass' do
         let(:subclass) { Class.new(ObjectThing) }
         let(:value) { subclass.new }
 
@@ -223,7 +187,7 @@ describe ActiveInteraction::ObjectFilter, :filter do
 
         before do
           options[:default] = ObjectThing.new
-          options[:converter] = ->(_) { nil }
+          options[:converter] = ->(_) {}
         end
 
         it 'raises an error' do