effective_test_bot 0.4.16 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 124e24f5a23f78013a2895ed9b1cb6c84553f50c
-  data.tar.gz: bf2e35d6c19792b9fd322c870d6dd65260a86f48
+  metadata.gz: 9718dff008026433cc1541ce36c27eefbf396777
+  data.tar.gz: 6710d59f4c60c6861a450d7c1b277bc32b1d6eaa
 SHA512:
-  metadata.gz: fe29d076bafcb5ab447e37f7a4f69e5417e3169eec65a6c446019e5cb92428e385ac7fb4cb1ad530eaba669bb52d06fdef167ab44bada016fae093c0d57bf02e
-  data.tar.gz: 5a703c21aa3183e2c3fdc1c4429810ea052947696ab0078b591181392c526e2f5e88389db9c532dbab20a88f9f9c0b3eaf3c9573c6b65eace9c2e6938219294b
+  metadata.gz: 14251ee81b143df1aa5f70f72cde976fd2f288f8df5dda323f301799f4001f87962b84e4d3e0af3423e404c8ad27c801d81063147770e2cc2904807c57d141a4
+  data.tar.gz: f65722976ab5a9974736d7cabf9a7a6e3fb983711dbcae8ff8c88c6092fa17629be239c7ed3b17265149f88fca25ea1b0c35240b3a1a958d5f84b4bf6ef80a1d

data/README.md

@@ -248,22 +248,22 @@ There are a few variations on the one-liner method:
 ```ruby
 class PostsTest < ActionDispatch::IntegrationTest
   # Runs all 9 crud_action tests against /posts
-  crud_test(Post, User.first)
+  crud_test(resource: Post, user: User.first)
 
   # Runs all 9 crud_action tests against /posts and use this Post's attributes when calling fill_form.
-  crud_test(Post.new(title: 'my first post'), User.first)
+  crud_test(resource: Post.new(title: 'my first post'), user: User.first)
 
   # Runs all 9 crud_action tests against /admin/posts controller as a previously seeded or fixtured admin user
-  crud_test('admin/posts', User.where(admin: true).first)
+  crud_test(resource: 'admin/posts', user: User.where(admin: true).first)
 
   # Run only some tests
-  crud_test(Post, User.first, only: [:new, :create_valid, :create_invalid, :show, :index])
+  crud_test(resource: Post, user: User.first, only: [:new, :create_valid, :create_invalid, :show, :index])
 
   # Run all except some tests
-  crud_test(Post, User.first, except: [:edit, :update_valid, :update_invalid])
+  crud_test(resource: Post, user: User.first, except: [:edit, :update_valid, :update_invalid])
 
   # Skip individual assertions
-  crud_test(Post, User.first, skip: {create_valid: :path, update_invalid: [:path, :flash]})
+  crud_test(resource: Post, user: User.first, skip: {create_valid: :path, update_invalid: [:path, :flash]})
 end
 ```
 
@@ -272,13 +272,13 @@ The individual test suites may also be used as part of a larger test:
 ```ruby
 class PostsTest < ActionDispatch::IntegrationTest
   test 'user may only update a post once' do
-    crud_action_test(:create_valid, Post, User.first)
+    crud_action_test(test: :create_valid, resource: Post, user: User.first)
     assert_text 'successfully created post.  You may only update it once.'
 
-    crud_action_test(:update_valid, Post.last, User.first)
+    crud_action_test(test: :update_valid, resource: Post.last, user: User.first)
     assert_text 'successfully updated post.'
 
-    crud_action_test(:update_valid, Post.last, User.first, skip: [:no_assigns_errors, :updated_at])
+    crud_action_test(test: :update_valid, resource: Post.last, user: User.first, skip: [:no_assigns_errors, :updated_at])
     assert_assigns_errors(:post, 'you may no longer update this post.')
     assert_text 'you may no longer update this post.'
   end
@@ -308,7 +308,7 @@ Or each individually in part of a regular test:
 ```ruby
 class MyApplicationTest < ActionDispatch::IntegrationTest
   test 'user receives 10 tokens after signing up' do
-    devise_action_test(:sign_up)
+    devise_action_test(test: :sign_up)
     assert_text 'Tokens: 10'
     assert_equals 10, User.last.tokens
     assert_equals 10, assigns(:current_user).tokens
@@ -333,10 +333,10 @@ Use it as a one-liner:
 ```ruby
 class PostsTest < ActionDispatch::IntegrationTest
   # Uses find_or_create_resource! to load a seeded resource or create a new one
-  member_test('posts', 'unarchive', User.first)
+  member_test(controller: 'posts', action: 'unarchive', user: User.first)
 
   # Run the member_test with a specific post
-  member_test('posts', 'unarchive', User.first, Post.find(1))
+  member_test(controller: 'posts', action: 'unarchive', user: User.first, member: Post.find(1))
 end
 ```
 
@@ -348,7 +348,7 @@ class PostsTest < ActionDispatch::IntegrationTest
     post = Post.create(title: 'first post', archived: true)
 
     assert Post.where(archived: false).empty?
-    member_action_test('posts', 'unarchive', User.first, post)
+    member_action_test(controller: 'posts', action: 'unarchive', user: User.first, member: post)
     assert Post.where(archived: false).present?
   end
 end
@@ -362,7 +362,7 @@ Use it as a one-liner:
 
 ```ruby
 class PostsTest < ActionDispatch::IntegrationTest
-  page_test(:posts_path, User.first)  # Runs the page_test test suite against posts_path as User.first
+  page_test(path: :posts_path, user: User.first)  # Runs the page_test test suite against posts_path as User.first
 end
 ```
 
@@ -373,7 +373,7 @@ class PostsTest < ActionDispatch::IntegrationTest
   test 'posts are displayed on the index page' do
     Post.create(title: 'first post')
 
-    page_action_test(:posts_path, User.first)
+    page_action_test(path: :posts_path, user: User.first)
 
     assert page.current_path, '/posts'
     assert_text 'first post'
@@ -390,7 +390,7 @@ Use it as a one-liner:
 ```ruby
 class PostsTest < ActionDispatch::IntegrationTest
   # Visits /blog and tests that it redirects to a working /posts page
-  redirect_test('/blog', '/posts', User.first)
+  redirect_test(from: '/blog', to: '/posts', user: User.first)
 end
 ```
 
@@ -400,7 +400,7 @@ Or as part of a regular test:
 class PostsTest < ActionDispatch::IntegrationTest
   test 'visiting blog redirects to posts' do
     Post.create(title: 'first post')
-    redirect_action_test('/blog', '/posts', User.first)
+    redirect_action_test(from: '/blog', to: '/posts', user: User.first)
     assert_text 'first post'
   end
 end
@@ -418,7 +418,7 @@ Use it as a one-liner:
 
 ```ruby
 class PostsTest < ActionDispatch::IntegrationTest
-  wizard_test('/build_post/step1', '/build_post/step5', User.first)
+  wizard_test(from: '/build_post/step1', to: '/build_post/step5', user: User.first)
 end
 ```
 
@@ -427,7 +427,7 @@ Or as part of a regular test:
 ```ruby
 class PostsTest < ActionDispatch::IntegrationTest
   test 'building a post in 5 steps' do
-    wizard_action_test('/build_post/step1', '/build_post/step5', User.first) do
+    wizard_action_test(from: '/build_post/step1', to: '/build_post/step5', user: User.first) do
       if page.current_path.end_with?('step4')
         assert_text 'your post is ready but must first be approved by an admin.'
       end

data/lib/effective_test_bot/version.rb

@@ -1,3 +1,3 @@
 module EffectiveTestBot
-  VERSION = '0.4.16'.freeze
+  VERSION = '0.5.0'.freeze
 end

data/test/concerns/test_botable/base_dsl.rb

@@ -5,6 +5,10 @@ module TestBotable
     module ClassMethods
       TEST_BOT_TEST_PREFIXES = ['crud_test', 'devise_test', 'member_test', 'page_test', 'redirect_test', 'wizard_test']
 
+      def _test_bot_user
+        @test_bot_user
+      end
+
       # 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
@@ -119,6 +123,10 @@ module TestBotable
 
     # Instance Methods
 
+    def _test_bot_user
+      @test_bot_user
+    end
+
     # 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.

data/test/concerns/test_botable/crud_dsl.rb

@@ -1,10 +1,10 @@
 # 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]})
+#   crud_test(resource: (Post || 'admin/posts'), user: 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)
+#     crud_action_test(test: :new, resource: Post, user: User.first, skip: :title)
 #   end
 # end
 
@@ -18,29 +18,25 @@ module TestBotable
 
       # 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 = {})
+      def crud_test(resource:, user: _test_bot_user(), label: nil, skip: {}, only: nil, except: nil, **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)
+        raise 'invalid skip syntax, expecting skip: {create_invalid: [:path]}' unless skip.kind_of?(Hash)
 
-        label = options.delete(:label).presence
-        only = options.delete(:only)
-        except = options.delete(:except)
         current_crud_tests = crud_tests_to_define(only, except)
 
         begin
-          normalize_test_bot_options!(options.merge!(user: user, resource: resource, current_crud_tests: current_crud_tests))
+          normalize_test_bot_options!(options.merge!(resource: resource, user: user, current_crud_tests: current_crud_tests))
         rescue => e
-          raise "Error: #{e.message}.  Expected usage: crud_test(Post || Post.new, User.first, only: [:new, :create], skip: {create_invalid: [:path]})"
+          raise "Error: #{e.message}.  Expected usage: crud_test(resource: (Post || Post.new), user: User.first, only: [:new, :create], skip: {create_invalid: [:path]})"
         end
 
         current_crud_tests.each do |test|
           options_for_method = options.dup
 
-          options_for_method[:skips] = Array(skips[test]) if skips[test]
+          options_for_method[:skip] = Array(skip[test]) if skip[test]
           options_for_method[:current_test] = [
             options[:controller_namespace].presence,
             options[:resource_name].pluralize
@@ -50,7 +46,7 @@ module TestBotable
 
           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) }
+          define_method(method_name) { crud_action_test(test: test, resource: resource, user: user, options: options_for_method) }
         end
       end
 
@@ -82,11 +78,11 @@ module TestBotable
     #
     # 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 = {})
+    def crud_action_test(test:, resource:, user: _test_bot_user(), **options)
       begin
-        assign_test_bot_lets!(options.reverse_merge!(user: user, resource: resource))
+        assign_test_bot_lets!(options.reverse_merge!(resource: resource, user: user))
       rescue => e
-        raise "Error: #{e.message}.  Expected usage: crud_action_test(:new, Post || Post.new, User.first)"
+        raise "Error: #{e.message}.  Expected usage: crud_action_test(test: :new, resource: (Post || Post.new), user: User.first)"
       end
 
       self.send("test_bot_#{test}_test")

data/test/concerns/test_botable/devise_dsl.rb

@@ -4,9 +4,9 @@
 #   devise_test()
 #
 #   test 'a one-off action' do
-#     devise_action_test(:sign_up)
-#     devise_action_test(:sign_in_valid)
-#     devise_action_test(:sign_in_invalid)
+#     devise_action_test(test: :sign_up)
+#     devise_action_test(test: :sign_in_valid)
+#     devise_action_test(test: :sign_in_invalid)
 #   end
 # end
 
@@ -16,23 +16,21 @@ module TestBotable
 
     module ClassMethods
 
-      def devise_test(options = {})
-        label = options.delete(:label).presence
-
+      def devise_test(label: nil, **options)
         [:sign_up, :sign_in_valid, :sign_in_invalid].each do |test|
           options[:current_test] = label || test
           next if EffectiveTestBot.skip?(options[:current_test])
 
           method_name = test_bot_method_name('devise_test', options[:current_test])
 
-          define_method(method_name) { devise_action_test(test, options) }
+          define_method(method_name) { devise_action_test(test: test, options: options) }
         end
       end
 
     end
 
     # Instance Methods - Call me from within a test
-    def devise_action_test(test, options = {})
+    def devise_action_test(test:, **options)
       options[:email] ||= "unique-#{Time.zone.now.to_i}@example.com"
       options[:password] ||= '!Password123'
       options[:username] ||= 'unique-username'

data/test/concerns/test_botable/member_dsl.rb

@@ -1,10 +1,10 @@
 # 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)
+#   member_test(controller: 'admin/jobs', action: 'unarchive', user: User.first, member: Post.first)
 #
 #   test 'a one-off action' do
-#     member_action_test('admin/jobs', 'unarchive', User.first)
+#     member_action_test(controller: 'admin/jobs', action: 'unarchive', user: User.first, member: Post.first)
 #   end
 # end
 
@@ -16,24 +16,23 @@ module TestBotable
     extend ActiveSupport::Concern
 
     module ClassMethods
-
-      def member_test(controller, action, user, obj_to_param = nil, options = {})
-        options[:current_test] = options.delete(:label) || "#{controller}##{action}"
+      def member_test(controller:, action:, user: _test_bot_user(), member: nil, label: nil, **options)
+        options[:current_test] = label || "#{controller}##{action}"
         return if EffectiveTestBot.skip?(options[:current_test])
 
         method_name = test_bot_method_name('member_test', options[:current_test])
 
-        define_method(method_name) { member_action_test(controller, action, user, obj_to_param, options) }
+        define_method(method_name) { member_action_test(controller: controller, action: action, user: user, member: member, options: options) }
       end
 
     end
 
     # Instance Methods - Call me from within a test
-    def member_action_test(controller, action, user, member = nil, options = {})
+    def member_action_test(controller:, action:, user: _test_bot_user(), member:, **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)"
+        raise "Error: #{e.message}.  Expected usage: member_test(controller: 'admin/jobs', action: 'unarchive', user: User.first, member: (Post.first || nil))"
       end
 
       self.send(:test_bot_member_test)

data/test/concerns/test_botable/page_dsl.rb

@@ -1,10 +1,10 @@
 # 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)
+#   page_test(path: :posts_path, user: User.first)
 #
 #   test 'a one-off action' do
-#     page_action_test(:posts_path, User.first)
+#     page_action_test(path: :posts_path, user: User.first)
 #   end
 # end
 
@@ -15,23 +15,23 @@ module TestBotable
 
     module ClassMethods
 
-      def page_test(path, user, options = {})
-        options[:current_test] = options.delete(:label) || path.to_s
+      def page_test(path:, user: _test_bot_user(), label: nil, **options)
+        options[:current_test] = label || path.to_s
         return if EffectiveTestBot.skip?(options[:current_test])
 
         method_name = test_bot_method_name('page_test', options[:current_test])
 
-        define_method(method_name) { page_action_test(path, user, options) }
+        define_method(method_name) { page_action_test(path: path, user: user, options: options) }
       end
 
     end
 
     # Instance Methods - Call me from within a test
-    def page_action_test(path, user, options = {})
+    def page_action_test(path:, user: _test_bot_user(), **options)
       begin
         assign_test_bot_lets!(options.reverse_merge!(user: user, page_path: path))
       rescue => e
-        raise "Error: #{e.message}.  Expected usage: page_action_test(root_path, User.first)"
+        raise "Error: #{e.message}.  Expected usage: page_action_test(path: root_path, user: User.first)"
       end
 
       self.send(:test_bot_page_test)

data/test/concerns/test_botable/redirect_dsl.rb

@@ -1,10 +1,10 @@
 # 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)
+#   redirect_test(from: '/about', to: '/new-about', user: User.first)
 #
 #   test 'a one-off action' do
-#     redirect_action_test('/about', '/new-about', User.first)
+#     redirect_action_test(from: '/about', to: '/new-about', user: User.first)
 #   end
 # end
 
@@ -14,22 +14,22 @@ module TestBotable
 
     module ClassMethods
 
-      def redirect_test(from_path, to_path, user, options = {})
-        options[:current_test] = options.delete(:label) || "#{from_path} to #{to_path}"
+      def redirect_test(from:, to:, user: _test_bot_user(), label: nil, **options)
+        options[:current_test] = label || "#{from} to #{to}"
         return if EffectiveTestBot.skip?(options[:current_test])
 
         method_name = test_bot_method_name('redirect_test', options[:current_test])
 
-        define_method(method_name) { redirect_action_test(from_path, to_path, user, options) }
+        define_method(method_name) { redirect_action_test(from: from, to: to, user: user, options: options) }
       end
     end
 
     # Instance Methods - Call me from within a test
-    def redirect_action_test(from_path, to_path, user, options = {})
+    def redirect_action_test(from:, to:, user: _test_bot_user(), options: {})
       begin
-        assign_test_bot_lets!(options.reverse_merge!(from_path: from_path, to_path: to_path, user: user))
+        assign_test_bot_lets!(options.reverse_merge!(from: from, to: to, user: user))
       rescue => e
-        raise "Error: #{e.message}.  Expected usage: redirect_action_test('/about', '/new-about', User.first)"
+        raise "Error: #{e.message}.  Expected usage: redirect_action_test(from: '/about', to: '/new-about', user: User.first)"
       end
 
       self.send(:test_bot_redirect_test)

data/test/concerns/test_botable/wizard_dsl.rb

@@ -1,10 +1,10 @@
 # This DSL gives a class level and an instance level way of calling specific test suite
 #
 # class PostsTest < ActionDispatch::IntegrationTest
-#   wizard_test('/fee_wizard/step1', '/fee_wizard/step5', User.first)
+#   wizard_test(from: '/fee_wizard/step1', to: ('/fee_wizard/step5' || nil), user: User.first)
 #
 #   test 'a one-off action' do
-#     wizard_action_test('/fee_wizard/step1', '/fee_wizard/step5', User.first) do
+#     wizard_action_test(from: '/fee_wizard/step1', to: ('/fee_wizard/step5' || nil), user: User.first) do
 #       puts page.current_path
 #     end
 #   end
@@ -19,28 +19,29 @@ module TestBotable
 
     module ClassMethods
 
-      def wizard_test(from_path, to_path, user, options = {})
-        if to_path.present?
-          options[:current_test] = options.delete(:label) || "#{from_path} to #{to_path}"
+      def wizard_test(from:, to: nil, user: _test_bot_user(), label: nil, **options)
+
+        if to.present?
+          options[:current_test] = label || "#{from} to #{to}"
         else
-          options[:current_test] = options.delete(:label) || "#{from_path}"
+          options[:current_test] = label || "#{from}"
         end
 
         return if EffectiveTestBot.skip?(options[:current_test])
 
         method_name = test_bot_method_name('wizard_test', options[:current_test])
 
-        define_method(method_name) { wizard_action_test(from_path, to_path, user, options) }
+        define_method(method_name) { wizard_action_test(from: from, to: to, user: user, options: options) }
       end
 
     end
 
     # Instance Methods - Call me from within a test
-    def wizard_action_test(from_path, to_path, user, options = {})
+    def wizard_action_test(from:, to: nil, user: _test_bot_user(), **options)
       begin
-        assign_test_bot_lets!(options.reverse_merge!(from_path: from_path, to_path: to_path, user: user))
+        assign_test_bot_lets!(options.reverse_merge!(from: from, to: to, user: user))
       rescue => e
-        raise "Error: #{e.message}.  Expected usage: wizard_action_test('/fee_wizard/step1', '/fee_wizard/step5', User.first)"
+        raise "Error: #{e.message}.  Expected usage: wizard_action_test(from: '/fee_wizard/step1', to: ('/fee_wizard/step5' || nil), user: User.first)"
       end
 
       block_given? ? test_bot_wizard_test { yield } : test_bot_wizard_test

data/test/support/effective_test_bot_login_helper.rb

@@ -2,7 +2,9 @@
 
 module EffectiveTestBotLoginHelper
   def as_user(user)
-    sign_in(user); yield; sign_out
+    sign_in(user); @test_bot_user = user
+    yield
+    sign_out; @test_bot_user = nil
   end
 
   # This is currently hardcoded to use the warden login_as test helper

data/test/test_bot/integration/application_test.rb

@@ -13,6 +13,8 @@ module TestBot
       def initialize_tests
         puts 'test_bot scanning....'
 
+        @test_bot_user = User.first
+
         routes = Rails.application.routes.routes.to_a
         seen_actions = Hash.new([])  # {posts: ['new', 'edit'], events: ['new', 'edit', 'show']}
 
@@ -31,7 +33,7 @@ module TestBot
           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)
+            redirect_test(from: path, to: route.app.path([], nil))
 
           # CRUD Test
           elsif is_crud_controller?(route)
@@ -46,7 +48,7 @@ module TestBot
                 only_tests = seen_actions.delete(controller)
                 only_tests << :tour if EffectiveTestBot.tour_mode?
 
-                crud_test(controller, User.first, only: only_tests)
+                crud_test(resource: controller, only: only_tests)
               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
@@ -55,15 +57,15 @@ module TestBot
           # Wizard Test
           elsif is_wicked_controller?(route)
             first_step_path = "/#{controller}/#{controller_instance(route).wizard_steps.first}"
-            wizard_test(first_step_path, nil, User.first)
+            wizard_test(from: first_step_path)
 
           # Member Test
           elsif route.verb.to_s.include?('GET') && route.path.required_names == ['id']
-            member_test(controller, action, User.first)
+            member_test(controller: controller, action: action)
 
           # Page Test
           elsif route.verb.to_s.include?('GET') && route.name.present? && Array(route.path.required_names).blank? # This could eventually be removed to supported nested routes
-            page_test("#{route.name}_path".to_sym, User.first, route: route, label: "#{route.name}_path")
+            page_test(path: "#{route.name}_path".to_sym, route: route, label: "#{route.name}_path")
 
           else
             puts "skipping #{route.name}_path | #{route.path.spec} | #{route.verb} | #{route.defaults[:controller]} | #{route.defaults[:action]}"

data/test/test_botable/wizard_test.rb

@@ -5,7 +5,7 @@ module WizardTest
   protected
 
   def test_bot_wizard_test(&block)
-    sign_in(user) and visit(from_path)
+    sign_in(user) and visit(from)
 
     0.upto(50) do |index|   # Can only test wizards 51 steps long
       assert_page_normal
@@ -21,9 +21,9 @@ module WizardTest
 
       assert_no_assigns_errors
 
-      if to_path.present?
+      if to.present?
         # Keep going till we hit a certain to_path
-        break if page.current_path == to_path
+        break if page.current_path == to
       else
         # Keep going till there's no more submit buttons
         break if all("input[type='submit']").blank?
@@ -32,7 +32,7 @@ module WizardTest
 
     save_test_bot_screenshot
 
-    assert_current_path(to_path) if to_path.present?
+    assert_current_path(to) if to.present?
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_test_bot
 version: !ruby/object:Gem::Version
-  version: 0.4.16
+  version: 0.5.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-15 00:00:00.000000000 Z
+date: 2016-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails