activesupport_testcase_extras 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f8b60be1e5000d07f15f93b1b44b6007f8734581
+  data.tar.gz: 9a4acc5ccb203f3e889af8762a458abf02bd86d5
+SHA512:
+  metadata.gz: 3a4bf242cb1c286eb2a082ae037909f94a35f74f812270e32c5fb4964f42f5286b4bc56cb250b1301b7ea2b83d9da9a9ea7662ee89f2181ca11aa227b5808f10
+  data.tar.gz: 495f0b96e1d59ba53ec4d0651291ec0d3c94f57a8bd1af1b5f76d28306800c505c40b25fff1cb35ad3f80785f552d70112024a5d3b1c916d09c5e8f774d08d23

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.2
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in activesupport_testcase_extras.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    activesupport_testcase_extras (1.0.2)
+      activesupport (>= 4.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.2.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    concurrent-ruby (1.0.5)
+    i18n (1.0.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.11.3)
+    rake (10.5.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport_testcase_extras!
+  bundler (~> 1.16)
+  minitest (~> 5.0)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Beau Barker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# ActivesupportTestcaseExtras
+
+I found it desirable to add additional test and assertion methods to unit tests.  This is the result.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activesupport_testcase_extras'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activesupport_testcase_extras
+
+## Usage
+
+Use the additional methods in your assertions.
+
+```ruby
+test "should require name" do
+  assert_required @item, :name
+end
+
+test "should limit length of name" do
+  assert_max_length @item, :name, 100
+end
+
+test "name should be unique" do
+  assert_uniqueness @item, :name
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/barkerest/activesupport_testcase_extras.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/activesupport_testcase_extras.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "activesupport_testcase_extras/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "activesupport_testcase_extras"
+  spec.version       = ActivesupportTestcaseExtras::VERSION
+  spec.authors       = ["Beau Barker"]
+  spec.email         = ["beau@barkerest.com"]
+
+  spec.summary       = "Provides some additional test methods to ActiveSupport::TestCase."
+  spec.homepage      = "https://github.com/barkerest/activesupport_testcase_extras"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'activesupport' ,       '>= 4.0'
+
+  spec.add_development_dependency "bundler",  "~> 1.16"
+  spec.add_development_dependency "rake",     "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "activesupport_testcase_extras"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/activesupport_testcase_extras.rb

@@ -0,0 +1,6 @@
+require "activesupport_testcase_extras/version"
+require "activesupport_testcase_extras/test_case"
+
+module ActivesupportTestcaseExtras
+
+end

data/lib/activesupport_testcase_extras/test_case.rb

@@ -0,0 +1,494 @@
+require 'active_support'
+
+module ActivesupportTestcaseExtras
+  ##
+  # Adds some extra assertions and methods for use in tests.
+  module TestCase
+
+    ##
+    # Tests a specific field for presence validation.
+    #
+    # model::
+    #     This must respond to _attribute_ and _attribute=_ as well as _valid?_ and _errors_.
+    #
+    # attribute::
+    #     This must provide the name of a valid attribute in the model.
+    #
+    # message::
+    #     This is optional, but if provided it will be postfixed with the failure reason.
+    #
+    # regex::
+    #     This is the regex to match against the error message to ensure that the failure is for the correct reason.
+    #
+    def assert_required(model, attribute, message = nil, regex = /can't be blank/i)
+      original_value = model.send(attribute)
+      assert model.valid?, 'Model should be valid to start.'
+      is_string = original_value.is_a?(::String)
+      setter = :"#{attribute}="
+      model.send setter, nil
+      assert_not model.valid?, message ? (message + ': (nil)') : "Should not allow #{attribute} to be set to nil."
+      assert model.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : 'Did not fail for expected reason.'
+      if is_string
+        model.send setter, ''
+        assert_not model.valid?, message ? (message + ": ('')") : "Should not allow #{attribute} to be set to empty string."
+        assert model.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : 'Did not fail for expected reason.'
+        model.send setter, '   '
+        assert_not model.valid?, message ? (message + ": ('   ')") : "Should not allow #{attribute} to be set to blank string."
+        assert model.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : 'Did not fail for expected reason.'
+      end
+      model.send setter, original_value
+      assert model.valid?, message ? (message + ": !(#{original_value.inspect})") : "Should allow #{attribute} to be set back to '#{original_value.inspect}'."
+    end
+
+    ##
+    # Tests a specific field for maximum length restriction.
+    #
+    # model::
+    #     This must respond to _attribute_ and _attribute=_ as well as _valid?_ and _errors_.
+    #
+    # attribute::
+    #     This must provide the name of a valid attribute in the model.
+    #
+    # max_length::
+    #     This is the maximum valid length for the field.
+    #
+    # message::
+    #     This is optional, but if provided it will be postfixed with the failure reason.
+    #
+    # regex::
+    #     This is the regex to match against the error message to ensure that the failure is for the correct reason.
+    #
+    # options::
+    #     This is a list of options for the validation.
+    #     Currently :start_with and :end_with are recognized.
+    #     Use :start_with to specify a prefix for the tested string.
+    #     Use :end_with to specify a postfix for the tested string.
+    #     This would be most useful when you value has to follow a format (eg - email address :end_with => '@example.com')
+    #
+    def assert_max_length(model, attribute, max_length, message = nil, regex = /is too long/i, options = {})
+      original_value = model.send(attribute)
+      assert model.valid?, 'Model should be valid to start.'
+      setter = :"#{attribute}="
+
+      if message.is_a?(::Hash)
+        options = message.merge(options || {})
+        message = nil
+      end
+
+      if regex.is_a?(::Hash)
+        options = regex.merge(options || {})
+        regex = /is too long/i
+      end
+
+      pre = options[:start_with].to_s
+      post = options[:end_with].to_s
+      len = max_length - pre.length - post.length
+
+      # try with maximum valid length.
+      value = pre + ('a' * len) + post
+      model.send setter, value
+      assert model.valid?, message ? (message + ": !(#{value.length})") : "Should allow a string of #{value.length} characters."
+
+      # try with one extra character.
+      value = pre + ('a' * (len + 1)) + post
+      model.send setter, value
+      assert_not model.valid?, message ? (message + ": (#{value.length})") : "Should not allow a string of #{value.length} characters."
+      assert model.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : 'Did not fail for expected reason.'
+
+      model.send setter, original_value
+      assert model.valid?, message ? (message + ": !(#{original_value.inspect})") : "Should allow #{attribute} to be set back to '#{original_value.inspect}'."
+    end
+
+    ##
+    # Tests a specific field for maximum length restriction.
+    #
+    # model::
+    #     This must respond to _attribute_ and _attribute=_ as well as _valid?_ and _errors_.
+    #
+    # attribute::
+    #     This must provide the name of a valid attribute in the model.
+    #
+    # min_length::
+    #     This is the minimum valid length for the field.
+    #
+    # message::
+    #     This is optional, but if provided it will be postfixed with the failure reason.
+    #
+    # regex::
+    #     This is the regex to match against the error message to ensure that the failure is for the correct reason.
+    #
+    # options::
+    #     This is a list of options for the validation.
+    #     Currently :start_with and :end_with are recognized.
+    #     Use :start_with to specify a prefix for the tested string.
+    #     Use :end_with to specify a postfix for the tested string.
+    #     This would be most useful when you value has to follow a format (eg - email address :end_with => '@example.com')
+    #
+    def assert_min_length(model, attribute, min_length, message = nil, regex = /is too short/i, options = {})
+      original_value = model.send(attribute)
+      assert model.valid?, 'Model should be valid to start.'
+      setter = :"#{attribute}="
+
+      if message.is_a?(::Hash)
+        options = message.merge(options || {})
+        message = nil
+      end
+
+      if regex.is_a?(::Hash)
+        options = regex.merge(options || {})
+        regex = /is too short/i
+      end
+
+      pre = options[:start_with].to_s
+      post = options[:end_with].to_s
+      len = min_length - pre.length - post.length
+
+      # try with minimum valid length.
+      value = pre + ('a' * len) + post
+      model.send setter, value
+      assert model.valid?, message ? (message + ": !(#{value.length})") : "Should allow a string of #{value.length} characters."
+
+      # try with one extra character.
+      value = pre + ('a' * (len - 1)) + post
+      model.send setter, value
+      assert_not model.valid?, message ? (message + ": (#{value.length})") : "Should not allow a string of #{value.length} characters."
+      assert model.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : 'Did not fail for expected reason.'
+
+      model.send setter, original_value
+      assert model.valid?, message ? (message + ": !(#{original_value.inspect})") : "Should allow #{attribute} to be set back to '#{original_value.inspect}'."
+    end
+
+    ##
+    # Tests a specific field for uniqueness.
+    #
+    # model::
+    #     This must respond to _attribute_ and _attribute=_ as well as _valid?_, _errors_, and _save!_.
+    #     The model will be saved to perform uniqueness testing.
+    #
+    # attribute::
+    #     This must provide the name of a valid attribute in the model.
+    #
+    # case_sensitive::
+    #     This determines if changing case should change validation.
+    #
+    # message::
+    #     This is optional, but if provided it will be postfixed with the failure reason.
+    #
+    # regex::
+    #     This is the regex to match against the error message to ensure that the failure is for the correct reason.
+    #
+    #
+    # alternate_scopes::
+    #     This is also optional.  If provided the keys of the hash will be used to
+    #     set additional attributes on the model.  When these attributes are changed to the alternate
+    #     values, the model should once again be valid.
+    #     The alternative scopes are processed one at a time and the original values are restored
+    #     before moving onto the next scope.
+    #     A special key :unique_fields, allows you to provide values for other unique fields in the model so they
+    #     don't affect testing.  If the value of :unique_fields is not a hash, then it is put back into the
+    #     alternate_scopes hash for testing.
+    #
+    def assert_uniqueness(model, attribute, case_sensitive = false, message = nil, regex = /has already been taken/i, alternate_scopes = {})
+      setter = :"#{attribute}="
+      original_value = model.send(attribute)
+
+      assert model.valid?, 'Model should be valid to start.'
+
+      if case_sensitive.is_a?(::Hash)
+        alternate_scopes = case_sensitive.merge(alternate_scopes || {})
+        case_sensitive = false
+      end
+      if message.is_a?(::Hash)
+        alternate_scopes = message.merge(alternate_scopes || {})
+        message = nil
+      end
+      if regex.is_a?(::Hash)
+        alternate_scopes = regex.merge(alternate_scopes || {})
+        regex = /has already been taken/i
+      end
+
+      model.save!
+      copy = model.dup
+
+      other_unique_fields = alternate_scopes.delete(:unique_fields)
+      if other_unique_fields
+        if other_unique_fields.is_a?(::Hash)
+          other_unique_fields.each do |attr,val|
+            setter = :"#{attr}="
+            copy.send setter, val
+          end
+        else
+          alternate_scopes[:unique_fields] = other_unique_fields
+        end
+      end
+
+      assert_not copy.valid?, message ? (message + ": (#{copy.send(attribute).inspect})") : "Duplicate model with #{attribute}=#{copy.send(attribute).inspect} should not be valid."
+      assert copy.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : "Did not fail for expected reason"
+      if original_value.is_a?(::String)
+        unless case_sensitive
+          copy.send(setter, original_value.upcase)
+          assert_not copy.valid?, message ? (message + ": (#{copy.send(attribute).inspect})") : "Duplicate model with #{attribute}=#{copy.send(attribute).inspect} should not be valid."
+          assert copy.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : "Did not fail for expected reason"
+          copy.send(setter, original_value.downcase)
+          assert_not copy.valid?, message ? (message + ": (#{copy.send(attribute).inspect})") : "Duplicate model with #{attribute}=#{copy.send(attribute).inspect} should not be valid."
+          assert copy.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : "Did not fail for expected reason"
+        end
+      end
+
+      unless alternate_scopes.blank?
+        copy.send(setter, original_value)
+        assert_not copy.valid?, message ? (message + ": (#{copy.send(attribute).inspect})") : "Duplicate model with #{attribute}=#{copy.send(attribute).inspect} should not be valid."
+        assert copy.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : "Did not fail for expected reason"
+        alternate_scopes.each do |k,v|
+          kset = :"#{k}="
+          vorig = copy.send(k)
+          copy.send(kset, v)
+          assert_equal v, copy.send(k), message ? (message + ": (failed to set #{k})") : "Failed to set #{k}=#{v.inspect}."
+          assert copy.valid?, message ? (message + ": !#{k}(#{v})") : "Duplicate model with #{k}=#{v.inspect} should be valid with #{attribute}=#{copy.send(attribute).inspect}."
+          copy.send(kset, vorig)
+          assert_equal vorig, copy.send(k), message ? (message + ": (failed to reset #{k})") : "Failed to reset #{k}=#{v.inspect}."
+          assert_not copy.valid?, message ? (message + ": (#{copy.send(attribute).inspect})") : "Duplicate model with #{attribute}=#{copy.send(attribute).inspect} should not be valid."
+          assert copy.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : "Did not fail for expected reason"
+        end
+      end
+    end
+
+    ##
+    # Tests a specific field for email verification.
+    #
+    # model::
+    #     This must respond to _attribute_ and _attribute=_ as well as _valid?_ and _errors_.
+    #
+    # attribute::
+    #     This must provide the name of a valid attribute in the model.
+    #
+    # message::
+    #     This is optional, but if provided it will be postfixed with the failure reason.
+    #
+    # regex::
+    #     This is the regex to match against the error message to ensure that the failure is for the correct reason.
+    #
+    def assert_email_validation(model, attribute, message = nil, regex = /is not a valid email address/i)
+      assert model.valid?, 'Model should be valid to start.'
+      setter = :"#{attribute}="
+      orig = model.send attribute
+
+      valid = %w(
+        user@example.com
+        USER@foo.COM
+        A_US-ER@foo.bar.org
+        first.last@foo.jp
+        alice+bob@bax.cn
+      )
+
+      invalid = %w(
+        user@example,com
+        user_at_foo.org
+        user@example.
+        user@example.com.
+        foo@bar_baz.com
+        foo@bar+baz.com
+        @example.com
+        user@
+        user
+        user@..com
+        user@example..com
+        user@.example.com
+        user@@example.com
+        user@www@example.com
+      )
+
+      valid.each do |addr|
+        model.send setter, addr
+        assert model.valid?, message ? (message + ': (rejected valid address)') : "Should have accepted #{addr.inspect}."
+      end
+
+      invalid.each do |addr|
+        model.send setter, addr
+        assert_not model.valid?, message ? (message + ': (accepted invalid address)') : "Should have rejected #{addr.inspect}."
+        assert model.errors[attribute].to_s =~ regex, message ? (message + ': (error message)') : 'Did not fail for expected reason.'
+      end
+
+      model.send setter, orig
+      assert model.valid?, message ? (message + ': (rejected original value)') : "Should have accepted original value of #{orig.inspect}."
+
+    end
+
+
+    ##
+    # Tests a specific field for IP address verification.
+    #
+    # model::
+    #     This must respond to _attribute_ and _attribute=_ as well as _valid?_ and _errors_.
+    #
+    # attribute::
+    #     This must provide the name of a valid attribute in the model.
+    #
+    # mask::
+    #     This can be one of :allow_mask, :require_mask, or :deny_mask.  The default is :allow_mask.
+    #
+    # message::
+    #     This is optional, but if provided it will be postfixed with the failure reason.
+    #
+    # regex::
+    #     This is the regex to match against the error message to ensure that the failure is for the correct reason.
+    #     The default value is nil to test for the various default messages.
+    #
+    def assert_ip_validation(model, attribute, mask = :allow_mask, message = nil, regex = nil)
+      assert model.valid?, 'Model should be valid to start.'
+      setter = :"#{attribute}="
+      orig = model.send attribute
+
+      valid = %w(
+          0.0.0.0
+          1.2.3.4
+          10.20.30.40
+          255.255.255.255
+          10:20::30:40
+          ::1
+          1:2:3:4:5:6:7:8
+          A:B:C:D:E:F::
+      )
+
+      invalid = %w(
+          localhost
+          100.200.300.400
+          12345::abcde
+          1.2.3.4.5
+          1.2.3
+          0
+          1:2:3:4:5:6:7:8:9:0
+          a:b:c:d:e:f:g:h
+      )
+
+      valid.each do |addr|
+        if mask == :require_mask
+          if addr.index(':')
+            addr += '/128'
+          else
+            addr += '/32'
+          end
+        end
+        model.send setter, addr
+        assert model.valid?, message ? (message + ': (rejected valid address)') : "Should have accepted #{addr.inspect}."
+      end
+
+      r = regex ? regex : /is not a valid ip address/i
+      invalid.each do |addr|
+        if mask == :require_mask
+          if addr.index(':')
+            addr += '/128'
+          else
+            addr += '/32'
+          end
+        end
+        model.send setter, addr
+        assert_not model.valid?, message ? (message + ': (accepted invalid address)') : "Should have rejected #{addr.inspect}."
+        assert model.errors[attribute].to_s =~ r, message ? (message + ': (error message)') : 'Did not fail for expected reason.'
+      end
+
+      if mask == :allow_mask || mask == :require_mask
+        address = '127.0.0.0/8'
+        model.send setter, address
+        assert model.valid?, message ? (message + ': (rejected masked address)') : "Should have accepted #{address.inspect}."
+      end
+
+      if mask == :allow_mask || mask == :deny_mask
+        address = '127.0.0.1'
+        model.send setter, address
+        assert model.valid?, message ? (message + ': (rejected unmasked address)') : "Should have accepted #{address.inspect}."
+      end
+
+      if mask == :require_mask
+        r = regex ? regex : /must contain a mask/i
+        address = '127.0.0.1'
+        model.send setter, address
+        assert_not model.valid?, message ? (message + ': (accepted unmasked address)') : "Should have rejected #{address.inspect} for no mask."
+        assert model.errors[attribute].to_s =~ r, message ? (message + ': (error message)') : 'Did not fail for expected reason.'
+      end
+
+      if mask == :deny_mask
+        r = regex ? regex : /must not contain a mask/i
+        address = '127.0.0.0/8'
+        model.send setter, address
+        assert_not model.valid? message ? (message + ': (accepted masked address)') : "Should have rejected #{address.inspect} for mask."
+        assert model.errors[attribute].to_s =~ r, message ? (message + ': (error message)') : 'Did not fail for expected reason.'
+      end
+
+      model.send setter, orig
+      assert model.valid?, message ? (message + ': (rejected original value)') : "Should have accepted original value of #{orig.inspect}."
+    end
+
+    ##
+    # Tests a specific field for safe name verification.
+    #
+    # model::
+    #     This must respond to _attribute_ and _attribute=_ as well as _valid?_ and _errors_.
+    #
+    # attribute::
+    #     This must provide the name of a valid attribute in the model.
+    #
+    # length::
+    #     The length of the string to test.  Must be greater than 2.  Default is 6.
+    #
+    # message::
+    #     This is optional, but if provided it will be postfixed with the failure reason.
+    #
+    # regex::
+    #     This is the regex to match against the error message to ensure that the failure is for the correct reason.
+    #     The default value is nil to test for the various default messages.
+    #
+    def assert_safe_name_validation(model, attribute, length = 6, message = nil, regex = nil)
+      assert model.valid?, 'Model should be valid to start.'
+      setter = :"#{attribute}="
+      orig = model.send attribute
+
+      assert length > 2, message ? (message + ': (field is too short to test)') : 'Requires a field length greater than 2 to perform tests.'
+
+      # valid tests.
+      mid_length = length - 2
+      mid = ''    # _z_z_z_z_z_
+      while mid.length < mid_length
+        if mid.length + 1 < mid_length
+          mid += '_z'
+        else
+          mid += '_'
+        end
+      end
+
+      [
+          'a' * length,
+          'a' + ('1' * (length - 1)),
+          'a' + mid + 'a',
+          'a' + mid + '1'
+      ].each do |val|
+        model.send setter, val
+        assert model.valid?, message ? (message + ': (rejected valid string)') : "Should have accepted #{val.inspect}."
+        val.upcase!
+        model.send setter, val
+        assert model.valid?, message ? (message + ': (rejected valid string)') : "Should have accepted #{val.inspect}."
+      end
+
+      # invalid tests.
+      {
+          '_' + ('a' * (length - 1)) => /must start with a letter/i,
+          '1' + ('a' * (length - 1)) => /must start with a letter/i,
+          ('a' * (length - 1)) + '_' => /must not end with an underscore/i,
+          ('a' * (length - 2)) + '-' + 'a' => /must contain only letters, numbers, and underscore/i,
+          ('a' * (length - 2)) + '#' + 'a' => /must contain only letters, numbers, and underscore/i,
+          ('a' * (length - 2)) + ' ' + 'a' => /must contain only letters, numbers, and underscore/i
+      }.each do |val, reg|
+        r = regex ? regex : reg
+        model.send setter, val
+        assert_not model.valid?, message ? (message + ': (accepted invalid string)') : "Should have rejected #{val.inspect}."
+        assert model.errors[attribute].to_s =~ r, message ? (message + ': (error message)') : "Did not fail for expected reason on #{val.inspect}."
+      end
+
+      model.send setter, orig
+      assert model.valid?, message ? (message + ': (rejected original value)') : "Should have accepted original value of #{orig.inspect}."
+    end
+
+  end
+end
+
+ActiveSupport::TestCase.include ActivesupportTestcaseExtras::TestCase

data/lib/activesupport_testcase_extras/version.rb

@@ -0,0 +1,3 @@
+module ActivesupportTestcaseExtras
+  VERSION = "1.0.2"
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: activesupport_testcase_extras
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Beau Barker
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- beau@barkerest.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- activesupport_testcase_extras.gemspec
+- bin/console
+- bin/setup
+- lib/activesupport_testcase_extras.rb
+- lib/activesupport_testcase_extras/test_case.rb
+- lib/activesupport_testcase_extras/version.rb
+homepage: https://github.com/barkerest/activesupport_testcase_extras
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Provides some additional test methods to ActiveSupport::TestCase.
+test_files: []