mutations 0.5.0

data/spec/errors_spec.rb

@@ -0,0 +1,93 @@
+require_relative 'spec_helper'
+
+describe "Mutations - errors" do
+  
+  class GivesErrors < Mutations::Command
+    required do
+      string :str1
+      string :str2, :in => %w(opt1 opt2 opt3)
+    end
+    
+    optional do
+      integer :int1
+      hash :hash1 do
+        boolean :bool1
+        boolean :bool2
+      end
+      array :arr1 do integer end
+    end
+    
+    def execute
+      inputs
+    end
+  end
+  
+  it "returns an ErrorHash as the top level error object, and ErrorAtom's inside" 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_nil o.errors[:int1]
+    assert o.errors[:hash1].is_a?(Mutations::ErrorAtom)
+    assert o.errors[:arr1].is_a?(Mutations::ErrorAtom)
+  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)
+  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_nil o.errors[:arr1][1]
+    assert o.errors[:arr1][2].is_a?(Mutations::ErrorAtom)
+  end
+  
+  it "titleizes keys" do
+    atom = Mutations::ErrorAtom.new(:newsletter_subscription, :boolean)
+    assert_equal "Newsletter Subscription isn't a boolean", atom.message
+  end
+  
+  describe "Bunch o errors" do
+    before do 
+      @outcome = GivesErrors.run(str1: "", str2: "opt9", int1: "zero", hash1: {bool1: "bob"}, arr1: ["bob", 1, "sally"])
+    end
+    
+    it "gives symbolic errors" do
+      expected = {"str1"=>:empty,
+       "str2"=>:in,
+       "int1"=>:integer,
+       "hash1"=>{"bool1"=>:boolean, "bool2"=>:required},
+       "arr1"=>[:integer, nil, :integer]}
+
+      assert_equal expected, @outcome.errors.symbolic
+    end
+    
+    it "gives messages" do
+      expected = {"str1"=>"Str1 can't be blank", "str2"=>"Str2 isn't an option", "int1"=>"Int1 isn't an integer", "hash1"=>{"bool1"=>"Bool1 isn't a boolean", "bool2"=>"Bool2 is required"}, "arr1"=>["Arr1[0] isn't an integer", nil, "Arr1[2] isn't an integer"]}
+
+      assert_equal expected, @outcome.errors.message
+    end
+    
+    it "can flatten those messages" 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, @outcome.errors.message_list
+    end
+  end
+  
+  
+  
+end

data/spec/inheritance_spec.rb

@@ -0,0 +1,39 @@
+require_relative 'spec_helper'
+require 'simple_command'
+
+describe 'Mutations - inheritance' do
+  
+  class SimpleInherited < SimpleCommand
+    
+    required do
+      integer :age
+    end
+    
+    def execute
+      @filtered_input
+    end
+  end
+  
+  it 'should filter with inherited command' do
+    mutation = SimpleInherited.run(name: "bob", email: "jon@jones.com", age: 10, amount: 22)
+    assert mutation.success?
+    assert_equal HashWithIndifferentAccess.new(name: "bob", email: "jon@jones.com", age: 10, amount: 22), mutation.result
+  end
+  
+  it 'should filter with original command' do
+    mutation = SimpleCommand.run(name: "bob", email: "jon@jones.com", age: 10, amount: 22)
+    assert mutation.success?
+    assert_equal HashWithIndifferentAccess.new(name: "bob", email: "jon@jones.com", amount: 22), mutation.result
+  end
+  
+  it 'shouldnt collide' do
+    mutation = SimpleInherited.run(name: "bob", email: "jon@jones.com", age: 10, amount: 22)
+    assert mutation.success?
+    assert_equal HashWithIndifferentAccess.new(name: "bob", email: "jon@jones.com", age: 10, amount: 22), mutation.result
+    
+    mutation = SimpleCommand.run(name: "bob", email: "jon@jones.com", age: 10, amount: 22)
+    assert mutation.success?
+    assert_equal HashWithIndifferentAccess.new(name: "bob", email: "jon@jones.com", amount: 22), mutation.result
+  end
+  
+end

data/spec/integer_filter_spec.rb

@@ -0,0 +1,76 @@
+require_relative 'spec_helper'
+
+describe "Mutations::IntegerFilter" do
+  
+  it "allows integers" do
+    f = Mutations::IntegerFilter.new
+    filtered, errors = f.filter(3)
+    assert_equal 3, filtered
+    assert_equal nil, errors
+  end
+  
+  it "allows strings that start with a digit" do
+    f = Mutations::IntegerFilter.new
+    filtered, errors = f.filter("3")
+    assert_equal 3, filtered
+    assert_equal nil, errors
+  end
+  
+  it "allows negative strings" do
+    f = Mutations::IntegerFilter.new
+    filtered, errors = f.filter("-3")
+    assert_equal -3, filtered
+    assert_equal nil, errors
+  end
+  
+  it "doesnt't allow other strings, nor does it allow random objects or symbols" do
+    f = Mutations::IntegerFilter.new
+    ["zero","a1", {}, [], Object.new, :d].each do |thing|
+      filtered, errors = f.filter(thing)
+      assert_equal :integer, errors
+    end
+  end
+  
+  it "considers nil to be invalid" do
+    f = Mutations::IntegerFilter.new(nils: false)
+    filtered, errors = f.filter(nil)
+    assert_equal nil, filtered
+    assert_equal :nils, errors
+  end
+  
+  it "considers nil to be valid" do
+    f = Mutations::IntegerFilter.new(nils: true)
+    filtered, errors = f.filter(nil)
+    assert_equal nil, filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers low numbers invalid" do
+    f = Mutations::IntegerFilter.new(min: 10)
+    filtered, errors = f.filter(3)
+    assert_equal 3, filtered
+    assert_equal :min, errors
+  end
+  
+  it "considers low numbers valid" do
+    f = Mutations::IntegerFilter.new(min: 10)
+    filtered, errors = f.filter(31)
+    assert_equal 31, filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers high numbers invalid" do
+    f = Mutations::IntegerFilter.new(max: 10)
+    filtered, errors = f.filter(31)
+    assert_equal 31, filtered
+    assert_equal :max, errors
+  end
+  
+  it "considers high numbers vaild" do
+    f = Mutations::IntegerFilter.new(max: 10)
+    filtered, errors = f.filter(3)
+    assert_equal 3, filtered
+    assert_equal nil, errors
+  end
+  
+end

data/spec/model_filter_spec.rb

@@ -0,0 +1,92 @@
+require_relative 'spec_helper'
+
+describe "Mutations::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 = Mutations::ModelFilter.new(:simple_model)
+    m = SimpleModel.new
+    filtered, errors = f.filter(m)
+    assert_equal m, filtered
+    assert_equal nil, errors
+  end
+  
+  # it "disallows different types of models" do
+  # end
+  
+  it "raises an exception during initialization if constantization fails" do
+    assert_raises NameError do
+      Mutations::ModelFilter.new(:complex_model)
+    end
+  end
+  
+  it "raises an exception during initialization if constantization of class fails" do
+    assert_raises NameError do
+      Mutations::ModelFilter.new(:simple_model, class: "ComplexModel")
+    end
+  end
+  
+  it "raises an exception during initialization if constantization of builder fails" do
+    assert_raises NameError do
+      Mutations::ModelFilter.new(:simple_model, builder: "ComplexModel")
+    end
+  end
+  
+  it "considers nil to be invalid" do
+    f = Mutations::ModelFilter.new(:simple_model, nils: false)
+    filtered, errors = f.filter(nil)
+    assert_equal nil, filtered
+    assert_equal :nils, errors
+  end
+  
+  it "considers nil to be valid" do
+    f = Mutations::ModelFilter.new(:simple_model, nils: true)
+    filtered, errors = f.filter(nil)
+    assert_equal nil, filtered
+    assert_equal nil, errors
+  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/mutations_spec.rb

@@ -0,0 +1,9 @@
+require_relative 'spec_helper'
+
+describe 'Mutations' do
+  
+  it 'should have a version' do
+    assert Mutations::VERSION.is_a?(String)
+  end
+  
+end

data/spec/simple_command.rb

@@ -0,0 +1,15 @@
+class SimpleCommand < Mutations::Command
+  
+  required do
+    string :name, max_length: 10
+    string :email
+  end
+  
+  optional do
+    integer :amount
+  end
+  
+  def execute
+    inputs
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'minitest/unit'
+require 'minitest/pride'
+require 'minitest/autorun'
+require 'pp'
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'mutations'

data/spec/string_filter_spec.rb

@@ -0,0 +1,138 @@
+require_relative 'spec_helper'
+
+describe "Mutations::StringFilter" do
+
+  it "allows valid strings" do
+    sf = Mutations::StringFilter.new
+    filtered, errors = sf.filter("hello")
+    assert_equal "hello", filtered
+    assert_equal nil, errors
+  end
+  
+  it "allows symbols" do
+    sf = Mutations::StringFilter.new
+    filtered, errors = sf.filter(:hello)
+    assert_equal "hello", filtered
+    assert_equal nil, errors
+  end
+  
+  it "allows fixnums" do
+    sf = Mutations::StringFilter.new
+    filtered, errors = sf.filter(1)
+    assert_equal "1", filtered
+    assert_equal nil, errors
+  end
+  
+  it "disallows non-string" do
+    sf = Mutations::StringFilter.new
+    [["foo"], {a: "1"}, Object.new].each do |thing|
+      filtered, errors = sf.filter(thing)
+      assert_equal :string, errors
+    end
+  end
+  
+  it "strips" do
+    sf = Mutations::StringFilter.new(strip: true)
+    filtered, errors = sf.filter(" hello ")
+    assert_equal "hello", filtered
+    assert_equal nil, errors
+  end
+  
+  it "doesn't strip" do
+    sf = Mutations::StringFilter.new(strip: false)
+    filtered, errors = sf.filter(" hello ")
+    assert_equal " hello ", filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers nil to be invalid" do
+    sf = Mutations::StringFilter.new(nils: false)
+    filtered, errors = sf.filter(nil)
+    assert_equal nil, filtered
+    assert_equal :nils, errors
+  end
+  
+  it "considers nil to be valid" do
+    sf = Mutations::StringFilter.new(nils: true)
+    filtered, errors = sf.filter(nil)
+    assert_equal nil, filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers empty strings to be invalid" do
+    sf = Mutations::StringFilter.new(empty: false)
+    filtered, errors = sf.filter("")
+    assert_equal "", filtered
+    assert_equal :empty, errors
+  end
+  
+  it "considers empty strings to be valid" do
+    sf = Mutations::StringFilter.new(empty: true)
+    filtered, errors = sf.filter("")
+    assert_equal "", filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers stripped strings that are empty to be invalid" do
+    sf = Mutations::StringFilter.new(empty: false)
+    filtered, errors = sf.filter("   ")
+    assert_equal "", filtered
+    assert_equal :empty, errors
+  end
+  
+  it "considers long strings to be invalid" do
+    sf = Mutations::StringFilter.new(max_length: 5)
+    filtered, errors = sf.filter("123456")
+    assert_equal "123456", filtered
+    assert_equal :max_length, errors
+  end
+  
+  it "considers long strings to be valid" do
+    sf = Mutations::StringFilter.new(max_length: 5)
+    filtered, errors = sf.filter("12345")
+    assert_equal "12345", filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers short strings to be invalid" do
+    sf = Mutations::StringFilter.new(min_length: 5)
+    filtered, errors = sf.filter("1234")
+    assert_equal "1234", filtered
+    assert_equal :min_length, errors
+  end
+  
+  it "considers short strings to be valid" do
+    sf = Mutations::StringFilter.new(min_length: 5)
+    filtered, errors = sf.filter("12345")
+    assert_equal "12345", filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers bad matches to be invalid" do
+    sf = Mutations::StringFilter.new(matches: /aaa/)
+    filtered, errors = sf.filter("aab")
+    assert_equal "aab", filtered
+    assert_equal :matches, errors
+  end
+  
+  it "considers good matches to be valid" do
+    sf = Mutations::StringFilter.new(matches: /aaa/)
+    filtered, errors = sf.filter("baaab")
+    assert_equal "baaab", filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers non-inclusion to be invalid" do
+    sf = Mutations::StringFilter.new(in: %w(red blue green))
+    filtered, errors = sf.filter("orange")
+    assert_equal "orange", filtered
+    assert_equal :in, errors
+  end
+  
+  it "considers inclusion to be valid" do
+    sf = Mutations::StringFilter.new(in: %w(red blue green))
+    filtered, errors = sf.filter("red")
+    assert_equal "red", filtered
+    assert_equal nil, errors
+  end
+end