moto 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e048efe2a7dae21ba01da0503fdeb40e56755827
+  data.tar.gz: 00882f74920d1fab0729c015e8260ecba2b115ff
+SHA512:
+  metadata.gz: 8b89e9d40644d2a751c9e4fd7455d40395f3c2a7d682cec532e6ac8dd9cf02497338e26952ae8156eee510d9289a21dc61f286fcb8c071e29400d9f2fb88931f
+  data.tar.gz: e8710637b4dbbb2ccd4e2d9412f932033e79fc7baee4713b82926a4e6ac5c83732b1b76f9a02521bb714cc1835ea436171f3d7677a4e339bddcdb18b6ddca3ed

data/bin/moto

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'moto'
+MotoCliRunner.run ARGV

data/lib/empty_listener.rb

@@ -0,0 +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
+end

data/lib/listeners/base.rb

@@ -0,0 +1,26 @@
+module Moto
+  module Listeners
+    class Base
+      
+      def initialize(runner)
+        @runner=runner
+      end
+      
+      def start_run
+        # abstract
+      end
+      
+      def end_run
+        # abstract
+      end
+      
+      def start_test(test)
+        # abstract
+      end
+  
+      def end_test(test)
+        # abstract
+      end      
+    end
+  end
+end

data/lib/listeners/console.rb

@@ -0,0 +1,23 @@
+module Moto
+  module Listeners
+    class Console < Base
+
+      def start_run
+        @runner.logger.info("Starting...")
+      end
+      
+      def end_run
+        @runner.logger.info("...done: #{@runner.result.summary[:result]}, duration: #{@runner.result.summary[:duration]}")
+      end
+
+      def start_test(test)
+        @runner.logger.info("Starting test #{test.name}")
+      end
+  
+      def end_test(test)
+        @runner.logger.info("Ending test #{test.name} with result #{@runner.result[test.name][:result]}")
+      end
+
+    end
+  end
+end

data/lib/moto.rb

@@ -0,0 +1,42 @@
+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

data/lib/result.rb

@@ -0,0 +1,59 @@
+module Moto
+  class Result
+    
+    PENDING = :pending # -2
+    RUNNING = :running # -1
+    PASSED = :passed # 0
+    FAILURE = :failure # 1
+    ERROR = :error # 2
+
+    attr_reader :summary
+
+    def [](key)
+      @results[key]
+    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[:error].nil? }.empty?
+      # TODO: calculate count and percentage of errors/failures
+    end
+    
+    def start_test(test)
+      @results[test.name] = { class: test.class, result: RUNNING, env: nil, params: nil, name: test.name, error: nil, failures: [] } 
+    end
+
+    def end_test(test)
+      # calculate result basing on errors/failures
+      test.result = PASSED
+      test.result = FAILURE unless @results[test.name][:failures].empty?
+      test.result = ERROR unless @results[test.name][:error].nil?
+      @results[test.name][:result] = test.result
+      test.logger.info("Result: #{test.result}")
+    end
+
+    def add_failure(test, msg)
+      @results[test.name][:failures] << msg
+    end
+    
+    def add_error(test, e)
+      
+    end
+    
+  end
+end

data/lib/runner.rb

@@ -0,0 +1,52 @@
+module Moto
+  class Runner
+    
+    attr_reader :result
+    attr_reader :listeners
+    attr_reader :logger
+    attr_reader :environments
+    
+    def initialize(tests, listeners, config = {})
+      @tests = tests
+      @config = config
+      @threads = []
+      
+      # TODO: initialize logger from config (yml or just ruby code)
+      @logger = Logger.new(STDOUT)
+      # @logger.level = Logger::WARN
+      
+      @result = Moto::Result.new(self)
+      
+      # TODO: validate envs, maybe no-env should be supported as well?
+      @environments = config[:environments]
+      
+      @listeners = []
+      listeners.each do |l|
+        @listeners << l.new(self)
+      end
+      @listeners.unshift(@result)
+    end
+    
+    def run
+      @listeners.each { |l| l.start_run }
+      test_slices = @tests.each_slice((@tests.size.to_f/@config[:thread_cnt]).ceil).to_a
+      (0...test_slices.count).each do |i|
+        @threads << Thread.new do
+          tc = ThreadContext.new(self, test_slices[i])
+          tc.run
+        end
+      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
+end

data/lib/test.rb

@@ -0,0 +1,71 @@
+module Moto
+  class Test
+    
+    attr_writer :context
+    attr_accessor :result
+    attr_reader :name
+
+    class << self
+      attr_accessor :_path
+    end
+    
+    def self.inherited(k)
+      k._path = caller.first.match( /(.+):\d+:in/ )[1]
+    end
+    
+    def path
+      self.class._path
+    end
+    
+    def initialize
+      # @context = context
+      @result = Moto::Result::PENDING
+    end
+
+    def init(env, params)
+      @env = env
+      @params = params
+      set_name
+    end
+
+    def logger
+      @context.logger
+    end
+
+    def set_name
+      return @name = "#{self.class.to_s}/#{@env}" if @params.empty?
+      return @name = "#{self.class.to_s}/#{@env}/#{@params[:__name]}" if @params.key?(:__name)
+      @name = self.class.to_s
+    end
+
+    def dir
+      # puts self.class.path
+      File.dirname(self.path)
+    end
+    
+    def filename
+      File.basename(path, ".*")
+    end
+
+    def run
+      # abstract
+    end
+
+    def before
+      # abstract
+    end
+
+    def after
+      # abstract
+    end
+
+    def assert(*args)
+      @context.runner.assert(self,*args)
+    end
+
+    def client(name)
+      @context.client(name)
+    end
+
+  end
+end

data/lib/thread_context.rb

@@ -0,0 +1,54 @@
+module Moto
+  class ThreadContext
+    
+    # all resources specific for single thread will be initialized here. E.g. browser session
+    attr_reader :runner
+    attr_reader :logger
+    
+    def initialize(runner, tests)
+      @runner = runner
+      @tests = tests
+      @tests.each do |t|
+        t.context = self
+      end
+    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      
+    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.each do |params|
+            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))
+            # TODO: make logger level configurable
+            # @logger.level = Logger::INFO
+            @current_test = test
+            @runner.listeners.each { |l| l.start_test(test) }
+            test.before
+            # TODO: handle exception thrown during test run
+            test.run
+            test.after
+            @runner.listeners.each { |l| l.end_test(test) }
+            @logger.close
+          end
+        end
+      end
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: moto
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Bartek Wilczek
+- Maciej Przybylski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-07 00:00:00.000000000 Z
+dependencies: []
+description: With a fancy description
+email: bw@vouk.info
+executables:
+- moto
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/empty_listener.rb
+- lib/moto.rb
+- lib/result.rb
+- lib/runner.rb
+- lib/test.rb
+- lib/thread_context.rb
+- lib/listeners/base.rb
+- lib/listeners/console.rb
+- bin/moto
+homepage: http://vouk.info
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Moto - yet another testing framework
+test_files: []