moto 0.0.22 → 0.0.23

data/lib/listeners/junit_xml.rb

@@ -1,37 +1,37 @@
-require 'nokogiri'
-
-module Moto
-  module Listeners
-    class JunitXml < Base
-
-      def end_run
-        path = @runner.my_config[:output_file]
-
-        builder = Nokogiri::XML::Builder.new { |xml|
-          xml.testsuite(
-                errors: @runner.result.summary[:cnt_error], 
-                failures: @runner.result.summary[:cnt_failure], 
-                name: "Moto run", 
-                tests: @runner.result.summary[:cnt_all], 
-                time: @runner.result.summary[:duration], 
-                timestamp: Time.at(@runner.result.summary[:started_at])) do
-            @runner.result.all.each do |test_name, data|
-              xml.testcase(name: test_name, time: data[:duration], classname: data[:class].name, moto_result: data[:result]) do
-                if !data[:error].nil?
-                  xml.error(message: data[:error].message)
-                elsif data[:failures].count > 0
-                  data[:failures].each do |f|
-                    xml.failure(message: f)
-                  end
-                end
-              end
-            end
-          end
-        }
-
-        File.open(path, 'w') {|f| f.write(builder.to_xml) }        
-      end
-
-    end
-  end
+require 'nokogiri'
+
+module Moto
+  module Listeners
+    class JunitXml < Base
+
+      def end_run
+        path = @runner.my_config[:output_file]
+
+        builder = Nokogiri::XML::Builder.new { |xml|
+          xml.testsuite(
+                errors: @runner.result.summary[:cnt_error], 
+                failures: @runner.result.summary[:cnt_failure], 
+                name: "Moto run", 
+                tests: @runner.result.summary[:cnt_all], 
+                time: @runner.result.summary[:duration], 
+                timestamp: Time.at(@runner.result.summary[:started_at])) do
+            @runner.result.all.each do |test_name, data|
+              xml.testcase(name: test_name, time: data[:duration], classname: data[:class].name, moto_result: data[:result]) do
+                if !data[:error].nil?
+                  xml.error(message: data[:error].message)
+                elsif data[:failures].count > 0
+                  data[:failures].each do |f|
+                    xml.failure(message: f)
+                  end
+                end
+              end
+            end
+          end
+        }
+
+        File.open(path, 'w') {|f| f.write(builder.to_xml) }        
+      end
+
+    end
+  end
 end

data/lib/page.rb

@@ -1,32 +1,28 @@
-module Moto
-
-  class Page
-
-    include Moto::TestLogging
-    include Moto::ForwardContextMethods
-    
-    ignore_logging :const
-    ignore_logging :session
-    
-    attr_reader :website
-    attr_reader :context
-
-    def initialize(website)
-      @website = website
-      @context = @website.context
-    end
-    
-    def session
-      @website.session
-    end
-    
-    def page(p)
-      @context.client(@website.class.name.split('::').pop).page(p)
-    end
-
-    def raise_unless_loaded
-      raise "Invalid state: page #{self.class.name} is not loaded." unless loaded?
-    end
-    
-  end
+module Moto
+
+  class Page
+
+    include Moto::TestLogging
+    include Moto::ForwardContextMethods
+
+    ignore_logging :const
+    ignore_logging :session
+
+    attr_reader :website
+    attr_reader :context
+
+    def initialize(website)
+      @website = website
+      @context = @website.context
+    end
+
+    def page(p)
+      @context.client(@website.class.name.split('::').pop).page(p)
+    end
+
+    def raise_unless_loaded
+      raise "Invalid state: page #{self.class.name} is not loaded." unless loaded?
+    end
+
+  end
 end

data/lib/parser.rb

@@ -1,103 +1,103 @@
-require 'optparse'
-require 'yaml'
-
-require_relative '../lib/cli'
-require_relative '../lib/app_generator'
-
-module Moto
-
-  class Parser
-  
-    def self.run(argv)
-      begin
-        # TODO Generate app / Change the way parsing options goes so it doesnt generate them if they`re not needed
-        case argv[0]
-          when '--version' then puts Moto::VERSION
-          when 'run' then Moto::Cli.run run_parse(argv)
-          when 'help' then show_help
-          when 'generate' then Moto::AppGenerator.run generate_parse(argv)
-          else puts "Command '#{argv[0]}' not recognized. Type help for list of supported commands."
-        end
-      rescue Exception => e
-        puts e.message
-      end
-    end
-    
-    def self.run_parse(argv)
-
-      # TODO: fix this dumb verification of current working directory.
-      unless File.exists? "#{MotoApp::DIR}/config/moto.rb"
-        msg = "Config file (config/moto.rb) not present.\n"
-        msg << 'Does current working directory contain Moto application?'
-        raise msg
-      end    
-
-      require 'bundler/setup'
-      Bundler.require
-      
-      # Default options
-      options = {}
-      options[:reporters] = []
-      # TODO Mandatory env var in app config
-      options[:config] = eval(File.read("#{MotoApp::DIR}/config/moto.rb"))
-      options[:environments] = []
-      options[:name] = ""
-         
-      # Parse arguments
-      # TODO eval ?
-      # TODO const 
-      # TODO reporters should be consts - not strings
-      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('-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 }
-        opts.on('-f', '--config Config') { |v| options[:config] = options[:config].merge( eval( v ) ) }
-      end.parse!
-
-      if options[:name].empty?
-        options[:name] = evaluate_name(options[:tags], options[:tests])
-      end
-
-      if options[ :config ][ :moto ][ :runner ][ :mandatory_environment ] && options[ :environments ].empty?
-        puts 'Environment is mandatory for this project.'
-        exit 1
-      end
-
-      return options
-    end
-    
-    def self.evaluate_name(tags, tests)
-      tags ||= ""
-      tests ||= ""
-      if !tags.empty? && !tests.empty?
-        return "#{tags.count} tags + #{tests.count} tests"
-      elsif tags.empty?
-        return tests.count == 1 ? "Test: #{tests.first}" : "#{tests.count} tests"
-      elsif tests.empty?
-        return tags.count == 1 ? "Tag: #{tags.first}" : "#{tags.count} tags"
-      end
-    end
-    
-    def self.generate_parse(argv)
-      options = {}
-      options[:dir]
-    end
-    
-    def self.show_help
-      puts """
-      Moto (#{Moto::VERSION}) CLI Help:
-      moto --version Display current version
-      moto run:      
-       -t, --tests = Tests to be executed. For e.x Tests\Failure\Failure.rb should be passed as Tests::Failure
-       -r, --reporter = Reporters to be used. Defaults are Moto::Listeners::ConsoleDots, Moto::Listeners::JunitXml
-       -e, --environment etc etc
-      moto generate:
-      moto generate app_name -d, --dir = directory. Default is current dir.
-      """
-    end
-    
-  end
-end
+require 'optparse'
+require 'yaml'
+
+require_relative '../lib/cli'
+require_relative '../lib/app_generator'
+
+module Moto
+
+  class Parser
+  
+    def self.run(argv)
+      begin
+        # TODO Generate app / Change the way parsing options goes so it doesnt generate them if they`re not needed
+        case argv[0]
+          when '--version' then puts Moto::VERSION
+          when 'run' then Moto::Cli.run run_parse(argv)
+          when 'help' then show_help
+          when 'generate' then Moto::AppGenerator.run generate_parse(argv)
+          else puts "Command '#{argv[0]}' not recognized. Type help for list of supported commands."
+        end
+      rescue Exception => e
+        puts e.message
+      end
+    end
+    
+    def self.run_parse(argv)
+
+      # TODO: fix this dumb verification of current working directory.
+      unless File.exists? "#{MotoApp::DIR}/config/moto.rb"
+        msg = "Config file (config/moto.rb) not present.\n"
+        msg << 'Does current working directory contain Moto application?'
+        raise msg
+      end    
+
+      require 'bundler/setup'
+      Bundler.require
+      
+      # Default options
+      options = {}
+      options[:reporters] = []
+      # TODO Mandatory env var in app config
+      options[:config] = eval(File.read("#{MotoApp::DIR}/config/moto.rb"))
+      options[:environments] = []
+      options[:name] = ""
+         
+      # Parse arguments
+      # TODO eval ?
+      # TODO const 
+      # TODO reporters should be consts - not strings
+      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('-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 }
+        opts.on('-f', '--config Config') { |v| options[:config].deep_merge!( eval( File.read(v) ) ) }
+      end.parse!
+
+      if options[:name].empty?
+        options[:name] = evaluate_name(options[:tags], options[:tests])
+      end
+
+      if options[ :config ][ :moto ][ :runner ][ :mandatory_environment ] && options[ :environments ].empty?
+        puts 'Environment is mandatory for this project.'
+        exit 1
+      end
+
+      return options
+    end
+    
+    def self.evaluate_name(tags, tests)
+      tags ||= ""
+      tests ||= ""
+      if !tags.empty? && !tests.empty?
+        return "#{tags.count} tags + #{tests.count} tests"
+      elsif tags.empty?
+        return tests.count == 1 ? "Test: #{tests.first}" : "#{tests.count} tests"
+      elsif tests.empty?
+        return tags.count == 1 ? "Tag: #{tags.first}" : "#{tags.count} tags"
+      end
+    end
+    
+    def self.generate_parse(argv)
+      options = {}
+      options[:dir]
+    end
+    
+    def self.show_help
+      puts """
+      Moto (#{Moto::VERSION}) CLI Help:
+      moto --version Display current version
+      moto run:      
+       -t, --tests = Tests to be executed. For e.x Tests\Failure\Failure.rb should be passed as Tests::Failure
+       -r, --reporter = Reporters to be used. Defaults are Moto::Listeners::ConsoleDots, Moto::Listeners::JunitXml
+       -e, --environment etc etc
+      moto generate:
+      moto generate app_name -d, --dir = directory. Default is current dir.
+      """
+    end
+    
+  end
+end

data/lib/result.rb

@@ -1,84 +1,84 @@
-module Moto
-  class Result
-    
-    PENDING = :pending # -2
-    RUNNING = :running # -1
-    PASSED = :passed # 0
-    FAILURE = :failure # 1
-    ERROR = :error # 2
-    SKIPPED = :skipped # 3
-
-    attr_reader :summary
-
-    def [](key)
-      @results[key]
-    end
-    
-    def all
-      @results
-    end
-    
-    def initialize(runner)
-      @runner = runner
-      @results = {}
-      @summary = {}
-    end
-    
-    def start_run
-      # start timer
-      @summary[:started_at] = Time.now.to_f
-    end
-    
-    def end_run
-      # info about duration and overall execution result
-      @summary[:finished_at] = Time.now.to_f
-      @summary[:duration] = @summary[:finished_at] - @summary[:started_at]
-      @summary[:result] = PASSED
-      @summary[:result] = FAILURE unless @results.values.select{ |v| v[:failures].count > 0 }.empty?
-      @summary[:result] = ERROR unless @results.values.select{ |v| v[:result] == ERROR }.empty?
-      @summary[:cnt_all] = @results.count
-      @summary[:tests_passed] = @results.select{ |k,v| v[:result] == PASSED }
-      @summary[:tests_failure] = @results.select{ |k,v| v[:result] == FAILURE }
-      @summary[:tests_error] = @results.select{ |k,v| v[:result] == ERROR }
-      @summary[:tests_skipped] = @results.select{ |k,v| v[:result] == SKIPPED }
-      @summary[:cnt_passed] = @summary[:tests_passed].count
-      @summary[:cnt_failure] = @summary[:tests_failure].count
-      @summary[:cnt_error] = @summary[:tests_error].count
-      @summary[:cnt_skipped] = @summary[:tests_skipped].count
-    end
-    
-    def start_test(test)
-      @results[test.name] = { class: test.class, result: RUNNING, env: test.env, params: test.params, name: test.name, error: nil, failures: [], started_at: Time.now.to_f } 
-    end
-
-    def end_test(test)
-      # calculate result basing on errors/failures
-      @results[test.name][:finished_at] = Time.now.to_f
-      test.result = PASSED
-      test.result = FAILURE unless @results[test.name][:failures].empty?
-      unless @results[test.name][:error].nil?
-        if @results[test.name][:error].is_a? Moto::Exceptions::TestSkipped
-          test.result = SKIPPED
-        elsif @results[test.name][:error].is_a? Moto::Exceptions::TestForcedPassed
-          test.result = PASSED
-        elsif @results[test.name][:error].is_a? Moto::Exceptions::TestForcedFailure
-          add_failure(test, @results[test.name][:error].message)
-          test.result = FAILURE
-        else
-          test.result = ERROR
-        end
-      end
-      @results[test.name][:duration] = @results[test.name][:finished_at] - @results[test.name][:started_at]
-      @results[test.name][:result] = test.result
-    end
-
-    def add_failure(test, msg)
-      @results[test.name][:failures] << msg
-    end
-    
-    def add_error(test, e)
-      @results[test.name][:error] = e
-    end
-    
-  end
+module Moto
+  class Result
+    
+    PENDING = :pending # -2
+    RUNNING = :running # -1
+    PASSED = :passed # 0
+    FAILURE = :failure # 1
+    ERROR = :error # 2
+    SKIPPED = :skipped # 3
+
+    attr_reader :summary
+
+    def [](key)
+      @results[key]
+    end
+    
+    def all
+      @results
+    end
+    
+    def initialize(runner)
+      @runner = runner
+      @results = {}
+      @summary = {}
+    end
+    
+    def start_run
+      # start timer
+      @summary[:started_at] = Time.now.to_f
+    end
+    
+    def end_run
+      # info about duration and overall execution result
+      @summary[:finished_at] = Time.now.to_f
+      @summary[:duration] = @summary[:finished_at] - @summary[:started_at]
+      @summary[:result] = PASSED
+      @summary[:result] = FAILURE unless @results.values.select{ |v| v[:failures].count > 0 }.empty?
+      @summary[:result] = ERROR unless @results.values.select{ |v| v[:result] == ERROR }.empty?
+      @summary[:cnt_all] = @results.count
+      @summary[:tests_passed] = @results.select{ |k,v| v[:result] == PASSED }
+      @summary[:tests_failure] = @results.select{ |k,v| v[:result] == FAILURE }
+      @summary[:tests_error] = @results.select{ |k,v| v[:result] == ERROR }
+      @summary[:tests_skipped] = @results.select{ |k,v| v[:result] == SKIPPED }
+      @summary[:cnt_passed] = @summary[:tests_passed].count
+      @summary[:cnt_failure] = @summary[:tests_failure].count
+      @summary[:cnt_error] = @summary[:tests_error].count
+      @summary[:cnt_skipped] = @summary[:tests_skipped].count
+    end
+    
+    def start_test(test)
+      @results[test.name] = { class: test.class, result: RUNNING, env: test.env, params: test.params, name: test.name, error: nil, failures: [], started_at: Time.now.to_f } 
+    end
+
+    def end_test(test)
+      # calculate result basing on errors/failures
+      @results[test.name][:finished_at] = Time.now.to_f
+      test.result = PASSED
+      test.result = FAILURE unless @results[test.name][:failures].empty?
+      unless @results[test.name][:error].nil?
+        if @results[test.name][:error].is_a? Moto::Exceptions::TestSkipped
+          test.result = SKIPPED
+        elsif @results[test.name][:error].is_a? Moto::Exceptions::TestForcedPassed
+          test.result = PASSED
+        elsif @results[test.name][:error].is_a? Moto::Exceptions::TestForcedFailure
+          add_failure(test, @results[test.name][:error].message)
+          test.result = FAILURE
+        else
+          test.result = ERROR
+        end
+      end
+      @results[test.name][:duration] = @results[test.name][:finished_at] - @results[test.name][:started_at]
+      @results[test.name][:result] = test.result
+    end
+
+    def add_failure(test, msg)
+      @results[test.name][:failures] << msg
+    end
+    
+    def add_error(test, e)
+      @results[test.name][:error] = e
+    end
+    
+  end
 end