semantic_attributes 1.0.2

data/test/unit/active_record_predicates_test.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ActiveRecordExtensionsTest < SemanticAttributes::TestCase
+  class FooUser < User
+    attr_accessor :foo
+  end
+  
+  def setup
+    FooUser.semantic_attributes = nil
+  end
+
+  def test_module
+    assert ActiveRecord::Base.included_modules.include?(SemanticAttributes::Predicates)
+    assert ActiveRecord::Base.semantic_attributes.is_a?(SemanticAttributes::Set)
+  end
+
+  def test_declarative_sugar
+    @klass = FooUser
+
+    assert_nothing_raised 'creating predicates via method_missing sugar' do
+      @klass.foo_is_required
+      @klass.foo_has_a_length
+      @klass.foo_is_a_phone_number
+    end
+
+    assert @klass.semantic_attributes[:foo].has?(:required)
+    assert @klass.foo_is_required?
+
+    assert @klass.semantic_attributes[:foo].has?(:length)
+    assert @klass.foo_has_length?
+
+    assert @klass.semantic_attributes[:foo].has?(:phone_number)
+    assert @klass.foo_is_a_phone_number?
+  end
+  
+  def test_declarative_sugar_allows_inline_required
+    @klass = FooUser
+    
+    @klass.foo_is_a_required_phone_number
+    assert !@klass.semantic_attributes[:foo].get(:phone_number).allow_empty?
+    assert @klass.foo_is_a_phone_number?
+  end
+  
+  def test_declarative_sugar_catches_unknown_attributes
+    @klass = FooUser
+    assert_raises SemanticAttributes::MissingAttribute do
+      @klass.unknown_is_required
+    end
+  end
+  
+  def test_declarative_sugar_for_mass_assignment
+    @klass = FooUser
+    assert_nothing_raised do
+      @klass.fields_are_required :foo
+    end
+    assert @klass.foo_is_required?
+  end
+
+  def test_method_missing_still_works
+    assert_raise NoMethodError do User.i_do_not_exist end
+  end
+
+  ##
+  ## Want to test :expected_error_for with some common predicates.
+  ##
+
+  class PasswordUser < PluginTestModels::User
+    attr_accessor :password, :password_confirmation
+  end
+
+  def test_expected_error_for_with_unique_predicate
+    PasswordUser.stub_semantics_with(:login => :unique)
+    assert_not_nil PasswordUser.expected_error_for(:login, users(:bob).login)
+    assert_nil PasswordUser.expected_error_for(:login, "veryuniquelogin!")
+  end
+
+  def test_expected_error_for_with_length_predicate
+    PasswordUser.stub_semantics_with(:login => {:length => {:above => 5}})
+    assert_not_nil PasswordUser.expected_error_for(:login, "a" * 4)
+    assert_nil PasswordUser.expected_error_for(:login, "a" * 6)
+  end
+
+  def test_expected_error_for_with_same_as_predicate
+    PasswordUser.stub_semantics_with(:password_confirmation => {:same_as => {:method => :password}})
+    assert_not_nil PasswordUser.expected_error_for(:password_confirmation, "one thing", :password => "another thing")
+    assert_nil PasswordUser.expected_error_for(:password_confirmation, "thing", :password => "thing")
+  end
+end

data/test/unit/attribute_formats_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class AttributeFormatsTest < SemanticAttributes::TestCase
+  class User < User
+    cell_is_a_phone_number
+    cell_is_required
+  end
+
+  def setup
+    @record = User.new
+  end
+
+  def test_semantic_attribute_read_and_write
+    assert_nothing_raised do
+      @record.cell = '(222) 333.4444'
+    end
+    assert_equal '+12223334444', @record.attributes['cell'], 'value is stored in normalized format'
+
+    assert_equal '+12223334444', @record.cell, 'read defaults to machine format'
+    assert @record.respond_to?(:cell_for_human)
+    assert_equal '(222) 333-4444', @record.cell_for_human, 'reading in human format'
+  end
+
+  def test_regular_attribute_read_and_write
+    assert_nothing_raised do
+      @record.login = 'hugo'
+    end
+    assert_equal 'hugo', @record.attributes['login']
+    assert !@record.respond_to?(:login_for_human)
+    assert_raise NoMethodError do @record.login_for_human end
+  end
+
+  def test_normalize
+    assert_equal '+12223334444', User.normalize(:cell, '(222) 333.4444')
+  end
+
+  def test_humanize
+    assert_equal '(222) 333-4444', User.humanize(:cell, '+12223334444')
+  end
+end

data/test/unit/inheritance_test.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class InheritanceTest < SemanticAttributes::TestCase
+  class Worker < User
+    attr_accessor :name_tag
+    name_tag_is_required
+  end
+
+  class Clerk < Worker
+    attr_accessor :pen
+    pen_is_required
+  end
+
+  def test_parent_semantics
+    assert Worker.semantic_attributes[:name_tag].has?(:required)
+    assert !Worker.semantic_attributes[:pen].has?(:required)
+  end
+
+  def test_child_semantics
+    assert Clerk.semantic_attributes[:name_tag].has?(:required)
+    assert Clerk.semantic_attributes[:pen].has?(:required)
+  end
+end

data/test/unit/predicates/aliased_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class AliasedPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Aliased.new(:foo, :options => {'10111001' => '185'})
+  end
+
+  def test_formats
+    assert_equal '185', @predicate.to_human('10111001')
+    assert_equal '10111001', @predicate.normalize('185')
+  end
+
+  def test_validation
+    assert @predicate.validate('185', nil)
+    assert !@predicate.validate('10111001', nil)
+  end
+end

data/test/unit/predicates/association_predicate_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class AssociationPredicateTest < SemanticAttributes::TestCase
+  def test_singular_associations
+    predicate = Predicates::Association.new(:subscription)
+    assert predicate.validate(users(:bob).subscription, users(:bob))
+  end
+
+  def test_plural_associations
+    predicate = Predicates::Association.new(:subscriptions)
+    assert predicate.validate(services(:free).subscriptions, services(:free))
+  end
+
+  def test_association_min
+    predicate = Predicates::Association.new(:subscriptions)
+    assert_equal 3, services(:free).subscriptions.size, "assuming three free subscriptions"
+
+    predicate.min = 4
+    predicate.max = nil
+    assert !predicate.validate(services(:free).subscriptions, services(:free)), "min works"
+
+    predicate.min = 3
+    predicate.max = nil
+    assert predicate.validate(services(:free).subscriptions, services(:free)), "min doesn't not work"
+  end
+
+  def test_association_max
+    predicate = Predicates::Association.new(:subscriptions)
+    assert_equal 3, services(:free).subscriptions.size, "assuming three free subscriptions"
+
+    predicate.min = nil
+    predicate.max = 2
+    assert !predicate.validate(services(:free).subscriptions, services(:free)), "max works"
+
+    predicate.min = nil
+    predicate.max = 3
+    assert predicate.validate(services(:free).subscriptions, services(:free)), "max doesn't not work"
+  end
+
+#   def test_recursion_for_new_records
+#     # service has_many subscriptions
+#     Service.stub_semantics_with(:subscriptions => :association)
+#     # subscription belongs_to service
+#     Subscription.stub_semantics_with(:service => :association)
+#
+#     unleaded = Service.new(:name => 'unleaded')
+#     unleaded.subscriptions = [Subscription.new(:service => unleaded, :user => users(:bob))]
+#
+#     assert_nothing_raised {unleaded.valid?}
+#   end
+end

data/test/unit/predicates/base_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class BasePredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Base.new(:foo)
+  end
+
+  def test_unimplemented_methods
+    assert_equal 2, @predicate.method(:validate).arity
+    assert_raise NotImplementedError do @predicate.validate(nil, nil) end
+    assert_equal 'foo', @predicate.to_human('foo')
+    assert_equal 'foo', @predicate.normalize('foo')
+  end
+
+  def test_initializer_assignment
+    predicate = Predicates::Base.new(:foo, :error_message => 'hello world')
+    assert_equal 'hello world', predicate.error_message
+  end
+
+  def test_initializer_assignment_with_typos
+    assert_raises NoMethodError do
+      Predicates::Base.new(:foo, :unknown_option => "something")
+    end
+  end
+  
+  def test_default_values
+    assert @predicate.allow_empty?, "allow empty/nil values by default"
+    assert_equal :both, @predicate.validate_on, "validate on create and update by default"
+    assert_equal :invalid, @predicate.error_message, "error message is a bland :invalid by default"
+    assert_equal Hash.new, @predicate.error_binds, "there are no binds by default"
+  end
+
+  def test_or_empty
+    predicate = Predicates::Base.new(:foo, :or_empty => true)
+    assert predicate.allow_empty?
+    predicate = Predicates::Base.new(:foo, :or_empty => false)
+    assert !predicate.allow_empty?
+  end
+  
+  def test_message_aliasing
+    predicate = Predicates::Base.new(:foo)
+    predicate.error_message = "something"
+    assert_equal "something", predicate.message
+    predicate.message = "another thing"
+    assert_equal "another thing", predicate.error_message
+  end
+  
+  def test_string_errors_are_preserved
+    predicate = Predicates::Base.new(:foo)
+    predicate.error_message = "something"
+    assert_equal "something", predicate.error
+  end
+end

data/test/unit/predicates/blacklisted_predicate_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class BlacklistedPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Blacklisted.new(:foo)
+  end
+
+  def test_case_insensitive_validation
+    @predicate.case_sensitive = false
+    @predicate.restricted = [1, "foo"]
+    assert !@predicate.validate(1, nil)
+    assert !@predicate.validate("1", nil)
+    assert !@predicate.validate("foo", nil)
+    assert !@predicate.validate("foO", nil)
+  end
+  
+  def test_case_sensitive_validation
+    @predicate.case_sensitive = true
+  
+    @predicate.restricted = [1, 2, '3']
+
+    assert !@predicate.validate(1, nil)
+    assert !@predicate.validate(2, nil)
+    assert @predicate.validate(3, nil), 'type is important'
+    assert !@predicate.validate('3', nil)
+    assert @predicate.validate(6, nil)
+  end
+end

data/test/unit/predicates/domain_predicate_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class DomainPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Domain.new(:foo)
+  end
+
+  def test_valid_domains
+    %w(example.com www.example.com).each do |domain|
+      assert @predicate.validate(domain, nil), "#{domain} is a valid domain"
+    end
+  end
+
+  def test_invalid_domains
+    %w(example example.com/foo http://example.com 123.45.6.78).each do |domain|
+      assert !@predicate.validate(domain, nil), "#{domain} is not a valid domain"
+    end
+  end
+
+  def test_normalize
+    assert_equal "example.com", @predicate.normalize("http://example.com:8080/foo")
+    assert_equal "example.com", @predicate.normalize("example.com/foo")
+    assert_equal nil, @predicate.normalize(nil)
+    assert_equal "", @predicate.normalize("")
+    assert_equal "example.com", @predicate.normalize("example.com")
+  end
+end

data/test/unit/predicates/email_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class EmailPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Email.new(:foo)
+  end
+
+  ##
+  ## Test cases from Alex Dunae's validates_email_format_of
+  ## see http://code.dunae.ca/validates_email_format_of/trunk/test/validates_email_format_of_test.rb
+  ##
+
+  def test_should_allow_valid_email_addresses
+    ['valid@example.com',
+     'Valid@test.example.com',
+     'valid+valid123@test.example.com',
+     'valid_valid123@test.example.com',
+     'valid-valid+123@test.example.co.uk',
+     'valid-valid+1.23@test.example.com.au',
+     'valid@example.co.uk',
+     'v@example.com',
+     'valid@example.ca',
+     'valid_@example.com',
+     'valid123.456@example.org',
+     'valid123.456@example.travel',
+     'valid123.456@example.museum',
+     'valid@example.mobi',
+     'valid@example.info',
+     'valid-@example.com',
+  # from RFC 3696, page 6
+     'customer/department=shipping@example.com',
+     '$A12345@example.com',
+     '!def!xyz%abc@example.com',
+     '_somename@example.com',
+  # apostrophes
+     "test'test@example.com",
+  # from http://www.rfc-editor.org/errata_search.php?rfc=3696
+     '"Abc\@def"@example.com',
+     '"Fred\ Bloggs"@example.com',
+     '"Joe.\\Blow"@example.com',
+     ].each do |email|
+      assert @predicate.validate(email, nil), "#{email} should be valid"
+    end
+  end
+
+  def test_should_not_allow_invalid_email_addresses
+    ['invalid@example-com',
+  # period can not start local part
+     '.invalid@example.com',
+  # period can not end local part
+     'invalid.@example.com',
+  # period can not appear twice consecutively in local part
+     'invali..d@example.com',
+     'invalid@example.com.',
+     'invalid@example.com_',
+     'invalid@example.com-',
+     'invalid-example.com',
+     'invalid@example.b#r.com',
+     'invalid@example.c',
+     'invali d@example.com',
+     'invalidexample.com',
+     'invalid@example.',
+  # from http://tools.ietf.org/html/rfc3696, page 5
+  # corrected in http://www.rfc-editor.org/errata_search.php?rfc=3696
+     'Fred\ Bloggs_@example.com',
+     'Abc\@def+@example.com',
+     'Joe.\\Blow@example.com',
+  # too lengthy
+     "#{"a".rjust(65, 'a')}@example.com",
+     "test@#{"a.com".rjust(256, 'a')}"
+     ].each do |email|
+      assert !@predicate.validate(email, nil), "#{email} should not be valid"
+    end
+  end
+
+  def test_with_mx_record
+    assert @predicate.validate('test@example.com', nil), 'syntax check only'
+    @predicate.with_mx_record = true
+    assert !@predicate.validate('test@example.com', nil), 'syntax and mx check'
+    assert @predicate.validate('test@gmail.com', nil)
+  end
+end

data/test/unit/predicates/enumerated_predicate_test.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class EnumeratedPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Enumerated.new(:foo)
+  end
+
+  def test_validation
+    @predicate.options = [1, 2, '3']
+
+    assert @predicate.validate(1, nil)
+    assert @predicate.validate(2, nil)
+    assert !@predicate.validate(3, nil), 'type is important'
+    assert @predicate.validate('3', nil)
+    assert !@predicate.validate(6, nil)
+  end
+
+  def test_or_empty
+    assert !Predicates::Enumerated.new(:foo).allow_empty?
+    assert Predicates::Enumerated.new(:foo, :or_empty => true).allow_empty?
+  end
+end

data/test/unit/predicates/hex_color_predicate_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class HexColorPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::HexColor.new(:foo)
+  end
+
+  def test_normalize_conversions
+    assert_equal "", @predicate.normalize("")
+    assert_equal nil, @predicate.normalize(nil)
+    assert_equal "#123456", @predicate.normalize("123456"), "adds a pound sign"
+    assert_equal "#123456", @predicate.normalize("#123456"), "does not duplicate the pound sign"
+    assert_equal "#112233", @predicate.normalize("123"), "expand three-character syntax"
+    assert_equal "#112233", @predicate.normalize("#123"), "handles existing pound sign when expanding to six characters"
+  end
+
+  def test_valid_colors
+    %w(#123456 #fff000).each do |color|
+      assert @predicate.validate(color, nil), "#{color} should be a valid hex color"
+    end
+  end
+
+  def test_invalid_colors
+    %w(1 12 123 1234 12345 abc zzz kf0f00).each do |color|
+      assert !@predicate.validate(color, nil), "#{color} should be a invalid hex color"
+    end
+  end
+
+end

data/test/unit/predicates/length_predicate_test.rb

@@ -0,0 +1,85 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class LengthPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Length.new(:foo)
+  end
+
+  def test_range
+    @predicate.range = 1..5
+    assert_equal :wrong_length, @predicate.error_message
+
+    assert !@predicate.validate('', nil)
+    assert @predicate.validate('1', nil)
+    assert @predicate.validate('12345', nil)
+    assert !@predicate.validate('123456', nil)
+
+    @predicate.range = 1...5
+    assert_equal :wrong_length, @predicate.error_message, 'same message for inclusive range'
+    assert !@predicate.validate('12345', nil)
+  end
+
+  def test_min
+    @predicate.above = 5
+    assert_equal :too_short, @predicate.error_message
+
+    assert !@predicate.validate('', nil)
+    assert !@predicate.validate('12345', nil)
+    assert @predicate.validate('123456', nil)
+  end
+
+  def test_max
+    @predicate.below = 5
+    assert_equal :too_long, @predicate.error_message
+
+    assert @predicate.validate('', nil)
+    assert @predicate.validate('1234', nil)
+    assert !@predicate.validate('12345', nil)
+  end
+
+  def test_exact
+    @predicate.exactly = 5
+    assert_equal :inexact_length, @predicate.error_message
+
+    assert !@predicate.validate('', nil)
+    assert !@predicate.validate('1234', nil)
+    assert @predicate.validate('12345', nil)
+    assert !@predicate.validate('123456', nil)
+  end
+  
+  def test_symbols
+    @predicate.range = 2..3
+    assert @predicate.validate(:abc, nil)
+    assert !@predicate.validate(:abcdef, nil)
+  end
+  
+  def test_numbers
+    @predicate.range = 2..3
+    assert !@predicate.validate(3, nil)
+    assert @predicate.validate(123, nil)
+  end
+  
+  def test_arrays
+    @predicate.range = 2..3
+    assert !@predicate.validate(['abc'], nil)
+    assert @predicate.validate(['abc', 'def', 'ghi'], nil)
+  end
+  
+  def test_multibyte_characters
+    $KCODE = "UTF8" if RUBY_VERSION < "1.9" # so ActiveSupport uses the UTF8Handler for Chars
+    @predicate.exactly = 4
+    assert @predicate.validate('ægis', nil)
+    assert !@predicate.validate('aegis', nil)
+  end
+  
+  def test_normalization
+    assert_equal "hello\nworld", @predicate.normalize("hello\r\nworld")
+    assert_equal ['a', 'b'], @predicate.normalize(['a', 'b'])
+  end
+
+  def test_no_options
+    assert_raise RuntimeError do @predicate.error_message end
+    assert @predicate.validate(nil, nil)
+  end
+end

data/test/unit/predicates/number_test.rb

@@ -0,0 +1,109 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class NumberPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Number.new(:foo)
+  end
+
+  def test_basic_error_message
+    assert_equal :not_a_number, @predicate.error_message
+  end
+
+  def test_integers
+    @predicate.integer = true
+
+    assert @predicate.validate(0, nil)
+    assert @predicate.validate(-15, nil)
+    assert @predicate.validate(15, nil)
+    assert @predicate.validate('0', nil)
+    assert @predicate.validate('-15', nil)
+    assert @predicate.validate('+15', nil)
+
+    assert !@predicate.validate('1.0', nil)
+    assert !@predicate.validate(1.0, nil)
+  end
+
+  def test_floats
+    assert !@predicate.integer
+    assert @predicate.validate(5, nil), 'still allows integers'
+    assert @predicate.validate(-5, nil)
+    assert @predicate.validate(5.2, nil)
+    assert @predicate.validate(-5.2, nil)
+    assert @predicate.validate(0.0, nil)
+    assert @predicate.validate(5.2e5, nil)
+    assert @predicate.validate(5.2e-5, nil)
+  end
+
+  def test_min
+    @predicate.above = 5
+    assert_equal :greater_than, @predicate.error_message
+
+    assert !@predicate.validate(-10, nil)
+    assert !@predicate.validate(-5, nil)
+    assert !@predicate.validate(0, nil)
+    assert !@predicate.validate(5, nil)
+    assert @predicate.validate(10, nil)
+
+    assert @predicate.validate(5.0001, nil)
+    @predicate.integer = true
+    assert !@predicate.validate(5.0001, nil)
+  end
+
+  def test_min_inclusive
+    @predicate.at_least = 5
+    assert_equal 5, @predicate.above
+    assert @predicate.inclusive
+    assert_equal :greater_than_or_equal_to, @predicate.error_message
+
+    assert !@predicate.validate(4, nil)
+    assert @predicate.validate(5, nil)
+  end
+
+  def test_max
+    @predicate.below = 5
+    assert_equal :less_than, @predicate.error_message
+
+    assert @predicate.validate(-10, nil)
+    assert @predicate.validate(-5, nil)
+    assert @predicate.validate(0, nil)
+    assert !@predicate.validate(5, nil)
+    assert !@predicate.validate(10, nil)
+
+    assert @predicate.validate(4.9999, nil)
+    @predicate.integer = true
+    assert !@predicate.validate(4.9999, nil)
+  end
+
+  def test_max_inclusive
+    @predicate.no_more_than = 5
+    assert_equal 5, @predicate.below
+    assert @predicate.inclusive
+    assert_equal :less_than_or_equal_to, @predicate.error_message
+
+    assert @predicate.validate(5, nil)
+    assert !@predicate.validate(6, nil)
+  end
+
+  def test_range
+    @predicate.range = -5...5
+    assert_equal :between, @predicate.error_message
+
+    assert !@predicate.validate(-10, nil)
+    assert @predicate.validate(-5, nil)
+    assert @predicate.validate(0, nil)
+    assert !@predicate.validate(5, nil)
+    assert !@predicate.validate(10, nil)
+
+    assert @predicate.validate(4.9999, nil)
+    @predicate.integer = true
+    assert !@predicate.validate(4.9999, nil)
+  end
+
+  def test_range_inclusive
+    @predicate.range = -5..5
+    assert_equal :between, @predicate.error_message
+
+    assert @predicate.validate(5, nil)
+    assert !@predicate.validate(6, nil)
+  end
+end