effective_test_bot 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e103116aeed8578d3cb62239ab87759208152860
-  data.tar.gz: a4978f5794f46d577111f8bbfbfbf32c0aafa9d6
+  metadata.gz: faf3170be69a804110713bd4fffd0d2802841fa2
+  data.tar.gz: 3ac29840a0b524fad45cded4d7d81c3bcb56bee4
 SHA512:
-  metadata.gz: a18ae0e701b4e5abcd1275070c9347c10116b626896c6b59edcb7bfe2dcdfd987e7cf17a1fad08b8f6879b4de3eaa0182ccd81603d8f7b22e4108f84d56f0d92
-  data.tar.gz: c764261c4bbfbef91ac98864877dbae1f2e549b24b3cc01ed215a934c14cc3c68891fa821ea6367ddd5ef89e8af6d1cfa242b8f742b2fccf5ad300d6b6e0a7aa
+  metadata.gz: e1bc8fe65d07f530b193e9498e5d3537944d09903727f0407cc7c93bccfeed52addaa1383a56faea2bc005be2429b1e5d856da74da5bc7209e5949425dfb3d7c
+  data.tar.gz: 4174f5a21a7cfa52081df5d86de979b48cfe1a44fe167a5974b84653cb64f4bcd24555d0787b269336f33540376684bafc566937c46df7186e91b6a6c48c607e

data/app/helpers/effective_test_bot_controller_helper.rb

@@ -1,4 +1,5 @@
 module EffectiveTestBotControllerHelper
+  # This is included as an after_filter
   def assign_test_bot_http_headers
     response.headers['Test-Bot-Flash'] = Base64.encode64(flash.to_hash.to_json)
 

data/lib/effective_test_bot.rb

@@ -2,8 +2,69 @@ require "effective_test_bot/engine"
 require "effective_test_bot/version"
 
 module EffectiveTestBot
+  mattr_accessor :except
+  mattr_accessor :only
+
   def self.setup
     yield self
   end
 
+  def self.skip?(test, assertion = nil)
+    value = [test.to_s.presence, assertion.to_s.presence].compact.join(' ')
+    return false if value.blank?
+
+    if onlies.present?
+      onlies.find { |only| value.start_with?(only) }.blank? # Let partial matches work
+    elsif excepts.present?
+      excepts.find { |except| except == value }.present?
+    else
+      false
+    end
+  end
+
+  private
+
+  def self.onlies
+    @@onlines ||= begin
+      flatten_and_sort(
+        if ENV['TEST_BOT_TEST'].present?
+          ENV['TEST_BOT_TEST'].to_s.gsub('[', '').gsub(']', '').split(',').map { |str| str.strip }
+        else
+          only
+        end
+      )
+    end
+  end
+
+  def self.excepts
+    @@excepts ||= flatten_and_sort(except)
+  end
+
+    # config.except = [
+    #   'assert_path',
+    #   'users#show',
+    #   'users#create_invalid' => ['assert_path'],
+    #   'users#create_invalid' => 'assert_unpermitted_params',
+    #   'report_total_allocation_index_path'
+    # ]
+
+    # We need to flatten any Hashes into
+    #   'users#create_invalid' => ['assert_path', 'assert_page_title'],
+    # into this
+    # ['users#create_invalid assert_path'
+    # 'users#create_invalid assert_page_title']
+
+  def self.flatten_and_sort(skips)
+    Array(skips).flat_map do |skip|
+      case skip
+      when Symbol
+        skip.to_s
+      when Hash
+        skip.keys.product(skip.values.flatten).map { |p| p.join(' ') }
+      else
+        skip
+      end
+    end.compact.sort
+  end
+
 end

data/lib/effective_test_bot/engine.rb

@@ -14,10 +14,23 @@ module EffectiveTestBot
 
     initializer 'effective_test_bot.test_suite' do |app|
       Rails.application.config.to_prepare do
+        # test/test_botable/
+        ActionDispatch::IntegrationTest.include BaseTest
         ActionDispatch::IntegrationTest.include CrudTest
-        ActionDispatch::IntegrationTest.include TestBotable::CrudTest
-
-        # A whole bunch of helper methods
+        ActionDispatch::IntegrationTest.include MemberTest
+        ActionDispatch::IntegrationTest.include PageTest
+        ActionDispatch::IntegrationTest.include RedirectTest
+        ActionDispatch::IntegrationTest.include WizardTest
+
+        # test/concerns/test_botable/
+        ActionDispatch::IntegrationTest.include TestBotable::BaseDsl
+        ActionDispatch::IntegrationTest.include TestBotable::CrudDsl
+        ActionDispatch::IntegrationTest.include TestBotable::MemberDsl
+        ActionDispatch::IntegrationTest.include TestBotable::PageDsl
+        ActionDispatch::IntegrationTest.include TestBotable::RedirectDsl
+        ActionDispatch::IntegrationTest.include TestBotable::WizardDsl
+
+        # test/support/
         ActionDispatch::IntegrationTest.include EffectiveTestBotAssertions
         ActionDispatch::IntegrationTest.include EffectiveTestBotFormHelper
         ActionDispatch::IntegrationTest.include EffectiveTestBotLoginHelper
@@ -29,6 +42,8 @@ module EffectiveTestBot
       ActiveSupport.on_load :action_controller do
         if Rails.env.test?
           ActionController::Base.send :include, ::EffectiveTestBotControllerHelper
+
+          ActionController::Base.send :before_filter, :expires_now # Prevent 304 Not Modified caching
           ActionController::Base.send :after_filter, :assign_test_bot_http_headers
 
           ApplicationController.instance_exec do

data/lib/effective_test_bot/version.rb

@@ -1,3 +1,3 @@
 module EffectiveTestBot
-  VERSION = '0.4.1'.freeze
+  VERSION = '0.4.2'.freeze
 end

data/lib/generators/templates/test_helper.rb

@@ -34,7 +34,7 @@ class ActionDispatch::IntegrationTest
   # end
 
   def after_teardown # I reset sessions here so capybara-screenshot can still make screenshots when tests fail
-    super() and Capybara.reset_sessions!
+    super(); Capybara.reset_sessions!
   end
 
 end

data/lib/tasks/effective_test_bot_tasks.rake

@@ -1,9 +1,19 @@
 require 'rake/testtask'
 require 'rails/test_unit/sub_test_task'
 
+# rake test:bot
+# rake test:bot TEST=documents#new
+# rake test:bot TEST=documents#new,documents#show
+# rake test:bot TEST=documents#new path,documents#show,documents#update_valid no_unpermitted_params
+
 namespace :test do
   desc 'Runs Effective Test Bot'
   task :bot do
+    if ENV['TEST'].present?
+      ENV['TEST_BOT_TEST'] = ENV['TEST']
+      ENV['TEST'] = nil
+    end
+
     Rake::Task["test:effective_test_bot"].invoke
   end
 
@@ -18,5 +28,4 @@ namespace :test do
     load(seeds) if File.exists?(seeds)
   end
 
-
 end

data/test/concerns/test_botable/base_dsl.rb

@@ -0,0 +1,142 @@
+module TestBotable
+  module BaseDsl
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      TEST_BOT_TEST_PREFIXES = ['crud_test', 'member_test', 'page_test', 'redirect_test', 'wizard_test']
+
+      # Parses and validates lots of options
+      # This is a big manual merge wherein we translate some DSL methods into one consistent Hash here
+      # The output is what gets sent to each test and defined as lets
+
+      # {
+      #   user: User<1> instance
+      #   controller_namespace: 'admin'
+      #   controller: 'jobs'
+      #   skips: []
+      #   resource: Post<1> instance
+      #   resource_class: Post
+      #   resource_name: 'post'
+      #   resource_attributes: {:user_id => 3} attributes, if called with an instance of ActiveRecord with non-default attributes
+      #   current_test: posts#new (if from the class level) or NIL if from the instance level
+      # }
+      #
+
+      def normalize_test_bot_options!(options)
+        raise 'expected options to be a Hash' unless options.kind_of?(Hash)
+        raise 'expected key :user to be a User' unless options[:user].kind_of?(User)
+        #raise 'expected key :current_test to be a String' unless options[:current_test].kind_of?(String)
+
+        # Controller stuff
+        options[:controller_namespace] ||= options[:namespace]
+
+        # Skip stuff
+        skips = options[:skip] || options[:skips]
+        unless skips.blank? || skips.kind_of?(Symbol) || (skips.kind_of?(Array) && skips.all? { |s| s.kind_of?(Symbol) })
+          raise 'expected skips to be a Symbol or Array of Symbols'
+        end
+        options[:skips] = Array(skips)
+
+        # Resource could be an ActiveRecord Class, Instance of a class, or String
+        # Build a resource stuff
+        if options[:resource].present?
+          obj = options[:resource]
+          raise 'expected resource to be a Class or Instance or String' unless obj.kind_of?(Class) || obj.kind_of?(ActiveRecord::Base) || obj.kind_of?(String)
+
+          if obj.kind_of?(String) # Let's assume this is a controller, 'admin/jobs', or just 'jobs', or 'jobs_controller'
+            obj.sub!('_controller', '')
+
+            (*namespace, klass) = obj.split('/')
+            namespace = Array(namespace).join('/').presence
+
+            # See if I can turn it into a model
+            klass = klass.classify.safe_constantize
+
+            raise "failed to constantize resource from string #{obj}, unable to proceed" unless klass.present?
+
+            options[:controller_namespace] ||= namespace
+            options[:controller] = obj.dup
+
+            obj = klass
+          end
+
+          # Make sure Obj.new() works
+          if obj.kind_of?(Class) && (obj.new() rescue false) == false
+            raise "failed to initialize resource with #{obj}.new(), unable to proceed"
+          end
+
+          # Parse the resource and resource class
+          resource = obj.kind_of?(Class) ? obj.new() : obj
+          resource_class = obj.kind_of?(Class) ? obj : obj.class
+
+          # If obj is an ActiveRecord object with attributes, Post.new(:title => 'My Title')
+          # then compute any explicit attributes, so forms will be filled with those values
+          resource_attributes = if obj.kind_of?(ActiveRecord::Base)
+            empty = resource_class.new()
+            {}.tap { |atts| resource.attributes.each { |k, v| atts[k] = v if empty.attributes[k] != v } }
+          end || {}
+
+          options[:resource] = resource
+          options[:resource_class] = resource_class
+          options[:resource_name] = resource_class.name.underscore
+          options[:resource_attributes] = resource_attributes
+
+          options[:normalized] = true
+        end
+
+        options
+      end
+
+      # Run any test_bot tests first, in the order they're defined
+      # then the rest of the tests with whatever order they come in
+      def runnable_methods
+        public_instance_methods.select do |name|
+          name = name.to_s
+          TEST_BOT_TEST_PREFIXES.any? { |prefix| name.starts_with?(prefix) }
+        end.map(&:to_s) + super
+      end
+
+      protected
+
+      # You can't define multiple methods with the same name
+      # So we need to create a unique name, where appropriate, that still looks good in MiniTest output
+      def test_bot_method_name(test_family, current_test)
+        number_of_tests = if current_test.blank?
+          @num_defined_test_bot_tests ||= {}
+          @num_defined_test_bot_tests[test_family] = (@num_defined_test_bot_tests[test_family] || 0) + 1
+        end
+
+        if current_test.present?
+          "#{test_family}: (#{current_test})"
+        elsif number_of_tests > 1
+          "#{test_family}: (#{number_of_tests})"
+        else
+          "#{test_family}:"
+        end
+      end
+    end
+
+    # Instance Methods
+
+
+    # Using reverse_merge! in the dsl action_tests makes sure that the
+    # class level can assign a current_test variable
+    # wheras the action level ones it's not present.
+    def assign_test_bot_lets!(options)
+      lets = if options.kind_of?(Hash) && options[:normalized]
+        options
+      else
+        self.class.normalize_test_bot_options!(options)
+      end
+
+      lets.each { |k, v| self.class.let(k) { v } } # Using the minitest spec let(:foo) { 'bar' } syntax
+
+      # test_bot may leak some lets from one test to the next, if they're not overridden
+      # I take special care to undefine just current test so far
+      self.class.let(:current_test) { nil } if options[:current_test].blank?
+
+      lets
+    end
+
+  end
+end

data/test/concerns/test_botable/crud_dsl.rb

@@ -0,0 +1,92 @@
+# This DSL gives a class level and an instance level way of calling specific test suite
+#
+# class PostsTest < ActionDispatch::IntegrationTest
+#   crud_test(Post || 'admin/posts', User.first, except: :show, skip: {create_valid: :path, update_invalid: [:path, :flash]})
+#
+#   test 'a one-off action' do
+#     crud_action_test(:new, Post, User.first, skip: :title)
+#   end
+# end
+
+module TestBotable
+  module CrudDsl
+    extend ActiveSupport::Concern
+
+    CRUD_TESTS = [:new, :create_valid, :create_invalid, :edit, :update_valid, :update_invalid, :index, :show, :destroy]
+
+    module ClassMethods
+
+      # All this does is define a 'test_bot' method for each required action on this class
+      # So that MiniTest will see the test functions and run them
+      def crud_test(resource, user, options = {})
+        # This skips paramaters is different than the initializer skips, which affect just the rake task
+
+        # These are specificially for the DSL
+        # In the class method, this value is a Hash, in the instance method it's expecting an Array
+        skips = options.delete(:skip) || options.delete(:skips) || {} # So you can skip sub tests
+        raise 'invalid skip syntax, expecting skip: {create_invalid: [:path]}' unless skips.kind_of?(Hash)
+
+        label = options.delete(:label).presence
+        only = options.delete(:only)
+        except = options.delete(:except)
+
+        begin
+          normalize_test_bot_options!(options.merge!(user: user, resource: resource))
+        rescue => e
+          raise "Error: #{e.message}.  Expected usage: crud_test(Post || Post.new, User.first, only: [:new, :create], skip: {create_invalid: [:path]})"
+        end
+
+        crud_tests_to_define(only, except).each do |test|
+          options_for_method = options.dup
+
+          options_for_method[:skips] = Array(skips[test]) if skips[test]
+          options_for_method[:current_test] = [
+            options[:controller_namespace].presence,
+            options[:resource_name].pluralize
+          ].compact.join('/') + '#' + test.to_s
+
+          method_name = test_bot_method_name('crud_test', label || options_for_method[:current_test])
+
+          define_method(method_name) { crud_action_test(test, resource, user, options_for_method) }
+        end
+      end
+
+      private
+
+      # Parses the incoming options[:only] and [:except]
+      # To only define the appropriate methods
+      # This guarantees the functions will be defined in the same order as CRUD_TESTS
+      def crud_tests_to_define(only, except)
+        if only
+          only = Array(only).flatten.compact.map { |x| x.to_sym }
+          only = only + [:create_valid, :create_invalid] if only.delete(:create)
+          only = only + [:update_valid, :update_invalid] if only.delete(:update)
+
+          CRUD_TESTS & only
+        elsif except
+          except = Array(except).flatten.compact.map { |x| x.to_sym }
+          except = except + [:create_valid, :create_invalid] if except.delete(:create)
+          except = except + [:update_valid, :update_invalid] if except.delete(:update)
+
+          CRUD_TESTS - except
+        else
+          CRUD_TESTS
+        end
+      end
+    end
+
+    # Instance Methods - Call me from within a test
+    #
+    # If obj is a Hash {:resource => ...} just skip over parsing options
+    # And assume it's already been done (by the ClassMethod crud_test)
+    def crud_action_test(test, resource, user = nil, options = {})
+      begin
+        assign_test_bot_lets!(options.reverse_merge!(user: user, resource: resource))
+      rescue => e
+        raise "Error: #{e.message}.  Expected usage: crud_action_test(:new, Post || Post.new, User.first, options_hash)"
+      end
+
+      self.send("test_bot_#{test}_test")
+    end
+  end
+end

data/test/concerns/test_botable/member_dsl.rb

@@ -0,0 +1,41 @@
+# This DSL gives a class level and an instance level way of calling specific test suite
+#
+# class PostsTest < ActionDispatch::IntegrationTest
+#   member_test('admin/jobs', 'unarchive', User.first, Post.first)
+#
+#   test 'a one-off action' do
+#     member_action_test('admin/jobs', 'unarchive', User.first)
+#   end
+# end
+
+# A member_test assumes assumes route.name.present? && route.verb.to_s.include?('GET') && route.path.required_names == ['id']
+# we HAVE TO build or have available one of these resources so we can pass the ID to it and see what happens :)
+
+module TestBotable
+  module MemberDsl
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def member_test(controller, action, user, obj_to_param = nil, options = {})
+        options[:current_test] = "#{controller}##{action}"
+        method_name = test_bot_method_name('member_test', options.delete(:label) || options[:current_test])
+
+        define_method(method_name) { member_action_test(controller, action, user, obj_to_param, options) }
+      end
+
+    end
+
+    # Instance Methods - Call me from within a test
+    def member_action_test(controller, action, user, member = nil, options = {})
+      begin
+        assign_test_bot_lets!(options.reverse_merge!(resource: controller, action: action, user: user, member: member))
+      rescue => e
+        raise "Error: #{e.message}.  Expected usage: member_test('admin/jobs', 'unarchive', User.first, Post.first || nil)"
+      end
+
+      self.send(:test_bot_member_test)
+    end
+
+  end
+end