rubotium 0.0.7 → 0.0.17

data/lib/rubotium/test_results.rb

@@ -13,6 +13,113 @@ module Rubotium
       json
     end
 
+    def group_by_failures
+      TestSuites.new(
+      group_by_package.map{|name, test_results|
+        TestSuite.new(name, test_results)
+      }.sort_by{|test_suite|
+        test_suite.state
+      })
+    end
+
     attr_reader :results
   end
+
+  class TestSuites
+    def initialize(test_suites)
+      @test_suites = test_suites
+    end
+
+    def time
+      test_suites.map(&:time).inject(&:+).to_s
+    end
+
+    def each
+      test_suites.each{|suite|
+        yield(suite)
+      }
+    end
+
+    def total
+      sum_of(:tests_count)
+    end
+
+    def passed
+      sum_of(:passed_count)
+
+    end
+
+    def errored
+      sum_of(:error_count)
+    end
+
+    def failed
+      sum_of(:failures_count)
+    end
+
+    private
+    attr_reader :test_suites
+
+    def sum_of(value)
+      select_suites_with(value).inject(&:+)
+    end
+
+    def select_suites_with(value)
+      test_suites.map(&value).compact
+    end
+  end
+
+  class TestSuite
+    attr_reader :name
+
+    def initialize(name, test_cases)
+      @name = name
+      @test_cases = test_cases
+    end
+
+    def failures_count
+      @failures ||= count_by(:failed?).to_i
+    end
+
+    def error_count
+      @errors ||= count_by(:errored?).to_i
+    end
+
+    def passed_count
+      @passed_count ||= count_by(:passed?).to_i
+    end
+
+    def state
+      return (failures_count + error_count > 0) ? 'failed' : 'passed'
+    end
+
+    def time
+      @time ||= sum_of(:time)
+    end
+
+    def tests_count
+      @tests_count ||= test_cases.count
+    end
+
+    def each_test
+      test_cases.each{|test_case|
+        yield(test_case)
+      }
+    end
+
+    private
+    attr_reader :test_cases
+
+    def count_by(value)
+      test_cases
+      .select(&value)
+      .count
+    end
+
+    def sum_of(value_to_sum)
+      test_cases
+        .map(&value_to_sum)
+        .inject(&:+)
+    end
+  end
 end

data/lib/rubotium/test_runners/instrumentation_test_runner.rb

@@ -8,14 +8,24 @@ module Rubotium
       end
 
       def run_test(runnable_test)
-        result = device.shell(instrument_command(runnable_test))
-        Rubotium::TestResult.new(Rubotium::Adb::Parsers::TestResultsParser.new(result), runnable_test)
+        device.clean_logcat
+        result = execute(instrument_command(runnable_test))
+        File.open("results/logs/#{runnable_test.name}.log", 'w+') do |file|
+          file.write device.logcat
+        end
+        Rubotium::TestResult.new(result , runnable_test)
       end
 
       private
 
       attr_reader :device, :test_package
 
+      def execute(command)
+        Rubotium::Adb::Parsers::TestResultsParser.new(device.shell(command))
+      end
+
+
+
       def instrument_command (runnable_test)
         "am instrument -w -r -e class #{runnable_test.name} #{test_package.name}/#{test_package.test_runner}"
       end

data/lib/rubotium/tests_runner.rb

@@ -7,6 +7,7 @@ module Rubotium
       @tests_package  = tests_package
       @tests_runner   = tests_package.test_runner
       @options        = options
+      @clear          = options[:clear]
       @test_number    = 0
     end
 
@@ -15,7 +16,7 @@ module Rubotium
     end
 
     def tests_to_execute
-      tests_queue.count
+        tests_queue.count
     end
 
     def tests_results
@@ -25,16 +26,19 @@ module Rubotium
     def run_tests
       fill_tests_queue
       Parallel.each(devices, :in_threads => devices.count) { |device|
-        until tests_queue.empty?
-          test = next_test
+        while(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?)
+            screencast = Rubotium::Recorder.new(device.serial)
+            screencast.start(test.name)
             result = test_runner(device).run_test(test)
+            screencast.stop
           end
           results.push(result)
+          clear_if_required(device)
           memory_monitor.stop_and_save(memory_results_file(test))
         end
       }
@@ -47,7 +51,7 @@ module Rubotium
 
     private
 
-    attr_reader :devices, :tests_package, :tests
+    attr_reader :devices, :tests_package, :tests, :clear
 
     def memory_results_file(test)
       File.open("results/memory_logs/#{test.name}.json", 'w+')
@@ -58,7 +62,7 @@ module Rubotium
     end
 
     def next_test
-      tests_queue.pop
+      tests_queue.pop(true) rescue nil
     end
 
     def fill_tests_queue
@@ -69,6 +73,10 @@ module Rubotium
       @queue ||= Queue.new
     end
 
+    def clear_if_required(device)
+      device.shell("pm clear #{clear}") if clear
+    end
+
     def test_runner(device)
       Rubotium::TestRunners::InstrumentationTestRunner.new(device, tests_package)
     end

data/lib/rubotium/version.rb

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

data/lib/rubotium.rb

@@ -6,6 +6,8 @@ require 'rubotium/device'
 require 'rubotium/devices'
 require 'rubotium/tests_runner'
 require 'rubotium/formatters/junit_formatter'
+require 'rubotium/screencast'
+require 'rubotium/formatters/html_formatter'
 require 'rubotium/runnable_test'
 require 'rubotium/package'
 require 'rubotium/memory'
@@ -38,32 +40,43 @@ module Rubotium
       raise RuntimeError,   "Empty configuration"       if opts.empty?
       raise Errno::ENOENT,  "Tests apk does not exist"  if !File.exist?(opts[:tests_apk_path])
       raise Errno::ENOENT,  "App apk does not exist"    if !File.exist?(opts[:app_apk_path])
+      if !opts[:helper_apk_path].nil?
+        raise Errno::ENOENT,  "Helper apk does not exist" if !File.exist?(opts[:helper_apk_path])
+      end
 
       logger.level = Logger::INFO
 
       startTime = Time.now
-      FileUtils.mkdir_p('results')
+      FileUtils.mkdir_p('results/logs')
       FileUtils.mkdir_p('results/memory_logs')
+      FileUtils.mkdir_p('results/screencasts')
       FileUtils.mkdir_p('screens')
       FileUtils.mkdir_p('logs')
 
       application_package = Rubotium::Package.new(opts[:app_apk_path])
       tests_package       = Rubotium::Package.new(opts[:tests_apk_path], opts[:runner])
+      helper_package      = Rubotium::Package.new(opts[:helper_apk_path])
 
-      devices = Devices.new(:name => opts[:device_matcher]).all
+      devices = Devices.new(:name => opts[:device_matcher], :sdk => opts[:device_sdk], :serial=> opts[:serial]).all
 
       devices = Parallel.map(devices, :in_threads => devices.count) {|device|
         device.uninstall application_package.name
         device.install application_package.path
         device.uninstall tests_package.name
         device.install tests_package.path
+        if !opts[:helper_apk_path].nil?
+          device.uninstall helper_package.name
+          device.install helper_package.path
+        end
+        device.shell('mkdir /sdcard/screencasts')
         device
       }
 
-      test_suites = Rubotium::TestCasesReader.new(devices.first, tests_package).read_tests
+      test_suites = Rubotium::TestCasesReader.new(devices.first, tests_package, { :annotation=>opts[:annotation]}).read_tests
+
       puts "There are #{test_suites.count} tests to run"
 
-      runner = Rubotium::TestsRunner.new(devices, test_suites, tests_package, {:annotation=>opts[:annotation]})
+      runner = Rubotium::TestsRunner.new(devices, test_suites, tests_package, {annotation: opts[:annotation], clear: application_package.name})
       runner.run_tests
 
       FileUtils.mkdir_p(['screens', 'logs'])
@@ -71,16 +84,20 @@ module Rubotium
       devices.each{|device|
         device.pull('/sdcard/Robotium-Screenshots')
         device.pull('/sdcard/RobotiumLogs')
-        device.shell('rm -R /sdcard/Robotium-Screenshots ')
-        device.shell('rm -R /sdcard/RobotiumLogs ')
+        device.pull('/sdcard/screencasts')
+        device.shell('rm -R /sdcard/Robotium-Screenshots')
+        device.shell('rm -R /sdcard/RobotiumLogs')
+        device.shell('rm -R /sdcard/screencasts')
+        device.shell('reboot')
       }
       FileUtils.mv(Dir.glob('*.jpg'), 'screens')
       FileUtils.mv(Dir.glob('*.log'), 'logs')
+      FileUtils.mv(Dir.glob('*.mp4'), 'results/screencasts')
 
       puts "Tests took: #{Time.at(Time.now-startTime).utc.strftime("%H:%M:%S")}"
 
       Formatters::JunitFormatter.new(runner.tests_results.group_by_package, opts[:report])
-
+      Formatters::HtmlFormatter.new(runner.tests_results.group_by_failures, 'results/index.html')
     end
 
     def logger

data/rubotium.gemspec

@@ -21,12 +21,11 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler",    "~> 1.5"
   spec.add_development_dependency "simplecov",  "0.8.2"
   spec.add_development_dependency "coveralls",  "0.7.0"
-  spec.add_development_dependency "rspec",      "2.14.1"
-  spec.add_development_dependency "rspec-mocks"
+  spec.add_development_dependency "rspec",      "3.2.0"
+
   spec.add_development_dependency "rake"
 
   spec.add_dependency 'builder',      '3.2.2'
   spec.add_dependency 'trollop',      '2.0'
   spec.add_dependency 'parallel',     '0.9.2'
-  spec.add_dependency 'dex2jar',      '0.0.6'
 end

data/spec/lib/rubotium/adb/adb_result_parser_spec.rb

@@ -135,13 +135,13 @@ describe Rubotium::Adb::TestResultParser do
     let(:parsed_result) { parser.new(Fixtures::Adb.gingerbread_exception, package, "") }
 
     it 'should behave as error case' do
-      pending
-      parsed_result.should be_errored
+
+
     end
 
     it 'should know the error reason' do
-      pending
-      parsed_result.error_message.should eql('')
+
+
     end
   end
 end

data/spec/lib/rubotium/adb/commands/command_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Rubotium::Adb::Commands::Command do
+  let(:subject) { described_class.new(serial) }
+  let(:adb_command) { 'the command' }
+  let(:result) { 'result' }
+  let(:command_to_run) { double(Object) }
+
+  before do
+    expect(Rubotium::CMD).to receive(:run_command).with(shell_command) { result }
+    expect(command_to_run).to receive(:executable_command).at_least(:once) { adb_command }
+  end
+
+  context 'when nil serial is defined' do
+    let(:serial) { nil }
+    let(:shell_command) { "adb #{adb_command}" }
+
+    it 'executes the command without a serial' do
+      expect(subject.execute(command_to_run)).to eq result
+    end
+  end
+
+  context 'when "" serial is defined' do
+    let(:serial) { '' }
+    let(:shell_command) { "adb #{adb_command}" }
+
+    it 'executes the command without a serial' do
+      expect(subject.execute(command_to_run)).to eq result
+    end
+  end
+
+  context 'when a real serial is defined' do
+    let(:serial) { '01234567' }
+    let(:shell_command) { "adb -s #{serial} #{adb_command}" }
+
+    it 'executes the command with a serial' do
+      expect(subject.execute(command_to_run)).to eq result
+    end
+  end
+end

data/spec/lib/rubotium/adb/parsers/test_results_parser_spec.rb

@@ -13,7 +13,7 @@ describe Rubotium::Adb::Parsers::TestResultsParser do
     end
 
     it 'should return time' do
-      expect(parser.time).to eql('0.142')
+      expect(parser.time).to eql(0.142)
     end
 
     it 'should not have error message' do
@@ -33,7 +33,7 @@ describe Rubotium::Adb::Parsers::TestResultsParser do
     end
 
     it 'should return time' do
-      expect(parser.time).to eql('16.79')
+      expect(parser.time).to eql(16.79)
     end
 
     it 'should not have error message' do
@@ -53,7 +53,7 @@ describe Rubotium::Adb::Parsers::TestResultsParser do
     end
 
     it 'should return time = 0' do
-      expect(parser.time).to eql('0')
+      expect(parser.time).to eql(0.0)
     end
 
     it 'should return error message' do
@@ -75,7 +75,7 @@ describe Rubotium::Adb::Parsers::TestResultsParser do
     end
 
     it 'should return time = 0' do
-      expect(parser.time).to eql('0')
+      expect(parser.time).to eql(0.0)
     end
 
     it 'should return error message' do
@@ -97,7 +97,7 @@ describe Rubotium::Adb::Parsers::TestResultsParser do
     end
 
     it 'should return time = 0' do
-      expect(parser.time).to eql('0')
+      expect(parser.time).to eql(0.0)
     end
 
     it 'should return error message' do

data/spec/lib/rubotium/apk/android_apk_spec.rb

@@ -4,14 +4,16 @@ require 'spec_helper'
 require "pp"
 
 describe Rubotium::Apk::AndroidApk do
+  let(:aapt) {double(Rubotium::Apk::Aapt)}
 
   sample_file_path = File.dirname(__FILE__) + "/mock/sample.apk"
   sample2_file_path = File.dirname(__FILE__) + "/mock/BarcodeScanner4.2.apk"
   icon_not_set_file_path = File.dirname(__FILE__) + "/mock/UECExpress.apk"
   dummy_file_path = File.dirname(__FILE__) + "/mock/dummy.apk"
 
+
   context 'with non existing apk' do
-    let(:apk) { described_class.new('dummy.apk') }
+    let(:apk) { described_class.new(aapt, 'dummy.apk') }
 
     it "should raise exception" do
       expect{apk}.to raise_exception(Errno::ENOENT)
@@ -19,17 +21,36 @@ describe Rubotium::Apk::AndroidApk do
   end
 
   context 'with not readable apk' do
-    let(:apk) { described_class.new(dummy_file_path) }
+    let(:apk) { described_class.new(aapt, dummy_file_path) }
 
     it 'should raise exception' do
-      expect{apk.package_name}.to raise_error(RuntimeError, /ERROR: dump failed because no AndroidManifest.xml found/)
+      expect(aapt).to receive(:dump).and_return "W/zipro   (77199): Error opening archive spec/lib/rubotium/apk/mock/dummy.apk: Invalid file
+ERROR: dump failed because assets could not be loaded"
+      expect{apk.package_name}.to raise_error(RuntimeError)
     end
   end
 
   context 'with valid apk file' do
-    let(:apk) { described_class.new(sample_file_path) }
+    let(:apk) { described_class.new(aapt, sample_file_path) }
 
       it 'should read package_name' do
+        expect(aapt).to receive(:dump).and_return "package: name='com.example.sample' versionCode='1' versionName='1.0' platformBuildVersionName=''
+sdkVersion:'7'
+targetSdkVersion:'15'
+application-label:'sample'
+application-label-ja:'g'
+application-icon-160:'res/drawable-mdpi/ic_launcher.png'
+application-icon-240:'res/drawable-hdpi/ic_launcher.png'
+application-icon-320:'res/drawable-xhdpi/ic_launcher.png'
+application: label='sample' icon='res/drawable-mdpi/ic_launcher.png'
+application-debuggable
+feature-group: label=''
+  uses-feature: name='android.hardware.touchscreen'
+  uses-implied-feature: name='android.hardware.touchscreen' reason='default feature for all apps'
+supports-screens: 'small' 'normal' 'large' 'xlarge'
+supports-any-density: 'true'
+locales: '--_--' 'ja'
+densities: '160' '240' '320'"
         expect(apk.package_name).to eql 'com.example.sample'
       end
 

data/spec/lib/rubotium/device_spec.rb

@@ -1,12 +1,6 @@
 require 'spec_helper'
 
-describe Rubotium::Device do
-  let(:device)  { described_class.new('12345') }
-  let(:command) { double(Rubotium::Adb::Commands::Command)}
-  before do
-    device.stub(:adb_command).and_return(command)
-  end
-
+shared_examples 'a Rubotium::Device' do
   it 'installs package on device' do
     path_to_apk = 'path/to/apk'
     expect(command).to receive(:install).with(path_to_apk)
@@ -36,3 +30,24 @@ describe Rubotium::Device do
     device.shell(getprop)
   end
 end
+
+describe Rubotium::Device do
+  let(:device)  { described_class.new(serial) }
+  let(:command) { double(Rubotium::Adb::Commands::Command)}
+
+  before do
+    device.stub(:adb_command).and_return(command)
+  end
+
+  context 'when a serial is provided' do
+    let(:serial) { '12345' }
+
+    it_behaves_like 'a Rubotium::Device'
+  end
+
+  context 'when no serial is provided' do
+    let(:serial) { nil }
+
+    it_behaves_like 'a Rubotium::Device'
+  end
+end

data/spec/lib/rubotium/tests_runner_spec.rb

@@ -21,6 +21,7 @@ describe Rubotium::TestsRunner do
 
     context 'when running tests' do
       before do
+        runner.stub(:memory_results_file).and_return Tempfile.new('memory_monitor')
         device1.stub(:shell)
         device2.stub(:shell)
         runner.stub(:test_runner).and_return(test_runner)

data/test.rb

@@ -1,11 +1,42 @@
-require 'parallel'
+require "observer"
 
-q = Queue.new
+class Ticker          ### Periodically fetch a stock price.
+  include Observable
 
-(0..10).to_a.each{|e| q.push(e)}
-b = (1..4).to_a
-Parallel.map(b, :in_processes => 10){|executor|
-  until(q.empty?)
-  puts q.pop
+  def test_changed(msg)
+    changed
   end
-}
+
+  def test_notify(msg)
+    notify_observers(msg)
+  end
+end
+
+class Observer
+  def initialize(ticker, name)
+    @ticker = ticker
+    @name = name
+    ticker.add_observer(self)
+  end
+
+  def unsubscribe
+    @ticker.delete_observer(self)
+  end
+
+  def update(*args)
+    puts @name
+    p *args
+  end
+
+  def message_missing(*args)
+    puts @name
+    p args
+  end
+
+end
+
+
+ticker = Ticker.new()
+observer = Observer.new(ticker, "observer1")
+
+