effective_test_bot 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4264790049653f4d61c579da4c76c30414783b2b
-  data.tar.gz: f760d945c4f4bbb14fe9d4f795b59aedc34f88f5
+  metadata.gz: 50ef005db97e70ce2576d749a0a4542409319da7
+  data.tar.gz: c12dc73aacd70b89fc4d4bcdde5b875c723f7c90
 SHA512:
-  metadata.gz: 09f18672e89360df638fe5dd3ffe22e6f522445a9fa63d9d3b51f714d0b03ef0b95ef7d8e9ce5111549604bfcc7ab010f1b234241a682d43f05f5aace2193505
-  data.tar.gz: c99c37e6a85fd1052759de639f2d4b89794b3ced10f28b593f2b2fd8c13b4b529f8854f3a782fa5d88881da876ed9a76afd15db48c81f85d5ddcc60bee75bbdd
+  metadata.gz: 4c71082a5e0e90643d1bb90ceca1f01d9aaa37200c4d5a31cbc71dcfc59faa224c0572d1f13ceef05643b75d8df99665f816bf815617a4d2786402cc1418c047
+  data.tar.gz: 820f5070944df5997434796a7ce0d775fd809c3b686c19ac03e95589b80b1b74fef6b7b6bf17741c9bc3e4353422f58860664dfcb5227df8c164fdcff645881a

data/README.md

@@ -40,6 +40,10 @@ bundle exec rake test:bot
 You should now see multiple -- hopefully passing -- tests that you didn't write!
 
 
+
+rake test TEST=test/integration/clinic_assets_test.rb
+
+
 ## Fixtures
 
 TODO

data/app/helpers/effective_test_bot_controller_helper.rb

@@ -0,0 +1,25 @@
+module EffectiveTestBotControllerHelper
+  def assign_test_bot_http_headers
+    response.headers['Test-Bot-Flash'] = Base64.encode64(flash.to_hash.to_json)
+
+    # Assign the Assigns now
+    # With the assigns, we're a little bit more selective
+    # Anything that's a simple object can be serialized
+    test_bot_assigns = {}
+
+    view_assigns.each do |key, object|
+      case object
+      when ActiveRecord::Base
+        test_bot_assigns[key] = object.attributes
+        test_bot_assigns[key][:errors] = object.errors.messages.delete_if { |_, v| v.blank? } if object.errors.present?
+      when TrueClass, FalseClass, NilClass, String, Symbol, Numeric
+        test_bot_assigns[key] = object
+      else
+        # We don't want to serialize them, but they should be present
+        test_bot_assigns[key] = :present_but_not_serialized
+      end
+    end
+
+    response.headers['Test-Bot-Assigns'] = Base64.encode64(test_bot_assigns.to_hash.to_json)
+  end
+end

data/lib/effective_test_bot/engine.rb

@@ -2,9 +2,9 @@ module EffectiveTestBot
   class Engine < ::Rails::Engine
     engine_name 'effective_test_bot'
 
+    config.autoload_paths += Dir["#{config.root}/test/test_botable/**/"]
     config.autoload_paths += Dir["#{config.root}/test/concerns/**/"]
     config.autoload_paths += Dir["#{config.root}/test/support/**/"]
-    config.autoload_paths += Dir["#{config.root}/test/test_botable/**/"]
 
     # Set up our default configuration options.
     initializer "effective_test_bot.defaults", :before => :load_config_initializers do |app|
@@ -14,12 +14,23 @@ module EffectiveTestBot
 
     initializer 'effective_test_bot.test_suite' do |app|
       Rails.application.config.to_prepare do
-        ActionDispatch::IntegrationTest.send(:include, ActsAsTestBotable)
+        ActionDispatch::IntegrationTest.include CrudTest
+        ActionDispatch::IntegrationTest.include TestBotable::CrudTest
+
+        # A whole bunch of helper methods
+        ActionDispatch::IntegrationTest.include EffectiveTestBotAssertions
+        ActionDispatch::IntegrationTest.include EffectiveTestBotFormHelper
+        ActionDispatch::IntegrationTest.include EffectiveTestBotLoginHelper
+        ActionDispatch::IntegrationTest.include EffectiveTestBotTestHelper
+      end
+    end
 
-        ActionDispatch::IntegrationTest.send(:include, EffectiveTestBotAssertions)
-        ActionDispatch::IntegrationTest.send(:include, EffectiveTestBotFormHelper)
-        ActionDispatch::IntegrationTest.send(:include, EffectiveTestBotLoginHelper)
-        ActionDispatch::IntegrationTest.send(:include, EffectiveTestBotTestHelper)
+    initializer 'effective_test_bot.assign_assign_headers' do
+      ActiveSupport.on_load :action_controller do
+        if Rails.env.test?
+          ActionController::Base.send :include, ::EffectiveTestBotControllerHelper
+          ActionController::Base.send :after_filter, :assign_test_bot_http_headers
+        end
       end
     end
 

data/lib/effective_test_bot/version.rb

@@ -1,3 +1,3 @@
 module EffectiveTestBot
-  VERSION = '0.2.3'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/lib/generators/templates/test_helper.rb

@@ -63,6 +63,7 @@ ActiveRecord::Migration.maintain_test_schema!
 
 Rake::Task['db:fixtures:load'].invoke # There's just no way to get the seeds first, as this has to delete everything
 Rake::Task['db:seed'].invoke
+Rake::Task['test:load_fixture_seeds'].invoke # This is included by effective_test_bot.  It just runs the app's test/fixtures/seeds.rb if it exists
 
 # Make all database transactions use the same thread, otherwise signing up in capybara won't get rolled back
 # This must be run after the Rake::Tasks above

data/lib/tasks/effective_test_bot_tasks.rake

@@ -12,7 +12,11 @@ namespace :test do
     t.test_files = FileList["#{File.dirname(__FILE__)}/../../test/test_bot/**/*_test.rb"]
   end
 
+  desc 'loads test/fixtures/seeds.rb'
+  task :load_fixture_seeds => :environment do
+    seeds = "#{Rails.root}/test/fixtures/seeds.rb"
+    load(seeds) if File.exists?(seeds)
+  end
 
 
 end
-

data/test/concerns/test_botable/crud_test.rb

@@ -0,0 +1,135 @@
+module TestBotable
+  module CrudTest
+    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(obj, user, options = {})
+        # Check for expected usage
+        unless (obj.kind_of?(Class) || obj.kind_of?(ActiveRecord::Base)) && user.kind_of?(User) && options.kind_of?(Hash)
+          raise 'invalid parameters passed to crud_test(), expecting crud_test(Post || Post.new(), User.first, options_hash)'
+        end
+
+        test_options = crud_test_options(obj, user, options) # returns a Hash of let! options
+        tests_prefix = crud_tests_prefix(options) # returns a string something like "test_bot (3)"
+
+        crud_tests_to_define(options).each do |test|
+          test_name = case test
+            when :new               ; "#{tests_prefix} #new"
+            when :create_valid      ; "#{tests_prefix} #create valid"
+            when :create_invalid    ; "#{tests_prefix} #create invalid"
+            when :edit              ; "#{tests_prefix} #edit"
+            when :update_valid      ; "#{tests_prefix} #update valid"
+            when :update_invalid    ; "#{tests_prefix} #update invalid"
+            when :index             ; "#{tests_prefix} #index"
+            when :show              ; "#{tests_prefix} #show"
+            when :destroy           ; "#{tests_prefix} #destroy"
+          end
+
+          define_method(test_name) { crud_action_test(test, test_options) }
+        end
+      end
+
+      # Parses and validates lots of options
+      # The output is what gets sent to each test and defined as lets
+      def crud_test_options(obj, user, options = {})
+        # Make sure Obj.new() works
+        if obj.kind_of?(Class) && (obj.new() rescue false) == false
+          raise "effective_test_bot: failed to initialize object 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 || {}
+
+        # Final options to call each test with
+        {
+          resource: resource,
+          resource_class: resource_class,
+          resource_name: resource_class.name.underscore,
+          resource_attributes: resource_attributes,
+          controller_namespace: options[:namespace],
+          user: user
+        }
+      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
+        self.public_instance_methods.select { |name| name.to_s.starts_with?('test_bot') }.map(&:to_s) +
+          super.reject { |name| name.starts_with?('test_bot') }
+      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(options)
+        to_run = if options[:only]
+          options[:only] = Array(options[:only]).flatten.compact.map(&:to_sym)
+          options[:only] = options[:only] + [:create_valid, :create_invalid] if options[:only].delete(:create)
+          options[:only] = options[:only] + [:update_valid, :update_invalid] if options[:only].delete(:update)
+
+          CRUD_TESTS & options[:only]
+        elsif options[:except]
+          options[:except] = Array(options[:except]).flatten.compact.map(&:to_sym)
+          options[:except] = options[:except] + [:create_valid, :create_invalid] if options[:except].delete(:create)
+          options[:except] = options[:except] + [:update_valid, :update_invalid] if options[:except].delete(:update)
+
+          CRUD_TESTS - options[:except]
+        else
+          CRUD_TESTS
+        end
+      end
+
+      # 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 crud_tests_prefix(options)
+        @num_defined_crud_tests = (@num_defined_crud_tests || 0) + 1
+
+        if options[:label].present?
+          "test_bot: (#{options[:label]})"
+        elsif @num_defined_crud_tests > 1
+          "test_bot: (#{@num_defined_crud_tests})"
+        else
+          'test_bot:'
+        end
+      end
+
+    end
+
+    # Instance Methods
+
+    # This should allow you to run a crud_test method in a test
+    # crud_action_test(:create_valid, Clinic, User.first)
+    #
+    # 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, obj, user = nil, options = {})
+      if obj.kind_of?(Hash) && obj.key?(:resource)
+        obj
+      else
+        # Check for expected usage
+        unless (obj.kind_of?(Class) || obj.kind_of?(ActiveRecord::Base)) && user.kind_of?(User) && options.kind_of?(Hash)
+          raise 'invalid parameters passed to crud_action_test(), expecting crud_action_test(:new, Post || Post.new(), User.first, options_hash)'
+        end
+
+        self.class.crud_test_options(obj, user, options)
+      end.each { |k, v| self.class.let(k) { v } } # Using the regular let(:foo) { 'bar'} syntax
+
+      self.send(test)
+    end
+  end
+end

data/test/support/effective_test_bot_assertions.rb

@@ -11,7 +11,7 @@ module EffectiveTestBotAssertions
     assert page.has_selector?('form#new_user')
   end
 
-  def assert_page_title(title = :any, message = 'page title is blank')
+  def assert_page_title(title = :any, message = 'expected page title to be present')
     if title.present? && title != :any
       assert_title(title) # Capybara TitleQuery, match this text
     else
@@ -21,7 +21,7 @@ module EffectiveTestBotAssertions
   end
 
   def assert_page_status(status = 200)
-    assert_equal status, page.status_code, "page failed to load with #{status} HTTP status code"
+    assert_equal status, page.status_code, "expected page to load with #{status} HTTP status code"
   end
 
   def assert_no_js_errors
@@ -29,4 +29,31 @@ module EffectiveTestBotAssertions
     assert_equal 0, errors.size, errors.ai
   end
 
+  # assert_flash
+  # assert_flash :success
+  # assert_flash :error, 'there was a specific error'
+  def assert_flash(key = nil, value = nil)
+    if key.present? && value.present?
+      assert_equal value, flash[key.to_s]
+    elsif key.present?
+      assert flash[key.to_s].present?, "expected flash[#{key}] to be present"
+    else
+      assert flash.present?, '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)
+    if key.present? && value.present?
+      assert_equal value, assigns[key.to_s]
+    elsif key.present?
+      assert assigns[key.to_s].present?, "expected @#{key} to be assigned"
+    else
+      assert assigns.present?, 'expected assigns to be present'
+    end
+  end
+
+
 end

data/test/support/effective_test_bot_test_helper.rb

@@ -13,6 +13,20 @@ module EffectiveTestBotTestHelper
     sign_in(user)
     session.driver.submit :delete, path, {}
     session.document.find('html')
+
+    # Assign the Flash and Assigns
+    @flash = (JSON.parse(Base64.decode64(session.driver.response_headers['Test-Bot-Flash'])) rescue {})
+    @assigns = (JSON.parse(Base64.decode64(session.driver.response_headers['Test-Bot-Assigns'])) rescue {})
+  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
+    @flash ||= (JSON.parse(Base64.decode64(page.driver.browser.response_headers['Test-Bot-Flash'])) rescue {})
+  end
+
+  def assigns
+    @assigns ||= (JSON.parse(Base64.decode64(page.driver.browser.response_headers['Test-Bot-Assigns'])) rescue {})
   end
 
 end

data/test/test_bot/integration/devise_test.rb

@@ -18,6 +18,7 @@ if defined?(Devise) && defined?(User)
         assert_equal page.status_code, 200
         assert_content I18n.t('devise.registrations.signed_up')
         assert User.find_by_email(email).present?
+        assert_assigns :current_user
       end
 
       test 'sign in' do
@@ -32,6 +33,7 @@ if defined?(Devise) && defined?(User)
         assert_equal 200, page.status_code
         assert_content I18n.t('devise.sessions.signed_in')
         assert_equal 1, User.find_by_email(email).sign_in_count
+        assert_assigns :current_user
       end
 
       test 'invalid sign in' do
@@ -45,6 +47,7 @@ if defined?(Devise) && defined?(User)
 
         assert_equal 200, page.status_code
         assert_content I18n.t('devise.failure.invalid', authentication_keys: Devise.authentication_keys.join(', '))
+        assert assigns[:current_user].blank?
       end
     end
   end

data/test/test_bot/integration/minitest_test.rb

@@ -13,20 +13,37 @@ module TestBot
       :alpha
     end
 
-    test '1: seeds and fixtures loaded' do
+    test '01: seeds and fixtures loaded' do
       assert_normal
     end
 
-    test '2: activerecord can create a user' do
+    test '02: all fixtures and seeds valid' do
+      ActiveRecord::Base.descendants.each do |model|
+        begin
+          (model.unscoped.all rescue []).each do |resource|
+            assert resource.valid?, "fixture or seed data is invalid (#{model.to_s} id=#{resource.id} #{resource.errors.full_messages.join(', ')})"
+          end
+        rescue ActiveRecord::StatementInvalid
+          ; # Not entirely sure why I'm getting this error
+        end
+      end
+    end
+
+    # I could remove this if sign_in checks for and creates a user with devise or not
+    test '03: at least one user is seeded' do
+      assert (User.all.count > 0), 'please create at least 1 seed or fixture user for effective_test_bot to function'
+    end
+
+    test '04: activerecord can create a user' do
       create_user!
       assert_equal (original_users_count + 1), User.count
     end
 
-    test '3: test database is back to normal' do
+    test '05: test database is back to normal' do
       assert_normal
     end
 
-    test '4: capybara can create a user' do
+    test '06: capybara can create a user' do
       user = sign_up()
       assert user.kind_of?(User)
 
@@ -34,26 +51,26 @@ module TestBot
       assert_signed_in
     end
 
-    test '5: test database is back to normal' do
+    test '07: test database is back to normal' do
       assert_normal
     end
 
-    test '6: capybara session has been reset after manual sign up' do
+    test '08: capybara session has been reset after manual sign up' do
       assert_signed_out
       create_user!
       sign_in(email)
       assert_signed_in
     end
 
-    test '7: test database is back to normal' do
+    test '09: test database is back to normal' do
       assert_normal
     end
 
-    test '8: capybara session has been reset after warden login_as' do
+    test '10: capybara session has been reset after warden login_as' do
       assert_signed_out
     end
 
-    test '9: test database is back to normal' do
+    test '11: test database is back to normal' do
       assert_normal
     end
 
@@ -63,6 +80,11 @@ module TestBot
       visit root_path
       assert_equal page.status_code, 200
       assert_equal original_users_count, User.count
+
+      # Someitmes it's nice to assert your environment...
+      #assert users(:normal).present?
+      #assert 2, User.count
+      #assert 3, Physician.count
     end
 
   end

data/test/test_botable/crud_test.rb

@@ -1,12 +1,11 @@
 module CrudTest
-  define_method 'test_bot: #new' do
-    should_skip!(:new)
-
+  def new
     sign_in(user) and visit(new_resource_path)
 
     assert_page_status
     assert_page_title
     assert_no_js_errors
+    assert_assigns resource_name
 
     # Make sure there's a form with a submit button
     form_selector = "form#new_#{resource_name}"
@@ -17,9 +16,7 @@ module CrudTest
     end
   end
 
-  define_method 'test_bot: #create valid' do
-    should_skip!(:create)
-
+  def create_valid
     sign_in(user) and visit(new_resource_path)
 
     before = { count: resource_class.count, path: page.current_path }
@@ -33,11 +30,14 @@ module CrudTest
 
     refute_equal before[:count], after[:count], "unable to create #{resource_class} object"
     refute_equal before[:path], after[:path], "unable to create #{resource_class} object"
-  end
 
-  define_method 'test_bot: #create invalid' do
-    should_skip!(:create)
+    # In a rails controller, if i redirect to resources_path it may not assign the instance variable
+    # Wheras if I redirect to edit_resource_path I must ensure that the instance variable is set
+    assert_assigns(resource_name) if after[:path].include?('/edit/')
+    assert(assigns[resource_name]['errors'].blank?) if assigns[resource_name].present?
+  end
 
+  def create_invalid
     sign_in(user) and visit(new_resource_path)
     before = { count: resource_class.count }
 
@@ -50,16 +50,21 @@ module CrudTest
     assert_equal before[:count], after[:count], 'unexpectedly created object anyway'
     assert_equal resources_path, page.current_path, 'did not return to #create url'
     assert_page_title :any, 'page title missing after failed validation'
+
+    assert_flash :danger
+    assert_assigns resource_name
+    assert assigns[resource_name]['errors'].present?
   end
 
-  define_method 'test_bot: #edit' do
-    should_skip!(:edit) and sign_in(user) and (resource = create_resource!)
+  def edit
+    sign_in(user) and (resource = find_or_create_resource!)
 
     visit(edit_resource_path(resource))
 
     assert_page_status
     assert_page_title
     assert_no_js_errors
+    assert_assigns resource_name
 
     # Make sure there's a form with a submit button
     form_selector = "form#edit_#{resource_name}_#{resource.id}"
@@ -68,10 +73,12 @@ module CrudTest
     within(form_selector) do
       assert_selector 'input[type=submit]', 'page form does not contain a submit button'
     end
+
+    assert_assigns resource_name
   end
 
-  define_method 'test_bot: #update valid' do
-    should_skip!(:update) and sign_in(user) and (resource = create_resource!)
+  def update_valid
+    sign_in(user) and (resource = find_or_create_resource!)
 
     visit(edit_resource_path(resource))
 
@@ -87,10 +94,16 @@ module CrudTest
 
     assert_equal before[:count], after[:count], "updating resource unexpectedly changed #{resource_class}.count"
     assert(after[:updated_at] > before[:updated_at], "failed to update resource") if resource.respond_to?(:updated_at)
+
+    assert_flash :success
+    # In a rails controller, if i redirect to resources_path it may not assign the instance variable
+    # Wheras if I redirect to edit_resource_path I must ensure that the instance variable is set
+    assert_assigns(resource_name) if after[:path] == edit_resource_path(resource)
+    assert(assigns[resource_name]['errors'].blank?) if assigns[resource_name].present?
   end
 
-  define_method 'test_bot: #update invalid' do
-    should_skip!(:update) and sign_in(user) and (resource = create_resource!)
+  def update_invalid
+    sign_in(user) and (resource = find_or_create_resource!)
 
     visit(edit_resource_path(resource))
 
@@ -108,30 +121,36 @@ module CrudTest
     assert_equal(after[:updated_at], before[:updated_at], 'unexpectedly updated object anyway') if resource.respond_to?(:updated_at)
     assert_equal resource_path(resource), page.current_path, 'did not return to #update url'
     assert_page_title :any, 'page title missing after failed validation'
+
+    assert_flash :danger
+    assert_assigns resource_name
+    assert assigns[resource_name]['errors'].present?
   end
 
-  define_method 'test_bot: #index' do
-    should_skip!(:index) and sign_in(user) and (resource = create_resource!)
+  def index
+    sign_in(user) and (resource = find_or_create_resource!)
 
     visit resources_path
 
     assert_page_status
     assert_page_title
     assert_no_js_errors
+    assert (assigns['datatable'].present? || assigns[resource_name.pluralize].present?), "expected @datatable or @#{resource_name.pluralize} to be set"
   end
 
-  define_method 'test_bot: #show' do
-    should_skip!(:show) and sign_in(user) and (resource = create_resource!)
+  def show
+    sign_in(user) and (resource = create_resource!)
 
     visit resource_path(resource)
 
     assert_page_status
     assert_page_title
     assert_no_js_errors
+    assert_assigns resource_name
   end
 
-  define_method 'test_bot: #destroy' do
-    should_skip!(:destroy) and sign_in(user) and (resource = create_resource!)
+  def destroy
+    sign_in(user) and (resource = find_or_create_resource!)
 
     before = { count: resource_class.count, archived: (resource.archived rescue nil) }
 
@@ -139,6 +158,8 @@ module CrudTest
 
     after = { count: resource_class.count, archived: (resource_class.find(resource.id).archived rescue nil) }
 
+    assert_flash :success
+
     if resource.respond_to?(:archived)
       assert after[:archived] == true, "expected #{resource_class}.archived == true"
     else
@@ -148,9 +169,9 @@ module CrudTest
 
   protected
 
-  def should_skip!(action)
-    skip('skipped') unless crud_actions_to_test.include?(action)
-    true
+  def find_or_create_resource!
+    existing = resource_class.last
+    existing.present? ? existing : create_resource!
   end
 
   def create_resource!
@@ -160,7 +181,6 @@ module CrudTest
       fill_form(resource_attributes) and submit_form
     end
 
-    refute_equal new_resource_path, page.current_url
     resource_class.last
   end
 
@@ -181,5 +201,4 @@ module CrudTest
   def edit_resource_path(resource) # edit
     edit_polymorphic_path([*controller_namespace, resource])
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_test_bot
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-23 00:00:00.000000000 Z
+date: 2015-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -203,6 +203,7 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- app/helpers/effective_test_bot_controller_helper.rb
 - lib/effective_test_bot.rb
 - lib/effective_test_bot/engine.rb
 - lib/effective_test_bot/version.rb
@@ -210,7 +211,7 @@ files:
 - lib/generators/templates/effective_test_bot.rb
 - lib/generators/templates/test_helper.rb
 - lib/tasks/effective_test_bot_tasks.rake
-- test/concerns/acts_as_test_botable.rb
+- test/concerns/test_botable/crud_test.rb
 - test/support/effective_assets_upload_file._test
 - test/support/effective_test_bot_assertions.rb
 - test/support/effective_test_bot_form_helper.rb

data/test/concerns/acts_as_test_botable.rb

@@ -1,57 +0,0 @@
-module ActsAsTestBotable
-  extend ActiveSupport::Concern
-
-  module ClassMethods
-    CRUD_ACTIONS = [:index, :new, :create, :edit, :update, :show, :destroy]
-
-    def crud_test(obj, user, options = {})
-      # Check for expected usage
-      unless (obj.kind_of?(Class) || obj.kind_of?(ActiveRecord::Base)) && user.kind_of?(User) && options.kind_of?(Hash)
-        puts 'invalid parameters passed to crud_test(), expecting crud_test(Post || Post.new(), User.first, options_hash)' and return
-      end
-
-      # Make sure Obj.new() works
-      if obj.kind_of?(Class) && (obj.new() rescue false) == false
-        puts "effective_test_bot: failed to initialize object with #{obj}.new(), unable to proceed" and return
-      end
-
-      # Set up the crud_actions_to_test
-      crud_actions_to_test = if options[:only]
-        Array(options[:only]).flatten.compact.map(&:to_sym)
-      elsif options[:except]
-        (CRUD_ACTIONS - Array(options[:except]).flatten.compact.map(&:to_sym))
-      else
-        CRUD_ACTIONS
-      end
-
-      # Parse the resource and resourece 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 || {}
-
-      # Assign variables to be used in test/test_botable/crud_test.rb
-      let(:resource) { resource }
-      let(:resource_class) { resource_class }
-      let(:resource_name) { resource_class.name.underscore }
-      let(:resource_attributes) { resource_attributes }
-      let(:user) { user }
-      let(:controller_namespace) { options[:namespace] }
-      let(:crud_actions_to_test) { crud_actions_to_test }
-
-      include ::CrudTest
-
-      # This will run any CrudTest methods, in order, as it's defined in the file
-      # Then the rest of the methods in whatever order they occur originally (:random, :alpha, :sorted)
-      def self.runnable_methods
-        ::CrudTest.public_instance_methods.map { |name| name.to_s if name.to_s.starts_with?('test_bot') }.compact + super.select { |name| !name.starts_with?('test_bot') }
-      end
-    end
-
-  end
-end