rubotium 0.0.4 → 0.0.7

data/lib/rubotium/device.rb

@@ -1,49 +1,35 @@
 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)
+    attr_reader   :serial
+    def initialize(serial)
+      @serial     = serial
     end
 
-    def test_runner_name= name
-      runner.test_runner = name
-    end
-
-    def test_package_name= name
-      runner.test_package_name = name
+    def name
+      @name ||= adb_command.shell('getprop ro.product.model').strip
     end
 
     def install(apk_path)
-      command.execute(Rubotium::Adb::InstallCommand.new(apk_path))
+      adb_command.install(apk_path)
     end
 
     def uninstall(package_name)
-      command.execute(Rubotium::Adb::UninstallCommand.new(package_name))
+      adb_command.uninstall(package_name)
+    end
+
+    def pull(path)
+      adb_command.pull(path)
     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] = [] if(@results[runable_test.package_name].nil?)
-        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)
-      }
+    def shell(command)
+      adb_command.shell(command)
     end
 
     private
-    attr_reader :runner, :command
+    attr_reader :command
+
+    def adb_command
+      @command ||= Rubotium::Adb::Commands::Command.new(serial)
+    end
   end
-end
+end

data/lib/rubotium/devices.rb

@@ -1,25 +1,38 @@
 module Rubotium
   class Devices
-    def initialize(device_matcher = '')
-      @attached_devices = Adb::Devices.new.list
-      @matched          = matched_devices device_matcher
+    def initialize(options = {})
+      @match_serial = options[:serial]  || ''
+      @match_name   = options[:name]    || ''
     end
 
     def all
       raise NoDevicesError if attached_devices.empty?
-      raise NoMatchedDevicesError if matched.empty?
-      matched.map{|device|
-        Device.new(device, Adb::Instrumentation.new(device))
-      }
+      raise NoMatchedDevicesError if matched_by_name.empty?
+      (matched_by_name + matched_by_serial).uniq
     end
 
     private
-      attr_reader :matched, :attached_devices
+    attr_reader :matched, :attached_devices, :match_name, :match_serial
+
+    def attached_devices
+      @attached_devices ||= adb_devices.attached
+    end
+
+    def matched_by_serial
+      attached_devices.select { |device|
+        device.serial.eql? match_serial
+      }
+    end
+
+    def matched_by_name
+      attached_devices.select { |device|
+        device.name.include? match_name
+      }
+    end
+
+    def adb_devices
+      Adb::Devices.new
+    end
 
-      def matched_devices(device_matcher)
-        device_matcher ? attached_devices.select{|device|
-          device.include? device_matcher
-        } : attached_devices
-      end
   end
-end
+end

data/lib/rubotium/formatters/junit_formatter.rb

@@ -4,22 +4,21 @@ module Rubotium
   module Formatters
     class JunitFormatter
       attr_reader :xml
-      def initialize(device, path_to_file)
-        @device_serial    = device.serial
-        @results          = device.results
+      def initialize(results, path_to_file)
+        @results          = results
         @report_file_path = path_to_file
 
         @xml = Builder::XmlMarkup.new :target => ensure_io(report_path), :indent => 2
 
         xml.testsuites do
-          results.each{|_, tests|
-            start_test_suite(tests)
+          results.each{|package_name, tests|
+            start_test_suite(package_name, tests)
           }
         end
       end
       private
         attr_reader :report_file_path, :device_serial, :results
-        def start_test_suite(tests)
+        def start_test_suite(package_name, tests)
           failures    = get_failures(tests)
           errors      = get_errors(tests)
           tests_time  = get_tests_time(tests)
@@ -27,7 +26,7 @@ module Rubotium
           params = {
                     :errors     => errors,
                     :failures   => failures,
-                    :name       => device_serial,
+                    :name       => package_name,
                     :tests      => tests_count,
                     :time       => tests_time,
                     :timestamp  => Time.now
@@ -41,13 +40,13 @@ module Rubotium
         end
 
         def print_testcase(test)
-          xml.testcase(:classname=>test.package_name, :name=>test.test_name, :time=>test.time) do
+          xml.testcase(:classname=> test.class_name, :name=>test.test_name, :time=>test.time) do
             has_failures(test)
             has_errors(test)
           end
         end
 
-        def has_failures(test)
+      def has_failures(test)
           if test.failed?
             xml.failure :message=>"", :type=>"" do
               xml.cdata! test.stack_trace
@@ -80,7 +79,7 @@ module Rubotium
         end
 
         def report_path
-          "#{device_serial}_#{report_file_path}"
+          report_file_path
         end
 
         def ensure_io(path_to_file)
@@ -88,4 +87,4 @@ module Rubotium
         end
     end
   end
-end
+end

data/lib/rubotium/memory/data_point.rb

@@ -0,0 +1,63 @@
+require 'json'
+module Rubotium
+  module Memory
+    class DataPoint
+      attr_reader :time
+
+      def initialize(time, data_struct)
+        @time = time
+        @data_struct = data_struct
+      end
+
+      def pid
+        parsed_result.pid
+      end
+
+      def vss
+        parsed_result.vss
+      end
+
+      def rss
+        parsed_result.rss
+      end
+
+      def pss
+        parsed_result.pss
+      end
+
+      def uss
+        parsed_result.uss
+      end
+
+      def cmdline
+        parsed_result.cmdline
+      end
+
+      def to_s
+        to_json.to_json
+      end
+
+      def to_json
+        {
+          :time => time,
+          :pid  => pid,
+          :vss  => vss,
+          :rss  => rss,
+          :uss  => uss,
+          :cmd  => cmdline
+        }
+      end
+
+      private
+      attr_reader :data_struct
+
+      def parsed_result
+        @parsed_result ||= parser.parse
+      end
+
+      def parser
+        Rubotium::Adb::Parsers::Procrank.new(data_struct)
+      end
+    end
+  end
+end

data/lib/rubotium/memory/monitor.rb

@@ -0,0 +1,65 @@
+require_relative 'data_point'
+
+module Rubotium
+  module Memory
+    class Monitor
+      def initialize(device, opts = {})
+        @device       = device
+        @process_name = opts.delete(:process_name) || nil
+        @interval     = opts.delete(:interval) || 0
+      end
+
+      def start
+        @should_pool_memory = !!process_name
+        start_probing_memory
+      end
+
+      def stop_and_save(io)
+        stop
+        io.write("[#{data_points.join(',')}]")
+        reset
+      end
+
+      def stop
+        @should_pool_memory = false
+        start_probing_memory.join
+        Rubotium.logger.debug("Memory collector stopped")
+      end
+
+      def data_points
+        data.clone
+      end
+
+      def reset
+        @data = []
+      end
+
+      private
+
+      attr_reader :device, :interval, :process_name
+      attr_accessor :should_pool_memory
+
+      def start_probing_memory
+        @pooling_thread ||= Thread.new do
+          while @should_pool_memory do
+            data.push(DataPoint.new(time, probe_memory))
+            sleep interval
+          end
+        end
+      end
+
+      def data
+        @data ||= []
+      end
+
+      def time
+        Time.at(Time.now).strftime("%H:%M:%S")
+      end
+
+      def probe_memory
+        device.shell(Rubotium::Adb::Commands::MemoryCommand.new(process_name).executable_command)
+      end
+
+    end
+  end
+end

data/lib/rubotium/memory.rb

@@ -0,0 +1,8 @@
+require_relative 'memory/data_point'
+require_relative 'memory/monitor'
+
+module Rubotium
+  module Memory
+
+  end
+end

data/lib/rubotium/package.rb

@@ -1,9 +1,8 @@
-require 'android_apk'
-
 module Rubotium
   class Package
-    def initialize(package_path)
+    def initialize(package_path, test_runner = '')
       @package_path = package_path
+      @test_runner  = test_runner || 'android.test.InstrumentationTestRunner'
     end
 
     def valid?
@@ -26,11 +25,15 @@ module Rubotium
       analyzed_package.version_code
     end
 
+    def test_runner
+      @test_runner
+    end
+
     private
     attr_reader :package_path
 
     def analyzed_package
-      @analyzed_package ||= AndroidApk.analyze(package_path)
+      @analyzed_package ||= Rubotium::Apk::AndroidApk.new(package_path)
     end
   end
 end

data/lib/rubotium/runnable_test.rb

@@ -0,0 +1,13 @@
+module Rubotium
+  class RunnableTest
+    attr_reader :package_name, :test_name
+    def initialize(package_name, test_name)
+      @package_name = package_name
+      @test_name    = test_name
+    end
+
+    def name
+      "#{package_name}##{test_name}"
+    end
+  end
+end

data/lib/rubotium/test_cases_reader.rb

@@ -0,0 +1,32 @@
+module Rubotium
+  class TestCasesReader
+    def initialize(device, test_package, options = {})
+      @device         = device
+      @test_package   = test_package
+      @annotation     = options.delete(:annotation)
+    end
+
+    def read_tests
+      result = device.shell(instrument_command)
+      Rubotium::Adb::Parsers::TestResultsParser.new(result).test_results.map{|test|
+        create_runnable_test(test)
+      }
+    end
+
+    def create_runnable_test(test)
+      Rubotium::RunnableTest.new(test.class_name, test.test_name)
+    end
+
+    private
+
+    attr_reader :device, :test_package, :annotation
+
+    def instrument_command
+      "am instrument -w -r -e log true #{with_annotation} #{test_package.name}/#{test_package.test_runner}"
+    end
+
+    def with_annotation
+      annotation ? "-e annotation #{annotation}" : ''
+    end
+  end
+end

data/lib/rubotium/test_result.rb

@@ -0,0 +1,52 @@
+module Rubotium
+  class TestResult
+
+    attr_reader :stack_trace, :time, :error_message, :status, :test_name, :class_name, :device
+
+    def initialize(test_results_parser, runnable_test)
+      @parsed_result  = test_results_parser
+      @class_name     = runnable_test.package_name
+      @test_name      = runnable_test.test_name
+    end
+
+    def stack_trace
+      if(failed_run?)
+        parsed_result.message
+      else
+        test_case.stack_trace
+      end
+    end
+
+    def failed?
+      failed_run? || test_case.failed?
+    end
+
+    def passed?
+      not failed_run? and test_case.passed?
+    end
+
+    def errored?
+      failed_run? || test_case.errored?
+    end
+
+    def error_message
+      stack_trace
+    end
+
+    def time
+      parsed_result.time
+    end
+
+    private
+
+    attr_reader :parsed_result
+
+    def failed_run?
+      parsed_result.failed?
+    end
+
+    def test_case
+      parsed_result.test_results.first
+    end
+  end
+end

data/lib/rubotium/test_results.rb

@@ -0,0 +1,18 @@
+module Rubotium
+  class TestResults
+    def initialize(results)
+      @results = results
+    end
+
+    def group_by_package
+      json = {}
+      results.each{|result|
+        json[result.class_name] = [] unless json[result.class_name]
+        json[result.class_name].push(result)
+      }
+      json
+    end
+
+    attr_reader :results
+  end
+end

data/lib/rubotium/test_runners/instrumentation_test_runner.rb

@@ -0,0 +1,24 @@
+module Rubotium
+  module TestRunners
+    class InstrumentationTestRunner
+      def initialize(device, test_package, options = {})
+        @device         = device
+        @test_package   = test_package
+        @annotations    = options.delete(:annotation)
+      end
+
+      def run_test(runnable_test)
+        result = device.shell(instrument_command(runnable_test))
+        Rubotium::TestResult.new(Rubotium::Adb::Parsers::TestResultsParser.new(result), runnable_test)
+      end
+
+      private
+
+      attr_reader :device, :test_package
+
+      def instrument_command (runnable_test)
+        "am instrument -w -r -e class #{runnable_test.name} #{test_package.name}/#{test_package.test_runner}"
+      end
+    end
+  end
+end

data/lib/rubotium/tests_runner.rb

@@ -0,0 +1,80 @@
+require 'parallel'
+module Rubotium
+  class TestsRunner
+    def initialize(devices, tests, tests_package, options = {})
+      @devices        = devices
+      @tests          = tests
+      @tests_package  = tests_package
+      @tests_runner   = tests_package.test_runner
+      @options        = options
+      @test_number    = 0
+    end
+
+    def tests_count
+      tests.count
+    end
+
+    def tests_to_execute
+      tests_queue.count
+    end
+
+    def tests_results
+      Rubotium::TestResults.new(results)
+    end
+
+    def run_tests
+      fill_tests_queue
+      Parallel.each(devices, :in_threads => devices.count) { |device|
+        until tests_queue.empty?
+          test = next_test
+          memory_monitor = Rubotium::Memory::Monitor.new(device, { :interval => 1 })
+          memory_monitor.start
+          display_test_progress
+          result = test_runner(device).run_test(test)
+          if(result.failed? || result.errored?)
+            result = test_runner(device).run_test(test)
+          end
+          results.push(result)
+          memory_monitor.stop_and_save(memory_results_file(test))
+        end
+      }
+    end
+
+    def display_test_progress
+      @test_number += 1
+      puts "Running test: #{@test_number} out of #{tests_count}"
+    end
+
+    private
+
+    attr_reader :devices, :tests_package, :tests
+
+    def memory_results_file(test)
+      File.open("results/memory_logs/#{test.name}.json", 'w+')
+    end
+
+    def results
+      @results ||= []
+    end
+
+    def next_test
+      tests_queue.pop
+    end
+
+    def fill_tests_queue
+      tests.map { |test| tests_queue.push(test) }
+    end
+
+    def tests_queue
+      @queue ||= Queue.new
+    end
+
+    def test_runner(device)
+      Rubotium::TestRunners::InstrumentationTestRunner.new(device, tests_package)
+    end
+
+    def retrying_test_runner
+      Rubotium::TestRunners::RetryingTestRunner.new(device, test)
+    end
+  end
+end

data/lib/rubotium/version.rb

@@ -1,3 +1,3 @@
 module Rubotium
-  VERSION = "0.0.4"
+  VERSION = "0.0.7"
 end