rubotium 0.0.7 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72623c02c54541abecf0431da8b66994b1404a95
-  data.tar.gz: 25d93c5df3c122e59a6fe66f9d848c5be3744556
+  metadata.gz: d1b0f0bd231baeeb352f147b7eed2517a2bbf3c0
+  data.tar.gz: c7cfcc8c601126f54bc4dfea8c6a11575cfb7f40
 SHA512:
-  metadata.gz: f42c5267c1aba6a11a8d6e2b5b7d8c813a1690e3479544294847b4c91474e30ae65ec8407685e7bd0fa7c679c146d6cedb5787d5bbc28fefb71b28f2b5341926
-  data.tar.gz: edd630a22f94aa3004f3287b031a40bf3ada2de15e5db653c488016941d868cc44dd9f0e983eba2b5e1a8db96da9b1e8a512dd6e59c84c5e0c7e5d8d91bc3060
+  metadata.gz: e22610e5725858e4c8a5af4e9868e1fc5ed7dc03c229a393239e153c76bf62b122bbaa3273435530892d38b01ed6e6feeed82e9275f7b24f4f2f993ad027be8f
+  data.tar.gz: 4a976b43dfdd6ebd0105bbcce1742897256b01bc3aaa457c7ede59db7b66325039e0c7a8e2c6d52b2a0c7a7bf7853bd26ebf8d087eae9147202e816279e38015

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+- "1.9.2"
+- "1.9.3"
+- "2.1.1"
+script: bundle exec rspec spec
+addons:
+  code_climate:
+    repo_token:
+      secure: f16d367e3357b0375c13e49094a99c656921d3dc0e24a8aa6899e7ad330f857e
+

data/README.md

@@ -1,3 +1,7 @@
+[![Build Status](https://travis-ci.org/ssmiech/rubotium.svg?branch=master)](https://travis-ci.org/ssmiech/rubotium)
+[![Code Climate](https://codeclimate.com/github/ssmiech/rubotium/badges/gpa.svg)](https://codeclimate.com/github/ssmiech/rubotium)
+[![Coverage Status](https://coveralls.io/repos/ssmiech/rubotium/badge.svg?branch=master)](https://coveralls.io/r/ssmiech/rubotium?branch=master)
+
 # Rubotium
 
 This is an Android's Instrumentation test runner. It's in quite early phase but already solves couple of issues with instrumentation tests: 

data/bin/rubotium

@@ -10,19 +10,25 @@ opts = Trollop::options do
     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 :sdk,             'Run on devices with sdk',      :type     => :string,       :short  =>  '-k'
     opt :runner,          'Test runner',                  :type     => :string,       :short  =>  '-r'
     opt :annotation,      'Run annotated tests',          :type     => :string,       :short  =>  '-n'
+    opt :helper_apk_path, 'Path to the helper .apk file', :type     => :string,       :short  =>  '-H'
+    opt :serial,          'Device serial',                :type     => :string,       :short  =>  '-s'
 end
 
 params = {
+    :serial             => opts[:serial],
     :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],
+    :device_sdk         => opts[:sdk],
     :runner             => opts[:runner],
-    :annotation         => opts[:annotation]
+    :annotation         => opts[:annotation],
+    :helper_apk_path    => opts[:helper_apk_path]
 }
 
 Rubotium.new(params)

data/lib/rubotium/adb/commands/command.rb

@@ -6,6 +6,14 @@ module Rubotium
           @device_serial = device_serial
         end
 
+        def clean_logcat
+          execute(logcat_command(:clean => true))
+        end
+
+        def logcat
+          execute(logcat_command(:dump => true))
+        end
+
         def install(apk_path)
           execute(install_command(apk_path))
         end
@@ -18,20 +26,36 @@ module Rubotium
           execute(pull_command(files_glob))
         end
 
+        def push(local_glob, remote_dest)
+          execute(push_command(local_glob, remote_dest))
+        end
+
         def shell(command)
           execute(shell_command(command))
         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)
+          commands = command_to_run.executable_command
+          puts "EXECUTING_COMMAND: #{adb_command} #{commands}"
+
+          begin
+            commands.each do |command|
+              CMD.run_command(adb_command + ' ' + command)
+            end
+          rescue NoMethodError
+            CMD.run_command(adb_command + ' ' + commands)
+          end
         end
 
         private
         attr_reader :device_serial
 
         def adb_command
-          "adb -s #{device_serial} "
+          if device_serial.nil? || device_serial == ''
+            'adb'
+          else
+            "adb -s #{device_serial}"
+          end
         end
 
         def install_command(apk_path)
@@ -46,9 +70,17 @@ module Rubotium
           Rubotium::Adb::Commands::PullCommand.new(files_glob)
         end
 
+        def push_command(local_glob, remote_dest)
+          Rubotium::Adb::Commands::PushCommand.new(local_glob, remote_dest)
+        end
+
         def shell_command(command)
           Rubotium::Adb::Commands::ShellCommand.new(command)
         end
+
+        def logcat_command(options = {})
+          Rubotium::Adb::Commands::LogcatCommand.new(options)
+        end
       end
     end
   end

data/lib/rubotium/adb/commands/logcat_command.rb

@@ -0,0 +1,24 @@
+module Rubotium
+  module Adb
+    module Commands
+      class LogcatCommand
+        COMMAND = 'logcat'
+        def initialize(options)
+          @clean = options.delete(:clean) ? '-c' : ''
+          @dump  = options.delete(:dump) ? '-d' : ''
+        end
+
+        def executable_command
+          "#{COMMAND} #{options}"
+        end
+
+        private
+        attr_reader :clean, :dump
+
+        def options
+          [clean, dump].join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/rubotium/adb/commands/push_command.rb

@@ -0,0 +1,24 @@
+module Rubotium
+  module Adb
+    module Commands
+      class PushCommand
+        COMMAND = 'push'
+
+        def initialize(local_glob, remote_dest)
+          @local_paths = Dir[local_glob]
+          @remote_dest = remote_dest
+        end
+
+        def executable_command
+          local_paths.map do |path|
+            "#{COMMAND} #{path} #{remote_dest}"
+          end
+        end
+
+        private
+        attr_reader :local_paths
+        attr_reader :remote_dest
+      end
+    end
+  end
+end

data/lib/rubotium/adb/commands.rb

@@ -3,5 +3,7 @@ require_relative 'commands/install_command'
 require_relative 'commands/instrument_command'
 require_relative 'commands/memory_command'
 require_relative 'commands/pull_command'
+require_relative 'commands/push_command'
 require_relative 'commands/shell_command'
 require_relative 'commands/uninstall_command'
+require_relative 'commands/logcat_command'

data/lib/rubotium/adb/parsers/test_results_parser.rb

@@ -1,3 +1,5 @@
+require 'time'
+
 module Rubotium
   module Adb
     module Parsers
@@ -31,7 +33,7 @@ module Rubotium
         end
 
         def time
-          match_time.strip
+          match_time.strip.to_f
         end
 
         def message

data/lib/rubotium/apk/aapt.rb

@@ -0,0 +1,9 @@
+module Rubotium
+  module Apk
+    class Aapt
+      def dump(path)
+        CMD.run_command("aapt dump badging \"" + path + "\" 2>&1")
+      end
+    end
+  end
+end

data/lib/rubotium/apk/android_apk.rb

@@ -5,13 +5,18 @@ module Rubotium
     require "tmpdir"
     require "pp"
     class AndroidApk
+      attr_reader :aapt
       attr_accessor :results,:label,:labels,:icon,:icons,:package_name,:version_code,:version_name,:sdk_version,:target_sdk_version,:filepath
-      def initialize(path_to_apk)
+      def initialize(aapt = Aapt.new, path_to_apk)
+        @aapt = aapt
         @path = path_to_apk
         raise(Errno::ENOENT, "File does not exist") unless File.exist?(@path)
       end
 
       def package_name
+        if parsed_aapt['package'].nil?
+          raise RuntimeError.new('ERROR: dump failed because no AndroidManifest.xml found')
+        end
         parsed_aapt['package']['name']
       end
 
@@ -20,12 +25,11 @@ module Rubotium
       end
 
       def results
-        command = "aapt dump badging \"" + @path + "\" 2>&1"
-        results = `#{command}`
-        if $?.exitstatus != 0 or results.index("ERROR: dump failed")
-          raise(RuntimeError, results)
+        @results ||= aapt.dump(@path)
+        if $?.exitstatus != 0 or @results.index("ERROR: dump failed")
+          raise(RuntimeError, @results)
         end
-        @results ||= results
+        @results
       end
 
       def parsed_aapt

data/lib/rubotium/apk.rb

@@ -1,4 +1,5 @@
 require_relative 'apk/android_apk'
+require_relative 'apk/aapt'
 
 module Rubotium
   module Apk

data/lib/rubotium/device.rb

@@ -1,6 +1,6 @@
 module Rubotium
   class Device
-    attr_reader   :serial
+    attr_reader   :serial, :sdk
     def initialize(serial)
       @serial     = serial
     end
@@ -9,6 +9,18 @@ module Rubotium
       @name ||= adb_command.shell('getprop ro.product.model').strip
     end
 
+    def sdk
+      @sdk ||= adb_command.shell('getprop ro.build.version.sdk').strip
+    end
+
+    def clean_logcat
+      adb_command.clean_logcat
+    end
+
+    def logcat
+      adb_command.logcat
+    end
+
     def install(apk_path)
       adb_command.install(apk_path)
     end

data/lib/rubotium/devices.rb

@@ -3,16 +3,22 @@ module Rubotium
     def initialize(options = {})
       @match_serial = options[:serial]  || ''
       @match_name   = options[:name]    || ''
+      @match_sdk    = options[:sdk]     || ''
     end
 
     def all
       raise NoDevicesError if attached_devices.empty?
-      raise NoMatchedDevicesError if matched_by_name.empty?
-      (matched_by_name + matched_by_serial).uniq
+      raise NoMatchedDevicesError if matched_devices.nil? or matched_devices.empty?
+      matched_devices
     end
 
+
     private
-    attr_reader :matched, :attached_devices, :match_name, :match_serial
+    attr_reader :matched, :attached_devices, :match_name, :match_serial, :match_sdk
+
+    def matched_devices
+      @matched_devices ||=[matched_by_name, matched_by_serial, matched_by_sdk].reject( &:empty? ).reduce( :& )
+    end
 
     def attached_devices
       @attached_devices ||= adb_devices.attached
@@ -30,6 +36,12 @@ module Rubotium
       }
     end
 
+    def matched_by_sdk
+      attached_devices.select { |device|
+        device.sdk.eql? match_sdk
+      }
+    end
+
     def adb_devices
       Adb::Devices.new
     end

data/lib/rubotium/formatters/html_formatter.css

@@ -0,0 +1,97 @@
+body {
+    margin: 0 auto;
+    padding: 0;
+    text-align: left;
+    height: 100%;
+    font-family: myriad, arial, tahoma, verdana, sans-serif;
+    color: #151515;
+    font-size: 90%;
+    line-height: 1.3em;
+    background-color: #fff;
+}
+
+ul {
+    list-style: none;
+}
+
+#header {
+    padding: 0;
+    position: fixed;
+    width: 100%;
+    z-index: 10;
+    background-color: #c7ceda;
+}
+
+#header .time {
+    margin-top: 2.2em;
+    margin-right: 3.4em;
+    float: right;
+}
+
+#header h1 {
+    margin: 1em 3em 1em 1.7em;
+    color: #151515;
+    font-size: 180%;
+    line-height: 1.1em;
+    font-weight: bold;
+}
+.testsuite {
+    margin: 5px;
+}
+
+.testsuite > div {
+    padding: .5em 0 .5em 1em;
+    background-color: #f2f2f2;
+    font-size: 120%;
+    color: #151515;
+    font-weight: bold;
+}
+
+span.error {
+    color: #ff0000;
+}
+
+span.passed {
+    color: #1d9d01;
+}
+
+#content {
+    padding: 112px 2.5em 2em 1.7em;
+}
+
+.test_case > div{
+    padding: .5em 0 .5em 1em;
+    color: #0046b0;
+    font-size: 100%;
+    font-weight: bold;
+    border-bottom: solid 1px #dbdbdb;
+}
+
+.test_case .time {
+    margin-right: .5em;
+    width: 5em;
+    text-align: right;
+    font-size: 13px;
+    color: #151515;
+    font-style: normal;
+    font-weight: normal;
+    float: right;
+}
+
+#testsuites .passed {
+    border-left: solid 10px #93e078;
+}
+
+#testsuites .failed {
+    border-left: solid 10px #ff0000;
+}
+
+.stderr {
+    color: #8b0000 !important;
+    font-size: 80% !important;
+    font-weight: normal !important;
+    overflow-x: auto;
+    cursor: auto !important;
+    background: none !important;
+    border: none !important;
+}

data/lib/rubotium/formatters/html_formatter.rb

@@ -0,0 +1,181 @@
+require 'builder'
+require 'uri'
+
+module Rubotium
+  module Formatters
+    class HtmlFormatter
+      attr_reader :html
+      def initialize(results, path_to_file)
+        @test_results          = results
+        @report_file_path = path_to_file
+
+        @html = Builder::XmlMarkup.new :target => ensure_io(report_path), :indent => 2
+        inline_css
+        add_header
+        add_body
+        add_footer
+      end
+
+      private
+      attr_reader :report_file_path, :device_serial, :test_results
+
+      def inline_css
+        # html.link(:rel=>"stylesheet", :href=> (File.dirname(__FILE__) + '/html_formatter.css'))
+        html.style(:type => 'text/css') do
+          html << File.read(File.dirname(__FILE__) + '/html_formatter.css')
+        end
+      end
+
+      def add_header
+        html.div(:id => 'header') do
+          display_time
+          display_info
+        end
+      end
+
+      def display_info
+        html.h1 do
+          html.text('All tests:')
+          html.strong do
+            html.span("#{test_results.total} total,")
+            html.span("#{test_results.passed} passed,", { :class => 'passed' })
+            html.span("#{test_results.failed} failed", { :class => 'error' }) if test_results.failed
+
+          end
+        end
+      end
+
+      def display_time
+        html.div(format_time(test_results.time.to_i), { :class => 'time' })
+      end
+
+      def add_body
+        html.body do
+          add_content
+        end
+      end
+
+      def add_footer
+
+      end
+
+      def add_content
+        html.div(:id => 'content') do
+          html.ul(:id => 'testsuites') do
+            test_results.each{|suite|
+              start_test_suite(suite)
+            }
+          end
+        end
+      end
+
+      def start_test_suite(suite)
+          html.li(:class => 'testsuite') do
+            html.div(:class => suite.state) do
+              html.span(suite.name)
+            end
+
+            html.ul do
+              suite.each_test { |test|
+                html << TestCaseHtml.new(test).target
+              }
+            end
+
+          end
+      end
+
+      def report_path
+        report_file_path
+      end
+
+      def ensure_io(path_to_file)
+        File.open(path_to_file, 'w')
+      end
+
+      def format_time(seconds)
+        return '0 s' if seconds == 0
+        [[60, :s], [60, :m], [24, :h]].map{ |count, name|
+          if seconds > 0
+            seconds, n = seconds.divmod(count)
+            "#{n.to_i} #{name}"
+          end
+        }.compact.reverse.join(' ')
+      end
+
+      class TestCaseHtml
+        def initialize(test_result)
+          @test_result = test_result
+          @builder = Builder::XmlMarkup.new(:indent => 2)
+        end
+
+        def target
+          html
+        end
+
+        private
+        attr_reader :test_result, :builder
+
+        def html
+          builder.li(:class => 'test_case') do
+            print_name
+            builder.ul do
+              unless test_result.passed?
+                print_stacktrace
+                print_logcat
+                print_screen_record if File.exist?(File.join(Dir.pwd, 'results', video_file))
+              end
+            end
+          end
+        end
+
+        def print_stacktrace
+          builder.li(:class => 'stderr') do
+            test_result.stack_trace.each_line{|line|
+              builder.br
+              builder.span(line)
+            }
+          end
+        end
+
+        def print_logcat
+          builder.li(:class => 'logcat') do
+            builder.a("full log", :href => URI.encode(logcat_file))
+          end
+        end
+
+        def print_screen_record
+          builder.li(:class => 'screencast') do
+            builder.video({ :width => "240", :height => "320", :controls => true }) do
+              builder.source({ :src => URI.encode(video_file), :type => "video/mp4" })
+            end
+          end
+        end
+
+        def print_name
+          builder.div(:class => test_result.passed? ? 'passed' : 'failed') do
+            builder.div(format_time(test_result.time), { :class => 'time' })
+            builder.span(test_result.test_name)
+          end
+        end
+
+        def logcat_file
+          "logs/#{test_result.name}.log"
+        end
+
+        def video_file
+          "screencasts/#{test_result.name}.mp4"
+        end
+
+        def format_time(seconds)
+          return '0 s' if seconds == 0
+          [[60, :s], [60, :m], [24, :h]].map{ |count, name|
+            if seconds > 0
+              seconds, n = seconds.divmod(count)
+              "#{n.to_i} #{name}"
+            end
+          }.compact.reverse.join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/rubotium/screencast/recorder.rb

@@ -0,0 +1,43 @@
+module Rubotium
+  class Recorder
+    SIGINT = 'SIGINT'
+
+    def initialize(device_serial)
+      @serial = device_serial
+    end
+
+    def start(test_name)
+      @pid = Process.spawn(record_command(test_name))
+      puts "Starting screencast, PID: #{@pid}"
+    end
+
+    def record_command(test_name)
+      "adb -s #{serial} shell screenrecord /sdcard/screencasts/#{test_name}.mp4"
+    end
+
+    def stop
+      puts "Stopping screencast, PID: #{@pid}"
+      kill_children
+      kill_self
+    end
+
+    private
+    attr_reader :serial
+
+    def kill_self
+      Process.kill(SIGINT, @pid)
+    end
+
+    def kill_children
+      find_child_processes.each{|pid|
+        if pid > 0
+          Process.kill(SIGINT, pid)
+        end
+      }
+    end
+
+    def find_child_processes
+      `pgrep -P #{@pid}`.each_line.map(&:strip).map(&:to_i)
+    end
+  end
+end

data/lib/rubotium/screencast.rb

@@ -0,0 +1 @@
+require_relative 'screencast/recorder'

data/lib/rubotium/test_result.rb

@@ -9,6 +9,10 @@ module Rubotium
       @test_name      = runnable_test.test_name
     end
 
+    def name
+      "#{class_name}##{test_name}"
+    end
+
     def stack_trace
       if(failed_run?)
         parsed_result.message