moto 0.9.11 → 0.9.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e7d75bfa8620395beba5bd52ac893556c9662519
-  data.tar.gz: f47066f906dc8b4e8edc6ad3581ff57f49425113
+  metadata.gz: 7fd7651cf81d31a19644da80e0837649daa58e57
+  data.tar.gz: a3ab1acad8e60e01cfb3ea2a40e2738226addb8a
 SHA512:
-  metadata.gz: 7bf1de8ba4eea78865dd1c64323f069ddf9f61602bbc44b0e7e48a30bccabbbc9e0eeeb54a19f9e935d680ee7a6c08cb4e3201bd271fa8d37ef2e91c99030c77
-  data.tar.gz: ac99006b16ea7f86f00651a24a7a4186970f99aeb6df0d4f2306e0e921d3c23b850a95a1d8afb0f3d5bc3a5f714b0e980b5229e6b6cdb45c88eb189b0329b8d9
+  metadata.gz: 8eca0bcbda114f618032f367494e1c53fa7d7fb9bfd5153baf40de7d8e487ec5889cb4a5c07f2f1e110711a122dd162c4c7294ffe3bdadd890c46befc5a7e281
+  data.tar.gz: 0e33fcc4ebbe3efcc9ca3142e00f70732edddf4c0f04d0516c4454b53dfbcc4ee366668462bcac0a2573c4d54478952f69ef7f3fd58dfc9b81e2aa2bb0847995

data/bin/moto

@@ -1,5 +1,13 @@
 #!/usr/bin/env ruby
 
-require_relative '../lib/parser'
+require_relative '../lib/test_logging'
+require_relative '../lib/test/base'
 
-Moto::Parser.run ARGV
+require_relative '../lib/reporting/listeners/base'
+require_relative '../lib/reporting/listeners/console'
+require_relative '../lib/reporting/listeners/console_dots'
+require_relative '../lib/reporting/listeners/junit_xml'
+require_relative '../lib/reporting/listeners/webui'
+
+require_relative '../lib/parameter_parser'
+Moto::ParameterParser.parse_user_input(ARGV)

data/lib/empty_listener.rb

@@ -1,17 +1,17 @@
-module Moto
-  module EmptyListener
-
-    def start_run
-    end
-    
-    def end_run
-    end
-    
-    def start_test(test)
-    end
-
-    def end_test(test)
-    end    
-
-  end
+module Moto
+  module EmptyListener
+
+    def start_run
+    end
+    
+    def end_run
+    end
+    
+    def start_test(test)
+    end
+
+    def end_test(test)
+    end    
+
+  end
 end

data/lib/exceptions/{moto.rb → base.rb}

@@ -1,6 +1,6 @@
 module Moto
   module Exceptions
-    class MotoException < RuntimeError
+    class Base < RuntimeError
       
     end
   end

data/lib/exceptions/test_forced_failure.rb

@@ -1,6 +1,8 @@
+require_relative 'base'
+
 module Moto
   module Exceptions
-    class TestForcedFailure  < MotoException
+    class TestForcedFailure  < Base
       
     end
   end

data/lib/exceptions/test_forced_passed.rb

@@ -1,6 +1,8 @@
+require_relative 'base'
+
 module Moto
   module Exceptions
-    class TestForcedPassed  < MotoException
+    class TestForcedPassed  < Base
       
     end
   end

data/lib/exceptions/test_skipped.rb

@@ -1,6 +1,8 @@
+require_relative 'base'
+
 module Moto
   module Exceptions
-    class TestSkipped  < MotoException
+    class TestSkipped  < Base
       
     end
   end

data/lib/modes/generate/test_template_generator.rb

@@ -0,0 +1,82 @@
+require 'fileutils'
+
+module Moto
+  module Modes
+    module Generate
+      class TestTemplateGenerator
+
+        # Creates directories and file with class template for a test.
+        # @param options [Hash] Informations required perfrom the task.
+        #   options[:app_name]        Name of the application that uses Moto Framework.
+        #   options[:dir]             Subdirectories of MotoApp/tests/ where test should be placed.
+        #   options[:base_class]      Path and filename of class from which the test will derive.
+        #   options[:force]           Whether generator should forcibly overwrite previously existing file.
+        def self.run(options)
+
+          # Build list of modules basing on the name of the application and subdirectory provided by the user.
+          # Second module is always 'tests' since it's where they should be kept.
+          modules = [options[:app_name], 'tests'] + options[:dir].split('/')
+          modules.map!(&:camelize)
+
+          # Name of the class in the template
+          class_name = modules.last
+
+          # Evaluate fully qualified name of the class to derive from or, if not specified
+          # use Moto's default one
+          if options[:base_class].nil?
+            base_class_qualified_name = 'Moto::Test::Base'
+          else
+            base_class_qualified_name = "#{options[:app_name]}::Lib::Test::#{options[:base_class].split('/').join('::').camelize}"
+          end
+
+          # Where to put finished template
+          test_file = File.basename(options[:dir]) + '.rb'
+          test_dir = MotoApp::DIR + '/tests/' + options[:dir]
+          test_path = "#{test_dir}/#{test_file}"
+
+          # Create directory
+          FileUtils.mkdir_p(test_dir)
+
+          if !File.exist?(test_path) || options[:force]
+            # Create new file in specified location and add class' template to it
+            File.open(test_path, 'w+') do |file|
+
+              indent = 0
+
+              if options[:base_class].nil?
+                file << "\n"
+              else
+                file << "require './lib/test/#{options[:base_class]}.rb'\n\n"
+              end
+
+              modules.each do |m|
+                file << (' ' * indent) + "module #{m}\n"
+                indent += 2
+              end
+
+              file << (' ' * indent) + "# Class template genereated by 'moto generate'\n"
+              file << (' ' * indent) + "class #{class_name} < #{base_class_qualified_name}\n\n"
+              indent += 2
+              file << (' ' * indent) + "def run\n"
+              file << (' ' * indent) + "end\n\n"
+              indent -= 2
+              file << (' ' * indent) + "end\n"
+
+              modules.each do
+                indent -= 2
+                file << (' ' * indent) + "end\n"
+              end
+
+            end
+
+            puts 'Result:'
+            puts "  File: #{test_path}"
+            puts "  Class: #{class_name} < #{base_class_qualified_name}"
+          else
+            raise 'File already exists. Use -f or --force to overwrite existing contents.'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/modes/mode_selector.rb

@@ -0,0 +1,78 @@
+require_relative '../reporting/test_reporter'
+
+require_relative '../test/metadata_generator'
+
+require_relative 'generate/test_template_generator'
+require_relative 'run/dry_runner'
+require_relative 'run/test_runner'
+require_relative 'validate/test_validator'
+
+
+module Moto
+  module Modes
+    class ModeSelector
+
+      def run(parsed_arguments)
+        tests_metadata = prepare_metadata(parsed_arguments)
+        test_reporter = prepare_test_reporter(parsed_arguments)
+
+        if Moto::Lib::Config.moto[:test_runner][:dry_run]
+          runner = Moto::Modes::Run::DryRunner.new(tests_metadata, test_reporter)
+        else
+          runner = Moto::Modes::Run::TestRunner.new(tests_metadata, test_reporter, parsed_arguments[:stop_on])
+        end
+
+        runner.run
+      end
+
+      def generate(parsed_arguments)
+        Moto::Modes::Generate::TestTemplateGenerator.run(parsed_arguments)
+      end
+
+      def validate(parsed_arguments)
+        tests_metadata = prepare_metadata(parsed_arguments)
+        test_reporter = prepare_test_reporter(parsed_arguments)
+
+        validation_options = {}
+        validation_options[:tags_regex_positive] = parsed_arguments[:validator_regex_positive] if parsed_arguments[:validator_regex_positive]
+        validation_options[:tags_regex_negative] = parsed_arguments[:validator_regex_negative] if parsed_arguments[:validator_regex_negative]
+        validation_options[:has_tags]            = parsed_arguments.key?(:validate_has_tags)
+        validation_options[:has_description]     = parsed_arguments.key?(:validate_has_description)
+        validation_options[:tag_whitelist]       = parsed_arguments[:tag_whitelist] if parsed_arguments[:tag_whitelist]
+
+        validator = Moto::Modes::Validate::TestValidator.new(tests_metadata, validation_options, test_reporter)
+        validator.run
+      end
+
+      def version
+        puts Moto::VERSION
+      end
+
+      def prepare_metadata(parsed_arguments)
+        tests_metadata = Moto::Test::MetadataGenerator.generate(parsed_arguments[:tests],
+                                                                 parsed_arguments[:tags],
+                                                                 parsed_arguments[:filters])
+
+        # TODO Display criteria used
+        if tests_metadata.empty?
+          puts 'No tests found for given arguments.'
+          Kernel.exit(-1)
+        else
+          return tests_metadata
+        end
+      end
+      private :prepare_metadata
+
+      def prepare_test_reporter(parsed_arguments)
+        run_params = {}
+        run_params[:run_name] = parsed_arguments[:run_name]
+        run_params[:suite_name] = parsed_arguments[:suite_name]
+        run_params[:assignee] = parsed_arguments[:assignee]
+
+        Moto::Reporting::TestReporter.new(parsed_arguments[:listeners], run_params)
+      end
+      private :prepare_test_reporter
+
+    end
+  end
+end

data/lib/modes/run/dry_runner.rb

@@ -0,0 +1,40 @@
+require_relative '../../reporting/test_reporter'
+require_relative '../../test/generator'
+
+module Moto
+  module Modes
+    module Run
+      class DryRunner
+
+        # @param [Array] tests_metadata Collection of [Moto::Test::Metadata] objects describing Tests
+        # @param [Moto::Reporting::TestReporter] test_reporter Reporter of test/run statuses that communicates with external status listeners
+        def initialize(tests_metadata, test_reporter)
+          @tests_metadata = tests_metadata
+          @test_reporter = test_reporter
+        end
+
+        def run
+          @test_reporter.report_start_run
+
+          test_generator = Moto::Test::Generator.new
+          @tests_metadata.each do |metadata|
+            test_variants = test_generator.get_test_with_variants(metadata)
+            test_variants.each do |tc|
+              @test_reporter.report_start_test(tc.status, tc.metadata)
+              tc.status.initialize_run
+              tc.status.log_exception(Exceptions::TestSkipped.new('Dry run.'))
+              tc.status.finalize_run
+              @test_reporter.report_end_test(tc.status)
+            end
+          end
+
+          @test_reporter.report_end_run
+
+          # Exit application with code that represents status of test run
+          Kernel.exit(@test_reporter.run_status.bitmap)
+        end
+
+      end
+    end
+  end
+end

data/lib/modes/run/test_provider.rb

@@ -0,0 +1,71 @@
+require 'thread'
+require_relative '../../test/generator'
+
+# Thread safe provider of test instances
+
+module Moto
+  module Modes
+    module Run
+      class TestProvider
+
+        # @param [Array] tests_metadata
+        def initialize(tests_metadata)
+          super()
+          @test_repeats = Moto::Lib::Config.moto[:test_runner][:test_repeats]
+          @current_test_repeat = 1
+          @queue = Queue.new
+          @tests_metadata = tests_metadata
+          @test_generator = Moto::Test::Generator.new
+        end
+
+        # Use this to retrieve tests safely in multithreaded environment
+        def get_test
+          create_tests
+          @queue.pop
+        end
+
+        # Pushes new tests to the queue if possible and the queue is already empty
+        def create_tests
+          if @queue.empty?
+
+            test_metadata = get_test_metadata
+
+            if test_metadata
+              test_variants = @test_generator.get_test_with_variants(test_metadata)
+              test_variants.each do |test|
+                @queue.push(test)
+              end
+            end
+
+          end
+        end
+        private :create_tests
+
+        # Returns metadata of the test while supporting the number of repeats specified by the user
+        # return [Moto::Test::Metadata]
+        def get_test_metadata
+
+          if @current_test_repeat == 1
+            @test_metadata = @tests_metadata.shift
+          end
+
+          if @current_test_repeat == @test_repeats
+            @current_test_repeat = 1
+          else
+            @current_test_repeat += 1
+          end
+
+          @test_metadata
+        end
+        private :get_test_metadata
+
+        # Number of threads waiting for a job
+        def num_waiting
+          @queue.num_waiting
+        end
+
+      end
+    end
+  end
+end
+

data/lib/modes/run/test_runner.rb

@@ -0,0 +1,74 @@
+require_relative '../../reporting/test_reporter'
+require_relative 'test_provider'
+require_relative 'thread_context'
+
+module Moto
+  module Modes
+    module Run
+      class TestRunner
+
+        attr_reader :test_reporter
+
+        # @param [Array] tests_metadata Collection of [Moto::Test::Metadata] objects describing Tests
+        # @param [Moto::Reporting::TestReporter] test_reporter Reporter of test/run statuses that communicates with external status listeners
+        # @param [Hash] stop_conditions Describe when TestRunner should abnormally stop its execution
+        #   :error  [Boolean]
+        #   :fail   [Boolean]
+        #   :skip   [Boolean]
+        def initialize(tests_metadata, test_reporter, stop_conditions)
+          @tests_metadata = tests_metadata
+          @test_reporter = test_reporter
+          @stop_conditions = stop_conditions
+        end
+
+        def run
+          test_provider = TestProvider.new(@tests_metadata)
+          threads_max = Moto::Lib::Config.moto[:test_runner][:thread_count] || 1
+
+          # remove log/screenshot files from previous execution
+          @tests_metadata.each do |metadata|
+            FileUtils.rm_rf("#{File.dirname(metadata.test_path)}/logs")
+          end
+
+          @test_reporter.report_start_run
+
+          # Create as many threads as we're allowed by the config file.
+          # test_provider.get_test - will invoke Queue.pop thus putting the thread to sleep
+          # once there is no more work.
+
+          Thread.abort_on_exception = true
+
+          (1..threads_max).each do |index|
+            Thread.new do
+              Thread.current[:id] = index
+              loop do
+                tc = ThreadContext.new(test_provider.get_test, @test_reporter)
+                tc.run
+              end
+            end
+          end
+
+          # Waiting for all threads to run out of work so we can end the application
+          # or abonormal termination to be triggered based on options provided by the user
+          loop do
+            run_status = @test_reporter.run_status
+            if (test_provider.num_waiting == threads_max) ||
+                (@stop_conditions[:error] && run_status.tests_error.length > 0) ||
+                (@stop_conditions[:fail] && run_status.tests_failed.length > 0) ||
+                (@stop_conditions[:skip] && run_status.tests_skipped.length > 0)
+              break
+            end
+
+            sleep 2
+          end
+
+          @test_reporter.report_end_run
+
+          # Exit application with code that represents status of test run
+          Kernel.exit(@test_reporter.run_status.bitmap)
+        end
+
+      end
+    end
+  end
+end