moto 0.0.31 → 0.0.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8893539c7e555384f14655fb9cbccefbdf7084f
-  data.tar.gz: ce183c409b9d6800ad422cecb7997cf24df2741c
+  metadata.gz: d23349f0a57bf09f12e54b6421cc34722300eae9
+  data.tar.gz: 4fdd6816603719eced2cef716639ea709531c44a
 SHA512:
-  metadata.gz: 7e9e6bb3ca9fe6f4621fc88f6f7ad3a574af73317cbd62dfee3c3d362fd87dd8eff55b3f04244ea0d258a730c36518add55774f3fd2eef7f730df83fcad04405
-  data.tar.gz: 9bac80f78ab1e58caf6adab8e791362b18db54915efd1dd42a837e6a00f64292c01f3234f24b2228f70dbccd23c328b8a4308264fb68a01eac0a8adc96f5fad8
+  metadata.gz: 1dd1416efd912208d68ecc4ff1080b64d7354ee36fdf6292d99d5b776a89a171a92399c8eea88445c3851926f19df8ea0337f6d6748ff230f985baed45bffb2c
+  data.tar.gz: 502c169e152bf8ee805e1bbf81f19ff54bf87e52362cb8de8ba16ee14985124c12cd285b19f710e7f3702e340a39d12c834d8fe10d33d9c4ba4185c09ab686af

data/lib/app_generator.rb

@@ -19,10 +19,10 @@ module Moto
       # Name of the class in the template
       class_name = modules.last
 
-      # Evaluate fully qulified name of the class to derive from or, if not specified
+      # 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_class_qualified_name = 'Moto::Test::Base'
       else
         base_class_qualified_name = "#{options[:app_name]}::Lib::Test::#{options[:base_class].split('/').join('::').camelize}"
       end

data/lib/cli.rb

@@ -19,17 +19,15 @@ require_relative './runner_logging'
 require_relative './runner'
 require_relative './thread_context'
 require_relative './thread_pool'
-require_relative './result'
-require_relative './assert'
-require_relative './test'
+require_relative './test/base'
 require_relative './page'
 require_relative './version'
 require_relative './clients/base'
-require_relative './listeners/base'
-require_relative './listeners/console'
-require_relative './listeners/console_dots'
-require_relative './listeners/junit_xml'
-require_relative './listeners/webui'
+require_relative './reporting/listeners/base'
+require_relative './reporting/listeners/console'
+require_relative './reporting/listeners/console_dots'
+require_relative './reporting/listeners/junit_xml'
+require_relative './reporting/listeners/webui'
 require_relative './test_generator'
 require_relative './exceptions/moto'
 require_relative './exceptions/test_skipped'
@@ -83,13 +81,9 @@ module Moto
         test_classes << tg.generate(test_path)
       end
 
-      listeners = []
-      argv[ :reporters ].each do |r|
-        listener = 'Moto::Listeners::' + r.camelize
-        listeners << listener.constantize
-      end
+      @test_reporter = Moto::Reporting::TestReporter.new(argv[:listeners], argv[:config], argv[:name])
 
-      runner = Moto::Runner.new(test_classes, listeners, argv[:environments], argv[:config], argv[:name])
+      runner = Moto::Runner.new(test_classes, argv[:environments], argv[:config], @test_reporter)
       runner.run
     end
 

data/lib/parser.rb

@@ -22,7 +22,8 @@ module Moto
         end
 
       rescue Exception => e
-        puts e.message
+        puts e.message + "\n\n"
+        puts e.backtrace.join("\n")
       end
     end
     
@@ -40,7 +41,7 @@ module Moto
       
       # Default options
       options = {}
-      options[:reporters] = []
+      options[:listeners] = []
       # TODO Mandatory env var in app config
       options[:config] = eval(File.read("#{MotoApp::DIR}/config/moto.rb"))
       options[:environments] = []
@@ -53,7 +54,7 @@ module Moto
       OptionParser.new do |opts|
         opts.on('-t', '--tests Tests', Array) { |v| options[:tests ] = v }
         opts.on('-g', '--tags Tags', Array) { |v| options[:tags ] = v }
-        opts.on('-r', '--reporters Reporters', Array) { |v| options[:reporters] = v }
+        opts.on('-l', '--listeners Listeners', Array) { |v| options[:listeners] = v }
         opts.on('-e', '--environments Environment', Array) { |v| options[:environments] = v }
         opts.on('-c', '--const Const') { |v| options[:const] = v }
         opts.on('-n', '--name Name') { |v| options[:name] = v }

data/lib/reporting/listeners/base.rb

@@ -0,0 +1,44 @@
+module Moto
+  module Reporting
+    module Listeners
+
+      # Base class for listeners that report results of testing 'outside' of the application.
+      class Base
+
+        attr_reader :config
+        attr_reader :custom_run_name
+
+        # @param [Hash] config
+        # @param [String] custom_run_name Optional run name to be passed to listeners
+        def initialize(config, custom_run_name = '')
+          @config = config
+          @custom_run_name = custom_run_name
+        end
+
+        # Invoked when whole batch of tests starts
+        def start_run
+          # Abstract
+        end
+
+        # Abstract
+        # Invoked when whole batch of tests ends
+        def end_run(run_status)
+          # Abstract
+        end
+
+        # Abstract
+        # Invoked when a single test is started
+        def start_test(test_status)
+          # Abstract
+        end
+
+        # Abstract
+        # Invoked when a single test is finished
+        def end_test(test_status)
+          # Abstract
+        end
+
+      end
+    end
+  end
+end

data/lib/reporting/listeners/console.rb

@@ -0,0 +1,31 @@
+module Moto
+  module Reporting
+    module Listeners
+      class Console < Base
+
+        def start_run
+          puts 'START'
+        end
+
+        def end_run(run_status)
+          puts ''
+          puts "FINISHED: #{run_status.to_s}, duration: #{Time.at(run_status.duration).utc.strftime("%H:%M:%S")}"
+          puts "Tests executed: #{run_status.tests_all.length}"
+          puts "  Passed:       #{run_status.tests_passed.length}"
+          puts "  Failure:      #{run_status.tests_failed.length}"
+          puts "  Error:        #{run_status.tests_error.length}"
+          puts "  Skipped:      #{run_status.tests_skipped.length}"
+        end
+
+        def start_test(test_status)
+          print test_status.name
+        end
+
+        def end_test(test_status)
+          puts "\t#{test_status.to_s}"
+        end
+
+      end
+    end
+  end
+end

data/lib/reporting/listeners/console_dots.rb

@@ -0,0 +1,60 @@
+module Moto
+  module Reporting
+    module Listeners
+      class ConsoleDots < Base
+
+        def end_run(run_status)
+          puts ''
+          puts ''
+          puts "FINISHED: #{run_status.to_s}, duration: #{Time.at(run_status.duration).utc.strftime("%H:%M:%S")}"
+          puts "Tests executed: #{run_status.tests_all.length}"
+          puts "  Passed:       #{run_status.tests_passed.length}"
+          puts "  Failure:      #{run_status.tests_failed.length}"
+          puts "  Error:        #{run_status.tests_error.length}"
+          puts "  Skipped:      #{run_status.tests_skipped.length}"
+
+          if run_status.tests_failed.length > 0
+            puts ''
+            puts 'FAILURES: '
+            run_status.tests_failed.each do |test_status|
+              puts test_status.name
+              puts "\t" + test_status.results.last.failures.join("\n\t")
+              puts ''
+            end
+          end
+
+          if run_status.tests_error.length > 0
+            puts ''
+            puts 'ERRORS: '
+            run_status.tests_error.each do |test_status|
+              puts test_status.name
+              puts test_status.results.last.message
+              puts ''
+            end
+          end
+
+          if run_status.tests_skipped.length > 0
+            puts ''
+            puts 'SKIPPED: '
+            run_status.tests_skipped.each do |test_status|
+              puts test_status.name
+              puts test_status.results.last.message
+              puts ''
+            end
+          end
+
+        end
+
+        def end_test(test_status)
+          print case test_status.results.last.code
+          when Moto::Test::Result::PASSED then '.'
+          when Moto::Test::Result::FAILURE then 'F'
+          when Moto::Test::Result::ERROR then 'E'
+          when Moto::Test::Result::SKIPPED then 's'
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/reporting/listeners/junit_xml.rb

@@ -0,0 +1,52 @@
+require 'nokogiri'
+
+module Moto
+  module Reporting
+    module Listeners
+      class JunitXml < Base
+
+        def end_run(run_status)
+          path = config[:output_file]
+
+          run_status_hash = {
+              errors:     run_status.tests_error.length,
+              failures:   run_status.tests_error.length,
+              name:       custom_run_name,
+              tests:      run_status.tests_all.length,
+              time:       run_status.duration,
+              timestamp:  Time.at(run_status.time_start)
+          }
+
+          builder = Nokogiri::XML::Builder.new { |xml|
+            xml.testsuite(run_status_hash) do
+              run_status.tests_all.each do |test_status|
+
+                test_status_hash = {
+                    name:        test_status.name,
+                    time:        test_status.duration,
+                    classname:   test_status.test_class_name,
+                    moto_result: test_status.to_s
+                }
+
+                xml.testcase(test_status_hash) do
+                  if test_status.results.last.code == Moto::Test::Result::ERROR
+                    xml.error(message: test_status.results.last.message)
+                  elsif test_status.results.last.code == Moto::Test::Result::FAILURE
+
+                    test_status.results.last.failures.each do |failure_message|
+                      xml.failure(message: failure_message)
+                    end
+
+                  end
+                end
+              end
+            end
+          }
+
+          File.open(path, 'w') {|f| f.write(builder.to_xml) }
+        end
+
+      end
+    end
+  end
+end

data/lib/reporting/listeners/webui.rb

@@ -0,0 +1,81 @@
+require 'rest-client'
+require 'sys/uname'
+
+module Moto
+  module Reporting
+    module Listeners
+      class Webui < Base
+
+        def start_run
+          # POST http://sandbox.dev:3000/api/runs/create
+          @url = config[:url]
+          data = {
+            name:         custom_run_name,
+            result:       :running,
+            cnt_all:      nil,
+            cnt_passed:   nil,
+            cnt_failure:  nil,
+            cnt_error:    nil,
+            cnt_skipped:  nil,
+            user:         Sys::Uname.sysname.downcase.include?('windows') ? ENV['USERNAME'] : ENV['LOGNAME'],
+            host:         Sys::Uname.nodename,
+            pid:          Process.pid
+          }
+
+          @run = JSON.parse( RestClient.post( "#{@url}/api/runs", data.to_json, :content_type => :json, :accept => :json ) )
+          @tests = {}
+        end
+
+        def end_run(run_status)
+          # PUT http://sandbox.dev:3000/api/runs/1
+          data = {
+            result:       run_status.result,
+            cnt_all:      run_status.tests_all.length,
+            cnt_passed:   run_status.tests_passed.length,
+            cnt_failure:  run_status.tests_failed.length,
+            cnt_error:    run_status.tests_error.length,
+            cnt_skipped:  run_status.tests_skipped.length,
+            duration:     run_status.duration
+          }
+
+          @run = JSON.parse( RestClient.put( "#{@url}/api/runs/#{@run['id']}", data.to_json, :content_type => :json, :accept => :json ) )
+        end
+
+        def start_test(test_status)
+          # POST http://sandbox.dev:3000/api/tests/create
+          data = {
+            name:       test_status.name,
+            class_name: test_status.test_class_name,
+            log:        nil,
+            run_id:     @run['id'],
+            env:        test_status.env,
+            parameters: test_status.params.to_s,
+            result:     :running,
+            error:      nil,
+            failures:   nil
+          }
+
+          @tests[test_status.name] = JSON.parse( RestClient.post( "#{@url}/api/tests", data.to_json, :content_type => :json, :accept => :json ) )
+        end
+
+        def end_test(test_status)
+          data = {
+            log:      File.read(test_status.log_path),
+            result:   test_status.results.last.code,
+            error:    test_status.results.last.code == Moto::Test::Result::ERROR ? nil : test_status.results.last.message,
+            failures: test_failures(test_status),
+            duration: test_status.duration
+          }
+
+          @tests[test_status.name] = JSON.parse( RestClient.put( "#{@url}/api/tests/#{@tests[test_status.name]['id']}", data.to_json, :content_type => :json, :accept => :json ) )
+        end
+
+        # @return [String] string with messages of all failures in a test
+        def test_failures(test_status)
+          test_status.results.last.failures.join("\n\t")
+        end
+
+      end
+    end
+  end
+end

data/lib/reporting/run_status.rb

@@ -0,0 +1,98 @@
+module Moto
+  module Reporting
+
+    # Value object holding information about whole 'run' of tests.
+    class RunStatus
+
+      # Array of all statuses [Moto::Test:Status] from current run
+      attr_reader :tests_all
+
+      # Array of [Moto::Test:Status] with @results.last.code == [Moto::Test::Result::PASSED]
+      attr_reader :tests_passed
+
+      # Array of [Moto::Test:Status] with @results.last.code == [Moto::Test::Result::SKIPPED]
+      attr_reader :tests_skipped
+
+      # Array of [Moto::Test:Status] with @results.last.code == [Moto::Test::Result::FAILURE]
+      attr_reader :tests_failed
+
+      # Array of [Moto::Test:Status] with @results.last.code == [Moto::Test::Result::ERROR]
+      attr_reader :tests_error
+
+      # Time of run's start
+      attr_reader :time_start
+
+      # Time of run's end
+      attr_reader :time_end
+
+      # Run's duration
+      attr_reader :duration
+
+      def initialize
+        @tests_all      = []
+        @tests_passed   = []
+        @tests_skipped  = []
+        @tests_failed   = []
+        @tests_error    = []
+      end
+
+      def initialize_run
+        @time_start = Time.now.to_f
+      end
+
+      def finalize_run
+        @time_end = Time.now.to_f
+        @duration = @time_end - @time_start
+      end
+
+      # Summarized result of whole run
+      # @return [String] one of the values defined as constants in this class in cohesion with [Moto::Test::Result]
+      def result
+
+        if @tests_error.length > 0
+          return Moto::Test::Result::ERROR
+        elsif @tests_failed.length > 0
+          return Moto::Test::Result::FAILURE
+        elsif tests_all.length == @tests_skipped.length
+          return Moto::Test::Result::SKIPPED
+        end
+
+        Moto::Test::Result::PASSED
+      end
+
+      # Adds single test's status to the collection which describes whole run
+      # @param [Moto::Test::Status] test_status to be incorporated into final run result
+      def add_test_status(test_status)
+
+        # Separate collections are kept and data is doubled in order to avoid
+        # calling Array.collect in getter for each type of results
+
+        case test_status.results.last.code
+          when Moto::Test::Result::PASSED
+            @tests_passed << test_status
+          when Moto::Test::Result::SKIPPED
+            @tests_skipped << test_status
+          when Moto::Test::Result::FAILURE
+            @tests_failed << test_status
+          when Moto::Test::Result::ERROR
+            @tests_error << test_status
+          else
+            raise 'Incorrect value of field: "code" in [Moto::Test::Status]'
+        end
+
+        @tests_all << test_status
+      end
+
+      # Overwritten definition of to string.
+      # @return [String] string with readable form of result field
+      def to_s
+        case result
+          when Moto::Test::Result::PASSED   then return 'PASSED'
+          when Moto::Test::Result::FAILURE  then return 'FAILED'
+          when Moto::Test::Result::ERROR    then return 'ERROR'
+          when Moto::Test::Result::SKIPPED  then return 'SKIPPED'
+        end
+      end
+    end
+  end
+end