moto 0.0.0 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e048efe2a7dae21ba01da0503fdeb40e56755827
-  data.tar.gz: 00882f74920d1fab0729c015e8260ecba2b115ff
+  metadata.gz: a53792d2e2c396c69d4304ea1ab6c1c4015fc895
+  data.tar.gz: f333327a20547acdd3f6ff7e4f97f15b0bea2016
 SHA512:
-  metadata.gz: 8b89e9d40644d2a751c9e4fd7455d40395f3c2a7d682cec532e6ac8dd9cf02497338e26952ae8156eee510d9289a21dc61f286fcb8c071e29400d9f2fb88931f
-  data.tar.gz: e8710637b4dbbb2ccd4e2d9412f932033e79fc7baee4713b82926a4e6ac5c83732b1b76f9a02521bb714cc1835ea436171f3d7677a4e339bddcdb18b6ddca3ed
+  metadata.gz: 73bf56964886a0525c9c2140341ae722870ecf5963e9fe2d641e9a9ca8342d5b6ec1bc956a898051a96b5235a15657ed1457e8be1e7546f12cbb2bfdfbd3f55b
+  data.tar.gz: a5b6188e9320d21e1bce04b9c5759260cebc2dbae5f34f2f5a916be756f0019ca455278158e3cc363ec9d4adc6669a3b113104cc6d5b4c6dcf1d01ec8a63d028

data/bin/moto

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'moto'
-MotoCliRunner.run ARGV
+require_relative '../lib/cli'
+
+Moto::Cli.run ARGV

data/lib/assert.rb

@@ -0,0 +1,16 @@
+module Moto
+  module Assert
+
+    def assert_equal(a, b)
+      assert(a==b, "Arguments should be equal: #{a} != #{b}")
+    end
+
+    def assert(condition, message)
+      unless condition
+        @context.runner.result.add_failure(self, message)
+        logger.error("ASSERTION FAILED: #{message}")
+      end
+    end
+
+  end
+end

data/lib/cli.rb

@@ -0,0 +1,52 @@
+require 'logger'
+require 'pp'
+require 'yaml'
+require 'active_support/inflector'
+require 'active_support/core_ext/object/blank'
+# require 'active_support/core_ext'
+
+APP_DIR = Dir.pwd
+MOTO_DIR = File.dirname(File.dirname(__FILE__))
+
+# TODO detect if cwd contains MotoApp
+
+require "#{APP_DIR}/config/moto"
+
+require_relative './empty_listener'
+require_relative './test_logging'
+require_relative './runner_logging'
+require_relative './runner'
+require_relative './thread_context'
+require_relative './result'
+require_relative './assert'
+require_relative './test'
+require_relative './page'
+require_relative './clients/base'
+require_relative './listeners/base'
+require_relative './listeners/console'
+require_relative './test_generator'
+
+module Moto
+
+  class Cli
+  
+    def self.run(argv)
+      test_class_name = argv[0]
+      
+      tg = TestGenerator.new(APP_DIR)
+      t = tg.generate(test_class_name)
+      
+      tests = [t]
+      
+      # parsing ARGV and creating config will come here
+      # instantiation of tests for ARGV params also happens here
+      # instantiate listeners/reporters
+      
+      # listeners = []
+      listeners = [Moto::Listeners::Console]
+      runner = Moto::Runner.new(tests, listeners, thread_cnt: 3, environments: [:qa, :qa2])
+      runner.run
+    end
+  
+  end
+end

data/lib/clients/base.rb

@@ -0,0 +1,22 @@
+module Moto
+  module Clients
+  
+    class Base
+      include Moto::EmptyListener
+
+      # include Moto::RunnerLogging
+      include Moto::TestLogging
+  
+      attr_reader :context
+  
+      def initialize(context)
+        @context = context
+      end
+
+      def init
+        # abstract
+      end
+  
+    end
+  end
+end

data/lib/clients/website.rb

@@ -0,0 +1,54 @@
+require 'capybara'
+
+module Moto
+  module Clients
+	
+  	class Website < Moto::Clients::Base
+
+      attr_reader :session
+      
+      ignore_logging(:page)
+      ignore_logging(:context)
+      ignore_logging(:session)
+  		
+  		def init
+  		  # can be overriden
+  		  @options = {
+  		    capybara_backend: :selenium
+  		  }
+  		end
+  		
+      def start_run
+        # TODO: make session driver configurable
+        @session = Capybara::Session.new(@options[:capybara_backend])
+        @pages = {}
+      end
+      
+      def end_run
+        @session.driver.browser.close # TODO: check that it really works
+      end
+      
+      def start_test(test)
+        # @context.current_test.logger.info("Hi mom, I'm opening some pages!")
+        @session.reset_session!
+      end
+  
+      def end_test(test)
+        @session.reset_session!
+      end   
+  		
+  		def page(p)
+  		  page_class_name = "#{self.class.name}Pages::#{p}"
+  		  page_class_name.gsub!('Moto::', 'MotoApp::')
+  		  if @pages[page_class_name].nil?
+          a = page_class_name.underscore.split('/')
+          page_path = a[1..20].join('/')
+          require "#{APP_DIR}/#{page_path}"	    
+  		    @pages[page_class_name] = page_class_name.constantize.new(self)
+  		  end
+  		  @pages[page_class_name]
+  		end
+  		
+  	end
+  end
+end

data/lib/listeners/console.rb

@@ -3,19 +3,24 @@ module Moto
     class Console < Base
 
       def start_run
-        @runner.logger.info("Starting...")
+        puts "START"
       end
       
       def end_run
-        @runner.logger.info("...done: #{@runner.result.summary[:result]}, duration: #{@runner.result.summary[:duration]}")
+        puts ""
+        puts "FINISHED: #{@runner.result.summary[:result]}, duration: #{Time.at(@runner.result.summary[:duration]).utc.strftime("%H:%M:%S")}"
+        puts "Tests executed: #{@runner.result.summary[:cnt_all]}"
+        puts "  Passed:       #{@runner.result.summary[:cnt_passed]}"
+        puts "  Failure:      #{@runner.result.summary[:cnt_failure]}"
+        puts "  Error:        #{@runner.result.summary[:cnt_error]}"
       end
 
       def start_test(test)
-        @runner.logger.info("Starting test #{test.name}")
+        print test.name
       end
   
       def end_test(test)
-        @runner.logger.info("Ending test #{test.name} with result #{@runner.result[test.name][:result]}")
+        puts "\t#{@runner.result[test.name][:result]}"
       end
 
     end

data/lib/page.rb

@@ -0,0 +1,32 @@
+module Moto
+
+  class Page
+
+    include Moto::TestLogging
+    
+    ignore_logging :const
+    ignore_logging :session
+
+    def initialize(website)
+      @website = website
+      @context = @website.context
+    end
+    
+    def const(key)
+      @website.context.const(key)
+    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
+end

data/lib/result.rb

@@ -31,11 +31,14 @@ module Moto
       @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[:error].nil? }.empty?
-      # TODO: calculate count and percentage of errors/failures
+      @summary[:cnt_all] = @results.count
+      @summary[:cnt_passed] = @results.values.select{ |v| v[:result] == PASSED }.count
+      @summary[:cnt_failure] = @results.values.select{ |v| v[:result] == FAILURE }.count
+      @summary[:cnt_error] = @results.values.select{ |v| v[:result] == ERROR }.count
     end
     
     def start_test(test)
-      @results[test.name] = { class: test.class, result: RUNNING, env: nil, params: nil, name: test.name, error: nil, failures: [] } 
+      @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)
@@ -43,8 +46,9 @@ module Moto
       test.result = PASSED
       test.result = FAILURE unless @results[test.name][:failures].empty?
       test.result = ERROR unless @results[test.name][:error].nil?
+      @results[test.name][:finished_at] = Time.now.to_f
+      @results[test.name][:duration] = @results[test.name][:finished_at] - @results[test.name][:started_at]
       @results[test.name][:result] = test.result
-      test.logger.info("Result: #{test.result}")
     end
 
     def add_failure(test, msg)
@@ -52,7 +56,7 @@ module Moto
     end
     
     def add_error(test, e)
-      
+      @results[test.name][:error] = e
     end
     
   end

data/lib/runner.rb

@@ -5,6 +5,7 @@ module Moto
     attr_reader :listeners
     attr_reader :logger
     attr_reader :environments
+    attr_reader :assert
     
     def initialize(tests, listeners, config = {})
       @tests = tests
@@ -12,10 +13,11 @@ module Moto
       @threads = []
       
       # TODO: initialize logger from config (yml or just ruby code)
-      @logger = Logger.new(STDOUT)
+      # @logger = Logger.new(STDOUT)
+      @logger = Logger.new(File.open("#{APP_DIR}/moto.log", File::WRONLY | File::APPEND | File::CREAT))
       # @logger.level = Logger::WARN
       
-      @result = Moto::Result.new(self)
+      @result = Result.new(self)
       
       # TODO: validate envs, maybe no-env should be supported as well?
       @environments = config[:environments]
@@ -38,14 +40,6 @@ module Moto
       end
       @threads.each{ |t| t.join }
       @listeners.each { |l| l.end_run }
-      # aggregate result from @tests list
-    end
-    
-    def assert(test, condition, message)
-      unless condition
-        @result.add_failure(test, message)
-        test.logger.error("ASSERTION FAILED: #{message}")
-      end
     end
     
   end

data/lib/runner_logging.rb

@@ -0,0 +1,27 @@
+module Moto
+  module RunnerLogging
+
+
+    # TODO: merge it somehow with TestLogging. Parametrize logger object?
+    def self.included(cls)
+      def cls.method_added(name)
+        excluded_methods = Moto::EmptyListener.instance_methods(false)
+        excluded_methods << :new
+        excluded_methods << :initialize
+        # TODO: configure more excluded classes/methods
+        return if @added 
+        @added = true # protect from recursion
+        original_method = "original_#{name}"
+        alias_method original_method, name
+        define_method(name) do |*args|
+          @context.runner.logger.debug("#{self.class.name}::#{__callee__} ENTER >>> #{args}") unless excluded_methods.include? name 
+          result = send original_method, *args
+          @context.runner.logger.debug("#{self.class.name}::#{__callee__} LEAVE <<< #{result} ") unless excluded_methods.include? name
+          result
+        end
+        @added = false
+      end
+
+    end    
+  end
+end

data/lib/test.rb

@@ -1,9 +1,14 @@
 module Moto
   class Test
     
+    include Moto::Assert
+    
     attr_writer :context
     attr_accessor :result
     attr_reader :name
+    attr_reader :env
+    attr_reader :params
+    attr_writer :static_path
 
     class << self
       attr_accessor :_path
@@ -40,12 +45,18 @@ module Moto
 
     def dir
       # puts self.class.path
+      return File.dirname(@static_path) unless @static_path.nil?
       File.dirname(self.path)
     end
     
     def filename
+      return File.basename(@static_path, ".*") unless @static_path.nil?
       File.basename(path, ".*")
     end
+ 
+    def const(key)
+      @context.const(key)
+    end
 
     def run
       # abstract
@@ -59,10 +70,6 @@ module Moto
       # abstract
     end
 
-    def assert(*args)
-      @context.runner.assert(self,*args)
-    end
-
     def client(name)
       @context.client(name)
     end

data/lib/test_generator.rb

@@ -0,0 +1,62 @@
+module MotoApp
+  module Tests
+  end
+end
+
+module Moto
+  class TestGenerator
+    
+    def initialize(app_dir)
+      @app_dir = app_dir
+    end
+    
+    # assuming that target file includes full valid ruby class
+    def create(class_name)
+      class_name = 'MotoApp::Tests::'+class_name
+      a = class_name.underscore.split('/')
+      test_path = (a[1..20]+[a[-1]]).join('/')
+      
+      # TODO: check if this path and constant exists
+      require "#{APP_DIR}/#{test_path}"
+      test_const = class_name.safe_constantize  
+      test_const.new    
+    end
+    
+    def create_module_tree(root_module, next_modules)
+      next_module_name = next_modules.shift
+      if root_module.const_defined?(next_module_name.to_sym)
+        m = root_module.const_get(next_module_name.to_sym)
+      else
+        m = Module.new
+        root_module.const_set(next_module_name.to_sym, m)
+      end
+      return m if next_modules.empty?
+      create_module_tree(m, next_modules)
+    end
+    
+    # assuming that target file includes only content of method 'run' and some magic comments
+    def generate(class_name)
+      full_class_name = 'MotoApp::Tests::'+class_name
+      a = full_class_name.underscore.split('/')
+      test_path = (a[1..20]+[a[-1]]).join('/')
+      test_path = "#{APP_DIR}/#{test_path}.rb"
+
+      method_body = File.read(test_path) + "\n"
+
+      # MotoApp::Tests::Login::Short
+      consts = full_class_name.split('::')
+      class_name = consts.pop
+
+      consts.shift 2 # remove Moto::Test as already defined
+      m = create_module_tree(MotoApp::Tests, consts)
+      cls = Class.new(Moto::Test)
+      m.const_set(class_name.to_sym, cls)
+      
+      test_object = cls.new
+      test_object.instance_eval( "def run\n  #{method_body} \n end" )
+      test_object.static_path = test_path
+      test_object
+    end
+    
+  end
+end

data/lib/test_logging.rb

@@ -0,0 +1,49 @@
+module Moto
+  module TestLogging
+
+    @@ignore_logging = []
+
+    def self.included(cls)
+
+      def cls.ignore_logging(method)
+        full_name = "#{self.name}::#{method}"
+        @@ignore_logging << full_name
+      end
+      
+      def cls.method_added(name)
+
+        Moto::EmptyListener.instance_methods(false).each do |m|
+          full_name = "#{self.name}::#{m}"
+          @@ignore_logging << full_name unless @@ignore_logging.include? full_name
+        end
+        @@ignore_logging << "#{self.name}::new"
+        @@ignore_logging << "#{self.name}::initialize"
+
+        return if @added 
+        @added = true # protect from recursion
+        original_method = "original_#{name}"
+        alias_method original_method, name
+        define_method(name) do |*args|
+          full_name = "#{self.class.name}::#{__callee__}"
+          # TODO: use self.class.ancestors to figure out if ancestor::__callee__ is not in @@ignore_logging
+          skip_logging = @@ignore_logging.include? full_name
+          unless skip_logging
+            self.class.ancestors.each do |a|
+              ancestor_name = "#{a.name}::#{__callee__}"
+              if @@ignore_logging.include? ancestor_name
+                skip_logging = true
+                break
+              end
+            end
+          end
+          @context.current_test.logger.debug("ENTER >>> #{self.class.name}::#{__callee__}(#{args})") unless skip_logging 
+          result = send original_method, *args
+          @context.current_test.logger.debug("LEAVE <<< #{self.class.name}::#{__callee__} => #{result} ") unless skip_logging
+          result
+        end
+        @added = false
+      end
+    end    
+
+  end
+end

data/lib/thread_context.rb

@@ -4,51 +4,99 @@ module Moto
     # all resources specific for single thread will be initialized here. E.g. browser session
     attr_reader :runner
     attr_reader :logger
+    attr_reader :log_path
+    attr_reader :current_test
     
     def initialize(runner, tests)
       @runner = runner
       @tests = tests
+      @clients = {}
       @tests.each do |t|
         t.context = self
       end
+      # TODO: add all *.yml files from that dir
+      @config = YAML.load_file("#{APP_DIR}/config/const.yml")
     end
     
     def client(name)
-      # TODO: implement registry caching per name+env
-      name = 'MotoApp::Clients::' + name
-      a = name.underscore.split('/')
-      test_path = (a[1..20]+[a[-1]]).join('/')
-      require "#{APP_DIR}/#{test_path}"
-      client_const = name.safe_constantize
-      client_const.new      
+      return @clients[name] if @clients.key? name
+      
+      name_app = 'MotoApp::Clients::' + name
+      name_moto = 'Moto::Clients::' + name
+      
+      c = try_client(name_app, APP_DIR)
+      unless c.nil?
+        @clients[name] = c
+        return c
+      end
+
+      c = try_client(name_moto, "#{MOTO_DIR}/lib")
+      unless c.nil?
+        @clients[name] = c
+        return c
+      end
+      raise "Could not find client class for name #{name}"
+    end
+    
+    def try_client(name, dir)
+      begin      
+        a = name.underscore.split('/')
+        client_path = a[1..20].join('/')
+        require "#{dir}/#{client_path}"
+        client_const = name.constantize
+        instance = client_const.new(self)
+        instance.init
+        instance.start_run
+        instance.start_test(@current_test)
+        return instance
+      rescue Exception => e  
+        return nil
+      end
+    end
+    
+    def const(key)
+      # TODO: add support to consts with no env
+      @config[@current_test.env.to_s][key.to_s]
     end
     
     def run
       @tests.each do |test|
-        # TODO: handle running same test in different environments / parameters - set name and logger
         @runner.environments.each do |env|
           params_path = "#{test.dir}/#{test.filename}.yml"
           params_all = [{}]
           params_all = YAML.load_file(params_path).map{|h| Hash[ h.map{|k,v| [ k.to_sym, v ] } ] } if File.exists?(params_path)
+          # params_all = YAML.load_file(params_path) if File.exists?(params_path)
           params_all.each do |params|
+            # TODO: add filtering out params that are specific to certain envs
             test.init(env, params)
             # TODO: log path might be specified (to some extent) by the configuration
-            log_path = "#{test.dir}/#{test.name.gsub(/\s+/, '_').gsub('::', '_').gsub('/', '_')}.log"
-            @logger = Logger.new(File.open(log_path, File::WRONLY | File::TRUNC | File::CREAT))
+            @log_path = "#{test.dir}/#{test.name.gsub(/\s+/, '_').gsub('::', '_').gsub('/', '_')}.log"
+            # TODO: remove log files from previous execution
+            @logger = Logger.new(File.open(@log_path, File::WRONLY | File::TRUNC | File::CREAT))
             # TODO: make logger level configurable
-            # @logger.level = Logger::INFO
+            @logger.level = Moto::Config::LOG_LEVEL
             @current_test = test
             @runner.listeners.each { |l| l.start_test(test) }
+            @clients.each_value { |c| c.start_test(test) }
             test.before
-            # TODO: handle exception thrown during test run
-            test.run
+            @logger.info "Start: #{test.name}"
+            begin
+              test.run
+            rescue Exception => e  
+              @logger.error("#{e.class.name}: #{e.message}")  
+              @logger.error(e.backtrace.join("\n"))
+              @runner.result.add_error(test, e)
+            end 
             test.after
+            @clients.each_value { |c| c.end_test(test) }
             @runner.listeners.each { |l| l.end_test(test) }
+            @logger.info("Result: #{test.result}")
             @logger.close
           end
         end
       end
+      @clients.each_value { |c| c.end_run }
     end
-    
+  
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moto
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.3
 platform: ruby
 authors:
 - Bartek Wilczek
@@ -11,23 +11,33 @@ bindir: bin
 cert_chain: []
 date: 2015-08-07 00:00:00.000000000 Z
 dependencies: []
-description: With a fancy description
+description: This is a development version of a rails philosophy inspired framework
+  for web applications functional testing. It supports (or will support) threading,
+  scenario parametrization, different test environments and much more. Stay tuned
+  for v.1.0.0 in the near future.
 email: bw@vouk.info
 executables:
 - moto
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/assert.rb
+- lib/cli.rb
 - lib/empty_listener.rb
-- lib/moto.rb
+- lib/page.rb
 - lib/result.rb
 - lib/runner.rb
+- lib/runner_logging.rb
 - lib/test.rb
+- lib/test_generator.rb
+- lib/test_logging.rb
 - lib/thread_context.rb
+- lib/clients/base.rb
+- lib/clients/website.rb
 - lib/listeners/base.rb
 - lib/listeners/console.rb
 - bin/moto
-homepage: http://vouk.info
+homepage: https://github.com/bwilczek/moto
 licenses:
 - MIT
 metadata: {}
@@ -50,5 +60,5 @@ rubyforge_project:
 rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
-summary: Moto - yet another testing framework
+summary: Moto - yet another web testing framework
 test_files: []

data/lib/moto.rb

@@ -1,42 +0,0 @@
-require 'logger'
-require 'yaml'
-require 'active_support/inflector'
-require 'active_support/core_ext/object/blank'
-
-require_relative '../lib/empty_listener'
-require_relative '../lib/runner'
-require_relative '../lib/thread_context'
-require_relative '../lib/result'
-require_relative '../lib/test'
-require_relative '../lib/listeners/base'
-require_relative '../lib/listeners/console'
-
-APP_DIR = Dir.pwd
-
-class MotoCliRunner
-
-  def self.run(argv)
-    t = argv[0]
-    t = 'MotoApp::Tests::'+t
-    a = t.underscore.split('/')
-    test_path = (a[1..20]+[a[-1]]).join('/')
-    
-    # TODO: check if this path and constat exists
-    require "#{APP_DIR}/#{test_path}"
-    test_const = t.safe_constantize
-    
-    tests = [
-      test_const.new
-    ]
-    
-    # parsing ARGV and creating config will come here
-    # instantiation of tests for ARGV params also happens here
-    # instantiate listeners/reporters
-    
-    # listeners = []
-    listeners = [Moto::Listeners::Console]
-    runner = Moto::Runner.new(tests, listeners, thread_cnt: 3, environments: [:qa2, :qa])
-    runner.run
-  end
-
-end