wardrobe 0.1.0

data/test/unit/plugins/validate/predicates/empty_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class ValidationPredicatesEmptyTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+    attribute :string, String, validates { empty? }
+    attribute :symbol, Symbol, validates { empty? }
+    attribute :array, Array, validates { empty? }
+    attribute :hash, Hash, validates { empty? }
+    attribute :set, Set, validates { empty? }
+  end
+
+  def test_nil
+    errors = Foo.new(
+      string: nil, symbol: nil, array: nil, hash: nil, set: nil
+    )._validation_errors
+
+    refute errors.has_key?(:string)
+    refute errors.has_key?(:symbol)
+    refute errors.has_key?(:array)
+    refute errors.has_key?(:hash)
+    refute errors.has_key?(:set)
+  end
+
+  def test_with_content
+    errors = Foo.new(
+    string: 'Bar', symbol: :'Bar', array: ['Bar'], hash: {foo: 'Bar'}, set: Set.new(['Bar'])
+    )._validation_errors
+
+    assert_equal 'must be empty', errors[:string][0]
+    assert_equal 'must be empty', errors[:symbol][0]
+    assert_equal 'must be empty', errors[:array][0]
+    assert_equal 'must be empty', errors[:hash][0]
+    assert_equal 'must be empty', errors[:set][0]
+  end
+end

data/test/unit/plugins/validate/predicates/even_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class ValidationPredicatesEvenTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+    attribute :integer, Integer, validates { even? }
+  end
+
+  def test_nil
+    assert_raises(NoMethodError) {
+      Foo.new(
+        integer: nil
+      )._validation_errors
+    }
+  end
+
+  def test_fail
+    errors = Foo.new(
+      integer: 1
+    )._validation_errors
+
+    assert_equal 'must be even', errors[:integer][0]
+  end
+
+  def test_success
+    errors = Foo.new(
+      integer: 2
+    )._validation_errors
+
+    refute errors.has_key?(:integer)
+  end
+end

data/test/unit/plugins/validate/predicates/excluded_from_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class ValidationPredicatesExludedFromTest < MiniTest::Test
+  TIME = Time.now
+  class Foo
+    include Wardrobe(coerce: false)
+    plugin :validation
+    attribute :string,    String,   validates { excluded_from?(['test']) }
+    attribute :symbol,    Symbol,   validates { excluded_from?([:test]) }
+    attribute :integer,   Integer,  validates { excluded_from?([1]) }
+    attribute :float,     Float,    validates { excluded_from?([1.1]) }
+    attribute :boolean,   Wardrobe::Boolean, validates { excluded_from?([true]) }
+    attribute :date,      Date,     validates { excluded_from?([TIME.to_date]) }
+    attribute :time,      Time,     validates { excluded_from?([TIME]) }
+    attribute :date_time, DateTime, validates { excluded_from?([TIME.to_datetime]) }
+    attribute :array,     Array,    validates { excluded_from?([[1]]) }
+    attribute :hash,      Hash,     validates { excluded_from?([{one: 1}]) }
+  end
+
+  def test_nil
+    errors = Foo.new(
+      string: nil, symbol: nil, integer: nil, float: nil, boolean: nil,
+      date: nil, time: nil, date_time: nil, array: nil, hash: nil
+    )._validation_errors
+
+    refute errors.has_key? :string
+    refute errors.has_key? :symbol
+    refute errors.has_key? :integer
+    refute errors.has_key? :float
+    refute errors.has_key? :boolean
+    refute errors.has_key? :date
+    refute errors.has_key? :time
+    refute errors.has_key? :date_time
+    refute errors.has_key? :array
+    refute errors.has_key? :hash
+  end
+
+  def test_with_values
+    errors = Foo.new(
+      string: 'test', symbol: :test, integer: 1, float: 1.1, boolean: true,
+      date: TIME.to_date, time: TIME, date_time: TIME.to_datetime, array: [1], hash: {one: 1}
+    )._validation_errors
+
+    assert_equal 'must not be one of: "test"', errors[:string][0]
+    assert_equal 'must not be one of: :test', errors[:symbol][0]
+    assert_equal 'must not be one of: 1', errors[:integer][0]
+    assert_equal 'must not be one of: 1.1', errors[:float][0]
+    assert_equal 'must not be one of: true', errors[:boolean][0]
+    assert_equal "must not be one of: #{TIME.to_date.to_s}", errors[:date][0]
+    assert_equal "must not be one of: #{TIME.to_s}", errors[:time][0]
+    assert_equal "must not be one of: #{TIME.to_datetime.to_s}", errors[:date_time][0]
+    assert_equal 'must not be one of: [1]', errors[:array][0]
+    assert_equal 'must not be one of: {:one=>1}', errors[:hash][0]
+  end
+end

data/test/unit/plugins/validate/predicates/filled_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class ValidationPredicatesFilledTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+    attribute :string, String, validates { filled? }
+    attribute :symbol, Symbol, validates { filled? }
+    attribute :array, Array, validates { filled? }
+    attribute :hash, Hash, validates { filled? }
+    attribute :set, Set, validates { filled? }
+  end
+
+  def test_nil
+    errors = Foo.new(
+      string: nil, symbol: nil, array: nil, hash: nil, set: nil
+    )._validation_errors
+
+    assert_equal 'must be filled', errors[:string][0]
+    assert_equal 'must be filled', errors[:symbol][0]
+    assert_equal 'must be filled', errors[:array][0]
+    assert_equal 'must be filled', errors[:hash][0]
+    assert_equal 'must be filled', errors[:set][0]
+  end
+
+  def test_empty
+    errors = Foo.new(
+      string: '', symbol: :'', array: [], hash: {}, set: Set.new
+    )._validation_errors
+
+    assert_equal 'must be filled', errors[:string][0]
+    assert_equal 'must be filled', errors[:symbol][0]
+    assert_equal 'must be filled', errors[:array][0]
+    assert_equal 'must be filled', errors[:hash][0]
+    assert_equal 'must be filled', errors[:set][0]
+  end
+
+  def test_with_content
+    errors = Foo.new(
+      string: 'Bar', symbol: :'Bar', array: ['Bar'], hash: {foo: 'Bar'}, set: Set.new(['Bar'])
+    )._validation_errors
+
+    refute errors.has_key?(:string)
+    refute errors.has_key?(:symbol)
+    refute errors.has_key?(:array)
+    refute errors.has_key?(:hash)
+    refute errors.has_key?(:set)
+  end
+end

data/test/unit/plugins/validate/predicates/format_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class ValidationPredicatesFormatTest < MiniTest::Test
+  class Foo
+    include Wardrobe(coerce: false)
+    plugin :validation
+    attribute :string, String, validates { format?(/^abc$/) }
+    attribute :symbol, Symbol, validates { format?(/^abc$/) }
+  end
+
+  def test_failin_regex
+    errors = Foo.new(
+      string: 'no', symbol: :no
+    )._validation_errors
+
+    assert_equal 'must match /^abc$/', errors[:string][0]
+    assert_equal 'must match /^abc$/', errors[:symbol][0]
+  end
+
+  def test_matching_regex
+    errors = Foo.new(
+      string: 'abc', symbol: :abc
+    )._validation_errors
+
+    refute errors.has_key?(:string)
+    refute errors.has_key?(:symbol)
+  end
+end

data/test/unit/plugins/validate/predicates/gt_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class ValidationPredicatesGreaterThanTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+    attribute :integer, Integer, validates { gt?(1) }
+    attribute :float, Float, validates { gt?(1.0) }
+  end
+
+  def test_nil
+    assert_raises(NoMethodError) {
+      Foo.new(
+        integer: nil, float: nil
+      )._validation_errors
+    }
+  end
+
+  def test_fail
+    errors = Foo.new(
+      integer: 0, float: 0.1
+    )._validation_errors
+
+    assert_equal 'must be greater than 1', errors[:integer][0]
+    assert_equal 'must be greater than 1.0', errors[:float][0]
+  end
+
+  def test_success
+    errors = Foo.new(
+      integer: 2, float: 1.2
+    )._validation_errors
+
+    refute errors.has_key?(:integer)
+    refute errors.has_key?(:float)
+  end
+end

data/test/unit/plugins/validate/predicates/gteq_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class ValidationPredicatesGreaterThanOrEqualToTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+    attribute :integer, Integer, validates { gteq?(1) }
+    attribute :float, Float, validates { gteq?(1.0) }
+  end
+
+  def test_nil
+    assert_raises(NoMethodError) {
+      Foo.new(
+        integer: nil, float: nil
+      )._validation_errors
+    }
+  end
+
+  def test_fail
+    errors = Foo.new(
+      integer: 0, float: 0.9
+    )._validation_errors
+
+    assert_equal 'must be greater than or equal to 1', errors[:integer][0]
+    assert_equal 'must be greater than or equal to 1.0', errors[:float][0]
+  end
+
+  def test_success
+    errors = Foo.new(
+      integer: 1, float: 1.0
+    )._validation_errors
+
+    refute errors.has_key?(:integer)
+    refute errors.has_key?(:float)
+  end
+end

data/test/unit/plugins/validate/predicates/included_in_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class ValidationPredicatesIncludedInTest < MiniTest::Test
+  TIME = Time.now
+  class Foo
+    include Wardrobe(coerce: false)
+    plugin :validation
+    attribute :string,    String,   validates { included_in?(['test']) }
+    attribute :symbol,    Symbol,   validates { included_in?([:test]) }
+    attribute :integer,   Integer,  validates { included_in?([1]) }
+    attribute :float,     Float,    validates { included_in?([1.1]) }
+    attribute :boolean,   Wardrobe::Boolean, validates { included_in?([true]) }
+    attribute :date,      Date,     validates { included_in?([TIME.to_date]) }
+    attribute :time,      Time,     validates { included_in?([TIME]) }
+    attribute :date_time, DateTime, validates { included_in?([TIME.to_datetime]) }
+    attribute :array,     Array,    validates { included_in?([[1]]) }
+    attribute :hash,      Hash,     validates { included_in?([{one: 1}]) }
+  end
+
+  def test_nil
+    errors = Foo.new(
+      string: nil, symbol: nil, integer: nil, float: nil, boolean: nil,
+      date: nil, time: nil, date_time: nil, array: nil, hash: nil
+    )._validation_errors
+
+    assert_equal 'must be one of: "test"', errors[:string][0]
+    assert_equal 'must be one of: :test', errors[:symbol][0]
+    assert_equal 'must be one of: 1', errors[:integer][0]
+    assert_equal 'must be one of: 1.1', errors[:float][0]
+    assert_equal 'must be one of: true', errors[:boolean][0]
+    assert_equal "must be one of: #{TIME.to_date.to_s}", errors[:date][0]
+    assert_equal "must be one of: #{TIME.to_s}", errors[:time][0]
+    assert_equal "must be one of: #{TIME.to_datetime.to_s}", errors[:date_time][0]
+    assert_equal 'must be one of: [1]', errors[:array][0]
+    assert_equal 'must be one of: {:one=>1}', errors[:hash][0]
+  end
+
+  def test_with_values
+    errors = Foo.new(
+      string: 'test', symbol: :test, integer: 1, float: 1.1, boolean: true,
+      date: TIME.to_date, time: TIME, date_time: TIME.to_datetime, array: [1], hash: {one: 1}
+    )._validation_errors
+
+    refute errors.has_key? :string
+    refute errors.has_key? :symbol
+    refute errors.has_key? :integer
+    refute errors.has_key? :float
+    refute errors.has_key? :boolean
+    refute errors.has_key? :date
+    refute errors.has_key? :time
+    refute errors.has_key? :date_time
+    refute errors.has_key? :array
+    refute errors.has_key? :hash
+  end
+end

data/test/unit/plugins/validate/predicates/lt_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class ValidationPredicatesLessThanTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+    attribute :integer, Integer, validates { lt?(1) }
+    attribute :float, Float, validates { lt?(1.0) }
+  end
+
+  def test_nil
+    assert_raises(NoMethodError) {
+      Foo.new(
+        integer: nil, float: nil
+      )._validation_errors
+    }
+  end
+
+  def test_fail
+    errors = Foo.new(
+      integer: 2, float: 1.1
+    )._validation_errors
+
+    assert_equal 'must be less than 1', errors[:integer][0]
+    assert_equal 'must be less than 1.0', errors[:float][0]
+  end
+
+  def test_success
+    errors = Foo.new(
+      integer: 0, float: 0.9
+    )._validation_errors
+
+    refute errors.has_key?(:integer)
+    refute errors.has_key?(:float)
+  end
+end

data/test/unit/plugins/validate/predicates/lteq_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class ValidationPredicatesLessThanOrEqualToTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+    attribute :integer, Integer, validates { lteq?(1) }
+    attribute :float, Float, validates { lteq?(1.0) }
+  end
+
+  def test_nil
+    assert_raises(NoMethodError) {
+      Foo.new(
+        integer: nil, float: nil
+      )._validation_errors
+    }
+  end
+
+  def test_fail
+    errors = Foo.new(
+      integer: 2, float: 1.1
+    )._validation_errors
+
+    assert_equal 'must be less than or equal to 1', errors[:integer][0]
+    assert_equal 'must be less than or equal to 1.0', errors[:float][0]
+  end
+
+  def test_success
+    errors = Foo.new(
+      integer: 1, float: 1.0
+    )._validation_errors
+
+    refute errors.has_key?(:integer)
+    refute errors.has_key?(:float)
+  end
+end

data/test/unit/plugins/validate/predicates/max_size_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class ValidationPredicatesMaxSizeTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+
+    attribute :array,  Array,  validates { max_size?(1) }
+    attribute :hash,   Hash,   validates { max_size?(1) }
+    attribute :set,    Set,    validates { max_size?(1) }
+    attribute :string, String, validates { max_size?(1) }
+  end
+
+  def test_nil
+    assert_raises(NoMethodError) {
+      Foo.new(
+        array: nil, hash: nil, set: nil, string: nil
+      )._validation_errors
+    }
+  end
+
+  def test_fail
+    errors = Foo.new(
+    array: [1, 2], hash: { 1 => 2, 3 => 4 }, set: Set.new([1, 2]), string: '12'
+    )._validation_errors
+
+    assert_equal 'size cannot be greater than 1', errors[:array][0]
+    assert_equal 'size cannot be greater than 1', errors[:hash][0]
+    assert_equal 'size cannot be greater than 1', errors[:set][0]
+    assert_equal 'size cannot be greater than 1', errors[:string][0]
+  end
+
+  def test_success
+    errors = Foo.new(
+      array: [], hash: {}, set: Set.new, string: ''
+    )._validation_errors
+
+    refute errors.has_key?(:array)
+    refute errors.has_key?(:hash)
+    refute errors.has_key?(:set)
+    refute errors.has_key?(:string)
+  end
+end

data/test/unit/plugins/validate/predicates/min_size_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class ValidationPredicatesMinSizeTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+
+    attribute :array,  Array,  validates { min_size?(1) }
+    attribute :hash,   Hash,   validates { min_size?(1) }
+    attribute :set,    Set,    validates { min_size?(1) }
+    attribute :string, String, validates { min_size?(1) }
+  end
+
+  def test_nil
+    assert_raises(NoMethodError) {
+      Foo.new(
+        array: nil, hash: nil, set: nil, string: nil
+      )._validation_errors
+    }
+  end
+
+  def test_fail
+    errors = Foo.new(
+      array: [], hash: {}, set: Set.new, string: ''
+    )._validation_errors
+
+    assert_equal 'size cannot be less than 1', errors[:array][0]
+    assert_equal 'size cannot be less than 1', errors[:hash][0]
+    assert_equal 'size cannot be less than 1', errors[:set][0]
+    assert_equal 'size cannot be less than 1', errors[:string][0]
+  end
+
+  def test_success
+    errors = Foo.new(
+      array: [1], hash: { 1 => 2 }, set: Set.new([1]), string: '1'
+    )._validation_errors
+
+    refute errors.has_key?(:array)
+    refute errors.has_key?(:hash)
+    refute errors.has_key?(:set)
+    refute errors.has_key?(:string)
+  end
+end

data/test/unit/plugins/validate/predicates/none_test.rb

@@ -0,0 +1,49 @@
+# require 'test_helper'
+#
+# class ValidationPredicatesNoneTest < MiniTest::Test
+#   class Foo
+#     include Wardrobe
+#     plugin :validation
+#     attribute :string, String, validates { none? }
+#     attribute :symbol, Symbol, validates { none? }
+#     attribute :array, Array, validates { none? }
+#     attribute :hash, Hash, validates { none? }
+#     attribute :set, Set, validates { none? }
+#   end
+#
+#   def test_nil
+#     errors = Foo.new(
+#       string: nil, symbol: nil, array: nil, hash: nil, set: nil
+#     )._validation_errors
+#
+#     assert_equal 'must be filled', errors[:string][0]
+#     assert_equal 'must be filled', errors[:symbol][0]
+#     assert_equal 'must be filled', errors[:array][0]
+#     assert_equal 'must be filled', errors[:hash][0]
+#     assert_equal 'must be filled', errors[:set][0]
+#   end
+#
+#   def test_empty
+#     errors = Foo.new(
+#       string: '', symbol: :'', array: [], hash: {}, set: Set.new
+#     )._validation_errors
+#
+#     assert_equal 'must be filled', errors[:string][0]
+#     assert_equal 'must be filled', errors[:symbol][0]
+#     assert_equal 'must be filled', errors[:array][0]
+#     assert_equal 'must be filled', errors[:hash][0]
+#     assert_equal 'must be filled', errors[:set][0]
+#   end
+#
+#   def test_with_content
+#     errors = Foo.new(
+#       string: 'Bar', symbol: :'Bar', array: ['Bar'], hash: {foo: 'Bar'}, set: Set.new(['Bar'])
+#     )._validation_errors
+#
+#     refute errors.has_key?(:string)
+#     refute errors.has_key?(:symbol)
+#     refute errors.has_key?(:array)
+#     refute errors.has_key?(:hash)
+#     refute errors.has_key?(:set)
+#   end
+# end

data/test/unit/plugins/validate/predicates/odd_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class ValidationPredicatesOddTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+    attribute :integer, Integer, validates { odd? }
+  end
+
+  def test_nil
+    assert_raises(NoMethodError) {
+      Foo.new(
+        integer: nil
+      )._validation_errors
+    }
+  end
+
+  def test_fail
+    errors = Foo.new(
+      integer: 0
+    )._validation_errors
+
+    assert_equal 'must be odd', errors[:integer][0]
+  end
+
+  def test_success
+    errors = Foo.new(
+      integer: 1
+    )._validation_errors
+
+    refute errors.has_key?(:integer)
+  end
+end

data/test/unit/plugins/validate/predicates/size_range_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class ValidationPredicatesSizeRangeTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+
+    attribute :array,  Array,  validates { size?(1..3) }
+    attribute :hash,   Hash,   validates { size?(1..3) }
+    attribute :set,    Set,    validates { size?(1..3) }
+    attribute :string, String, validates { size?(1..3) }
+  end
+
+  def test_nil
+    assert_raises(NoMethodError) {
+      Foo.new(
+        array: nil, hash: nil, set: nil, string: nil
+      )._validation_errors
+    }
+  end
+
+  def test_fail
+    errors = Foo.new(
+      array: [], hash: {}, set: Set.new, string: ''
+    )._validation_errors
+
+    assert_equal 'size must be within 1 - 3', errors[:array][0]
+    assert_equal 'size must be within 1 - 3', errors[:hash][0]
+    assert_equal 'size must be within 1 - 3', errors[:set][0]
+    assert_equal 'size must be within 1 - 3', errors[:string][0]
+  end
+
+  def test_success
+    errors = Foo.new(
+      array: [1], hash: { 1 => 2 }, set: Set.new([1]), string: '1'
+    )._validation_errors
+
+    refute errors.has_key?(:array)
+    refute errors.has_key?(:hash)
+    refute errors.has_key?(:set)
+    refute errors.has_key?(:string)
+  end
+end

data/test/unit/plugins/validate/predicates/size_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class ValidationPredicatesSizeTest < MiniTest::Test
+  class Foo
+    include Wardrobe
+    plugin :validation
+
+    attribute :array,  Array,  validates { size?(1) }
+    attribute :hash,   Hash,   validates { size?(1) }
+    attribute :set,    Set,    validates { size?(1) }
+    attribute :string, String, validates { size?(1) }
+  end
+
+  def test_nil
+    assert_raises(NoMethodError) {
+      Foo.new(
+        array: nil, hash: nil, set: nil, string: nil
+      )._validation_errors
+    }
+  end
+
+  def test_fail
+    errors = Foo.new(
+      array: [], hash: {}, set: Set.new, string: ''
+    )._validation_errors
+
+    assert_equal 'size must be 1', errors[:array][0]
+    assert_equal 'size must be 1', errors[:hash][0]
+    assert_equal 'size must be 1', errors[:set][0]
+    assert_equal 'size must be 1', errors[:string][0]
+  end
+
+  def test_success
+    errors = Foo.new(
+      array: [1], hash: { 1 => 2 }, set: Set.new([1]), string: '1'
+    )._validation_errors
+
+    refute errors.has_key?(:array)
+    refute errors.has_key?(:hash)
+    refute errors.has_key?(:set)
+    refute errors.has_key?(:string)
+  end
+end