brazenhead 0.1

data/lib/brazenhead/signer.rb

@@ -0,0 +1,66 @@
+require 'brazenhead/android'
+require 'brazenhead/process'
+
+module Brazenhead
+  module Signer
+    include Brazenhead::Android
+
+    def sign(apk, keystore)
+      @keystore = keystore
+      jarsign(apk)
+      verify(apk)
+      process.run(*zipalign(apk), *signed(apk))
+    end
+
+    private
+    def process
+      @process ||= Brazenhead::Process.new
+    end
+
+    def jarsign(apk)
+      process.run(*jar_command, *keypasses, *the_key, apk, key_alias)
+    end
+
+    def jar_command
+      "jarsigner -sigalg MD5withRSA -digestalg SHA1".split
+    end
+
+    def verify(apk)
+      process.run(*"jarsigner -verify".split, apk)
+      error_signing(apk) unless process.last_stdout.include? "jar verified"
+    end
+
+    def zipalign(apk)
+      "zipalign -v 4".split << apk
+    end
+
+    def signed(apk)
+      File.join dir(apk), new_name(apk)
+    end
+
+    def dir(apk)
+      File.dirname(apk)
+    end
+
+    def new_name(apk)
+      File.basename(apk, '.apk') << '-signed.apk'
+    end
+
+    def keypasses
+      "-storepass #{@keystore[:password]} -keypass #{@keystore[:keystore_password]}".split 
+    end
+
+    def the_key
+      ["-keystore", File.expand_path(@keystore[:path])]
+    end
+
+    def key_alias
+      @keystore[:alias]
+    end
+
+    def error_signing(apk)
+      raise Exception, "error signing #{apk} (#{process.last_stdout})"
+    end
+
+  end
+end

data/lib/brazenhead/version.rb

@@ -0,0 +1,3 @@
+module Brazenhead
+  VERSION = "0.1"
+end

data/lib/brazenhead.rb

@@ -0,0 +1,42 @@
+require 'brazenhead/version'
+require 'brazenhead/device'
+require 'brazenhead/request'
+require 'brazenhead/call_accumulator'
+require 'brazenhead/core_ext/string'
+
+module Brazenhead
+  def method_missing(method, *args)
+    call_method_on_driver(method.to_s.to_java_call, args)
+  end
+
+  def chain_calls(&block)
+    accumulator.clear
+    block.call accumulator
+    @last_response = device.send(accumulator.message)
+    @last_response
+  end
+
+  def last_response
+    @last_response
+  end
+
+  private
+
+  def call_method_on_driver(method, args)
+    message = request.build(method, args)
+    @last_response = device.send(message)
+    @last_response
+  end
+
+  def device
+    @device ||= Brazenhead::Device.new
+  end
+
+  def request
+    @request ||= Brazenhead::Request.new
+  end
+
+  def accumulator
+    @accumulator ||= Brazenhead::CallAccumulator.new
+  end
+end

data/spec/lib/brazenhead/android_spec.rb

@@ -0,0 +1,35 @@
+require 'brazenhead/android'
+
+class AndroidTest
+  include Brazenhead::Android
+end
+
+describe Brazenhead::Android do
+  let(:android) { AndroidTest.new }
+
+  context "resolving android paths" do
+
+    before(:each) do
+      ENV.stub(:[]).with('ANDROID_HOME').and_return('/path/to/android')
+      File.stub(:exists?).and_return(true)
+    end
+
+    it "should be able to locate the android jar" do
+      ENV.stub(:[]).with('ANDROID_HOME').and_return('/path/to/android')
+      android.path_to(8).should eq '/path/to/android/platforms/android-8/android.jar'
+    end
+
+    it "should raise an error if the path is not found" do
+      File.should_receive(:exists?).and_return(false)
+      api = 8
+      lambda { android.path_to(api) }.should raise_error (message="the path to android-#{api} was not found")
+    end
+  end
+
+  context "locating the keystore" do
+    it "should be able to locate the path to the default keystore" do
+      File.stub(:expand_path).with("~/.android/debug.keystore").and_return("/some/expanded/.android/debug.keystore")
+      android.default_keystore[:path].should eq "/some/expanded/.android/debug.keystore"
+    end
+  end
+end

data/spec/lib/brazenhead/builder_spec.rb

@@ -0,0 +1,108 @@
+require 'brazenhead/builder'
+
+describe Brazenhead::Builder do
+  let(:apk) { 'some_apk.apk' }
+  let(:activity) { 'SomeActivityToStart' }
+  let(:server) { Brazenhead::Builder.new }
+  let(:manifest_info) { double('manifest-info').as_null_object }
+  let(:tmpdir) { '/some/tmp/dir' }
+  let(:driver_apk) { 'brazenhead-release-unsigned.apk' }
+  let(:keystore) { {:path => 'default.keystore'} }
+
+  before(:each) do
+    File.stub(:exists?).and_return(true)
+    Dir.stub(:mktmpdir).and_yield(tmpdir)
+    FileUtils.stub(:copy_file)
+    File.stub(:read).and_return('')
+    File.stub(:write)
+    server.stub(:update_manifest)
+    server.stub(:sign)
+    server.stub(:install)
+    Brazenhead::ManifestInfo.stub(:new).with(apk).and_return(manifest_info)
+  end
+
+  context "building the test server" do
+    context "validating the arguments" do
+      it "should require that the package exists" do
+        File.should_receive(:exists?).and_return(false)
+        lambda { server.build_for('some_package.apk', keystore) }.should raise_error(message="Invalid package path:  some_package.apk")
+      end
+    end
+
+    context "setting up the test server sandbox" do
+      let(:base_gem_dir) { '/base/gem' }
+      let(:base_test_apk) { "#{base_gem_dir}/driver/#{driver_apk}" }
+      let(:manifest) { 'AndroidManifest.xml' }
+      let(:base_manifest) { "#{base_gem_dir}/driver/#{manifest}" }
+
+      before(:each) do
+        File.stub(:expand_path).with("~/.android/debug.keystore").and_return("expanded/.android/debug.keystore")
+        File.stub(:expand_path).with("../../../", anything()).and_return(base_gem_dir)
+      end
+
+      it "should use a temporary directory" do
+        Dir.should_receive(:mktmpdir)
+        server.build_for(apk, keystore)
+      end
+
+      it "should copy the unsigned release package into the directory" do
+        FileUtils.should_receive(:copy_file).with(base_test_apk, File.join(tmpdir, driver_apk))
+        server.build_for(apk, keystore)
+      end
+
+      it "should copy the manifest into the directory" do
+        FileUtils.should_receive(:copy_file).with(base_manifest, File.join(tmpdir, manifest))
+        server.build_for(apk, keystore)
+      end
+    end
+
+    context "updating the manifest" do
+      it "should load the contents of the existing manifest" do
+        File.should_receive(:read).with("#{tmpdir}/AndroidManifest.xml")
+        server.build_for(apk, keystore)
+      end
+
+      it "should replace the target package" do
+        the_target_package = "the.target.package"
+        File.should_receive(:read).and_return("android:targetPackage=\"it.does.not.matter\"")
+        manifest_info.should_receive(:package).and_return(the_target_package)
+        File.should_receive(:write).with("#{tmpdir}/AndroidManifest.xml", "android:targetPackage=\"#{the_target_package}\"")
+
+        server.build_for(apk, keystore)
+      end
+
+      it "should package the modified manifest back into the test package" do 
+        manifest_info.should_receive(:target_sdk).and_return(10)
+        server.should_receive(:update_manifest).with("#{tmpdir}/#{driver_apk}", "#{tmpdir}/AndroidManifest.xml", 10)
+        server.build_for(apk, keystore)
+      end
+
+    end
+
+    context "signing the test server" do
+      it "should use the provided keystore to sign the package" do
+        server.should_receive(:sign).with("#{tmpdir}/#{driver_apk}", {:path => 'another keystore'})
+        server.build_for(apk, :path => 'another keystore')
+      end
+    end
+
+    context "installing the test server" do
+      it "should reinstall the test server to the device" do
+        server.should_receive(:install).with("#{tmpdir}/#{driver_apk}", "-r", {}, 90)
+        server.build_for(apk, keystore)
+      end
+
+      it "should reinstall the target package to the device" do
+        server.should_receive(:install).with(apk, "-r", {}, 90)
+        server.build_for(apk, keystore)
+      end
+
+    end
+  end
+
+  context "sending back informationa about the server" do
+    it "should send back information about the target package" do
+      server.build_for(apk, keystore).should_be manifest_info
+    end
+  end
+end

data/spec/lib/brazenhead/call_accumulator_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Brazenhead::CallAccumulator do
+  let(:accumulator) { Brazenhead::CallAccumulator.new }
+
+  it "should accumulate a series of calls and build the message" do
+    accumulator.first_call
+    accumulator.second_call
+    accumulator.message.should == "commands=[{\"name\":\"firstCall\"},{\"name\":\"secondCall\"}]"
+  end
+end

data/spec/lib/brazenhead/device_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Brazenhead::Device do
+  let(:device) { Brazenhead::Device.new }
+  let(:http_mock) { double("http_mock") }
+
+  before(:each) do
+    Net::HTTP.stub(:new).and_return(http_mock)
+  end
+
+  it "should retry the http call if it fails the first time" do
+    http_mock.should_receive(:post).and_raise("error")
+    http_mock.should_receive(:post).with('/', "blah")
+    device.send "blah"
+  end
+
+  it "should retry the http call a maximum of 20 times" do
+    device.should_receive(:sleep).exactly(20).times
+    http_mock.should_receive(:post).exactly(20).times.and_raise("error")
+    expect { device.send "blah" }.to raise_error
+  end
+
+  it "should be able to stop the server" do
+    http_mock.should_receive(:post).with('/kill', '')
+    device.stop
+  end
+end

data/spec/lib/brazenhead/manifest_info_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Brazenhead::ManifestInfo do
+  let(:process) { double('brazenhead-process').as_null_object }
+  let(:manifest_info) { Brazenhead::ManifestInfo.new 'some_apk.apk' }
+
+  before(:each) do
+    Brazenhead::Process.stub(:new).and_return(process)
+  end
+
+  it "should grab the minimum sdk" do
+    process.should_receive(:last_stdout).and_return("
+E: uses-sdk (line=39)
+A: android:minSdkVersion(0x0101020c)=(type 0x10)0x0f
+A: android:targetSdkVersion(0x01010270)=(type 0x10)0xe")
+
+    manifest_info.min_sdk.should eq 15
+  end
+
+  it "should load the manifest the first time it needs it" do
+    process.should_receive(:run).with('aapt', 'dump', 'xmltree', 'some_apk.apk', 'AndroidManifest.xml')
+    manifest_info.min_sdk
+  end
+
+  it "should default the minimum sdk to 1" do
+    process.should_receive(:last_stdout).and_return("
+E: uses-sdk (line=39)
+A: android:notTheminSdkVersion(0x0101020c)=(type 0x10)0x0f
+A: android:targetSdkVersion(0x01010270)=(type 0x10)0xe")
+
+    manifest_info.min_sdk.should eq 1
+  end
+
+  it "should grab the maximum sdk" do
+    process.should_receive(:last_stdout).and_return("
+E: uses-sdk (line=39)
+A: android:minSdkVersion(0x0101020c)=(type 0x10)0x0f
+A: android:maxSdkVersion(0x0101020c)=(type 0x10)0x0a")
+
+    manifest_info.max_sdk.should eq 10
+  end
+
+  it "should grab the target sdk" do
+    process.should_receive(:last_stdout).and_return("
+E: uses-sdk (line=39)
+A: android:notTheminSdkVersion(0x0101020c)=(type 0x10)0x0f
+A: android:targetSdkVersion(0x01010270)=(type 0x10)0xe")
+
+    manifest_info.target_sdk.should eq 14
+  end
+
+  it "should grab the default package" do
+    process.should_receive(:last_stdout).and_return("
+N: android=http://schemas.android.com/apk/res/android
+E: manifest (line=22)
+A: package=\"com.example.android.apis\" (Raw: \"com.example.android.apis\")")
+
+    manifest_info.package.should eq 'com.example.android.apis'
+  end
+
+end

data/spec/lib/brazenhead/package_spec.rb

@@ -0,0 +1,30 @@
+require 'brazenhead/package'
+
+class PackageTest
+  include Brazenhead::Package
+end
+
+describe Brazenhead::Package do
+  let(:package) { PackageTest.new }
+  let(:process) { double('brazenhead-process').as_null_object }
+  let(:android) { double('brazenhead-android') }
+  let(:apk) { '/path/to/some_apk.apk' }
+
+  before(:each) do
+    Brazenhead::Process.stub(:new).and_return(process)
+  end
+
+  context "updating a manifest" do
+    let(:manifest) { '/path/to/AndroidManifest.xml' }
+    let(:android_jar) { '/path/to/android.jar' }
+
+    it "should update the manifest" do
+      package.stub(:path_to).and_return(android_jar)
+      process.should_receive(:run).with('aapt', 'p', '-u', '-f', '-F', apk, '-M', manifest, '-I', android_jar)
+
+      package.update_manifest(apk, manifest)
+    end
+    
+  end
+
+end

data/spec/lib/brazenhead/process_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Brazenhead::Process do
+  let(:stdout) { double(:name => 'stdout').as_null_object }
+  let(:stderr) { double(:name => 'stderr').as_null_object }
+  let(:running_process) { double('process').as_null_object }
+  let(:process) { Brazenhead::Process.new }
+
+  before(:each) do
+    Time.stub(:now) { 'this:time' }
+    Tempfile.stub(:new).and_return(stdout,stderr)
+
+    running_process.stub_chain(:io, :stdout).and_return(stdout)
+    running_process.stub_chain(:io, :stdout=)
+    running_process.stub_chain(:io, :stderr).and_return(stderr)
+    running_process.stub_chain(:io, :stderr=)
+
+    ChildProcess.stub(:build) { running_process }
+  end
+
+  it "should run the command with arguments" do
+    ChildProcess.should_receive(:build).with('command', 'some', 'argument')
+    running_process.should_receive(:start)
+    process.run('command', 'some', 'argument')
+  end
+
+  it "should wait for the command to complete" do
+    running_process.should_receive(:wait)
+    process.run('anything')
+  end
+
+  it "should redirect stdout and stderr" do
+    Tempfile.should_receive(:new).with('brazenhead-proc-out-this_time')
+    Tempfile.should_receive(:new).with('brazenhead-proc-err-this_time')
+    process.run('anything')
+  end
+
+  it "should capture stdout and stderr" do
+    running_process.io.should_receive(:stdout=).with(stdout)
+    running_process.io.should_receive(:stderr=).with(stderr)
+    process.run('anything')
+  end
+
+  it "should preserve the last stdout and stderr" do
+    [stdout, stderr].each do |iostream|
+      iostream.should_receive(:rewind)
+      iostream.should_receive(:read).and_return("last #{iostream.name}")
+    end
+
+    process.run('anything')
+
+    process.last_stdout.should eq 'last stdout'
+    process.last_stderr.should eq 'last stderr'
+  end
+
+  it "should clean up stdout and stderr temporary files" do
+    [stdout, stderr].each do |iostream|
+      iostream.should_receive(:close)
+      iostream.should_receive(:unlink)
+    end
+    process.run('anything')
+  end
+
+end

data/spec/lib/brazenhead/request_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'json'
+
+describe Brazenhead::Request do
+  let(:request) { Brazenhead::Request.new }
+
+  def json_message(message)
+    JSON.parse(message[9..-1])[0]
+  end
+
+  it "should place the method name in the json file" do
+    message = request.build('call_me', [])
+    json_message(message)['name'].should == 'call_me'
+  end
+
+  it "should place an argument in the json file" do
+    message = request.build('call_me', ['the_argument'])
+    json_message(message)['arguments'].should == ['the_argument']
+  end
+
+  it "should place multiple arguments in the json file" do
+    message = request.build('call_me', ['first', 'second'])
+    json_message(message)['arguments'].should == ['first', 'second']
+  end
+
+  it "should use the target when one is provided" do
+    message = request.build('call_me', [{:target => 'Robotium'}])
+    json_message(message)['target'].should == 'Robotium'
+  end
+
+  it "should grab the target from the final parameter" do
+    message = request.build('call_me', ['the_argument', {:target => 'Robotium'}])
+    json_message(message)['target'].should == 'Robotium'
+  end
+
+  it "should use a variable when one is provided" do
+    message = request.build('call_me', [{:variable => '@@var@@'}])
+    json_message(message)['variable'].should == "@@var@@"
+  end
+
+  it "should grab the variable from the final parameter" do
+    message = request.build('call_me', ['the_argument', {:variable => '@@var@@'}])
+    json_message(message)['variable'].should == '@@var@@'
+  end
+
+  it "should find both the target and variable in the final hash parameter" do
+    message = request.build('call_me', ['the_argument', {:target => 'Robotium', :variable => '@@var@@'}])
+    json_message(message)['variable'].should == '@@var@@'
+    json_message(message)['target'].should == 'Robotium'
+  end
+end

data/spec/lib/brazenhead/server_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Brazenhead::Server do
+  let(:server) { Brazenhead::Server.new(apk) }
+  let(:builder) { double('brazenhead-builder').as_null_object }
+  let(:manifest) { double('manifest-info') }
+  let(:apk) { 'someapk.apk' }
+  let(:activity) { 'SomeActivity' }
+  let(:default_keystore) { server.default_keystore }
+
+  before(:each) do
+    Brazenhead::Builder.stub(:new).and_return(builder)
+    builder.stub(:build_for).with(apk, anything()).and_return(manifest)
+    server.stub(:shell)
+    server.stub(:forward)
+    server.stub(:instrument)
+    manifest.stub(:package).and_return('com.example')
+  end
+
+  context "installing the server for the first time" do
+    it "should install the server" do
+      server.start(activity)
+    end
+
+    it "should only install it the first time" do
+      builder.should_receive(:build_for).once.and_return(manifest)
+      server.start(activity)
+      server.start(activity)
+    end
+
+    it "should use the default keystore if none is provided" do
+      builder.should_receive(:build_for).with(apk, server.default_keystore)
+      server.start(activity)
+    end
+
+    it "should use the provided keystore if it is given" do
+      other_keystore = {:path => 'other_keystore'}
+      builder.should_receive(:build_for).with(apk, other_keystore)
+      other_server = Brazenhead::Server.new(apk, other_keystore)
+      other_server.stub(:shell)
+      other_server.stub(:forward)
+      other_server.stub(:instrument)
+      other_server.start(activity)
+    end
+
+    it "should setup the proper port forwarding" do
+      server.should_receive(:forward).with("tcp:7777", "tcp:54767")
+      server.start(activity)
+    end
+  end
+
+  context "instrumenting the application" do
+    let(:runner) { 'com.leandog.brazenhead/com.leandog.brazenhead.BrazenheadInstrumentation' }
+
+    it "should use the package from the target manifest" do
+      manifest.should_receive(:package)
+      server.start(activity)
+    end
+
+    it "should start instrumenting" do
+      expected = {:packageName => 'com.example', :fullLauncherName => 'com.example.SomeActivity', :class => 'com.leandog.brazenhead.TheTest'}
+      server.should_receive(:instrument).with(runner, expected)
+      server.start(activity)
+    end
+
+    it "should be able to stop instrumenting" do
+      device = double('brazenhead-device')
+      Brazenhead::Device.should_receive(:new).and_return(device)
+      device.should_receive(:stop)
+      server.stop
+    end
+
+  end
+
+end

data/spec/lib/brazenhead/signer_spec.rb

@@ -0,0 +1,35 @@
+class SignerTest
+  include Brazenhead::Signer
+end
+
+describe Brazenhead::Signer do
+  let(:signer) { SignerTest.new }
+  let(:process) { double('brazenhead-process').as_null_object }
+  let(:keypath) { '/path/to/debug.keystore' }
+
+  before(:each) do
+    Brazenhead::Process.stub(:new).and_return(process)
+    process.stub(:last_stdout).and_return("jar verified")
+    signer.stub(:default_key_path).and_return(keypath)
+  end
+
+  it "should give back the default keystore information" do
+    expected = {:path => '/path/to/debug.keystore', :alias => 'androiddebugkey', :password => 'android', :keystore_password => 'android'}
+    signer.default_keystore.should eq expected
+  end
+
+  it "should be able to sign a package" do
+    expanded_keypath = "/expanded/#{keypath}"
+    File.should_receive(:expand_path).with(keypath).and_return(expanded_keypath)
+    process.should_receive(:run).with('jarsigner', '-sigalg', 'MD5withRSA', '-digestalg', 'SHA1', '-storepass', 'android', '-keypass', 'android', '-keystore', expanded_keypath, '/some_apk.apk', 'androiddebugkey')
+    process.should_receive(:run).with('zipalign', '-v', '4', '/some_apk.apk', '/some_apk-signed.apk')
+    signer.sign('/some_apk.apk', signer.default_keystore)
+  end
+
+  it "should raise if signing fails to verify" do
+    process.should_receive(:run).with(*"jarsigner -verify /some_apk.apk".split)
+    process.stub(:last_stdout).and_return("something went wrong")
+    lambda { signer.sign('/some_apk.apk', signer.default_keystore) }.should raise_error(message="error signing /some_apk.apk (something went wrong)")
+  end
+
+end

data/spec/lib/brazenhead_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class Driver
+  include Brazenhead
+end
+
+describe Brazenhead do
+
+  let(:driver) { Driver.new }
+  let(:http_mock) { double("http_mock") }
+  
+  context "when calling a method directly on the module" do
+    before(:each) do
+      Net::HTTP.stub(:new).and_return(http_mock)
+    end
+    
+    it "should convert method name to camel case with first letter lowercase" do
+      driver.should_receive(:call_method_on_driver).with("fooBar", [])
+      driver.foo_bar
+    end
+
+    it "should make an http call passing the method name as the name" do
+      Net::HTTP.should_receive(:new).and_return(http_mock)
+      http_mock.should_receive(:post).with('/', "commands=[{\"name\":\"fooBar\"}]")
+      driver.foo_bar
+    end
+
+    it "should make the result of the call available for inspection" do
+      http_mock.should_receive(:post).with('/', "commands=[{\"name\":\"fooBar\"}]").and_return("Success")
+      result = driver.foo_bar
+      driver.last_response.should == result
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+if ENV['coverage']
+  raise "simplecov only works on Ruby 1.9" unless RUBY_VERSION =~ /^1\.9/
+
+  require 'simplecov'
+  SimpleCov.start { add_filter "spec/" }
+end
+
+require 'rspec'
+require 'brazenhead'
+require 'brazenhead/manifest_info'
+require 'brazenhead/server'
+require 'net/http'
+require 'childprocess'
+require 'tempfile'