semantic_attributes 1.0.2

data/test/unit/predicates/pattern_predicate_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class PatternPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Pattern.new(:foo)
+  end
+
+  def test_regexp_pattern
+    @predicate.like = /bar$/
+
+    assert @predicate.validate('foobar', nil)
+    assert @predicate.validate(:foobar, nil)
+    assert !@predicate.validate('foobario', nil)
+  end
+
+  def test_string_pattern
+    @predicate.like = 'bar'
+
+    assert @predicate.validate('foobar', nil)
+    assert @predicate.validate(:bar, nil)
+  end
+
+  def test_line_breaks
+    @predicate.like = /^hello world$/
+    assert @predicate.validate("malicious\nhello world\ntext", nil)
+    @predicate.like = /\Ahello world\Z/
+    assert !@predicate.validate("malicious\nhello world\ntext", nil)
+  end
+end

data/test/unit/predicates/phone_number_predicate_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class PhoneNumberPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::PhoneNumber.new(:foo)
+  end
+
+  def test_north_american_bias
+    assert_equal 1, @predicate.implied_country_code, 'default implied country code is 1 (north america)'
+  end
+
+  def test_to_human
+    assert_equal '(222) 333-4444', @predicate.to_human('+12223334444'), 'NANP human format'
+    assert_equal '753', @predicate.to_human('753'), 'unknown formats untouched'
+  end
+
+  def test_validate_nanp
+    assert !@predicate.validate('12223334444', nil), 'requires country code indicator (+)'
+    assert @predicate.validate('+12223334444', nil), 'requires country code indicator (+)'
+
+    assert !@predicate.validate('+11223334444', nil), 'first digit of area code may not be 1'
+    assert !@predicate.validate('+12923334444', nil), 'second digit of area code may not be 9'
+    assert !@predicate.validate('+12221334444', nil), 'first digit of exchange code may not be 1'
+    assert !@predicate.validate('+1222333444', nil), 'must be 11 characters long'
+
+    assert !@predicate.validate('+12225550155', nil), 'restricted 555 code'
+    assert @predicate.validate('+12225550099', nil), 'allowed 555 code'
+    assert @predicate.validate('+12225550200', nil), 'allowed 555 code'
+  end
+
+  def test_normalize
+    @predicate.implied_country_code = 99
+
+    assert_equal '+12223334444', @predicate.normalize('12223334444'), 'recognizes north american country code without +'
+    assert_equal '+12223334444', @predicate.normalize('+12223334444'), 'leaves country codes alone if they exist'
+    assert_equal '+992223334444', @predicate.normalize('2223334444'), 'adds implied country code'
+    assert_equal '+12223334444', @predicate.normalize('1 (222) 333.4444'), 'ignores various formatting characters'
+    assert_equal '+992223334444', @predicate.normalize('222typo333oops4444'), 'ignores non-numeric characters'
+    assert_equal '', @predicate.normalize(''), 'leaves blanks intact'
+  end
+end

data/test/unit/predicates/required_predicate_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class RequiredPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Required.new(:foo)
+  end
+
+  def test_allow_empty
+    assert !@predicate.allow_empty?
+    @predicate.or_empty = false
+    assert !@predicate.allow_empty?
+  end
+end

data/test/unit/predicates/same_as_predicate_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class SameAsPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::SameAs.new(:foo)
+  end
+
+  def test_validation
+    @predicate.method = :bar
+
+    record = mock()
+    record.stubs(:bar).returns("something")
+
+    assert @predicate.validate('something', record)
+    assert !@predicate.validate('something else', record)
+    assert !@predicate.validate(nil, record)
+    assert !@predicate.validate(5, record)
+  end
+end

data/test/unit/predicates/time_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class TimePredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Time.new(:foo)
+  end
+
+  def test_default_validation
+    assert !@predicate.validate('2007-07-19 00:00:00', nil), 'value may not be a string, even if string parses'
+    assert !@predicate.validate(1184817600, nil), 'value must not be a timestamp'
+    assert @predicate.validate(Time.parse('2007-07-19 00:00:00'), nil)
+  end
+
+  def test_validation_with_before
+    @predicate.before = '2007-07-19 00:00:00'
+    assert_equal Time.parse('2007-07-19 00:00:00'), @predicate.before
+
+    assert @predicate.validate(Time.parse('2007-07-18 23:59:00'), nil), 'may be earlier'
+    assert !@predicate.validate(Time.parse('2007-07-19 00:00:00'), nil), 'may not be equal'
+    assert !@predicate.validate(Time.parse('2007-07-19 00:00:01'), nil), 'may not be after'
+  end
+
+  def test_validation_with_after
+    @predicate.after = '2007-07-19 00:00:00'
+    assert_equal Time.parse('2007-07-19 00:00:00'), @predicate.after
+
+    assert !@predicate.validate(Time.parse('2007-07-18 23:59:00'), nil), 'may not be before'
+    assert !@predicate.validate(Time.parse('2007-07-19 00:00:00'), nil), 'may not be equal'
+    assert @predicate.validate(Time.parse('2007-07-19 00:00:01'), nil), 'may be afterwards'
+  end
+
+  def test_validation_with_before_and_after
+    @predicate.before = '2007-01-01 00:00:00'
+    @predicate.after = '2006-01-01 00:00:00'
+
+    assert !@predicate.validate(Time.parse('2005-01-01 00:00:00'), nil), 'may not be earlier'
+    assert @predicate.validate(Time.parse('2006-06-01 00:00:00'), nil), 'may be inbetween'
+    assert !@predicate.validate(Time.parse('2008-01-01 00:00:00'), nil), 'may not be after'
+  end
+  
+  def test_validation_with_distance
+    @predicate.distance = (-1.hour)..(1.hour)
+    assert !@predicate.validate(61.minutes.ago, nil)
+    assert @predicate.validate(59.minutes.ago, nil)
+    assert @predicate.validate(Time.now, nil)
+    assert @predicate.validate(Time.now + 59.minutes, nil)
+    assert !@predicate.validate(Time.now + 61.minutes, nil)
+  end
+end

data/test/unit/predicates/unique_test.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class UniquePredicateTest < SemanticAttributes::TestCase
+  def setup
+    User.stub_semantics_with(:login => :unique)
+    @predicate = User.semantic_attributes[:login].get(:unique)
+
+    @fred = User.new(:first_name => 'fred', :last_name => 'flat')
+  end
+
+  def test_defaults
+    assert_equal false, @predicate.case_sensitive, 'case insensitive by default'
+    assert_equal [], @predicate.scope, 'default scope is empty array'
+  end
+
+  def test_uniqueness_validation_scoping
+    assert !@predicate.validate(users(:bob).login, @fred)
+    @predicate.scope = :last_name
+    assert @predicate.validate(users(:bob).login, @fred), "when scoped, it becomes valid"
+  end
+
+  def test_case_sensitive_uniqueness_validation
+    @predicate.case_sensitive = true
+
+    assert !@predicate.validate(users(:bob).login, @fred), "case match means not unique"
+    assert @predicate.validate(users(:bob).login.upcase, @fred), "case mismatch means unique"
+  end
+
+  def test_case_insensitive_uniqueness_validation
+    @predicate.case_sensitive = false
+
+    assert !@predicate.validate(users(:bob).login, @fred), "case match means not unique"
+    assert !@predicate.validate(users(:bob).login.upcase, @fred), "case mismatch is still not unique"
+  end
+
+  def test_uniqueness_validation_excludes_self
+    @fred.update_attribute(:login, 'fred')
+
+    assert @predicate.validate(@fred.login, @fred), "still valid after being saved"
+    assert !@predicate.validate(users(:bob).login, @fred), "but still not valid when duplicating a *different* record"
+  end
+
+  def test_uniqueness_of_numbers
+    Subscription.stub_semantics_with(:user_id => :unique)
+
+    bobs_second_subscription = Subscription.new(:user => users(:bob), :service => services(:premium))
+    assert !bobs_second_subscription.valid?
+    assert bobs_second_subscription.errors[:user_id]
+  end
+
+  def test_case_insensitive_is_non_destructive
+    @predicate.case_sensitive = false
+    @fred.update_attribute(:login, "Fred")
+
+    @predicate.validate(@fred.login, @fred)
+    assert_equal "Fred", @fred.login, "attribute value was not changed by validate()"
+  end
+end

data/test/unit/predicates/url_test.rb

@@ -0,0 +1,86 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class UrlPredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::Url.new(:foo)
+  end
+
+  def test_ip_addresses
+    assert_equal true, @predicate.allow_ip_address, 'default allow_ip_address is true'
+    assert @predicate.validate('http://192.168.0.10', nil), 'ip address'
+    assert @predicate.validate('http://www.example.com', nil), 'basic url still works'
+
+    @predicate.allow_ip_address = false
+    assert !@predicate.validate('http://192.168.0.10', nil), 'ip address'
+    assert @predicate.validate('http://www.example.com', nil), 'basic url still works'
+  end
+
+  def test_schemes
+    assert_equal ['http', 'https'], @predicate.schemes, 'default allowed schemes'
+
+    assert @predicate.validate('http://example.com/', nil)
+    assert !@predicate.validate('ftp://example.com/', nil)
+
+    @predicate.schemes = ['ftp']
+
+    assert !@predicate.validate('http://example.com/', nil)
+    assert @predicate.validate('ftp://example.com/', nil)
+  end
+
+  def test_domains
+    assert_equal nil, @predicate.domains, 'default allows any domain'
+
+    assert @predicate.validate('http://example.com', nil)
+    assert @predicate.validate('http://example.co.uk', nil)
+    assert @predicate.validate('http://example.xyz', nil)
+    assert !@predicate.validate('http://example', nil)
+    assert !@predicate.validate('http://example.', nil)
+    assert @predicate.validate('http://127.0.0.1', nil)
+
+    @predicate.domains = ['com', 'net', 'org']
+
+    assert @predicate.validate('http://example.com', nil)
+    assert !@predicate.validate('http://example.co.uk', nil)
+    assert !@predicate.validate('http://example.xyz', nil)
+    assert !@predicate.validate('http://example', nil)
+    assert !@predicate.validate('http://example.', nil)
+    assert !@predicate.validate('http://127.0.0.1', nil)
+  end
+
+  def test_ports
+    assert_equal nil, @predicate.ports, 'default allows any port'
+
+    assert @predicate.validate('http://example.com', nil)
+    assert @predicate.validate('http://example.com:80', nil)
+    assert @predicate.validate('http://example.com:443', nil)
+
+    @predicate.ports = [nil, 80]
+
+    assert @predicate.validate('http://example.com', nil)
+    assert @predicate.validate('http://example.com:80', nil)
+    assert !@predicate.validate('http://example.com:443', nil)
+  end
+
+  def test_bad_url
+    assert !@predicate.validate('http:\\\\example.com\\', nil)
+    assert !@predicate.validate('example.com', nil), 'human format does not validate'
+
+    assert_equal 'http:\\\\example.com\\', @predicate.normalize('http:\\\\example.com\\'), 'malformed human format is preserved'
+  end
+
+  def test_implied_scheme
+    assert_equal 'http', @predicate.implied_scheme
+
+    assert_equal 'http://example.com/', @predicate.normalize('http://example.com/'), 'no changes'
+    assert_equal 'ftp://example.com/', @predicate.normalize('ftp://example.com/'), 'no changes when scheme is not default'
+    assert_equal 'http://example.com', @predicate.normalize('example.com'), 'basic implied scheme support'
+    assert_equal 'http://example.com:443', @predicate.normalize('example.com:443'), 'preserve ports'
+
+    @predicate.implied_scheme = nil
+
+    assert_equal 'http://example.com/', @predicate.normalize('http://example.com/')
+    assert_equal 'ftp://example.com/', @predicate.normalize('ftp://example.com/')
+    assert_equal 'example.com', @predicate.normalize('example.com')
+    assert_equal 'example.com:80', @predicate.normalize('example.com:80')
+  end
+end

data/test/unit/predicates/usa_state_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class UsaStatePredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::UsaState.new(:foo)
+  end
+
+  def test_fixed_options
+    assert_raise NoMethodError do @predicate.options = {} end
+  end
+
+  def test_with_territories
+    @predicate.with_territories = true
+    assert_equal :us_state_or_territory, @predicate.error_message
+
+    assert @predicate.options.include?('Guam')
+    assert @predicate.options.include?('Minnesota')
+  end
+
+  def test_without_territories
+    @predicate.with_territories = false
+    assert_equal :us_state, @predicate.error_message
+
+    assert !@predicate.options.include?('Guam')
+    assert @predicate.options.include?('Minnesota')
+  end
+
+  def test_defaults
+    assert !@predicate.with_territories?
+  end
+end

data/test/unit/predicates/usa_zip_code_test.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class UsaZipCodePredicateTest < SemanticAttributes::TestCase
+  def setup
+    @predicate = Predicates::UsaZipCode.new(:foo)
+  end
+
+  def test_fixed_pattern
+    assert_raise NoMethodError do @predicate.like = nil end
+  end
+
+  def test_extended_allowed
+    @predicate.extended = :allowed
+
+    assert @predicate.validate(12345, nil)
+    assert @predicate.validate('12345', nil)
+    assert @predicate.validate('12345-4321', nil)
+    assert !@predicate.validate('12345-4', nil)
+  end
+
+  def test_extended_required
+    @predicate.extended = :required
+
+    assert !@predicate.validate(12345, nil)
+    assert !@predicate.validate('12345', nil)
+    assert @predicate.validate('12345-4321', nil)
+    assert !@predicate.validate('12345-4', nil)
+  end
+
+  def test_non_extended
+    @predicate.extended = false
+
+    assert @predicate.validate(12345, nil)
+    assert @predicate.validate('12345', nil)
+    assert !@predicate.validate('12345-4321', nil)
+    assert !@predicate.validate('12345-4', nil)
+  end
+
+  def test_defaults
+    assert !@predicate.extended
+  end
+end

data/test/unit/semantic_attribute_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class SemanticAttributeTest < SemanticAttributes::TestCase
+  def test_everything
+    @field = SemanticAttributes::Attribute.new('a')
+    assert_equal :a, @field.field
+
+    assert !@field.has?('required')
+    assert_nothing_raised do @field.add 'required' end
+    assert @field.has?('required')
+    assert @field.get('required').is_a?(Predicates::Required)
+  end
+
+  def test_short_names
+    @attribute = SemanticAttributes::Attribute.new('a')
+    assert_equal Predicates::PhoneNumber, @attribute.send(:class_of, 'phone_number')
+  end
+end

data/test/unit/semantic_attributes_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class SemanticAttributesTest < SemanticAttributes::TestCase
+  def setup
+    @set = SemanticAttributes::Set.new
+  end
+
+  def test_add
+    assert @set.instance_variable_get('@set').empty?
+    assert_raises ArgumentError, "can't add by symbol" do @set.add :foo end
+    assert @set.instance_variable_get('@set').empty?
+    assert_nothing_raised "can add a SemanticAttribute instance" do @set.add SemanticAttributes::Attribute.new(:foo) end
+    assert @set.instance_variable_get('@set').size == 1
+  end
+
+  def test_find
+    assert !@set.include?(:a)
+
+    # test retrieving a previously set field
+    a = SemanticAttributes::Attribute.new(:a)
+    @set.add a
+    assert @set.include?(:a)
+    assert_equal a, @set[:a], 'can find previously set fields'
+  end
+
+  def test_that_find_creates_if_not_found
+    assert @set[:a].is_a?(SemanticAttributes::Attribute), 'can create an Attribute by requesting it from the set'
+  end
+end

data/test/unit/validations_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ValidationsTest < SemanticAttributes::TestCase
+  def setup
+    User.stub_semantics_with(:login => :required)
+    @record = User.new
+    @login_required = @record.semantic_attributes['login'].get('required')
+  end
+
+  def test_validation_hook
+    @record.expects(:validate_predicates)
+    @record.valid?
+  end
+
+  def test_validation_errors
+    assert !@record.valid?
+    assert @record.errors[:login]
+    assert_equal ['is required.'], @record.errors[:login]
+  end
+
+  def test_validate_on_default
+    assert_equal :both, @record.semantic_attributes['login'].get('required').validate_on
+  end
+
+  ##
+  ## attr_valid?
+  ##
+
+  def test_attribute_valid?
+    assert !@record.login_valid?
+    @record.login = "foo"
+    assert @record.login_valid?
+  end
+
+  def test_attribute_valid_with_conditional_validation
+    assert !@record.login_valid?
+    @record.stubs(:validate_predicate?).returns(false)
+    assert @record.login_valid?
+  end
+
+  ##
+  ## validate_predicate?
+  ##
+
+  def test_validate_predicate_with_validate_if_symbol
+    @record.stubs(:no).returns(false)
+    @record.stubs(:yes).returns(true)
+
+    assert @record.send(:validate_predicate?, @login_required)
+
+    @record.semantic_attributes['login'].get('required').validate_if = :no
+    assert !@record.send(:validate_predicate?, @login_required)
+
+    @record.semantic_attributes['login'].get('required').validate_if = :yes
+    assert @record.send(:validate_predicate?, @login_required)
+  end
+
+  def test_validate_predicate_with_validate_if_proc
+    assert @record.send(:validate_predicate?, @login_required)
+
+    @record.semantic_attributes['login'].get('required').validate_if = proc {false}
+    assert !@record.send(:validate_predicate?, @login_required)
+
+    @record.semantic_attributes['login'].get('required').validate_if = proc {true}
+    assert @record.send(:validate_predicate?, @login_required)
+  end
+
+  def test_validate_predicate_with_validate_on_create
+    @record = users(:george)
+    @record.login = nil
+
+    # test assumptions
+    assert !@record.new_record?
+    assert @record.send(:validate_predicate?, @login_required)
+
+    # the test
+    @record.semantic_attributes['login'].get('required').validate_on = :create
+    assert !@record.send(:validate_predicate?, @login_required)
+  end
+
+  def test_validate_predicate_with_validate_on_update
+    # test assumptions
+    assert @record.new_record?
+    assert @record.send(:validate_predicate?, @login_required)
+
+    # the test
+    @record.semantic_attributes['login'].get('required').validate_on = :update
+    assert !@record.send(:validate_predicate?, @login_required)
+  end
+
+  ##
+  ## :or_empty
+  ##
+
+  def test_allow_empty
+    User.stub_semantics_with(:login => {:number => {:or_empty => true}})
+
+    # empty values should skip the validate method
+    predicate = @record.semantic_attributes['login'].get('number')
+    predicate.expects(:validate).never
+
+    [nil, '', []].each do |empty_value|
+      @record.login = empty_value
+      assert @record.valid?
+    end
+  end
+
+  def test_disallow_empty
+    User.stub_semantics_with(:login => {:number => {:or_empty => false}})
+
+    # empty values should skip the validate method
+    predicate = @record.semantic_attributes['login'].get('number')
+    predicate.expects(:validate).never
+
+    [nil, '', []].each do |empty_value|
+      @record.login = empty_value
+      assert !@record.valid?
+      assert @record.errors[:login]
+    end
+  end
+end