rubotium 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a668e6a758f73295484b33a8bb12d7787ace3669
+  data.tar.gz: 32bb1aedd3650eadb296d6cbe3c8030d85cbe013
+SHA512:
+  metadata.gz: e803e2b146f3654ef5b790f6e4c989b66afaf5aefd172c37c5c03b68ba43014d56ce1b7bd68af8123d84431d5fb953c2b895b4bd1c2f4f4a4c6294a99dd5987f
+  data.tar.gz: 999a97ea8be422f305648034fc05eab2dac5a12210bac25f1f7e0bb67c887d812773df18b75b75d00a890625cbf068a1847a54633877076aa9185fea4c268ae9

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rubotium.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Slawomir Smiechura
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+# Rubotium
+
+This is an Android's Instrumentation test runner. It's in quite early phase but already solves couple of issues with instrumentation tests: 
+ 
+ * runs tests in parallel
+ * retries failed tests
+ * does execute all the package tests even if the app dies during the execution
+
+## Installation
+
+    gem install rubotium
+
+## Usage
+
+    $ rubotium -t <path_to_tests.apk> -a <path_to_application.apk> -r <instrumentation_test_runner>
+    $ rubotium -h for help
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/rubotium/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/rubotium

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'rubotium'
+
+require 'trollop'
+opts = Trollop::options do
+    opt :test_jar_path,   'Path to the tests .jar file',  :type     => :string,       :short  =>  '-j'
+    opt :test_apk_path,   'Path to the tests .apk file',  :type     => :string,       :short  =>  '-t'
+    opt :app_apk_path,    'Path to the app   .apk file',  :type     => :string,       :short  =>  '-a'
+    opt :rerun,           'Retries count',                :default  => 0,             :short  =>  '-R'
+    opt :out,             'Report file',                  :default  => 'report.xml',  :short  =>  '-o'
+    opt :device,          'Match devices',                :type     => :string,       :short  =>  '-d'
+    opt :runner,          'Test runner',                  :type     => :string,       :short  =>  'r'
+end
+
+params = {
+    :tests_jar_path     => opts[:test_jar_path],
+    :tests_apk_path     => opts[:test_apk_path],
+    :app_apk_path       => opts[:app_apk_path],
+    :rerun_count        => opts[:rerun],
+    :report             => opts[:out],
+    :device_matcher     => opts[:device],
+    :runner             => opts[:runner]
+}
+
+Rubotium.new(params)

data/lib/rubotium/adb/command.rb

@@ -0,0 +1,21 @@
+module Rubotium
+  module Adb
+    class Command
+      def initialize(device_serial)
+        @device_serial = device_serial
+      end
+
+      def execute(command_to_run)
+        puts "EXECUTING_COMMAND: #{adb_command} #{command_to_run.executable_command}"
+        CMD.run_command(adb_command + " " + command_to_run.executable_command)
+      end
+
+      private
+      attr_reader :device_serial
+
+      def adb_command
+        "adb -s #{device_serial} "
+      end
+    end
+  end
+end

data/lib/rubotium/adb/devices.rb

@@ -0,0 +1,25 @@
+module Rubotium
+  module Adb
+    class Devices
+      attr_reader :list
+
+      def initialize
+        @list = parse(CMD.run_command('adb devices',{ :timeout => 5 } ))
+      end
+
+      private
+      def parse result
+        list = result.split("\n")
+        list.shift
+        attached_devices list
+      end
+
+      def attached_devices(list)
+        list.collect { |device|
+          parts = device.split("\t")
+          parts.last == 'device' ? parts.first : nil
+        }.compact
+      end
+    end
+  end
+end

data/lib/rubotium/adb/install_command.rb

@@ -0,0 +1,17 @@
+module Rubotium
+  module Adb
+    class InstallCommand
+      COMMAND = 'install'
+      def initialize(apk_path)
+        @apk_path = apk_path
+      end
+
+      def executable_command
+        "#{COMMAND} #{apk_path}"
+      end
+
+      private
+      attr_reader :apk_path
+    end
+  end
+end

data/lib/rubotium/adb/instrumentation.rb

@@ -0,0 +1,36 @@
+module Rubotium
+  module Adb
+    class NoTestRunnerError < StandardError; end
+    class NoTestPackageError < StandardError; end
+
+    class Instrumentation
+      attr_accessor :test_package_name, :test_runner
+      attr_reader :adb_shell
+
+      def initialize(device)
+        @adb_shell = Rubotium::Adb::Shell.new(device)
+      end
+
+      def run_test(runable_test)
+        check_packages
+        result = adb_shell.run_command(instrument_command(runable_test.package_name, runable_test.test_name))
+        TestResultParser.new(result, runable_test.package_name, runable_test.test_name)
+      end
+
+      private
+      def instrument_command package_name, test_name
+        "am instrument -w -e class #{class_test(package_name, test_name)} #{test_package_name}/#{test_runner}"
+      end
+
+      def class_test package_name, test_name
+        "#{package_name}##{test_name}"
+      end
+
+      def check_packages
+        raise NoTestRunnerError   if !test_runner
+        raise NoTestPackageError  if !test_package_name
+      end
+
+    end
+  end
+end

data/lib/rubotium/adb/shell.rb

@@ -0,0 +1,30 @@
+module Rubotium
+  module Adb
+    class Shell
+      ADB = 'adb'
+      attr_reader :device_serial
+
+      def initialize(device_serial)
+        @device_serial = device_serial
+      end
+
+      def run_command command_to_run
+        CMD.run_command(command + " " + command_to_run)
+      end
+
+      private
+        def command
+          [ADB, device, 'shell'].compact.join(" ")
+        end
+
+        def device
+          if device_serial && !device_serial.empty?
+            ['-s', device_serial]
+          else
+            nil
+          end
+        end
+
+    end
+  end
+end

data/lib/rubotium/adb/test_result_parser.rb

@@ -0,0 +1,87 @@
+module Rubotium
+  module Adb
+    class TestResultParser
+      ERROR_STATUS = 'ERROR'
+      FAIL_STATUS  = 'FAIL'
+      OK_STATUS    = 'OK'
+
+      attr_reader :result, :stack_trace, :time, :error_message, :status, :package_name, :test_name
+
+      def initialize(result, package_name, test_name)
+        @result       = result
+        @package_name = package_name
+        @test_name    = test_name
+        parse
+      end
+
+      def failed?
+        @status == FAIL_STATUS
+      end
+
+      def passed?
+        @status == OK_STATUS
+      end
+
+      def errored?
+        @status == ERROR_STATUS
+      end
+
+      private
+        def parse
+          if ENV['DEBUG']
+            p result
+          end
+          @stack_trace    = has_failed?   ? get_stack_trace : ""
+          @status         = get_status
+          @time           = has_errored?  ? 0 : get_time
+          @error_message  = has_errored?  ? get_error : ""
+        end
+
+        def get_status
+          if has_errored?
+            ERROR_STATUS
+          elsif has_failed?
+            FAIL_STATUS
+          else
+            OK_STATUS
+          end
+        end
+
+        def has_errored?
+          ['INSTRUMENTATION_ABORTED', 'INSTRUMENTATION_RESULT','INSTRUMENTATION_STATUS'].any? {|error_message|
+            result.include? error_message
+          }
+        end
+
+        def has_failed?
+          result.include? 'FAILURES'
+        end
+
+        def get_time
+          result.match(/Time: (-?\d+.\d+)/)[1].to_f.abs
+        end
+
+        def get_stack_trace
+          result.split("\r\n\r\n")[0].split(/^/)[3..-1].join
+        end
+
+        def get_error
+          if instrumentation_error
+            result.match(/INSTRUMENTATION_RESULT: longMsg=(.*)\r/)[1]
+          elsif application_error
+            result.match(/INSTRUMENTATION_ABORTED: (.*)/)[1]
+          else
+            result.match(/INSTRUMENTATION_STATUS: Error=(.*)\r/)[1]
+          end
+        end
+
+        def application_error
+          result.match(/INSTRUMENTATION_ABORTED/) != nil
+        end
+
+        def instrumentation_error
+          result.match(/INSTRUMENTATION_RESULT: longMsg/) != nil
+        end
+    end
+  end
+end

data/lib/rubotium/adb/uninstall_command.rb

@@ -0,0 +1,17 @@
+module Rubotium
+  module Adb
+    class UninstallCommand
+      COMMAND = 'uninstall'
+      def initialize(package_name)
+        @package_name = package_name
+      end
+
+      def executable_command
+        "#{COMMAND} #{package_name}"
+      end
+
+      private
+      attr_reader :package_name
+    end
+  end
+end

data/lib/rubotium/adb.rb

@@ -0,0 +1,13 @@
+require_relative 'adb/command'
+require_relative 'adb/install_command'
+require_relative 'adb/uninstall_command'
+require_relative 'adb/devices'
+require_relative 'adb/test_result_parser'
+require_relative 'adb/shell'
+require_relative 'adb/instrumentation'
+
+module Rubotium
+  module Adb
+
+  end
+end

data/lib/rubotium/apk/converter.rb

@@ -0,0 +1,22 @@
+require 'dex2jar'
+module Rubotium
+  module Apk
+    class Converter
+      def initialize(apk_path, output_path)
+        @apk_path     = apk_path
+        @output_path  = output_path
+      end
+
+      def convert_to_jar
+        Dex2jar.execute("-f -o #{output_path}", [apk_path])
+      end
+
+      private
+      attr_reader :apk_path, :output_path
+
+      def file_exists?
+        File.exist? apk_path
+      end
+    end
+  end
+end

data/lib/rubotium/apk.rb

@@ -0,0 +1,7 @@
+require_relative 'apk/converter'
+
+module Rubotium
+  module Apk
+
+  end
+end

data/lib/rubotium/cmd.rb

@@ -0,0 +1,17 @@
+require 'timeout'
+module Rubotium
+  class CMD
+    class << self
+      def run_command(command_to_run, opts = {})
+        begin
+          Timeout::timeout(opts[:timeout] || 10 * 60) {
+            puts "[EXECUTING]: #{command_to_run}" if ENV['DEBUG']
+            `#{command_to_run}`
+          }
+        rescue Timeout::Error
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/rubotium/device.rb

@@ -0,0 +1,49 @@
+module Rubotium
+  class Device
+    attr_accessor :testsuite
+    attr_reader   :serial, :results
+    def initialize(serial, test_runner)
+      @runner   = test_runner
+      @retry    = 1
+      @serial   = serial
+      @results  = {}
+      @command  = Rubotium::Adb::Command.new(serial)
+    end
+
+    def test_runner_name= name
+      runner.test_runner = name
+    end
+
+    def test_package_name= name
+      runner.test_package_name = name
+    end
+
+    def install(apk_path)
+      command.execute(Rubotium::Adb::InstallCommand.new(apk_path))
+    end
+
+    def uninstall(package_name)
+      command.execute(Rubotium::Adb::UninstallCommand.new(package_name))
+    end
+
+    def run_tests
+      raise(NoTestSuiteError, "Please setup test suite before running tests") if testsuite.nil?
+      puts "Running tests"
+      testsuite.each{|runable_test|
+        @results[runable_test.package_name] = []
+        puts runable_test.name
+        run_count = 0
+        puts "TEST: #{runable_test.name}"
+        while ((result = runner.run_test(runable_test)) && (result.failed? || result.errored?) && run_count < @retry ) do
+            puts "RERUNNING TEST: #{runable_test.name}, STATUS: #{result.status}"
+            run_count += 1
+          end
+        puts "FINISHED with status: #{result.status}"
+          @results[runable_test.package_name].push(result)
+      }
+    end
+
+    private
+    attr_reader :runner, :command
+  end
+end

data/lib/rubotium/devices.rb

@@ -0,0 +1,25 @@
+module Rubotium
+  class Devices
+    def initialize(device_matcher = '')
+      @attached_devices = Adb::Devices.new.list
+      @matched          = matched_devices device_matcher
+    end
+
+    def all
+      raise NoDevicesError if attached_devices.empty?
+      raise NoMatchedDevicesError if matched.empty?
+      matched.map{|device|
+        Device.new(device, Adb::Instrumentation.new(device))
+      }
+    end
+
+    private
+      attr_reader :matched, :attached_devices
+
+      def matched_devices(device_matcher)
+        device_matcher ? attached_devices.select{|device|
+          device.include? device_matcher
+        } : attached_devices
+      end
+  end
+end

data/lib/rubotium/formatters/junit_formatter.rb

@@ -0,0 +1,82 @@
+require 'builder'
+
+module Rubotium
+  module Formatters
+    class JunitFormatter
+      attr_reader :xml
+      def initialize(results, path_to_file)
+        @xml = Builder::XmlMarkup.new :target => ensure_io(path_to_file), :indent => 2
+
+        xml.testsuites do
+          results.each{|package_name, tests|
+            start_test_suite(package_name, tests)
+          }
+        end
+      end
+      private
+        def start_test_suite(package_name, tests)
+          failures    = get_failures(tests)
+          errors      = get_errors(tests)
+          tests_time  = get_tests_time(tests)
+          tests_count = tests.count
+          params = {
+                    :errors     => errors,
+                    :failures   => failures,
+                    :name       => package_name,
+                    :tests      => tests_count,
+                    :time       => tests_time,
+                    :timestamp  => Time.now
+          }
+
+          xml.testsuite(params) do
+            tests.each { |test|
+              print_testcase(test)
+            }
+          end
+        end
+
+        def print_testcase(test)
+          xml.testcase :classname=>test.package_name, :name=>test.test_name, :time=>test.time do
+            has_failures(test)
+            has_errors(test)
+          end
+        end
+
+        def has_failures(test)
+          if test.failed?
+            xml.failure :message=>"", :type=>"" do
+              xml.cdata! test.stack_trace
+            end
+          end
+        end
+
+        def has_errors(test)
+          if test.errored?
+            xml.error :message=>"", :type=>"" do
+              xml.cdata! test.error_message
+            end
+          end
+        end
+
+        def get_tests_time(tests)
+          tests.inject(0){|time_sum, test| time_sum += test.time.to_f }
+        end
+
+        def get_errors(tests)
+          tests.select{|test|
+            test.errored?
+          }.count
+        end
+
+        def get_failures(tests)
+          tests.select{|test|
+            test.failed?
+          }.count
+        end
+
+        def ensure_io(path_to_file)
+          File.open(path_to_file, 'w')
+        end
+    end
+  end
+end

data/lib/rubotium/grouper.rb

@@ -0,0 +1,40 @@
+module Rubotium
+  class Grouper
+    def initialize(test_suites, num_of_groups)
+      @test_suites   = test_suites
+      @num_of_groups = num_of_groups
+    end
+
+    def create_groups
+      runnable_tests.each{|runnable|
+        next_bucket.push(runnable)
+      }
+      buckets
+    end
+
+    def runnable_tests
+      test_suites.map {|test_suite|
+        test_suite.test_cases.map{|test|
+          RunableTest.new(test_suite.name, test.name)
+        }
+      }.flatten
+    end
+
+    def next_bucket
+      buckets_enum.next
+    end
+
+    def buckets_enum
+      @buckets_enum ||= buckets.cycle
+    end
+
+
+    def buckets
+      @buckets ||= Array.new(num_of_groups) { [] }
+    end
+
+    private
+    attr_reader :test_suites, :num_of_groups
+
+  end
+end

data/lib/rubotium/jar_reader.rb

@@ -0,0 +1,70 @@
+require 'set'
+module Rubotium
+  class JarReader
+    TEST_PATTERN = Regexp.new('public void (test.*)\(')
+    attr_reader :path_to_jar
+
+    def initialize(jar_path)
+      @path_to_jar = jar_path
+    end
+
+    def test_suites
+      Converter.new(classes_in_jar).convert
+    end
+
+    def get_tests
+      parse
+    end
+
+    private
+    def classes_in_jar
+      CMD.run_command("jar -tf #{path_to_jar} | grep '.class'")
+    end
+
+    def tests_in_class(suite_name)
+      CMD.run_command "javap -classpath #{path_to_jar} #{suite_name}"
+    end
+
+    def parse
+      test_suites.map{|test_suite|
+        tests_in_class(test_suite.name).scan(TEST_PATTERN).flatten.each{|test|
+          test_suite.add_test_case(TestCase.new(test))
+        }
+        test_suite
+      }.delete_if{|test_suite| test_suite.test_cases.empty?}
+    end
+
+
+    class Converter
+      attr_reader :list
+      def initialize(list_of_classes)
+        @list = list_of_classes.split
+      end
+
+      def convert
+        deduplicated_test_suites
+      end
+
+      private
+      def test_suites
+        converted_class_names.map{|class_name|
+          TestSuite.new(class_name)
+        }
+      end
+
+      def converted_class_names
+        list.map{|class_name|
+          class_name.gsub("/", ".")
+            .gsub(".class", "")
+            .gsub(/\$.*/, "")
+        }
+      end
+
+      def deduplicated_test_suites
+        test_suites.uniq{|test_suite|
+          test_suite.name
+        }
+      end
+    end
+  end
+end