mini_autobot 0.0.1

data/lib/mini_autobot/runner.rb

@@ -0,0 +1,91 @@
+module MiniAutobot
+  class Runner
+
+    attr_accessor :options
+    @after_hooks = []
+
+    def self.after_run(&blk)
+      @after_hooks << blk
+    end
+
+    def self.run!(args)
+      exit_code = self.run(args)
+      @after_hooks.reverse_each(&:call)
+      Kernel.exit(exit_code || false)
+    end
+
+    def self.run args = []
+      Minitest.load_plugins
+
+      @options = Minitest.process_args args
+
+      self.before_run
+
+      reporter = Minitest::CompositeReporter.new
+      reporter << Minitest::SummaryReporter.new(@options[:io], @options)
+      reporter << Minitest::ProgressReporter.new(@options[:io], @options)
+
+      Minitest.reporter = reporter # this makes it available to plugins
+      Minitest.init_plugins @options
+      Minitest.reporter = nil # runnables shouldn't depend on the reporter, ever
+
+      reporter.start
+      Minitest.__run reporter, @options
+      Minitest.parallel_executor.shutdown
+      reporter.report
+
+      reporter.passed?
+    end
+
+    # before hook where you have parsed @options when loading tests
+    def self.before_run
+      host_env = @options[:env]
+      if host_env.nil?
+        # TODO(phu): default host needs to be set in a user's local env file
+        host = 'rent'
+        puts "No argument given for option -e \nLoading tests using default host: #{host}"
+      else
+        host = host_env.split(/_/)[0]
+      end
+      self.load_tests(host)
+    end
+
+    # only load tests you need by specifying env option in command line
+    def self.load_tests(host)
+      tests_yml_full_path = MiniAutobot.root.join('config/mini_autobot', 'tests.yml').to_s
+      if File.exist? tests_yml_full_path
+        tests_yml = YAML.load_file tests_yml_full_path
+        tests_dir_relative_path = tests_yml['tests_dir']['relative_path']
+        multi_host_flag = tests_yml['tests_dir']['multi-host']
+      else
+        puts "Config file #{tests_yml_full_path} doesn't exist"
+        puts "mini_autobot doesn't know where your tests are located and how they are structured"
+      end
+
+      self.configure_load_path(tests_dir_relative_path)
+
+      # load page_objects.rb first
+      Dir.glob("#{tests_dir_relative_path}/#{multi_host_flag ? host+'/' : ''}*.rb") do |f|
+        f.sub!(/^#{tests_dir_relative_path}\//, '')
+        require f
+      end
+
+      # files under subdirectories shouldn't be loaded, eg. archive/
+      Dir.glob("#{tests_dir_relative_path}/#{multi_host_flag ? host+'/' : ''}test_cases/*.rb") do |f|
+        f.sub!(/^#{tests_dir_relative_path}\//, '')
+        require f
+      end
+    end
+
+    def self.configure_load_path(tests_dir_relative_path)
+      tests_dir_full_path = MiniAutobot.root.join(tests_dir_relative_path).to_s
+      if Dir.exist? tests_dir_full_path
+        $LOAD_PATH << tests_dir_full_path
+      else
+        puts "Tests directory #{tests_dir_full_path} doesn't exist"
+        puts "No test will run."
+      end
+    end
+
+  end
+end

data/lib/mini_autobot/settings.rb

@@ -0,0 +1,78 @@
+module MiniAutobot
+
+  # An object that holds runtime settings.
+  #
+  # Furthermore, Minitest doesn't provide any good way of passing a hash of
+  # options to each test.
+  #
+  # TODO: We're importing ActiveSupport's extensions to Hash, which means that
+  # we'll be amending the way Hash objects work; once AS updates themselves to
+  # ruby 2.0 refinements, let's move towards that.
+  class Settings
+
+    def initialize
+      @hsh = {}
+    end
+
+    def inspect
+      settings = self.class.public_instance_methods(false).sort.map(&:inspect).join(', ')
+      "#<MiniAutobot::Settings #{settings}>"
+    end
+
+    def auto_finalize?
+      hsh.fetch(:auto_finalize, true)
+    end
+
+    def connector
+      hsh.fetch(:connector, :firefox).to_s
+    end
+
+    def env
+      # add a gitignored env file which stores a default env
+      # pass the default env in as default
+      hsh.fetch(:env, :rent_qa).to_s
+    end
+
+    def io
+      hsh[:io]
+    end
+
+    def merge!(other)
+      hsh.merge!(other.symbolize_keys)
+      self
+    end
+
+    def parallel?
+      hsh.fetch(:parallel, false)
+    end
+
+    def raw_arguments
+      hsh.fetch(:args, nil).to_s
+    end
+
+    def reuse_driver?
+      hsh.fetch(:reuse_driver, false)
+    end
+
+    def seed
+      hsh.fetch(:seed, nil).to_i
+    end
+
+    def tags
+      hsh[:tags] ||= []
+    end
+
+    def verbose?
+      verbosity_level > 0
+    end
+
+    def verbosity_level
+      hsh.fetch(:verbosity_level, 0).to_i
+    end
+
+    private
+    attr_reader :hsh
+
+  end
+
+end

data/lib/mini_autobot/test_case.rb

@@ -0,0 +1,233 @@
+module MiniAutobot
+
+  # An MiniAutobot-specific test case container, which extends the default ones,
+  # adds convenience helper methods, and manages page objects automatically.
+  class TestCase < Minitest::Test
+    @@regression_suite = Array.new
+    @@already_executed = false
+    @@serials = Array.new
+    @@test_suite_data = if File.exist?(MiniAutobot.root.join("config/mini_autobot/test_suite.yml"))
+                          YAML.load_file(MiniAutobot.root.join("config/mini_autobot/test_suite.yml"))
+                        else
+                          default = {"regression"=>{"tag_to_exclude"=>:non_regression}}
+                          puts "config/mini_autobot/test_suite.yml doesn't exist, using default:\n#{default}"
+                          default
+                        end
+
+    # Standard exception class that signals that the test with that name has
+    # already been defined.
+    class TestAlreadyDefined < ::StandardError; end
+
+    # Include helper modules
+    include MiniAutobot::Utils::AssertionHelper
+    include MiniAutobot::Utils::DataGeneratorHelper
+    include MiniAutobot::Utils::Loggable
+    include MiniAutobot::Utils::PageObjectHelper
+
+    class <<self
+
+      # @!attribute [rw] options
+      #   @return [Hash] test case options
+      attr_accessor :options
+
+      # Explicitly remove _all_ tests from the current class. This will also
+      # remove inherited test cases.
+      #
+      # @return [TestCase] self
+      def remove_tests
+        klass = class <<self; self; end
+        public_instance_methods.grep(/^test_/).each do |method|
+          klass.send(:undef_method, method.to_sym)
+        end
+        self
+      end
+
+      # Call this at the top of your test case class in order to run all tests
+      # in alphabetical order
+      #
+      # @return [TestCase] self
+      # @example
+      #   class SomeName < TestCase
+      #     run_in_order!
+      #
+      #     test :feature_search_01 { ... }
+      #     test :feature_search_02 { ... }
+      #   end
+      def run_in_order!
+        # `self` is the class, so we want to reopen the metaclass instead, and
+        # redefine the methods there
+        class <<self
+          undef_method :test_order if method_defined? :test_order
+          define_method :test_order do
+            :alpha
+          end
+        end
+
+        # Be nice and return the class back
+        self
+      end
+
+      # Filter out anything not matching our tag selection, if any.
+      #
+      # @return [Enumerable<Symbol>] the methods marked runnable
+      def runnable_methods
+        methods  = super
+        selected = MiniAutobot.settings.tags
+
+        if MiniAutobot.settings.parallel?
+          # check this because I don't know why this runnable_methods gets called three times consecutively when one starts running tests
+          if @@already_executed
+            exit
+          end
+
+          # todo get the number value from "--parallel=" and replace nil with it
+          parallel = Parallel.new(nil, @@regression_suite)
+          parallel.run_in_parallel!
+
+          @@already_executed = true
+        end
+
+        # If no tags are selected, run all tests
+        return methods if selected.nil? || selected.empty?
+
+        return methods.select do |method|
+          # If the method's tags match any of the tag sets, allow it to run
+          selected.any? do |tag_set|
+            # Retrieve the tags for that method
+            method_options = self.options[method.to_sym] rescue nil
+            tags           = method_options[:tags]       rescue nil
+
+            # If the method's tags match ALL of the tags in the tag set, allow
+            # it to run; in the event of a problem, allow the test to run
+            tag_set.all? do |tag|
+              if tag =~ %r/^!/
+                !tags.include?(tag[%r/^!(.*)/,1].to_sym) || nil
+              else
+                tags.include?(tag.to_sym) || nil
+              end rescue true
+            end
+          end
+        end
+      end
+
+      # Install a setup method that runs before every test.
+      #
+      # @return [void]
+      def setup(&block)
+        define_method(:setup) do
+          super()
+          instance_eval(&block)
+        end
+      end
+
+      # Install a teardown method that runs after every test.
+      #
+      # @return [void]
+      def teardown(&block)
+        define_method(:teardown) do
+          super()
+          instance_eval(&block)
+        end
+      end
+
+      # Defines a test case.
+      #
+      # It can take the following options:
+      #
+      # * `tags`: An array of any number of tags associated with the test case.
+      #          When not specified, the test will always be run even when only
+      #          certain tags are run. When specified but an empty array, the
+      #          test will only be run if all tags are set to run. When the array
+      #          contains one or more tags, then the test will only be run if at
+      #          least one tag matches.
+      # * `serial`: An arbitrary string that is used to refer to all a specific
+      #            test case. For example, this can be used to store the serial
+      #            number for the test case.
+      #
+      # @param name [String, Symbol] an arbitrary but unique name for the test,
+      #   preferably unique across all test classes, but not required
+      # @param opts [Hash]
+      # @param block [Proc] the testing logic
+      # @return [void]
+      def test(name, **opts, &block)
+        # Ensure that the test isn't already defined to prevent tests from being
+        # swallowed silently
+        method_name = test_name(name)
+        check_not_defined!(method_name)
+
+        # Add an additional tag, which is unique for each test class, to all tests
+        # To allow user to run tests with option '-t class_name_of_the_test' without
+        # duplicate run for all tests in NameOfTheTest. The namespace of the class
+        # is ignored here.
+        opts[:tags] << ('class_'+ self.name.demodulize.underscore).to_sym
+
+        # Flunk unless a logic block was provided
+        if block_given?
+          self.options ||= {}
+          self.options[method_name.to_sym] = opts.deep_symbolize_keys
+          define_method(method_name, &block)
+        else
+          flunk "No implementation was provided for test '#{method_name}' in #{self}"
+        end
+
+        # add all tests to @@regression_suite
+        # excluding the ones with tags in tags_to_exclude defined in config
+        unless exclude_by_tag?('regression', opts[:tags])
+          @@regression_suite << method_name
+          @@serials << opts[:serial]
+        end
+      end
+
+      # @param suite [String] type of test suite
+      # @param tags [Array] an array of tags a test has
+      # @return [Boolean]
+      def exclude_by_tag?(suite, tags)
+        tag_to_exclude = @@test_suite_data[suite]['tag_to_exclude']
+        if tags.include? tag_to_exclude
+          true
+        else
+          false
+        end
+      end
+
+      # Check that +method_name+ hasn't already been defined as an instance
+      # method in the current class, or in any superclasses.
+      #
+      # @param method_name [Symbol] the method name to check
+      # @return [void]
+      protected
+      def check_not_defined!(method_name)
+        already_defined = instance_method(method_name) rescue false
+        raise TestAlreadyDefined, "Test #{method_name} already exists in #{self}" if already_defined
+      end
+
+      # Transform the test +name+ into a snake-case name, prefixed with "test_".
+      #
+      # @param name [#to_s] the test name
+      # @return [Symbol] the transformed test name symbol
+      # @example
+      #   test_name(:search_zip) # => :test_search_zip
+      private
+      def test_name(name)
+        undercased_name = sanitize_name(name).gsub(/\s+/, '_')
+        "test_#{undercased_name}".to_sym
+      end
+
+      # Sanitize the +name+ by removing consecutive non-word characters into a
+      # single whitespace.
+      #
+      # @param name [#to_s] the name to sanitize
+      # @return [String] the sanitized value
+      # @example
+      #   sanitize_name('The Best  Thing [#5]') # => 'The Best Thing 5'
+      #   sanitize_name(:ReallySuper___awesome) # => 'ReallySuper Awesome'
+      private
+      def sanitize_name(name)
+        name.to_s.gsub(/\W+/, ' ').strip
+      end
+
+    end
+
+  end
+
+end

data/lib/mini_autobot/test_cases.rb

@@ -0,0 +1,7 @@
+module MiniAutobot
+
+  # An empty container for actual test cases and test classes.
+  module TestCases
+  end
+
+end

data/lib/mini_autobot/utils.rb

@@ -0,0 +1,10 @@
+module MiniAutobot
+  module Utils; end
+end
+
+require_relative 'utils/assertion_helper'
+require_relative 'utils/castable'
+require_relative 'utils/data_generator_helper'
+require_relative 'utils/loggable'
+require_relative 'utils/page_object_helper'
+require_relative 'utils/overlay_and_widget_helper'

data/lib/mini_autobot/utils/assertion_helper.rb

@@ -0,0 +1,35 @@
+require 'minitest/assertions'
+
+module MiniAutobot
+  module Utils
+
+    # A collection of custom, but frequently-used assertions.
+    module AssertionHelper
+
+      # Assert that an element, specified by `how` and `what`, are absent from
+      # the current page's context.
+      #
+      # @param how [:class, :class_name, :css, :id, :link_text, :link,
+      #   :partial_link_text, :name, :tag_name, :xpath]
+      # @param what [String, Symbol]
+      def assert_element_absent(how, what)
+        assert_raises Selenium::WebDriver::Error::NoSuchElementError do
+          @driver.find_element(how, what)
+        end
+      end
+
+      # Assert that an element, specified by `how` and `what`, are present from
+      # the current page's context.
+      #
+      # @param how [:class, :class_name, :css, :id, :link_text, :link,
+      #   :partial_link_text, :name, :tag_name, :xpath]
+      # @param what [String, Symbol]
+      def assert_element_present(how, what)
+        @driver.find_element(how, what)
+      end
+
+    end
+
+  end
+end
+