brazenhead 0.1

data/driver/AndroidManifest.xml

@@ -0,0 +1,21 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.leandog.brazenhead"
+    android:versionCode="1"
+    android:versionName="1.0" >
+
+    <instrumentation
+        android:name="com.leandog.brazenhead.BrazenheadInstrumentation"
+        android:targetPackage="com.example.android.apis" />
+    
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
+    <uses-sdk
+        android:minSdkVersion="10"
+        android:targetSdkVersion="15" />
+
+    <application android:label="brazenhead">
+        <uses-library android:name="android.test.runner"/>
+    </application>
+
+</manifest>

data/features/brazenhead.feature

@@ -0,0 +1,35 @@
+Feature: Functionality provided by the Brazenhead module
+
+  Scenario: Calling a method which takes no parameters
+    When I call the method "scroll_down" on the Brazenhead module
+    Then I should receive a successful result from the Brazenhead module
+    
+  Scenario: Calling a method which takes a parameter
+    When I call the method "click_on_text" on the Brazenhead module passing "Content"
+    Then I should receive a successful result from the Brazenhead module
+
+  Scenario: Chaining two method calls together
+    When I chain together the methods "scroll_down" and "scroll_up" using the target "Robotium"
+    Then I should receive a successful result from the Brazenhead module
+
+  Scenario: Chaining two method calls together with second call on result of first
+    When I chain together the methods "getCurrentListViews" and "size" using the target "LastResultOrRobotium"
+    Then I should receive a successful result from the Brazenhead module
+    And the result from the chained calls should be "1"
+
+  Scenario: Chaining two method calls should use "LastResultOrRobotium" target by default
+    When I chain together the methods "getCurrentListViews" and "size" on the Brazenhead module
+    Then I should receive a successful result from the Brazenhead module
+    And the result from the chained calls should be "1"
+
+  Scenario: Chaining two method calls using a variable
+    When I call "get_text" passing the argument "Graphics" and saving it into the variable "@@graphics@@"
+    And then I call "click_on_view" using teh variable "@@graphics@@" using the target "Robotium"
+    Then I should see "AlphaBitmap" from teh Brazenhead module
+
+  Scenario: Chaining twice
+    When I chain together the methods "getCurrentListViews" and "size" on the Brazenhead module
+    And I call "get_text" passing the argument "Graphics" and saving it into the variable "@@graphics@@"
+    And then I call "click_on_view" using teh variable "@@graphics@@" using the target "Robotium" on the same driver
+    Then I should see "AlphaBitmap" from teh Brazenhead module
+

data/features/exception.feature

@@ -0,0 +1,6 @@
+Feature:  Relaying error information back to the client
+
+  Scenario: Gracefully handing invalid commands
+    When I attempt to call a method that does not exist
+    Then I should receive an internal server error
+    And the exception should have detailed information

data/features/robotium.feature

@@ -0,0 +1,31 @@
+Feature:  Calling Robotium methods
+
+  Scenario: Getting a result from a parameterless method
+    When I do nothing but "scrollDown"
+    Then I should receive a successful result
+
+  Scenario: Calling a method with integers
+    When I call a method with an integer
+    Then I should receive a successful result
+
+  Scenario: Calling a method with strings
+    When I call a method with a string
+    Then I should receive a successful result
+
+  Scenario:  Calling a method with floats
+    When I call a method with a float
+    Then I should receive a successful result
+
+  Scenario:  Calling a method with booleans
+    When I call a method with a boolean
+    Then I should receive a successful result
+
+  Scenario:  Getting useful View information
+    When I get the first "Text" View I find
+    Then I should receive a successful result
+    And the view should have some basic information
+
+  Scenario: Chaining method calls
+    When I call "getCurrentListViews" and then I call "size"
+    Then I should receive a successful result
+    And the result should be "1"

data/features/step_definitions/brazenhead_steps.rb

@@ -0,0 +1,52 @@
+When /^I call the method "(.*?)" on the Brazenhead module$/ do |method_name|
+  @driver.send method_name
+end
+
+When /^I call the method "(.*?)" on the Brazenhead module passing "(.*?)"$/ do |method_name, argument|
+  @driver.send method_name, argument
+end
+
+When /^I chain together the methods "(.*?)" and "(.*?)" using the target "(.*?)"$/ do |first_method, second_method, target|
+  @driver.chain_calls do |driver|
+    driver.send first_method, :target => target
+    driver.send second_method, :target => target
+  end
+end
+
+Then /^I should receive a successful result from the Brazenhead module$/ do
+  @driver.last_response.code.should == '200'
+end
+
+Then /^the result from the chained calls should be "(.*?)"$/ do |result|
+  @driver.last_response.body.should == result
+end
+
+When /^I chain together the methods "(.*?)" and "(.*?)" on the Brazenhead module$/ do |first_method, second_method|
+  @driver.chain_calls do |driver|
+    driver.send first_method
+    driver.send second_method
+  end
+end
+
+When /^I call "(.*?)" passing the argument "(.*?)" and saving it into the variable "(.*?)"$/ do |method, argument, variable|
+  @first_call = {:name => method, :arguments => argument, :variable => variable}
+end
+
+When /^then I call "(.*?)" using teh variable "(.*?)" using the target "(.*?)"$/ do |method, argument, target|
+  @driver.chain_calls do |driver|
+    driver.send @first_call[:name], @first_call[:arguments], {:variable => @first_call[:variable]}
+    driver.send method, argument, {:target => target}
+  end
+end
+
+When /^then I call "(.*?)" using teh variable "(.*?)" using the target "(.*?)" on the same driver$/ do |method, argument, target|
+  @driver.chain_calls do |driver|
+    driver.send @first_call[:name], @first_call[:arguments], {:variable => @first_call[:variable]}
+    driver.send method, argument, {:target => target}
+  end
+end
+
+Then /^I should see "(.*?)" from teh Brazenhead module$/ do |value|
+  @driver.search_text value
+  @driver.last_response.body.should == 'true'
+end

data/features/step_definitions/exception_steps.rb

@@ -0,0 +1,13 @@
+When /^I attempt to call a method that does not exist$/ do
+  @driver.should_not_exist_at_all
+end
+
+Then /^I should receive an internal server error$/ do
+  @driver.last_response.code.should eq '500'
+end
+
+Then /^the exception should have detailed information$/ do
+  json = JSON.parse(@driver.last_response.body)
+  json["exception"].should match ".*CommandNotFoundException"
+  json["errorMessage"].should match "The \\w+\\(.*\\) method was not found on .*Solo\\."
+end

data/features/step_definitions/robotium_steps.rb

@@ -0,0 +1,62 @@
+When /^I do nothing but "(.*?)"$/ do |method|
+  @driver.send method
+end
+
+Then /^I should receive "(.*?)"$/ do |json|
+  @driver.last_response.body.should match json
+end
+
+When /^I call a method with an integer$/ do
+  @driver.scroll_up_list(0)
+end
+
+When /^I call a method with a string$/ do 
+  @driver.search_button('will not find')
+end
+
+When /^I call a method with a float$/ do 
+  @driver.click_on_screen(100.0, 100.0)
+end
+
+When /^I call a method with a boolean$/ do 
+  @driver.search_text('Views', true)
+end
+
+Then /^I should receive a successful result$/ do
+  @driver.last_response.code.should eq '200'
+end
+
+When /^I get the first "(.*?)" View I find$/ do |view_type|
+  @driver.send "get_#{view_type.downcase}", 0
+end
+
+Then /^the view should have some basic information$/ do
+  response = JSON.parse(@driver.last_response.body)
+  response.should have_key "id"
+  response.should have_key "classType"
+  response.should have_key "width"
+  response.should have_key "height"
+  response.should have_key "screenLocation"
+  response.should have_key "windowLocation"
+  response.should have_key "left"
+  response.should have_key "top"
+  response.should have_key "right"
+  response.should have_key "bottom"
+end
+
+When /^I call "(.*?)" and then I call "(.*?)"$/ do |first_method, next_method|
+  @driver.chain_calls do |driver|
+    driver.send first_method
+    driver.send next_method
+  end
+end
+
+Then /^the result should be "(.*?)"$/ do |result|
+  @driver.last_response.body.should eq result
+end
+
+Then /^I should see "(.*?)"$/ do |text|
+  @driver.search_text text
+  @last_response.body.should eq 'true'
+end
+

data/features/support/env.rb

@@ -0,0 +1,30 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '../../', 'lib'))
+
+require 'brazenhead'
+require 'brazenhead/server'
+require 'ADB'
+require 'childprocess'
+
+World(ADB)
+
+keystore = {
+  :path => 'features/support/debug.keystore',
+  :alias => 'androiddebugkey',
+  :password => 'android',
+  :keystore_password => 'android'
+}
+
+server = Brazenhead::Server.new('features/support/ApiDemos.apk', keystore)
+
+class Driver
+  include Brazenhead
+end
+
+Before do
+  @driver = Driver.new
+  server.start("ApiDemos")
+end
+
+After do
+  server.stop
+end

data/lib/brazenhead/android.rb

@@ -0,0 +1,37 @@
+module Brazenhead
+  module Android
+    def path_to(sdk)
+      jar = android_jar(sdk)
+      android_jar_missing(sdk) unless File.exists? jar
+      jar
+    end
+
+    def default_keystore
+      {:path => default_key_path,
+       :alias => 'androiddebugkey',
+       :password => 'android',
+       :keystore_password => 'android'}
+    end
+
+    private
+    def android_home
+      ENV['ANDROID_HOME']
+    end
+
+    def platform(sdk)
+      "platforms/android-#{sdk}"
+    end
+
+    def default_key_path
+      File.expand_path("~/.android/debug.keystore")
+    end
+
+    def android_jar(sdk)
+      File.join(android_home, platform(sdk), 'android.jar')
+    end
+
+    def android_jar_missing(sdk)
+      raise Exception, "the path to android-#{sdk} was not found"
+    end
+  end
+end

data/lib/brazenhead/builder.rb

@@ -0,0 +1,92 @@
+require 'tempfile'
+require 'brazenhead/manifest_info'
+require 'brazenhead/package'
+require 'ADB'
+
+module Brazenhead
+  class Builder
+    include Brazenhead::Package
+    include ADB
+
+    def build_for(apk, keystore)
+      @source_apk = apk
+      @keystore = keystore
+      invalid_package_err(apk) unless File.exists? @source_apk
+      install_server
+      manifest_info
+    end
+
+    private
+    def install_server
+      Dir.mktmpdir do |dir|
+        copy_base_files_to(dir)
+        update_manifest_in(dir)
+        sign(test_apk_in(dir), @keystore)
+        reinstall test_apk_in(dir)
+        reinstall @source_apk
+      end
+    end
+
+    def reinstall(apk, timeout=90)
+      install apk, "-r", {}, timeout
+    end
+
+    def copy_base_files_to(dir)
+      [test_apk, manifest].each do |file|
+        FileUtils.copy_file(driver_path_for(file), join(dir, file))
+      end
+    end
+
+    def driver_path_for(file)
+      join(File.expand_path("../../../", __FILE__), 'driver', file)
+    end
+
+    def join(*paths)
+      File.join(*paths)
+    end
+
+    def update_manifest_in(dir)
+      manifest_path = join(dir, manifest)
+
+      replace(manifest_path, target_match, target_replace)
+      update_manifest(test_apk_in(dir), manifest_path, manifest_info.target_sdk)
+    end
+
+    def test_apk_in(dir)
+      join(dir, test_apk)
+    end
+
+    def replace(file, match, replacement)
+      File.write(file, File.read(file).gsub(match, replacement))
+    end
+
+    def target_match
+      /\btargetPackage="[^"]+"/
+    end
+
+    def target_replace
+      "targetPackage=\"#{the_target}\""
+    end
+
+    def the_target
+      @the_target ||= manifest_info.package
+    end
+
+    def manifest_info
+      @info ||= Brazenhead::ManifestInfo.new(@source_apk)
+    end
+
+    def test_apk
+      'brazenhead-release-unsigned.apk'
+    end
+
+    def manifest
+      'AndroidManifest.xml'
+    end
+
+    def invalid_package_err(apk)
+      raise Exception.new("Invalid package path:  #{apk}")
+    end
+
+  end
+end

data/lib/brazenhead/call_accumulator.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__),  '/', 'request')
+
+module Brazenhead
+  class CallAccumulator
+    def method_missing(method, *args)
+      calls << request.call(method.to_s.to_java_call, args)
+    end
+
+    def message
+      "commands=#{calls.to_json}"
+    end
+
+    def clear
+      @calls = []
+    end
+
+    private
+    
+    def calls
+      @calls ||= []
+    end
+
+    def request
+      @request ||= Brazenhead::Request.new
+    end
+
+  end
+end

data/lib/brazenhead/core_ext/string.rb

@@ -0,0 +1,7 @@
+class String
+  def to_java_call
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    camel = self.split('_').map{|e| e.capitalize}.join
+    camel.sub(camel[0], camel[0].downcase)
+  end
+end

data/lib/brazenhead/device.rb

@@ -0,0 +1,35 @@
+require 'net/http'
+
+module Brazenhead
+  class Device
+
+    def send(message)
+      retries = 0
+      begin
+        @last_response = http.post '/', message
+      rescue
+        retries += 1
+        sleep 0.5
+        retry unless retries == 20
+        $stderr.puts "Failed to send the command #{message} #{retries} times..."
+        raise
+      end
+      @last_response
+    end
+    
+    def stop
+      http.post '/kill', ''
+    end
+
+    def last_response
+      @last_response
+    end
+
+    private
+
+    def http
+      @http ||= Net::HTTP.new '127.0.0.1', 7777
+    end
+    
+  end
+end

data/lib/brazenhead/manifest_info.rb

@@ -0,0 +1,51 @@
+require 'brazenhead/process'
+
+module Brazenhead
+  class ManifestInfo
+
+    def package
+      first_capture /\bpackage="([^"]+)"/
+    end
+
+    def min_sdk
+      sdk(:min) || 1
+    end
+
+    def max_sdk
+      sdk(:max)
+    end
+
+    def target_sdk
+      sdk(:target)
+    end
+
+    def initialize(apk)
+      @apk = apk
+    end
+
+    private
+    def manifest
+      @manifest ||= load_manifest
+    end
+
+    def load_manifest
+      process.run('aapt', 'dump', 'xmltree', @apk, 'AndroidManifest.xml')
+      process.last_stdout
+    end
+
+    def first_capture(regex)
+      match = regex.match(manifest)
+      match.captures[0] unless match.nil?
+    end
+
+    def sdk(which)
+      found = first_capture /android:#{which}SdkVersion.*=\(.*\)0x(\h+)/
+      found.hex unless found.nil?
+    end
+
+
+    def process
+      @process ||= Brazenhead::Process.new
+    end
+  end
+end

data/lib/brazenhead/package.rb

@@ -0,0 +1,36 @@
+require 'brazenhead/android'
+require 'brazenhead/signer'
+
+module Brazenhead
+  module Package
+    include Brazenhead::Android
+    include Brazenhead::Signer
+
+    def update_manifest(apk, manifest, min_sdk = 8)
+      process.run(*update, *package(apk), *with(manifest), *using(path_to(min_sdk)))
+    end
+
+    private
+    def process
+      @process ||= Brazenhead::Process.new
+    end
+
+    def update
+      "aapt p -u -f".split
+    end
+
+    def package(apk)
+      ["-F", apk]
+    end
+
+    def with(manifest)
+      ["-M", manifest]
+    end
+
+    def using(path)
+      ["-I", path]
+    end
+
+  end
+
+end

data/lib/brazenhead/process.rb

@@ -0,0 +1,35 @@
+require 'childprocess'
+require 'tempfile'
+
+module Brazenhead
+  class Process
+
+    attr_accessor :last_stdout, :last_stderr
+
+    def run(process, *args)
+      process = ChildProcess.build(process, *args)
+      process.io.stdout, process.io.stderr = std_out_err
+      process.start
+      process.wait
+      @last_stdout = output(process.io.stdout)
+      @last_stderr = output(process.io.stderr)
+    end
+
+    def std_out_err
+      return ::Tempfile.new("brazenhead-proc-out-#{now}"), ::Tempfile.new("brazenhead-proc-err-#{now}")
+    end
+
+    private
+    def output(file)
+      file.rewind
+      out = file.read
+      file.close
+      file.unlink
+      out
+    end
+
+    def now
+      "#{Time.now}".gsub(':', '_')
+    end
+  end
+end

data/lib/brazenhead/request.rb

@@ -0,0 +1,40 @@
+require 'json'
+
+module Brazenhead
+  class Request
+    def build(method, args)
+      "commands=#{[call(method, args)].to_json}"
+    end
+
+    def call(method, args)
+      target = parse_target(args[-1])
+      variable = parse_variable(args[-1])
+      build_call(method, strip_hash_arg(args), variable, target)
+    end
+
+    private
+
+    def build_call(method, args, variable, target)
+      call = {:name => method} if args.empty?
+      call = {:name => method, :arguments => args} unless args.empty?
+      call[:variable] = variable if variable
+      call[:target] = target if target
+      call
+    end
+
+    def parse_target(hsh)
+      target = hsh.delete(:target) if hsh.is_a?(Hash)
+      return target.nil? ? nil : target
+    end
+
+    def parse_variable(hsh)
+      variable = hsh.delete(:variable) if hsh.is_a?(Hash)
+      return variable.nil? ? nil : variable
+    end
+
+    def strip_hash_arg(args)
+      args.delete_at(-1) if args[-1].is_a?(Hash) and args[-1].empty?
+      args
+    end
+  end
+end

data/lib/brazenhead/server.rb

@@ -0,0 +1,54 @@
+require 'brazenhead/builder'
+require 'brazenhead/device'
+
+module Brazenhead
+  class Server
+    include Brazenhead::Package
+    include ADB
+
+    def initialize(apk, keystore = default_keystore)
+      @apk = apk
+      @keystore = keystore
+    end
+
+    def start(activity)
+      build
+      instrument(runner, :packageName => their_package, :fullLauncherName => full(activity) , :class => the_test)
+    end
+
+    def stop
+      device.stop
+    end
+
+    private
+    def build
+      forward "tcp:7777", "tcp:54767"
+      @manifest_info ||= Brazenhead::Builder.new.build_for(@apk, @keystore)
+    end
+
+    def device
+      @device ||= Brazenhead::Device.new
+    end
+
+    def the_test
+      "#{leandog}.TheTest"
+    end
+
+    def full(activity)
+      "#{their_package}.#{activity}"
+    end
+
+    def their_package
+      @manifest_info.package
+    end
+
+    def runner
+      "#{leandog}/#{leandog}.BrazenheadInstrumentation"
+    end
+
+    def leandog
+      'com.leandog.brazenhead'
+    end
+
+  end
+end