rubotium 0.0.4 → 0.0.7

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Rubotium::Adb::Parsers::Procrank do
+  context 'when process has not started' do
+    let(:parser) { described_class.new('')}
+
+    it 'returns zero value PID' do
+      parser.parse.pid.should eql(0)
+    end
+
+    it 'returns zero value Vss' do
+      parser.parse.vss.should eql(0)
+    end
+
+    it 'returns zero value Rss' do
+      parser.parse.rss.should eql(0)
+    end
+
+    it 'returns zero value Pss' do
+      parser.parse.pss.should eql(0)
+    end
+
+    it 'returns zero value Uss' do
+      parser.parse.uss.should eql(0)
+    end
+
+    it 'returns empty cmdline' do
+      parser.parse.cmdline.should be_empty
+    end
+
+  end
+
+  context 'with process using memory' do
+    let(:parser) { described_class.new('  814   20404K   20328K    3030K    2168K  com.android.dialer')}
+
+    it 'returns PID' do
+      parser.parse.pid.should eql(814)
+    end
+
+    it 'returns Vss' do
+      parser.parse.vss.should eql(20404)
+    end
+
+    it 'returns Rss' do
+      parser.parse.rss.should eql(20328)
+    end
+
+    it 'returns Pss' do
+      parser.parse.pss.should eql(3030)
+    end
+
+    it 'returns Uss' do
+      parser.parse.uss.should eql(2168)
+    end
+
+    it 'returns cmdline' do
+      parser.parse.cmdline.should eql('com.android.dialer')
+    end
+
+  end
+end

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

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Rubotium::Adb::Parsers::SingleTestResultParser do
+  context 'with successful test' do
+    let(:parser) { described_class.new(Fixtures::AdbRawResult.successful_test_result) }
+
+    it 'should return test name' do
+      expect(parser.test_name).to eql('testMenuCrash')
+    end
+
+    it 'should return class name' do
+      expect(parser.class_name).to eql('com.soundcloud.android.MenuCrashTest')
+    end
+
+    it 'should be passed' do
+      parser.should be_passed
+    end
+
+    it 'should not be failed' do
+      parser.should_not be_failed
+    end
+
+    it 'should not be errored' do
+      parser.should_not be_errored
+    end
+
+    it 'should not have stack trace' do
+      parser.stack_trace.should be_empty
+    end
+  end
+
+
+  context 'with failed test' do
+    let(:parser) { described_class.new(Fixtures::AdbRawResult.single_failed_test_result) }
+
+    it 'should return test name' do
+      expect(parser.test_name).to eql('testMenuCrash')
+    end
+
+    it 'should return class name' do
+      expect(parser.class_name).to eql('com.soundcloud.android.MenuCrashTest')
+    end
+
+    it 'should not be passed' do
+      parser.should_not be_passed
+    end
+
+    it 'should be failed' do
+      parser.should be_failed
+    end
+
+    it 'should not be errored' do
+      parser.should_not be_errored
+    end
+
+    it 'should get the stack trace' do
+      parser.stack_trace.should == Fixtures::AdbRawResult.single_failed_test_stack_trace
+    end
+  end
+
+  context 'with errored test' do
+    let(:parser) { described_class.new(Fixtures::AdbRawResult.such_error_wow) }
+
+    it 'should return test name' do
+      expect(parser.test_name).to eql('testMenuCrash')
+    end
+
+    it 'should return class name' do
+      expect(parser.class_name).to eql('com.soundcloud.android.MenuCrashTest')
+    end
+
+    it 'should not be passed' do
+      parser.should_not be_passed
+    end
+
+    it 'should not be failed' do
+      parser.should_not be_failed
+    end
+
+    it 'should be errored' do
+      parser.should be_errored
+    end
+
+    it 'should get the stack trace' do
+      expect(parser.stack_trace).to eql(Fixtures::AdbRawResult.such_error_stack_trace)
+    end
+  end
+
+  context 'with errored test' do
+    let(:parser) { described_class.new(Fixtures::AdbRawResult.single_errored_test_result) }
+
+    it 'should return test name' do
+      expect(parser.test_name).to eql('testMenuCrash')
+    end
+
+    it 'should return class name' do
+      expect(parser.class_name).to eql('com.soundcloud.android.MenuCrashTest')
+    end
+
+    it 'should not be passed' do
+      parser.should_not be_passed
+    end
+
+    it 'should not be failed' do
+      parser.should_not be_failed
+    end
+
+    it 'should not be errored' do
+      parser.should be_errored
+    end
+
+    it 'should get the stack trace' do
+      parser.stack_trace.should == Fixtures::AdbRawResult.single_errored_test_result_stack_trace
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Rubotium::Adb::Parsers::TestResultsParser do
+  context 'with multiple tests ' do
+    let(:parser) { described_class.new(Fixtures::AdbRawResults.multiple_test_results) }
+
+    it 'should return three test results' do
+      parser.count.should be 3
+    end
+
+    it 'should be successful' do
+      expect(parser).to be_successful
+    end
+
+    it 'should return time' do
+      expect(parser.time).to eql('0.142')
+    end
+
+    it 'should not have error message' do
+      expect(parser.message).to be_empty
+    end
+  end
+
+  context 'with single test' do
+    let(:parser) { described_class.new(Fixtures::AdbRawResults.single_failed_test) }
+
+    it 'should return three test results' do
+      parser.count.should be 1
+    end
+
+    it 'should be successful' do
+      expect(parser).to be_successful
+    end
+
+    it 'should return time' do
+      expect(parser.time).to eql('16.79')
+    end
+
+    it 'should not have error message' do
+      expect(parser.message).to be_empty
+    end
+  end
+
+  context 'when tests cannot start' do
+    let(:parser) { described_class.new(Fixtures::AdbRawResults.test_cannot_start_error) }
+
+    it 'should return 0 test results' do
+      parser.count.should be 0
+    end
+
+    it 'should be failed' do
+      expect(parser).to be_failed
+    end
+
+    it 'should return time = 0' do
+      expect(parser.time).to eql('0')
+    end
+
+    it 'should return error message' do
+      error_message = "Unable to find instrumentation info for: " +
+        "ComponentInfo{com.soundcloud.android.tests/com.soundcloud.android.tests.RandomizingRunnr}"
+      expect(parser.message).to eql(error_message)
+    end
+  end
+
+  context 'when tests throw error' do
+    let(:parser) { described_class.new(Fixtures::AdbRawResults.test_run_error) }
+
+    it 'should return 0 test results' do
+      parser.count.should be 0
+    end
+
+    it 'should be failed' do
+      expect(parser).to be_failed
+    end
+
+    it 'should return time = 0' do
+      expect(parser.time).to eql('0')
+    end
+
+    it 'should return error message' do
+      error_message = "java.lang.RuntimeException\njava.lang.RuntimeException: " +
+        "Could not find test class. Class: com.soundcloud.android.MenuCrashTests"
+      expect(parser.message).to eql(error_message)
+    end
+  end
+
+  context 'when application crashes during test execution' do
+    let(:parser) { described_class.new(Fixtures::AdbRawResults.app_crashed_during_tests) }
+
+    it 'should return 0 test results' do
+      parser.count.should be 0
+    end
+
+    it 'should be failed' do
+      expect(parser).to be_failed
+    end
+
+    it 'should return time = 0' do
+      expect(parser.time).to eql('0')
+    end
+
+    it 'should return error message' do
+      error_message = "java.lang.RuntimeException\njava.lang.RuntimeException: developer requested crash"
+      expect(parser.message).to eql(error_message)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+# encoding: utf-8
+require "pp"
+
+describe Rubotium::Apk::AndroidApk do
+
+  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') }
+
+    it "should raise exception" do
+      expect{apk}.to raise_exception(Errno::ENOENT)
+    end
+  end
+
+  context 'with not readable apk' do
+    let(:apk) { described_class.new(dummy_file_path) }
+
+    it 'should raise exception' do
+      expect{apk.package_name}.to raise_error(RuntimeError, /ERROR: dump failed because no AndroidManifest.xml found/)
+    end
+  end
+
+  context 'with valid apk file' do
+    let(:apk) { described_class.new(sample_file_path) }
+
+      it 'should read package_name' do
+        expect(apk.package_name).to eql 'com.example.sample'
+      end
+
+  end
+end

data/spec/lib/rubotium/apk/mock/dummy.apk

@@ -0,0 +1 @@
+dummy

data/spec/lib/rubotium/device_spec.rb

@@ -0,0 +1,38 @@
+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
+
+  it 'installs package on device' do
+    path_to_apk = 'path/to/apk'
+    expect(command).to receive(:install).with(path_to_apk)
+    device.install(path_to_apk)
+  end
+
+  it 'uninstalls package from device' do
+    package_name = 'com.package.name'
+    expect(command).to receive(:uninstall).with(package_name)
+    device.uninstall(package_name)
+  end
+
+  it 'pulls files from device' do
+    files_to_pull = '/sdcard/files/'
+    expect(command).to receive(:pull).with(files_to_pull)
+    device.pull(files_to_pull)
+  end
+
+  it "knows it's name" do
+    expect(command).to receive(:shell).with("getprop ro.product.model").and_return('MyNameIs')
+    expect(device.name).to eql('MyNameIs')
+  end
+
+  it 'executes shell commands' do
+    getprop = 'getprop ro.product.model'
+    expect(command).to receive(:shell).with(getprop)
+    device.shell(getprop)
+  end
+end

data/spec/lib/rubotium/devices_spec.rb

@@ -1,45 +1,62 @@
 require 'spec_helper'
+require 'ostruct'
 
 describe Rubotium::Devices do
-  let(:devices_class) {described_class}
+  let(:adb_devices) { double(Rubotium::Adb::Devices) }
+  let(:device) { OpenStruct.new(:name => "TestDevice", :serial => '1234') }
 
   before do
-    Rubotium::Device.stub(:new).and_return("Device_Instance")
+    Rubotium::Device.stub(:new).and_return(device)
   end
 
-  context 'given device' do
-    let(:devices) {devices_class.new('emulator')}
-
-    it 'should complain about device being not accessible' do
-      Rubotium::Adb::Devices.any_instance.stub(:list).and_return([])
-      expect { devices.all }.to raise_error(Rubotium::NoDevicesError)
+  context 'when attached device' do
+    before do
+      expect(adb_devices).to receive(:attached).and_return([device])
+      expect(devices).to receive(:adb_devices).and_return(adb_devices)
     end
 
-    it 'should complain about not matched devices' do
-      Rubotium::Adb::Devices.any_instance.stub(:list).and_return(['nexus'])
-      expect { devices.all }.to raise_error(Rubotium::NoMatchedDevicesError)
+    context 'is matched' do
+      let(:devices) { described_class.new(:name => 'TestDevice') }
+
+      it 'should return matched devices' do
+        devices.all.should == [device]
+      end
     end
 
-    it 'should return test runner per device' do
-      Rubotium::Adb::Devices.any_instance.stub(:list).and_return(['emulator'])
-      devices.all.should == [ "Device_Instance" ]
+    context 'is not matched' do
+      let(:devices) { described_class.new(:name => 'Nexus') }
+
+      it 'should raise exception about not matched devices' do
+        expect { devices.all }.to raise_error(Rubotium::NoMatchedDevicesError)
+      end
     end
 
-    it 'should match devices' do
-      Rubotium::Adb::Devices.any_instance.stub(:list).and_return(['emulator', 'amolator', 'nexus', 'emulatores111', '113242'])
-      devices.send(:matched_devices, 'emulator').should == ["emulator", "emulatores111"]
+    context 'without given matcher' do
+      let(:devices) { described_class.new }
+
+      it 'should return all available devices' do
+        devices.all.should == [device]
+      end
     end
 
+    context 'with given serial' do
+      let(:devices) { described_class.new(:serial => '1234') }
+
+      it 'should return matched device' do
+        devices.all.should == [device]
+      end
+    end
   end
 
-  context 'without device' do
-    let(:devices) { devices_class.new }
+  context 'with no devices attached' do
+    let(:devices) { described_class.new(:name => 'Nexus') }
 
-    it 'should use all available devices' do
-      Rubotium::Adb::Devices.any_instance.stub(:list).and_return(['emulator', 'amolator', 'nexus', 'emulatores111', '113242'])
-      devices.all.should == ["Device_Instance", "Device_Instance", "Device_Instance", "Device_Instance", "Device_Instance"]
+    before do
+      Rubotium::Adb::Devices.any_instance.stub(:attached).and_return([])
     end
 
+    it 'should raise exception about device being not connected' do
+      expect { devices.all }.to raise_error(Rubotium::NoDevicesError)
+    end
   end
-
-end
+end

data/spec/lib/rubotium/memory/data_point_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+describe Rubotium::Memory::DataPoint do
+  let(:time) { Time.parse("3:00:00") }
+  subject(:data_point) {described_class.new(time, "") }
+
+  context 'with procrank results' do
+    let(:procrank_results) { OpenStruct.new(
+      :pid => 0,
+      :vss => 1,
+      :rss => 2,
+      :pss => 3,
+      :uss => 4,
+      :cmdline => 'cmdline')
+    }
+
+    before do
+      parser = double(Rubotium::Adb::Parsers::Procrank)
+      expect(parser).to receive(:parse).and_return(procrank_results)
+      expect(data_point).to receive(:parser).and_return(parser)
+    end
+
+    it 'returns pid' do
+      data_point.pid.should eql(0)
+    end
+
+    it 'returns vss' do
+      data_point.vss.should eql(1)
+    end
+    it 'returns rss' do
+      data_point.rss.should eql(2)
+    end
+    it 'returns pss' do
+      data_point.pss.should eql(3)
+    end
+    it 'returns uss' do
+      data_point.uss.should eql(4)
+    end
+    it 'returns cmdline' do
+      data_point.cmdline.should eql('cmdline')
+    end
+  end
+end

data/spec/lib/rubotium/memory/monitor_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+describe Rubotium::Memory::Monitor do
+  it 'starts memory pooling' do
+
+  end
+end

data/spec/lib/rubotium/tests_runner_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Rubotium::TestsRunner do
+  let(:device1) { double('Device1') }
+  let(:device2) { double('Device2') }
+  let(:devices) { [device1, device2] }
+  let(:tests) { (0..10).to_a.map{|elem| Rubotium::RunnableTest.new("package#{elem}", "name#{elem}")} }
+  let(:test_runner) { double(Rubotium::TestRunners::InstrumentationTestRunner) }
+  let(:test_package) { double(Rubotium::Package) }
+  let(:successful_test) {OpenStruct.new(:failed? => false )}
+
+  before do
+    device1.stub(:name).and_return('device1')
+    device2.stub(:name).and_return('device2')
+    test_package.stub(:test_runner).and_return('com.android.TestRunner')
+    test_package.stub(:name).and_return('com.android.test#testToRun')
+  end
+  context 'without extra options' do
+    let(:runner) { described_class.new(devices, tests, test_package) }
+
+    context 'when running tests' do
+      before do
+        device1.stub(:shell)
+        device2.stub(:shell)
+        runner.stub(:test_runner).and_return(test_runner)
+        test_runner.stub(:run_test).with(any_args).and_return(successful_test)
+      end
+
+      it 'runs all the tests from the queue' do
+        runner.run_tests
+        expect(runner.send :tests_queue).to be_empty
+      end
+
+      it 'executes tests on all devices' do
+        pending
+        expect(device1).to receive(:shell).exactly(1).times.and_return { sleep 1 }
+        expect(device2).to receive(:shell).exactly(10).times
+        runner.run_tests
+      end
+
+      it 'knows how many tests it has' do
+        runner.tests_count.should eql(11)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,6 +4,8 @@ require 'fixtures/javap_classes'
 require 'fixtures/jar_contents'
 require 'fixtures/adb_results'
 require 'fixtures/adb_devices_results'
+require 'fixtures/adb_raw_results'
+require 'fixtures/adb_raw_result'
 require 'rspec/mocks'
 
 SimpleCov.formatter = Coveralls::SimpleCov::Formatter

data/test.rb

@@ -0,0 +1,11 @@
+require 'parallel'
+
+q = Queue.new
+
+(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
+  end
+}