activevalidators 5.1.0 → 6.0.0

data/test/validations/respond_to_test.rb

@@ -14,21 +14,21 @@ describe "Respond To Validation" do
     subject.global_condition = true
     subject.local_condition = true
 
-    subject.valid?.must_equal true
-    subject.errors.size.must_equal 0
+    _(subject.valid?).must_equal(true)
+    _(subject.errors.size).must_equal(0)
   end
 
   describe "when does not respond_to?" do
     it "rejects the responder" do
       subject = build_respond_to_record :responder => 42, :global_condition => true, :local_condition => true
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generates an error message of type invalid" do
       subject = build_respond_to_record :responder => 42, :global_condition => true, :local_condition => true
-      subject.valid?.must_equal false
-      subject.errors[:responder].include?(subject.errors.generate_message(:responder, :invalid)).must_equal true
+      _(subject.valid?).must_equal(false)
+      _(subject.errors[:responder].include?(subject.errors.generate_message(:responder, :invalid))).must_equal(true)
     end
   end
 end

data/test/validations/sin_test.rb

@@ -6,66 +6,66 @@ describe "SIN validations" do
     describe "for invalid" do
       it "rejects empty sin" do
         subject = build_sin_record({:sin => ''})
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "rejects sin made out of zeroes" do
         subject = build_sin_record({:sin => '000 000 000'}, {:country => :canada})
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "rejects empty sin when country is provided" do
         subject = build_sin_record({:sin => ''}, {:country => :canada })
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "rejects too long sin" do
         subject = build_sin_record({:sin => '123 456 789 0'}, {:country => :canada })
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "rejects too short sin" do
         subject = build_sin_record({:sin => '123'}, {:country => :canada })
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "rejects valid sin for temporary residents by default" do
         subject = build_sin_record({:sin => '996 454 286'}, {:country => :canada })
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "rejects valid business numbers by default" do
         subject = build_sin_record({:sin => '897 454 286'}, {:country => :canada })
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "rejects invalid sin for permanent residents" do
         subject = build_sin_record({:sin => '123 456 789'}, {:country => :canada })
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
     end
 
     describe "for valid" do
       it "accept valid sin for permanent residents without flags (Canada by default)" do
         subject = build_sin_record({:sin => '046 454 286'}, true)
-        subject.valid?.must_equal true
+        _(subject.valid?).must_equal(true)
       end
 
       it "accept valid sin for permanent residents" do
         subject = build_sin_record({:sin => '046 454 286'}, {:country => :canada })
-        subject.valid?.must_equal true
+        _(subject.valid?).must_equal(true)
       end
 
       it "accept valid sin for temporary residents when flag is provided" do
         subject = build_sin_record({:sin => '996 454 286'},
                                    {:country => :canada, :country_options => { allow_permanent_residents: true } })
-        subject.valid?.must_equal true
+        _(subject.valid?).must_equal(true)
       end
 
       it "accept valid business numbers when flag is provided" do
         subject = build_sin_record({:sin => '897 454 286'},
                                    {:country => :canada, :country_options => { allow_business_numbers: true } })
-        subject.valid?.must_equal true
+        _(subject.valid?).must_equal(true)
       end
     end
   end

data/test/validations/siren_test.rb

@@ -4,47 +4,47 @@ ActiveValidators.activate(:siren)
 describe "Siren Validation" do
   it "Rejects if not supplied" do
     subject = build_siren_record true
-    subject.valid?.must_equal false
-    subject.errors.size.must_equal 1
+    _(subject.valid?).must_equal(false)
+    _(subject.errors.size).must_equal(1)
   end
 
   describe 'supplied as a string' do
     it "Accepts if valid" do
       subject = build_siren_record true, :siren => '552100554'
-      subject.valid?.must_equal true
-      subject.errors.size.must_equal 0
+      _(subject.valid?).must_equal(true)
+      _(subject.errors.size).must_equal(0)
     end
 
     it "Reject if invalid" do
       subject = build_siren_record true, :siren => '552100553'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "Reject if not the right size" do
       subject = build_siren_record true, :siren => '55210055'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
   end
 
   describe 'supplied as a number' do
     it "Accepts if valid" do
       subject = build_siren_record true, :siren => 732829320
-      subject.valid?.must_equal true
-      subject.errors.size.must_equal 0
+      _(subject.valid?).must_equal(true)
+      _(subject.errors.size).must_equal(0)
     end
 
     it "Reject if invalid" do
       subject = build_siren_record true, :siren => 732829321
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "Reject if not the right size" do
       subject = build_siren_record true, :siren => 73282932
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
   end
 

data/test/validations/slug_test.rb

@@ -11,29 +11,29 @@ describe "Slug Validation" do
   it "accepts valid slugs" do
     subject = build_slug_validation
     subject.slug = '1234567890-foo-bar-bar'
-    subject.valid?.must_equal true
-    subject.errors.size.must_equal 0
+    _(subject.valid?).must_equal(true)
+    _(subject.errors.size).must_equal(0)
   end
 
   describe "for invalid slugs" do
     it "rejects invalid slugs" do
       subject = build_slug_validation :slug => '@#$%^'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generates an error message of type invalid" do
       subject = build_slug_validation :slug => '@#$%^'
-      subject.valid?.must_equal false
-      subject.errors[:slug].include?(subject.errors.generate_message(:slug, :invalid)).must_equal true
+      _(subject.valid?).must_equal(false)
+      _(subject.errors[:slug].include?(subject.errors.generate_message(:slug, :invalid))).must_equal(true)
     end
   end
 
   describe "for empty slugs" do
     it "generates an error message of type blank" do
       subject = build_slug_validation :slug => nil
-      subject.valid?.must_equal false
-      subject.errors[:slug].include?(subject.errors.generate_message(:slug, :blank)).must_equal true
+      _(subject.valid?).must_equal(false)
+      _(subject.errors[:slug].include?(subject.errors.generate_message(:slug, :blank))).must_equal(true)
     end
   end
 

data/test/validations/ssn_test.rb

@@ -6,45 +6,45 @@ describe "SSN validations" do
     describe "for invalid" do
       it "rejects empty ssn" do
         subject = build_ssn_record({:ssn => ''}, true)
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "rejects ssn when it doesn't consist of numbers" do
         subject = build_ssn_record({:ssn => 'aaabbcccc'}, true)
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "rejects ssn when the first group of digits is 000" do
         subject = build_ssn_record({:ssn => '000112222'}, true)
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "rejects ssn when the first group of digits is 666" do
         subject = build_ssn_record({:ssn => '666112222'}, true)
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       (900..999).each do |first_group_num|
         it "rejects ssn when the first group of digits is #{first_group_num}" do
           subject = build_ssn_record({:ssn => "#{first_group_num}112222"}, true)
-          subject.valid?.must_equal false
+          _(subject.valid?).must_equal(false)
         end
       end
 
       it "reject ssn when the second group of digits is 00" do
         subject = build_ssn_record({:ssn => "555002222"}, true)
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       it "reject ssn when the third group of digits is 0000" do
         subject = build_ssn_record({:ssn => "555660000"}, true)
-        subject.valid?.must_equal false
+        _(subject.valid?).must_equal(false)
       end
 
       (987654320..987654329).each do |reserved_ssn|
         it "rejects reserved ssn such as #{reserved_ssn}" do
           subject = build_ssn_record({:ssn => "#{reserved_ssn}"}, true)
-          subject.valid?.must_equal false
+          _(subject.valid?).must_equal(false)
         end
       end
     end
@@ -53,13 +53,13 @@ describe "SSN validations" do
       it "supports deprecated usa_ssn syntax" do
         assert_deprecated do
           subject = build_ssn_record({:ssn => '444556666'}, {:type => :usa_ssn})
-          subject.valid?.must_equal true
+          _(subject.valid?).must_equal(true)
         end
       end
 
       it "accept ssn without type (and use by default 'usa_ssn')" do
         subject = build_ssn_record({:ssn => '444556666'}, true)
-        subject.valid?.must_equal true
+        _(subject.valid?).must_equal(true)
       end
     end
   end

data/test/validations/tracking_number_test.rb

@@ -13,16 +13,16 @@ describe "Tracking Number Validation" do
   def assert_valid_tracking_number(carrier_opts, tracking_number, &block)
     subject = build_tracking_number_record(carrier_opts, &block)
     subject.tracking_number = tracking_number
-    subject.valid?.must_equal true
-    subject.errors.size.must_equal 0
+    _(subject.valid?).must_equal(true)
+    _(subject.errors.size).must_equal(0)
   end
 
   def assert_invalid_tracking_number(carrier_opts, tracking_number, &block)
     subject = build_tracking_number_record(carrier_opts, &block)
     subject.tracking_number = tracking_number
-    subject.valid?.must_equal false
-    subject.errors.size.must_equal 1
-    subject.errors[:tracking_number].must_include subject.errors.generate_message(:tracking_number, :invalid)
+    _(subject.valid?).must_equal(false)
+    _(subject.errors.size).must_equal(1)
+    _(subject.errors[:tracking_number]).must_include(subject.errors.generate_message(:tracking_number, :invalid))
   end
 
   describe "when no carrier parameter is given" do

data/test/validations/twitter_test.rb

@@ -11,84 +11,84 @@ describe "Twitter Validation" do
 
   it "rejects invalid urls" do
     subject = build_twitter_record true
-    subject.valid?.must_equal false
-    subject.errors.size.must_equal 1
+    _(subject.valid?).must_equal(false)
+    _(subject.errors.size).must_equal(1)
   end
 
   it "generates an error message of type blank" do
     subject = build_twitter_record true
-    subject.valid?.must_equal false
+    _(subject.valid?).must_equal(false)
 
     message = subject.errors.generate_message(:twitter_username, :blank)
-    subject.errors[:twitter_username].include?(message).must_equal true
+    _(subject.errors[:twitter_username].include?(message)).must_equal(true)
   end
 
   describe "for twitter url validator" do
     it "validates with http" do
       subject = build_twitter_record :format => :url
       subject.twitter_username = 'http://twitter.com/garrettb'
-      subject.valid?.must_equal true
+      _(subject.valid?).must_equal(true)
     end
 
     it "validates with https protocol" do
       subject = build_twitter_record :format => :url
       subject.twitter_username = 'https://twitter.com/garrettb'
-      subject.valid?.must_equal true
+      _(subject.valid?).must_equal(true)
     end
 
     it "generate error with ftp protocol" do
       subject = build_twitter_record :format => :url
       subject.twitter_username = 'ftp://twitter.com/garrettb'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "validates with www and http" do
       subject = build_twitter_record :format => :url
       subject.twitter_username = 'http://www.twitter.com/garrettb'
-      subject.valid?.must_equal true
+      _(subject.valid?).must_equal(true)
     end
 
     it "generate error without www dot" do
       subject = build_twitter_record :format => :url
       subject.twitter_username = 'http://wwwtwitter.com/garrettb'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error without no username" do
       subject = build_twitter_record :format => :url
       subject.twitter_username = 'http://twitter.com'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error without no username and trailing slash" do
       subject = build_twitter_record :format => :url
       subject.twitter_username = 'http://twitter.com/'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error with too long of username" do
       subject = build_twitter_record :format => :url
       subject.twitter_username = 'http://twitter.com/garrettbjerkhoelwashere'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error with invalid character" do
       subject = build_twitter_record :format => :url
       subject.twitter_username = 'http://twitter.com/garrettbjerkhoé'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generates error with injected content" do
       subject = build_twitter_record :format => :url
       subject.twitter_username = "javascript:alert('xss');\nhttp://twitter.com/garrettbjerkhoelwashere"
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
   end
 
@@ -96,41 +96,41 @@ describe "Twitter Validation" do
     it "validate with valid username" do
       subject = build_twitter_record :format => :username_with_at
       subject.twitter_username = '@garrettb'
-      subject.valid?.must_equal true
+      _(subject.valid?).must_equal(true)
     end
 
     it "validate with one character" do
       subject = build_twitter_record :format => :username_with_at
       subject.twitter_username = '@a'
-      subject.valid?.must_equal true
+      _(subject.valid?).must_equal(true)
     end
 
     it "generate error with too long of username" do
       subject = build_twitter_record :format => :username_with_at
       subject.twitter_username = '@garrettbjerkhoelwashere'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error with no username" do
       subject = build_twitter_record :format => :username_with_at
       subject.twitter_username = '@'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error with invalid character" do
       subject = build_twitter_record :format => :username_with_at
       subject.twitter_username = '@érik'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error with injected content" do
       subject = build_twitter_record :format => :username_with_at
       subject.twitter_username = "injected\n@erik"
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
   end
 
@@ -138,48 +138,48 @@ describe "Twitter Validation" do
     it "validate with valid username" do
       subject = build_twitter_record true
       subject.twitter_username = 'garrettb'
-      subject.valid?.must_equal true
+      _(subject.valid?).must_equal(true)
     end
 
     it "validate with one character" do
       subject = build_twitter_record true
       subject.twitter_username = 'a'
-      subject.valid?.must_equal true
+      _(subject.valid?).must_equal(true)
     end
 
     it "generate error with too long of username" do
       subject = build_twitter_record true
       subject.twitter_username = 'garrettbjerkhoelwashere'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error with no username" do
       subject = build_twitter_record true
       subject.twitter_username = ''
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error with invalid character" do
       subject = build_twitter_record true
       subject.twitter_username = 'érik'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error with at sign character" do
       subject = build_twitter_record true
       subject.twitter_username = '@garrettb'
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
 
     it "generate error with at injected data" do
       subject = build_twitter_record true
       subject.twitter_username = "something\ngarrettb\nelse"
-      subject.valid?.must_equal false
-      subject.errors.size.must_equal 1
+      _(subject.valid?).must_equal(false)
+      _(subject.errors.size).must_equal(1)
     end
   end
 end