mutations 0.9.0 → 0.9.2

data/spec/date_filter_spec.rb

@@ -6,7 +6,7 @@ describe "Mutations::DateFilter" do
     f = Mutations::DateFilter.new
     filtered, errors = f.filter(date)
     assert_equal date, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
   
   it "takes a DateTime object" do
@@ -14,19 +14,15 @@ describe "Mutations::DateFilter" do
     f = Mutations::DateFilter.new
     filtered, errors = f.filter(date)
     assert_equal date, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
   
   it "takes a Time object and converts it to a date" do
     time = Time.now
     f = Mutations::DateFilter.new
     filtered, errors = f.filter(time)
-    if time.respond_to?(:to_date) # 1.8.7 doesn't support to_date
-      assert_equal time.to_date, filtered
-      assert_equal nil, errors
-    else
-      assert_equal :date, errors
-    end
+    assert_equal time.to_date, filtered
+    assert_nil errors
   end
 
   it "checks if the given date is after a certain date" do
@@ -36,7 +32,7 @@ describe "Mutations::DateFilter" do
     filtered, errors = f.filter(date)
 
     assert_equal date, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "gives errors when the given date is before the after date" do
@@ -45,7 +41,7 @@ describe "Mutations::DateFilter" do
     f = Mutations::DateFilter.new(:after => after_date)
     filtered, errors = f.filter(date)
 
-    assert_equal nil, filtered
+    assert_nil filtered
     assert_equal :after, errors
   end
 
@@ -56,7 +52,7 @@ describe "Mutations::DateFilter" do
     filtered, errors = f.filter(date)
 
     assert_equal date, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "gives errors when the given date is after the before date" do
@@ -65,7 +61,7 @@ describe "Mutations::DateFilter" do
     f = Mutations::DateFilter.new(:before => before_date)
     filtered, errors = f.filter(date)
 
-    assert_equal nil, filtered
+    assert_nil filtered
     assert_equal :before, errors
   end
 
@@ -77,7 +73,7 @@ describe "Mutations::DateFilter" do
     filtered, errors = f.filter(date)
 
     assert_equal date, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "should be able to parse a D-M-Y string to a date" do
@@ -87,7 +83,7 @@ describe "Mutations::DateFilter" do
     filtered, errors = f.filter(date_string)
 
     assert_equal date, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "should be able to parse a Y-M-D string to a date" do
@@ -97,7 +93,7 @@ describe "Mutations::DateFilter" do
     filtered, errors = f.filter(date_string)
 
     assert_equal date, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "should be able to handle date formatting" do
@@ -107,21 +103,21 @@ describe "Mutations::DateFilter" do
     filtered, errors = f.filter(date_string)
 
     assert_equal date, filtered
-    assert_equal nil, errors
+    assert_nil errors
 
     date_string = "1, 2, 2000"
     f = Mutations::DateFilter.new(:format => '%m, %d, %Y')
     filtered, errors = f.filter(date_string)
 
     assert_equal date, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "considers nil to be invalid" do
     f = Mutations::DateFilter.new
     filtered, errors = f.filter(nil)
 
-    assert_equal nil, filtered
+    assert_nil filtered
     assert_equal :nils, errors
   end
 
@@ -136,8 +132,8 @@ describe "Mutations::DateFilter" do
     f = Mutations::DateFilter.new(:nils => true)
     filtered, errors = f.filter(nil)
 
-    assert_equal nil, filtered
-    assert_equal nil, errors
+    assert_nil filtered
+    assert_nil errors
   end
 
   it "considers empty strings to be nil if empty_is_nil option is used" do
@@ -149,8 +145,8 @@ describe "Mutations::DateFilter" do
   it "returns empty strings as nil if empty_is_nil option is used" do
     f = Mutations::DateFilter.new(:empty_is_nil => true, :nils => true)
     filtered, errors = f.filter("")
-    assert_equal nil, filtered
-    assert_equal nil, errors
+    assert_nil filtered
+    assert_nil errors
   end
 
   it "doesn't allow non-existing dates" do
@@ -158,7 +154,7 @@ describe "Mutations::DateFilter" do
     f = Mutations::DateFilter.new
     filtered, errors = f.filter(date_string)
 
-    assert_equal nil, filtered
+    assert_nil filtered
     assert_equal :date, errors
   end
 end

data/spec/default_spec.rb

@@ -16,13 +16,13 @@ describe 'Mutations - defaults' do
   it "should have a default if no value is passed" do
     outcome = DefaultCommand.run
     assert_equal true, outcome.success?
-    assert_equal ({"name" => "Bob Jones"}), outcome.result
+    assert_equal({"name" => "Bob Jones"}, outcome.result)
   end
 
   it "should have the passed value if a value is passed" do
     outcome = DefaultCommand.run(:name => "Fred")
     assert_equal true, outcome.success?
-    assert_equal ({"name" => "Fred"}), outcome.result
+    assert_equal({"name" => "Fred"}, outcome.result)
   end
 
   it "should be an error if nil is passed on a required field with a default" do

data/spec/duck_filter_spec.rb

@@ -6,11 +6,11 @@ describe "Mutations::DuckFilter" do
     f = Mutations::DuckFilter.new(:methods => [:length])
     filtered, errors = f.filter("test")
     assert_equal "test", filtered
-    assert_equal nil, errors
+    assert_nil errors
 
     filtered, errors = f.filter([1, 2])
     assert_equal [1, 2], filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "doesn't allow objects that respond to a single specified method" do
@@ -27,15 +27,15 @@ describe "Mutations::DuckFilter" do
   it "considers nil to be invalid" do
     f = Mutations::DuckFilter.new(:nils => false)
     filtered, errors = f.filter(nil)
-    assert_equal nil, filtered
+    assert_nil filtered
     assert_equal :nils, errors
   end
 
   it "considers nil to be valid" do
     f = Mutations::DuckFilter.new(:nils => true)
     filtered, errors = f.filter(nil)
-    assert_equal nil, filtered
-    assert_equal nil, errors
+    assert_nil filtered
+    assert_nil errors
   end
 
   it "Allows anything if no methods are specified" do
@@ -43,7 +43,7 @@ describe "Mutations::DuckFilter" do
     [true, "hi", 1, [1, 2, 3]].each do |v|
       filtered, errors = f.filter(v)
       assert_equal v, filtered
-      assert_equal nil, errors
+      assert_nil errors
     end
   end
 end

data/spec/errors_spec.rb

@@ -26,33 +26,33 @@ describe "Mutations - errors" do
     o = GivesErrors.run(:hash1 => 1, :arr1 => "bob")
 
     assert !o.success?
-    assert o.errors.is_a?(Mutations::ErrorHash)
-    assert o.errors[:str1].is_a?(Mutations::ErrorAtom)
-    assert o.errors[:str2].is_a?(Mutations::ErrorAtom)
+    assert_kind_of Mutations::ErrorHash, o.errors
+    assert_kind_of Mutations::ErrorAtom, o.errors[:str1]
+    assert_kind_of Mutations::ErrorAtom, o.errors[:str2]
     assert_nil o.errors[:int1]
-    assert o.errors[:hash1].is_a?(Mutations::ErrorAtom)
-    assert o.errors[:arr1].is_a?(Mutations::ErrorAtom)
+    assert_kind_of Mutations::ErrorAtom, o.errors[:hash1]
+    assert_kind_of Mutations::ErrorAtom, o.errors[:arr1]
   end
 
   it "returns an ErrorHash for nested hashes" do
     o = GivesErrors.run(:hash1 => {:bool1 => "poop"})
 
     assert !o.success?
-    assert o.errors.is_a?(Mutations::ErrorHash)
-    assert o.errors[:hash1].is_a?(Mutations::ErrorHash)
-    assert o.errors[:hash1][:bool1].is_a?(Mutations::ErrorAtom)
-    assert o.errors[:hash1][:bool2].is_a?(Mutations::ErrorAtom)
+    assert_kind_of Mutations::ErrorHash, o.errors
+    assert_kind_of Mutations::ErrorHash, o.errors[:hash1]
+    assert_kind_of Mutations::ErrorAtom, o.errors[:hash1][:bool1]
+    assert_kind_of Mutations::ErrorAtom, o.errors[:hash1][:bool2]
   end
 
   it "returns an ErrorArray for errors in arrays" do
     o = GivesErrors.run(:str1 => "a", :str2 => "opt1", :arr1 => ["bob", 1, "sally"])
 
     assert !o.success?
-    assert o.errors.is_a?(Mutations::ErrorHash)
-    assert o.errors[:arr1].is_a?(Mutations::ErrorArray)
-    assert o.errors[:arr1][0].is_a?(Mutations::ErrorAtom)
+    assert_kind_of Mutations::ErrorHash, o.errors
+    assert_kind_of Mutations::ErrorArray, o.errors[:arr1]
+    assert_kind_of Mutations::ErrorAtom, o.errors[:arr1][0]
     assert_nil o.errors[:arr1][1]
-    assert o.errors[:arr1][2].is_a?(Mutations::ErrorAtom)
+    assert_kind_of Mutations::ErrorAtom, o.errors[:arr1][2]
   end
 
   describe "error messages" do
@@ -97,7 +97,7 @@ describe "Mutations - errors" do
       expected = ["Str1 can't be blank", "Str2 isn't an option", "Int1 isn't an integer", "Bool1 isn't a boolean", "Bool2 is required", "Arr1[0] isn't an integer", "Arr1[2] isn't an integer"]
 
       assert_equal expected.size, @outcome.errors.message_list.size
-      expected.each { |e| assert @outcome.errors.message_list.include?(e) }
+      expected.each { |e| assert_includes @outcome.errors.message_list, e }
     end
   end
 

data/spec/file_filter_spec.rb

@@ -8,16 +8,12 @@ describe "Mutations::FileFilter" do
     attr_accessor :content_type, :original_filename
   end
 
-  # NOTE: Ruby 1.8.7 doesn't have file.size. Mutations need file to respond to size.
-  # Therefore, in 1.8.7 File objects are invalid files.
-  if File.new("README.md").respond_to?(:size)
-    it "allows files - file class" do
-      file = File.new("README.md")
-      f = Mutations::FileFilter.new
-      filtered, errors = f.filter(file)
-      assert_equal file, filtered
-      assert_equal nil, errors
-    end
+  it "allows files - file class" do
+    file = File.new("README.md")
+    f = Mutations::FileFilter.new
+    filtered, errors = f.filter(file)
+    assert_equal file, filtered
+    assert_nil errors
   end
 
   it "allows files - stringio class" do
@@ -25,15 +21,15 @@ describe "Mutations::FileFilter" do
     f = Mutations::FileFilter.new
     filtered, errors = f.filter(file)
     assert_equal file, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "allows files - tempfile" do
     file = Tempfile.new("bob")
     f = Mutations::FileFilter.new
     filtered, errors = f.filter(file)
-    assert filtered.is_a?(Tempfile) # NOTE: 1.9.3 and 1.8.7 treat == and eql? differently
-    assert_equal nil, errors
+    assert_equal file, filtered
+    assert_nil errors
   end
 
   it "doesn't allow non-files" do
@@ -50,15 +46,15 @@ describe "Mutations::FileFilter" do
   it "considers nil to be invalid" do
     f = Mutations::FileFilter.new(:nils => false)
     filtered, errors = f.filter(nil)
-    assert_equal nil, filtered
+    assert_nil filtered
     assert_equal :nils, errors
   end
 
   it "considers nil to be valid" do
     f = Mutations::FileFilter.new(:nils => true)
     filtered, errors = f.filter(nil)
-    assert_equal nil, filtered
-    assert_equal nil, errors
+    assert_nil filtered
+    assert_nil errors
   end
   
   it "considers empty strings to be empty" do
@@ -72,7 +68,7 @@ describe "Mutations::FileFilter" do
     f = Mutations::FileFilter.new(:size => 4)
     filtered, errors = f.filter(file)
     assert_equal file, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "shouldn't allow big files" do
@@ -88,7 +84,7 @@ describe "Mutations::FileFilter" do
     f = Mutations::FileFilter.new(:upload => true)
     filtered, errors = f.filter(file)
     assert_equal file, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "should require extra methods if uploaded file: deny" do

data/spec/float_filter_spec.rb

@@ -6,42 +6,42 @@ describe "Mutations::FloatFilter" do
     f = Mutations::FloatFilter.new
     filtered, errors = f.filter(3.1415926)
     assert_equal 3.1415926, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "allows strings that start with a digit" do
     f = Mutations::FloatFilter.new
     filtered, errors = f.filter("3")
     assert_equal 3.0, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "allows string representation of float" do
     f = Mutations::FloatFilter.new
     filtered, errors = f.filter("3.14")
     assert_equal 3.14, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "allows string representation of float without a number before dot" do
     f = Mutations::FloatFilter.new
     filtered, errors = f.filter(".14")
     assert_equal 0.14, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "allows negative strings" do
     f = Mutations::FloatFilter.new
     filtered, errors = f.filter("-.14")
     assert_equal(-0.14, filtered)
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "allows strings with a positive sign" do
     f = Mutations::FloatFilter.new
     filtered, errors = f.filter("+.14")
     assert_equal 0.14, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "doesnt't allow other strings, nor does it allow random objects or symbols" do
@@ -55,15 +55,15 @@ describe "Mutations::FloatFilter" do
   it "considers nil to be invalid" do
     f = Mutations::FloatFilter.new(:nils => false)
     filtered, errors = f.filter(nil)
-    assert_equal nil, filtered
+    assert_nil filtered
     assert_equal :nils, errors
   end
 
   it "considers nil to be valid" do
     f = Mutations::FloatFilter.new(:nils => true)
     filtered, errors = f.filter(nil)
-    assert_equal nil, filtered
-    assert_equal nil, errors
+    assert_nil filtered
+    assert_nil errors
   end
   
   it "considers empty strings to be empty" do
@@ -83,7 +83,7 @@ describe "Mutations::FloatFilter" do
     f = Mutations::FloatFilter.new(:min => 10)
     filtered, errors = f.filter(31)
     assert_equal 31, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "considers high numbers invalid" do
@@ -97,7 +97,7 @@ describe "Mutations::FloatFilter" do
     f = Mutations::FloatFilter.new(:max => 10)
     filtered, errors = f.filter(3)
     assert_equal 3, filtered
-    assert_equal nil, errors
+    assert_nil errors
   end
 
 end

data/spec/hash_filter_spec.rb

@@ -8,8 +8,8 @@ describe "Mutations::HashFilter" do
       string :foo
     end
     filtered, errors = hf.filter(:foo => "bar")
-    assert_equal ({"foo" => "bar"}), filtered
-    assert_equal nil, errors
+    assert_equal({"foo" => "bar"}, filtered)
+    assert_nil errors
   end
 
   it 'disallows non-hashes' do
@@ -29,7 +29,7 @@ describe "Mutations::HashFilter" do
       string :foo
     end
     _filtered, errors = hf.filter(input)
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "allows wildcards in hashes" do
@@ -37,8 +37,8 @@ describe "Mutations::HashFilter" do
       string :*
     end
     filtered, errors = hf.filter(:foo => "bar", :baz => "ban")
-    assert_equal ({"foo" => "bar", "baz" => "ban"}), filtered
-    assert_equal nil, errors
+    assert_equal({"foo" => "bar", "baz" => "ban"}, filtered)
+    assert_nil errors
   end
 
   it "allows floats in hashes" do
@@ -46,8 +46,8 @@ describe "Mutations::HashFilter" do
       float :foo
     end
     filtered, errors = hf.filter(:foo => 3.14)
-    assert_equal ({"foo" => 3.14}), filtered
-    assert_equal nil, errors
+    assert_equal({"foo" => 3.14}, filtered)
+    assert_nil errors
   end
 
   it "allows ducks in hashes" do
@@ -55,8 +55,8 @@ describe "Mutations::HashFilter" do
       duck :foo, :methods => [:length]
     end
     filtered, errors = hf.filter(:foo => "123")
-    assert_equal ({"foo" => "123"}), filtered
-    assert_equal nil, errors
+    assert_equal({"foo" => "123"}, filtered)
+    assert_nil errors
   end
 
   it "allows dates in hashes" do
@@ -65,7 +65,7 @@ describe "Mutations::HashFilter" do
     end
     filtered, errors = hf.filter(:foo => "1-1-2000")
     assert_equal Date.new(2000, 1, 1), filtered[:foo]
-    assert_equal nil, errors
+    assert_nil errors
   end
 
   it "allows files in hashes" do
@@ -74,8 +74,8 @@ describe "Mutations::HashFilter" do
       file :foo
     end
     filtered, errors = hf.filter(:foo => sio)
-    assert_equal ({"foo" => sio}), filtered
-    assert_equal nil, errors
+    assert_equal({"foo" => sio}, filtered)
+    assert_nil errors
   end
 
   it "doesn't allow wildcards in hashes" do
@@ -83,7 +83,7 @@ describe "Mutations::HashFilter" do
       string :*
     end
     _filtered, errors = hf.filter(:foo => [])
-    assert_equal ({"foo" => :string}), errors.symbolic
+    assert_equal({"foo" => :string}, errors.symbolic)
   end
 
   it "allows a mix of specific keys and then wildcards" do
@@ -92,8 +92,8 @@ describe "Mutations::HashFilter" do
       integer :*
     end
     filtered, errors = hf.filter(:foo => "bar", :baz => "4")
-    assert_equal ({"foo" => "bar", "baz" => 4}), filtered
-    assert_equal nil, errors
+    assert_equal({"foo" => "bar", "baz" => 4}, filtered)
+    assert_nil errors
   end
 
   it "doesn't allow a mix of specific keys and then wildcards -- should raise errors appropriately" do
@@ -102,7 +102,7 @@ describe "Mutations::HashFilter" do
       integer :*
     end
     _filtered, errors = hf.filter(:foo => "bar", :baz => "poopin")
-    assert_equal ({"baz" => :integer}), errors.symbolic
+    assert_equal({"baz" => :integer}, errors.symbolic)
   end
 
   describe "optional params and nils" do
@@ -117,8 +117,8 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar")
-      assert_equal ({"foo" => "bar"}), filtered
-      assert_equal nil, errors
+      assert_equal({"foo" => "bar"}, filtered)
+      assert_nil errors
     end
 
     it "bar is optional -- it works if nil is passed" do
@@ -132,8 +132,8 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => nil)
-      assert_equal ({"foo" => "bar"}), filtered
-      assert_equal nil, errors
+      assert_equal({"foo" => "bar"}, filtered)
+      assert_nil errors
     end
 
     it "bar is optional -- it works if nil is passed and nils are allowed" do
@@ -147,8 +147,8 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => nil)
-      assert_equal ({"foo" => "bar", "bar" => nil}), filtered
-      assert_equal nil, errors
+      assert_equal({"foo" => "bar", "bar" => nil}, filtered)
+      assert_nil errors
     end
   end
 
@@ -164,8 +164,8 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => "")
-      assert_equal ({"foo" => "bar"}), filtered
-      assert_equal nil, errors
+      assert_equal({"foo" => "bar"}, filtered)
+      assert_nil errors
     end
     
     it "bar is optional -- discards empty if it needs to be stripped" do
@@ -179,8 +179,8 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => " ")
-      assert_equal ({"foo" => "bar"}), filtered
-      assert_equal nil, errors
+      assert_equal({"foo" => "bar"}, filtered)
+      assert_nil errors
     end
     
     it "bar is optional -- don't discard empty if it's spaces but stripping is off" do
@@ -194,8 +194,8 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => " ")
-      assert_equal ({"foo" => "bar", "bar" => " "}), filtered
-      assert_equal nil, errors
+      assert_equal({"foo" => "bar", "bar" => " "}, filtered)
+      assert_nil errors
     end
 
     it "bar is optional -- errors if discard_empty is false and value is blank" do
@@ -209,7 +209,7 @@ describe "Mutations::HashFilter" do
       end
 
       _filtered, errors = hf.filter(:foo => "bar", :bar => "")
-      assert_equal ({"bar" => :empty}), errors.symbolic
+      assert_equal({"bar" => :empty}, errors.symbolic)
     end
 
     it "bar is optional -- discards empty -- now with wildcards" do
@@ -223,8 +223,8 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => "", :baz => "\t")
-      assert_equal ({"foo" => "bar"}), filtered
-      assert_equal nil, errors
+      assert_equal({"foo" => "bar"}, filtered)
+      assert_nil errors
     end
   end
 
@@ -240,8 +240,8 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => "baz")
-      assert_equal ({"foo" => "bar"}), filtered
-      assert_equal nil, errors
+      assert_equal({"foo" => "bar"}, filtered)
+      assert_nil errors
     end
 
     it "should discard invalid optional values for wildcards" do
@@ -255,8 +255,8 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => "baz", :wat => 1)
-      assert_equal ({"foo" => "bar", "wat" => 1}), filtered
-      assert_equal nil, errors
+      assert_equal({"foo" => "bar", "wat" => 1}, filtered)
+      assert_nil errors
     end
 
 
@@ -268,7 +268,7 @@ describe "Mutations::HashFilter" do
       end
 
       _filtered, errors = hf.filter(:foo => "bar")
-      assert_equal ({"foo" => :integer}), errors.symbolic
+      assert_equal({"foo" => :integer}, errors.symbolic)
     end
   end