effective_test_bot 0.4.1 → 0.4.2

data/test/concerns/test_botable/page_dsl.rb

@@ -0,0 +1,39 @@
+# This DSL gives a class level and an instance level way of calling specific test suite
+#
+# class PostsTest < ActionDispatch::IntegrationTest
+#   page_test(:posts_path, User.first)
+#
+#   test 'a one-off action' do
+#     page_action_test(:posts_path, User.first)
+#   end
+# end
+
+
+module TestBotable
+  module PageDsl
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def page_test(path, user, options = {})
+        options[:current_test] = path.to_s
+        method_name = test_bot_method_name('page_test', options.delete(:label) || options[:current_test])
+
+        define_method(method_name) { page_action_test(path, user, options) }
+      end
+
+    end
+
+    # Instance Methods - Call me from within a test
+    def page_action_test(path, user, options = {})
+      begin
+        assign_test_bot_lets!(options.reverse_merge!(user: user, page_path: path))
+      rescue => e
+        raise "Error: #{e.message}.  Expected usage: crud_action_test(:new, Post || Post.new, User.first, options_hash)"
+      end
+
+      self.send(:test_bot_page_test)
+    end
+
+  end
+end

data/test/concerns/test_botable/redirect_dsl.rb

@@ -0,0 +1,37 @@
+# This DSL gives a class level and an instance level way of calling specific test suite
+#
+# class AboutTest < ActionDispatch::IntegrationTest
+#   redirect_test('/about', '/new-about', User.first)
+#
+#   test 'a one-off action' do
+#     redirect_action_test('/about', '/new-about', User.first)
+#   end
+# end
+
+module TestBotable
+  module RedirectDsl
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def redirect_test(from_path, to_path, user, options = {})
+        options[:current_test] = "#{from_path} to #{to_path}"
+        method_name = test_bot_method_name('redirect_test', options.delete(:label) || options[:current_test])
+
+        define_method(method_name) { redirect_action_test(from_path, to_path, user, options) }
+      end
+    end
+
+    # Instance Methods - Call me from within a test
+    def redirect_action_test(from_path, to_path, user, options = {})
+      begin
+        assign_test_bot_lets!(options.reverse_merge!(from_path: from_path, to_path: to_path, user: user))
+      rescue => e
+        raise "Error: #{e.message}.  Expected usage: redirect_action_test('/about', '/new-about', User.first)"
+      end
+
+      self.send(:test_bot_redirect_test)
+    end
+
+  end
+end

data/test/concerns/test_botable/wizard_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 WizardDsl
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def wizard_test(from_path, to_path, user, options = {})
+        options[:current_test] = "#{from_path} to #{to_path}"
+        method_name = test_bot_method_name('wizard_test', options.delete(:label) || options[:current_test])
+
+        define_method(method_name) { wizard_action_test(from_path, to_path, user, options) }
+      end
+
+    end
+
+    # Instance Methods - Call me from within a test
+    def wizard_action_test(from_path, to_path, user, options = {})
+      begin
+        assign_test_bot_lets!(options.reverse_merge!(from_path: from_path, to_path: to_path, user: user))
+      rescue => e
+        raise "Error: #{e.message}.  Expected usage: wizard_action_test('/fee_wizard/step1', '/fee_wizard/step5', User.first)"
+      end
+
+      self.send(:test_bot_wizard_test)
+    end
+
+  end
+end

data/test/support/effective_test_bot_assertions.rb

@@ -1,17 +1,17 @@
 module EffectiveTestBotAssertions
-  def assert_signed_in
+  def assert_signed_in(message = nil)
     visit new_user_session_path
-    assert_content I18n.t('devise.failure.already_authenticated')
-    assert page.has_no_selector?('form#new_user')
+    assert_content I18n.t('devise.failure.already_authenticated') #, message || '(signed_in) Expected devise already_authenticated content to be present'
+    assert page.has_no_selector?('form#new_user'), message || '(signed_in) Expected new_user form to be blank'
   end
 
-  def assert_signed_out
+  def assert_signed_out(message = nil)
     visit new_user_session_path
-    refute_content I18n.t('devise.failure.already_authenticated')
-    assert page.has_selector?('form#new_user')
+    refute_content I18n.t('devise.failure.already_authenticated') #, message || '(signed_out) Expected devise already_authenticated content to be blank'
+    assert page.has_selector?('form#new_user'), message || '(signed_out) Expected new_user form to be present'
   end
 
-  def assert_page_title(title = :any, message = 'Expected page title to be present')
+  def assert_page_title(title = :any, message = '(page_title) Expected page title to be present')
     if title.present? && title != :any
       assert_title(title) # Capybara TitleQuery, match this text
     else
@@ -20,44 +20,76 @@ module EffectiveTestBotAssertions
     end
   end
 
-  def assert_page_status(status = 200, message = 'Expected :status: HTTP status code')
+  def assert_page_status(status = 200, message = '(page_status) Expected :status: HTTP status code')
     assert_equal status, page.status_code, message.sub(':status:', status.to_s)
   end
 
-  def assert_no_js_errors
+  def assert_current_path(path, message = '(current_path) Expected current_path to be :path:')
+    path = public_send(path) if path.kind_of?(Symbol)
+    assert_equal path, page.current_path, message.sub(':path', path.to_s)
+  end
+
+  # assert_redirect '/about'
+  # assert_redirect '/about', '/about-us'
+  def assert_redirect(from_path, to_path = nil, message = nil)
+    if to_path.present?
+      assert_equal to_path, page.current_path, message || "(redirect) Expected redirect from #{from_path} to #{to_path}"
+    else
+      refute_equal from_path, page.current_path, message || "(redirect) Expected redirect away from #{from_path}"
+    end
+  end
+
+
+  def assert_no_js_errors(message = nil)
     errors = page.driver.error_messages
-    assert_equal 0, errors.size, errors.ai
+    assert_equal 0, errors.size, message || "(no_js_errors) Unexpected javascript error: #{errors.join(', ')}"
   end
 
-  def assert_no_unpermitted_params(message = 'Expected no unpermitted params')
+  def assert_no_unpermitted_params(message = '(no_unpermitted_params) Expected no unpermitted params')
     assert_equal [], unpermitted_params, message
   end
 
   # assert_flash
   # assert_flash :success
   # assert_flash :error, 'there was a specific error'
-  def assert_flash(key = nil, value = nil)
+  def assert_flash(key = nil, value = nil, message = nil)
     if key.present? && value.present?
-      assert_equal value, flash[key.to_s]
+      assert_equal value, flash[key.to_s], message || "(flash) Expected flash[#{key}] to equal #{value}. Instead, it was: #{value}"
     elsif key.present?
-      assert flash[key.to_s].present?, "Expected flash[#{key}] to be present"
+      assert flash[key.to_s].present?, message || "(flash) Expected flash[#{key}] to be present"
     else
-      assert flash.present?, 'Expected flash to be present'
+      assert flash.present?, message || '(flash) Expected flash to be present'
     end
   end
 
   # assert_assigns
   # assert_assigns :current_user
   # assert_assigns :current_user, true
-  def assert_assigns(key = nil, value = nil)
+  def assert_assigns(key = nil, value = nil, message = nil)
     if key.present? && value.present?
-      assert_equal value, assigns[key.to_s]
+      assert_equal value, assigns[key.to_s], message || "(assigns) Expected assigns[#{key}] to equal #{value}. Instead, it was: #{value}"
     elsif key.present?
-      assert assigns[key.to_s].present?, "Expected @#{key} to be assigned"
+      assert assigns[key.to_s].present?, message || "(assigns) Expected @#{key} to be assigned"
+    else
+      assert assigns.present?, message || '(assigns) Expected assigns to be present'
+    end
+  end
+
+  # assert_no_assigns_errors
+  # assert_no_assigns_errors :post
+  def assert_no_assigns_errors(key = nil, message = nil)
+    if key.present?
+      assert_equal [], ((assigns[key.to_s] || {})['errors'] || []), message || "(no_assigns_errors) Expected @#{key}[:errors] to be blank.  Instead, it was: #{assigns}"
     else
-      assert assigns.present?, 'Expected assigns to be present'
+      assigns.each do |key, value|
+        assert_equal [], (value['errors'] || []), message || "(no_assigns_errors) Expected @#{key}[:errors] to be blank"
+      end
     end
   end
 
+  # assert_assigns_errors :post
+  def assert_assigns_errors(key, message = nil)
+    refute_equal [], ((assigns[key.to_s] || {})['errors'] || []), message || "(assigns_errors) Expected @#{key}[:errors] to be present"
+  end
 
 end

data/test/support/effective_test_bot_form_helper.rb

@@ -14,6 +14,8 @@ module EffectiveTestBotFormHelper
     end
 
     all('input,select,textarea').each do |field|
+      next unless field.visible?
+
       case [field.tag_name, field['type']].compact.join('_')
       when 'input_text', 'input_email', 'input_password', 'input_tel', 'input_number', 'textarea'
         field.set(fill_value(field, fills))
@@ -23,7 +25,7 @@ module EffectiveTestBotFormHelper
         field.select(fill_value(field, fills), match: :first)
       when 'input_file'
         file_path = fill_value(field, fills)
-        field['class'].include?('asset-box-uploader-fileinput') ? upload_effective_asset(field, file_path) : field.set(file_path)
+        field['class'].to_s.include?('asset-box-uploader-fileinput') ? upload_effective_asset(field, file_path) : field.set(file_path)
       when 'input_submit', 'input_search'
         # Do nothing
       else
@@ -40,6 +42,7 @@ module EffectiveTestBotFormHelper
   end
 
   # Operates on just string keys
+  # This function receives the same fill values that you call fill_form with
   def fill_value(field, fills = nil)
     attributes = field['name'].to_s.gsub(']', '').split('[') # user[something_attributes][last_name] => ['user', 'something_attributes', 'last_name']
     field_name = [field.tag_name, field['type']].compact.join('_')
@@ -47,11 +50,12 @@ module EffectiveTestBotFormHelper
 
     if fills.present?
       key = nil
-      attributes.reverse_each do |name|
-        key = (key.present? ? "#{name}.#{key}" : name)
+      attributes.reverse_each do |name|  # match last_name, then something_attributes.last_name, then user.something_attributes.last_name
+        key = (key.present? ? "#{name}.#{key}" : name) # builds up the string as we go along
 
         if fills.key?(key)
           fill_value = fills[key]
+          # select is treated differently, because we want the passed prefill to match both the html text or value (which is implemented below)
           ['select'].include?(field_name) ? break : (return fill_value)
         end
       end
@@ -86,7 +90,7 @@ module EffectiveTestBotFormHelper
         Faker::Lorem.word
       end
     when 'select'
-      if fill_value.present? # accept a value or label
+      if fill_value.present? # accept a value or text
         field.all('option').each do |option|
           return option.text if option.text == fill_value || option.value.to_s == fill_value.to_s
         end
@@ -126,7 +130,7 @@ module EffectiveTestBotFormHelper
   def with_raised_unpermitted_params_exceptions(&block)
     action = nil
 
-    begin  # This will only work with Rails >= 4.0
+    begin  # This may only work with Rails >= 4.0
       action = ActionController::Parameters.action_on_unpermitted_parameters
       ActionController::Parameters.action_on_unpermitted_parameters = :raise
     rescue => e

data/test/support/effective_test_bot_login_helper.rb

@@ -6,14 +6,14 @@ module EffectiveTestBotLoginHelper
   end
 
   def sign_in(user) # Warden::Test::Helpers
-    user.kind_of?(String) == true ? login_as(User.find_by_email!(user)) : login_as(user)
+    user.kind_of?(String) ? login_as(User.find_by_email!(user)) : login_as(user)
   end
 
   def sign_in_manually(email, password)
     visit new_user_session_path
 
     within('form#new_user') do
-      fill_form(:email => email, :password => password)
+      fill_form(email: email, password: password)
       submit_form
     end
   end
@@ -22,7 +22,7 @@ module EffectiveTestBotLoginHelper
     visit new_user_registration_path
 
     within('form#new_user') do
-      fill_form(:email => email, :password => password, :password_confirmation => password)
+      fill_form(email: email, password: password, password_confirmation: password)
       submit_form
     end
 

data/test/support/effective_test_bot_test_helper.rb

@@ -1,5 +1,4 @@
 module EffectiveTestBotTestHelper
-
   # This makes sure capybara is done, and breaks out of any 'within' blocks
   def synchronize!
     page.document.find('html')
@@ -20,6 +19,10 @@ module EffectiveTestBotTestHelper
     @unpermitted_params = (JSON.parse(Base64.decode64(session.driver.response_headers['Test-Bot-Unpermitted-Params'])) rescue [])
   end
 
+  def was_redirect?(from_path, to_path = nil)
+    from_path != (to_path || page.current_path)
+  end
+
   # EffectiveTestBot includes an after_filter on ApplicationController to set an http header
   # that encodes the flash message, and some of the assigns
   def flash
@@ -33,5 +36,4 @@ module EffectiveTestBotTestHelper
   def unpermitted_params
     @unpermitted_params ||= (JSON.parse(Base64.decode64(page.response_headers['Test-Bot-Unpermitted-Params'])) rescue [])
   end
-
 end

data/test/test_bot/integration/application_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+module TestBot
+  class ApplicationTest < ActionDispatch::IntegrationTest
+    CRUD_ACTIONS = %w(index create new edit show update destroy) # Same order as resources :object creates them in
+
+    class << self
+
+      # Go through every route, and run an appropriate test suite on it
+      def initialize_tests
+        puts 'test_bot scanning....'
+
+        routes = Rails.application.routes.routes.to_a
+        seen_actions = Hash.new([])  # {posts: ['new', 'edit'], events: ['new', 'edit', 'show']}
+
+        #Rails.application.routes.recognize_path('/your/path/here')
+        #Rails.application.routes.recognize_path('/admin/jobs/3/unarchive')
+        # => {:action=>"unarchive", :controller=>"admin/jobs", :id=>"3"}
+
+        routes.each_with_index do |route, index|
+          controller = route.defaults[:controller]
+          action = route.defaults[:action]
+
+          # Devise Test
+          if (controller || '').include?('devise')
+            next if seen_actions['devise'].present?
+
+            puts 'define devise test!!'
+            seen_actions['devise'] = true # So we don't repeat it
+
+          # Redirect Test
+          elsif route.app.kind_of?(ActionDispatch::Routing::PathRedirect) && route.path.required_names.blank?
+            path = route.path.spec.to_s
+            route.path.optional_names.each { |name| path.sub!("(.:#{name})", '') } # Removes (.:format) from path
+            redirect_test(path, route.app.path([], nil), User.first)
+
+          # CRUD Test
+          elsif is_crud_controller?(route)
+            seen_actions[controller] += [action]
+
+            next_controller = (routes[index+1].defaults[:controller] rescue :last)
+            next_action = (routes[index+1].defaults[:action] rescue :last)
+
+            # If we're done accumulating CRUD actions, launch the crud_test with all seen actions
+            if controller != next_controller || CRUD_ACTIONS.include?(next_action) == false
+              begin
+                crud_test(controller, User.first, only: seen_actions.delete(controller))
+              rescue => e
+                puts e.message # Sometimes there is an object that can't be instantiated, so we still want to continue the application test
+              end
+            end
+
+          # Member Test
+          elsif route.verb.to_s.include?('GET') && route.path.required_names == ['id']
+            member_test(controller, action, User.first)
+
+          # Page Test
+          elsif route.verb.to_s.include?('GET') && route.name.present?
+            page_test("#{route.name}_path".to_sym, User.first, route: route, label: "#{route.name}_path")
+
+          else
+            puts "skipping #{route.name}_path | #{route.path.spec} | #{route.verb} | #{route.defaults[:controller]} | #{route.defaults[:action]}"
+
+          end # / Routes
+        end
+      end
+
+      private
+
+      def is_crud_controller?(route)
+        return false unless CRUD_ACTIONS.include?(route.defaults[:action])
+
+        controller_klass = (route.app.controller(route.defaults) rescue nil) if route.defaults[:controller].present? && route.app.respond_to?(:controller)
+        controller_instance = controller_klass.new() if controller_klass
+
+        # Is this a CRUD capable controller?
+        controller_instance && controller_instance.respond_to?(:new) && controller_instance.respond_to?(:create)
+      end
+
+    end
+
+    initialize_tests
+
+  end
+
+end

data/test/test_bot/integration/minitest_test.rb

@@ -39,11 +39,11 @@ module TestBot
       assert_equal (original_users_count + 1), User.count
     end
 
-    test '05: test database is back to normal' do
+    test '05: test database has reset' do
       assert_normal
     end
 
-    test '06: capybara can create a user' do
+    test '06: capybara can sign up a user' do
       user = sign_up()
       assert user.kind_of?(User)
 
@@ -51,26 +51,30 @@ module TestBot
       assert_signed_in
     end
 
-    test '07: test database is back to normal' do
+    test '07: database and session have reset' do
+      assert_signed_out
       assert_normal
     end
 
-    test '08: capybara session has been reset after manual sign up' do
-      assert_signed_out
+    test '08: capybara can login_as via warden test helper' do
       create_user!
       sign_in(email)
       assert_signed_in
     end
 
-    test '09: test database is back to normal' do
+    test '09: database and session have reset' do
+      assert_signed_out
       assert_normal
     end
 
-    test '10: capybara session has been reset after warden login_as' do
-      assert_signed_out
+    test '10: capybara can sign in manually' do
+      create_user!
+      sign_in_manually(email, password)
+      assert_signed_in
     end
 
-    test '11: test database is back to normal' do
+    test '11: database and session have reset' do
+      assert_signed_out
       assert_normal
     end
 
@@ -78,8 +82,9 @@ module TestBot
 
     def assert_normal
       visit root_path
-      assert_equal page.status_code, 200
-      assert_equal original_users_count, User.count
+      assert_page_status
+      assert_equal original_users_count, User.count, 'Epected User.count to be back to original'
+      assert assigns[:current_user].blank?, 'Expected current_user to be blank'
 
       # Someitmes it's nice to assert your environment...
       #assert users(:normal).present?