objective 0.1.0

data/spec/filters/file_filter_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'stringio'
+require 'tempfile'
+
+describe 'Objective::Filters::FileFilter' do
+  class UploadedStringIO < StringIO
+    attr_accessor :content_type, :original_filename
+  end
+
+  if File.new('README.md').respond_to?(:size)
+    it 'allows files - file class' do
+      file = File.new('README.md')
+      f = Objective::Filters::FileFilter.new
+      result = f.feed(file)
+      assert_equal file, result.inputs
+      assert_nil result.errors
+    end
+  end
+
+  it 'allows files - stringio class' do
+    file = StringIO.new('bob')
+    f = Objective::Filters::FileFilter.new
+    result = f.feed(file)
+    assert_equal file, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows files - tempfile' do
+    file = Tempfile.new('bob')
+    f = Objective::Filters::FileFilter.new
+    result = f.feed(file)
+    assert result.inputs.is_a?(Tempfile)
+    assert_nil result.errors
+  end
+
+  it 'doesn\'t allow non-files' do
+    f = Objective::Filters::FileFilter.new
+    result = f.feed('string')
+    assert_equal 'string', result.inputs
+    assert_equal :file, result.errors
+
+    result = f.feed(12)
+    assert_equal 12, result.inputs
+    assert_equal :file, result.errors
+  end
+
+  it 'considers nil to be invalid' do
+    f = Objective::Filters::FileFilter.new(:clippy)
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+  end
+
+  it 'considers nil to be valid' do
+    f = Objective::Filters::FileFilter.new(:clippy, nils: Objective::ALLOW)
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_nil result.errors
+  end
+
+  it 'should allow small files' do
+    file = StringIO.new('bob')
+    f = Objective::Filters::FileFilter.new(:clippy, size: 4)
+    result = f.feed(file)
+    assert_equal file, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'shouldn\'t allow big files' do
+    file = StringIO.new('bob')
+    f = Objective::Filters::FileFilter.new(:clippy, size: 2)
+    result = f.feed(file)
+    assert_equal file, result.inputs
+    assert_equal :size, result.errors
+  end
+
+  it 'should require extra methods if uploaded file: accept' do
+    file = UploadedStringIO.new('bob')
+    f = Objective::Filters::FileFilter.new(:clippy, upload: true)
+    result = f.feed(file)
+    assert_equal file, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'should require extra methods if uploaded file: deny' do
+    file = StringIO.new('bob')
+    f = Objective::Filters::FileFilter.new(:clippy, upload: true)
+    result = f.feed(file)
+    assert_equal file, result.inputs
+    assert_equal :file, result.errors
+  end
+end

data/spec/filters/float_filter_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'Objective::Filters::FloatFilter' do
+  it 'allows floats' do
+    f = Objective::Filters::FloatFilter.new
+    result = f.feed(3.1415926)
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 3.1415926, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows integers' do
+    f = Objective::Filters::FloatFilter.new
+    result = f.feed(3)
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows bigdecimals' do
+    f = Objective::Filters::FloatFilter.new
+    result = f.feed(BigDecimal.new('3'))
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows strings that start with a digit' do
+    f = Objective::Filters::FloatFilter.new
+    result = f.feed('3')
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 3.0, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows string representation of float' do
+    f = Objective::Filters::FloatFilter.new
+    result = f.feed('3.14')
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 3.14, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows string representation of float without a number before dot' do
+    f = Objective::Filters::FloatFilter.new
+    result = f.feed('.14')
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 0.14, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows negative strings' do
+    f = Objective::Filters::FloatFilter.new
+    result = f.feed('-.14')
+
+    assert result.inputs.is_a?(Float)
+    assert_equal(-0.14, result.inputs)
+    assert_nil result.errors
+  end
+
+  it 'allows strings with a positive sign' do
+    f = Objective::Filters::FloatFilter.new
+    result = f.feed('+.14')
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 0.14, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'does not allow other strings, nor does it allow random objects or symbols' do
+    f = Objective::Filters::FloatFilter.new
+    ['zero', 'a1', {}, [], Object.new, :d].each do |thing|
+      result = f.feed(thing)
+      assert_equal :float, result.errors
+    end
+  end
+
+  it 'considers nil to be invalid' do
+    f = Objective::Filters::FloatFilter.new(:x)
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+  end
+
+  it 'considers nil to be valid' do
+    f = Objective::Filters::FloatFilter.new(:x, nils: Objective::ALLOW)
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers empty strings invalid' do
+    f = Objective::Filters::FloatFilter.new
+    result = f.feed('')
+    assert_equal :float, result.errors
+  end
+
+  it 'considers low numbers invalid' do
+    f = Objective::Filters::FloatFilter.new(:x, min: 10)
+    result = f.feed(3)
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 3, result.inputs
+    assert_equal :min, result.errors
+  end
+
+  it 'considers low numbers valid' do
+    f = Objective::Filters::FloatFilter.new(:x, min: 10)
+    result = f.feed(31)
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 31, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers high numbers invalid' do
+    f = Objective::Filters::FloatFilter.new(:x, max: 10)
+    result = f.feed(31)
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 31, result.inputs
+    assert_equal :max, result.errors
+  end
+
+  it 'considers high numbers vaild' do
+    f = Objective::Filters::FloatFilter.new(:x, max: 10)
+    result = f.feed(3)
+
+    assert result.inputs.is_a?(Float)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+end

data/spec/filters/hash_filter_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'stringio'
+
+describe 'Objective::Filters::HashFilter' do
+  it 'allows valid hashes' do
+    hf = Objective::Filters::HashFilter.new do
+      string :foo
+    end
+
+    result = hf.feed(foo: 'bar')
+    assert_equal ({ 'foo' => 'bar' }), result.inputs
+    assert_nil result.errors
+  end
+
+  it 'disallows non-hashes' do
+    hf = Objective::Filters::HashFilter.new do
+      string :foo
+    end
+
+    result = hf.feed('bar')
+    assert_equal :hash, result.errors
+  end
+
+  it 'allows floats in hashes' do
+    hf = Objective::Filters::HashFilter.new do
+      float :foo
+    end
+
+    result = hf.feed(foo: 3.14)
+    assert_equal ({ 'foo' => 3.14 }), result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows ducks in hashes' do
+    hf = Objective::Filters::HashFilter.new do
+      duck :foo, methods: [:length]
+    end
+
+    result = hf.feed(foo: '123')
+    assert_equal ({ 'foo' => '123' }), result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows dates in hashes' do
+    hf = Objective::Filters::HashFilter.new do
+      date :foo, format: '%d-%m-%Y'
+    end
+
+    result = hf.feed(foo: '1-1-2000')
+    assert_equal Date.new(2000, 1, 1), result.inputs[:foo]
+    assert_nil result.errors
+  end
+
+  it 'allows files in hashes' do
+    sio = StringIO.new('bob')
+    hf = Objective::Filters::HashFilter.new do
+      file :foo
+    end
+
+    result = hf.feed(foo: sio)
+    assert_equal ({ 'foo' => sio }), result.inputs
+    assert_nil result.errors
+  end
+end

data/spec/filters/integer_filter_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'Objective::Filters::IntegerFilter' do
+  it 'allows integers' do
+    f = Objective::Filters::IntegerFilter.new
+    result = f.feed(3)
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows floats equivalent to an integer' do
+    f = Objective::Filters::IntegerFilter.new
+    result = f.feed(3.0)
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'does not allows floats with non-zero decimal places' do
+    f = Objective::Filters::IntegerFilter.new
+    result = f.feed(3.1)
+
+    assert_equal 3.1, result.inputs
+    assert_equal :integer, result.errors
+  end
+
+  it 'allows bigdecimals equivalent to an integer' do
+    f = Objective::Filters::IntegerFilter.new
+    result = f.feed(BigDecimal.new('3.000000'))
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'does not allows decimals with non-zero decimal places' do
+    f = Objective::Filters::IntegerFilter.new
+    result = f.feed(BigDecimal.new('3.111111'))
+
+    assert_equal BigDecimal.new('3.111111'), result.inputs
+    assert_equal :integer, result.errors
+  end
+
+  it 'allows strings that start with a digit' do
+    f = Objective::Filters::IntegerFilter.new
+    result = f.feed('3')
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows negative strings' do
+    f = Objective::Filters::IntegerFilter.new
+    result = f.feed('-3')
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal(-3, result.inputs)
+    assert_nil result.errors
+  end
+
+  it 'does not allow other strings, nor does it allow random objects or symbols' do
+    f = Objective::Filters::IntegerFilter.new
+    ['zero', 'a1', {}, [], Object.new, :d].each do |thing|
+      result = f.feed(thing)
+      assert_equal :integer, result.errors
+    end
+  end
+
+  it 'considers nil to be invalid' do
+    f = Objective::Filters::IntegerFilter.new(:i)
+    result = f.feed(nil)
+
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+  end
+
+  it 'considers nil to be valid' do
+    f = Objective::Filters::IntegerFilter.new(:i, nils: Objective::ALLOW)
+    result = f.feed(nil)
+
+    assert_nil result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers empty strings to be empty' do
+    f = Objective::Filters::IntegerFilter.new
+    result = f.feed('')
+
+    assert_equal :integer, result.errors
+  end
+
+  it 'considers low numbers invalid' do
+    f = Objective::Filters::IntegerFilter.new(:i, min: 10)
+    result = f.feed(3)
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal 3, result.inputs
+    assert_equal :min, result.errors
+  end
+
+  it 'considers low numbers valid' do
+    f = Objective::Filters::IntegerFilter.new(:i, min: 10)
+    result = f.feed(31)
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal 31, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers high numbers invalid' do
+    f = Objective::Filters::IntegerFilter.new(:i, max: 10)
+    result = f.feed(31)
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal 31, result.inputs
+    assert_equal :max, result.errors
+  end
+
+  it 'considers high numbers vaild' do
+    f = Objective::Filters::IntegerFilter.new(:i, max: 10)
+    result = f.feed(3)
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers not matching numbers to be invalid' do
+    f = Objective::Filters::IntegerFilter.new(:i, in: [3, 4, 5])
+    result = f.feed(6)
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal 6, result.inputs
+    assert_equal :in, result.errors
+  end
+
+  it 'considers matching numbers to be valid' do
+    f = Objective::Filters::IntegerFilter.new(:i, in: [3, 4, 5])
+    result = f.feed(3)
+
+    assert result.inputs.is_a?(Integer)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+end

data/spec/filters/model_filter_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'Objective::Filters::ModelFilter' do
+  class SimpleModel; end
+  class AlwaysNew
+    def new_record?
+      true
+    end
+  end
+
+  class AlwaysSaved
+    def new_record?
+      false
+    end
+  end
+
+  it 'allows models' do
+    f = Objective::Filters::ModelFilter.new(:simple_model)
+    m = SimpleModel.new
+    result = f.feed(m)
+    assert_equal m, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'raises an exception during filtering if constantization fails' do
+    f = Objective::Filters::ModelFilter.new(:non_existent_class)
+
+    # NOTE: nil will short circuit the check for an existing constant
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+
+    assert_raises NameError do
+      f.feed(0)
+    end
+  end
+
+  it 'raises an exception during filtering if constantization of class fails' do
+    f = Objective::Filters::ModelFilter.new(:simple_model, class: 'NonExistentClass')
+
+    # NOTE: nil will short circuit the check for an existing constant
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+
+    assert_raises NameError do
+      f.feed(0)
+    end
+  end
+
+  it 'considers nil to be invalid' do
+    f = Objective::Filters::ModelFilter.new(:simple_model)
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+  end
+
+  it 'considers nil to be valid' do
+    f = Objective::Filters::ModelFilter.new(:simple_model, nils: Objective::ALLOW)
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_nil result.errors
+  end
+
+  # it "disallows different types of models" do
+  # end
+  #
+  # it "allows you to override class with a constant and succeed" do
+  # end
+  #
+  # it "allows you to override class with a string and succeed" do
+  # end
+  #
+  # it "allows you to override class and fail" do
+  # end
+  #
+  # it "allows anything if new_record is true" do
+  # end
+  #
+  # it "disallows new_records if new_record is false" do
+  # end
+  #
+  # it "allows saved records if new_record is false" do
+  # end
+  #
+  # it "allows other records if new_record is false" do
+  # end
+  #
+  # it "allows you to build a record from a hash, and succeed" do
+  # end
+  #
+  # it "allows you to build a record from a hash, and fail" do
+  # end
+  #
+  # it "makes sure that if you build a record from a hash, it still has to be of the right class" do
+  # end
+end

data/spec/filters/root_filter_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'Objective::Filters::RootFilter' do
+  describe 'optional filters and nils' do
+    it 'bar is optional -- it works if not passed' do
+      hf = Objective::Filters::RootFilter.new do
+        filter do
+          string :foo
+          string :bar, none: Objective::ALLOW
+        end
+      end
+
+      result = hf.feed(foo: 'bar')
+      assert_equal OpenStruct.new(foo: 'bar'), result.inputs
+      assert_nil result.errors
+    end
+
+    it 'bar is optional -- it works if nil is passed' do
+      hf = Objective::Filters::RootFilter.new do
+        filter do
+          string :foo
+          string :bar, nils: Objective::DISCARD
+        end
+      end
+
+      result = hf.feed(foo: 'bar', bar: nil)
+      assert_equal OpenStruct.new(foo: 'bar'), result.inputs
+      assert_nil result.errors
+    end
+
+    it 'bar is optional -- it works if nil is passed and nils are allowed' do
+      hf = Objective::Filters::RootFilter.new do
+        filter do
+          string :foo
+          string :bar, nils: Objective::ALLOW
+        end
+      end
+
+      result = hf.feed(foo: 'bar', bar: nil)
+      assert_equal OpenStruct.new(foo: 'bar', bar: nil), result.inputs
+      assert_nil result.errors
+    end
+  end
+
+  describe 'optional filters and empty values' do
+    it 'bar is optional -- discards empty' do
+      hf = Objective::Filters::RootFilter.new do
+        filter do
+          string :foo
+          string :bar, empty: Objective::DISCARD
+        end
+      end
+
+      result = hf.feed(foo: 'bar', bar: '')
+      assert_equal OpenStruct.new(foo: 'bar'), result.inputs
+      assert_nil result.errors
+    end
+
+    it 'bar is optional -- discards empty if it needs to be stripped' do
+      hf = Objective::Filters::RootFilter.new do
+        filter do
+          string :foo
+          string :bar, empty: Objective::DISCARD
+        end
+      end
+
+      result = hf.feed(foo: 'bar', bar: ' ')
+      assert_equal OpenStruct.new(foo: 'bar'), result.inputs
+      assert_nil result.errors
+    end
+
+    it "bar is optional -- don't discard empty if it's spaces but stripping is off" do
+      hf = Objective::Filters::RootFilter.new do
+        filter do
+          string :foo
+          string :bar, empty: Objective::DISCARD, strip: false
+        end
+      end
+
+      result = hf.feed(foo: 'bar', bar: ' ')
+      assert_equal OpenStruct.new(foo: 'bar', bar: ' '), result.inputs
+      assert_nil result.errors
+    end
+
+    it 'bar is optional -- errors if value is blank' do
+      hf = Objective::Filters::RootFilter.new do
+        filter do
+          string :foo
+          string :bar, none: Objective::ALLOW
+        end
+      end
+
+      result = hf.feed(foo: 'bar', bar: '')
+      assert_equal({ 'bar' => :empty }, result.errors.codes)
+    end
+  end
+
+  describe 'discarding invalid values' do
+    it 'should discard invalid optional values' do
+      hf = Objective::Filters::RootFilter.new do
+        filter do
+          string :foo
+          integer :bar, invalid: Objective::DISCARD
+        end
+      end
+
+      result = hf.feed(foo: 'bar', bar: 'baz')
+      assert_equal OpenStruct.new(foo: 'bar'), result.inputs
+      assert_nil result.errors
+    end
+  end
+end