ruby_apk 0.4.0

data/spec/apk_spec.rb

@@ -0,0 +1,268 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'tempfile'
+require 'zip/zip'
+require 'digest/sha1'
+require 'digest/sha2'
+require 'digest/md5'
+
+class TempApk
+  attr_reader :path
+  def initialize
+    @tmp = Tempfile.open('apk_spec')
+    @path = @tmp.path
+    @tmp.close! # delete file
+    append("AndroidManifest.xml", "hogehoge")
+    append("resources.arsc", "hogehoge")
+  end
+  def destroy!
+    File.unlink(@path) if File.exist? @path
+  end
+  def append(entry_name, data)
+    Zip::ZipFile.open(@path, Zip::ZipFile::CREATE) { |zip|
+      zip.get_output_stream(entry_name) {|f| f.write data }
+    }
+  end
+  def remove(entry_name)
+    Zip::ZipFile.open(@path, Zip::ZipFile::CREATE) { |zip|
+      zip.remove(entry_name)
+    }
+  end
+end
+
+describe Android::Apk do
+  before do
+    $stderr.reopen('/dev/null','w')
+  end
+  let(:tmp_apk) { TempApk.new }
+  let(:tmp_path) { tmp_apk.path }
+  let(:apk) { Android::Apk.new(tmp_path) }
+  subject { apk }
+
+  after do
+    tmp_apk.destroy!
+  end
+
+  describe "#initialize" do
+    let(:path) { tmp_path }
+    subject { Android::Apk.new(path) }
+    context "with not exist path" do
+      let(:path) { "not exist path" }
+      it { expect{ subject }.to raise_error Android::NotFoundError }
+    end
+    context "with not zip file path" do
+      let(:path) { __FILE__ } # not zip file
+      it { expect{ subject }.to raise_error Android::NotApkFileError }
+    end
+    context "with zip(and non apk) file" do
+      before do
+        tmp_apk.append('hoge.txt', 'hogehoge')
+        tmp_apk.remove('AndroidManifest.xml')
+      end
+      it { expect{ subject }.to raise_error Android::NotApkFileError }
+    end
+    context "with zip includes AndroidManifest.xml" do
+      it { should be_a_instance_of Android::Apk }
+    end
+  end
+
+  describe "#path" do
+    subject { apk.path }
+    it "should equals initialized path" do
+      should == tmp_path
+    end
+  end
+
+  describe "#manifest" do
+    subject { apk.manifest }
+
+    context "when Manifest parse is succeeded." do
+      let(:mock_mani) { mock(Android::Manifest) }
+
+      before do
+      end
+      it "should return manifest object" do
+        Android::Manifest.should_receive(:new).and_return(mock_mani)
+        subject.should == mock_mani
+      end
+    end
+
+    context "when Manifest parse is failed" do
+      it 'should return nil' do
+        Android::Manifest.should_receive(:new).and_raise(Android::AXMLParser::ReadError)
+        subject.should be_nil
+      end
+    end
+  end
+
+  describe "#dex" do
+    let(:mock_dex) { mock(Android::Dex) }
+    subject { apk.dex }
+    context "when there is no dex file" do
+      it { should be_nil }
+    end
+    context "when invalid dex file" do
+      before do
+        tmp_apk.append("classes.dex", "invalid dex")
+      end
+      it { should be_nil }
+    end
+    context "with mock classes.dex file" do
+      before do
+        tmp_apk.append("classes.dex", "mock data")
+      end
+      it "should return mock value" do
+        Android::Dex.should_receive(:new).with("mock data").and_return(mock_dex)
+        subject.should == mock_dex
+      end
+    end
+    context "with real classes.dex file" do
+      before do
+        dex_path = File.expand_path(File.dirname(__FILE__) + '/data/sample_classes.dex')
+        tmp_apk.append("classes.dex", File.open(dex_path, "rb") {|f| f.read })
+      end
+      it { should be_instance_of Android::Dex }
+    end
+  end
+
+  its(:bindata) { should be_instance_of String }
+  describe '#bindata' do
+    specify 'encoding should be ASCII-8BIT' do
+      subject.bindata.encoding.should eq Encoding::ASCII_8BIT 
+    end
+  end
+
+  describe '#resource' do
+    let(:mock_rsc) { mock(Android::Resource) }
+    subject { apk.resource }
+    it "should return manifest object" do
+      Android::Resource.should_receive(:new).and_return(mock_rsc)
+      subject.should == mock_rsc
+    end
+  end
+
+  describe "#size" do
+    subject { apk.size }
+    it "should return apk file size" do 
+      should == File.size(tmp_path)
+    end
+  end
+
+  describe "#digest" do
+    let(:data) { File.open(tmp_apk.path, 'rb'){|f| f.read } }
+    subject { apk.digest(type) }
+    context "when type is sha1" do
+      let(:type) { :sha1 }
+      it "should return sha1 digest" do
+        should eq Digest::SHA1.hexdigest(data)
+      end
+    end
+    context "when type is sha256" do
+      let(:type) { :sha256 }
+      it "should return sha256 digest" do
+        should == Digest::SHA256.hexdigest(data)
+      end
+    end
+    context "when type is md5" do
+      let(:type) { :md5 }
+      it "should return md5 digest" do
+        should == Digest::MD5.hexdigest(data)
+      end
+    end
+    context "when type is unkown symbol" do
+      let(:type) { :unknown }
+      it do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+    context "when type is not symbol(String: 'sha1')" do
+      let(:type) { 'sha1' }
+      it { expect { subject }.to raise_error(ArgumentError) }
+    end
+  end
+
+  describe '#time' do
+    subject { apk.time }
+    it { should be_kind_of Time }
+  end
+
+  describe "#each_file" do
+    before do
+      tmp_apk.append("hoge.txt", "aaaaaaa")
+    end
+    it { expect { |b| apk.each_file(&b) }.to yield_successive_args(Array, Array, Array) }
+    let(:each_file_result ) {
+      result = []
+      apk.each_file do |name, data|
+        result << [name, data]
+      end
+      result
+    }
+
+    it "should invoke block with all file" do
+      each_file_result.should have(3).items
+      each_file_result.should include(['AndroidManifest.xml', 'hogehoge'])
+      each_file_result.should include(['hoge.txt','aaaaaaa'])
+    end
+  end
+
+  describe '#file' do
+    let(:data) { 'aaaaaaaaaaaaaaaaaaaaaaaaaaa' }
+    let(:path) { 'hoge.txt' }
+    subject { apk.file(path) }
+
+    before do
+      tmp_apk.append('hoge.txt', data)
+    end
+    context 'assigns exist path' do
+      it 'should equal file data' do
+        should eq data
+      end
+    end
+    context 'assigns not exist path' do
+      let(:path) { 'not_exist_path.txt' }
+      it { expect { subject }.to raise_error(Android::NotFoundError) }
+    end
+  end
+
+  describe '#each_entry' do
+    before do
+      tmp_apk.append("hoge.txt", "aaaaaaa")
+    end
+    it { expect { |b| apk.each_entry(&b) }.to yield_successive_args(Zip::ZipEntry, Zip::ZipEntry, Zip::ZipEntry) }
+  end
+
+  describe '#entry' do
+    subject { apk.entry(entry_name) }
+    context 'assigns exist entry' do
+      let(:entry_name) { 'AndroidManifest.xml' }
+      it { should be_instance_of Zip::ZipEntry }
+    end
+    context 'assigns not exist entry name' do
+      let(:entry_name) { 'not_exist_path' }
+      it { expect{ subject }.to raise_error(Android::NotFoundError) }
+    end
+  end
+
+  describe "#find" do
+    before do
+      tmp_apk.append("hoge.txt", "aaaaaaa")
+    end
+    it "should return matched array" do
+      array = apk.find do |name, data|
+        name == "hoge.txt"
+      end
+      array.should be_instance_of Array
+      array.should have(1).item
+      array[0] == "hoge.txt" # returns filename
+    end
+    context "when no entry is matched" do
+      it "should return emtpy array" do
+        array = apk.find do |name, dota|
+          false # nothing matched
+        end
+        array.should be_instance_of Array
+        array.should be_empty
+      end
+    end
+  end
+end

data/spec/axml_parser_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Android::AXMLParser do
+  let(:bin_xml_path){ File.expand_path(File.dirname(__FILE__) + '/data/sample_AndroidManifest.xml') }
+  let(:bin_xml){ File.open(bin_xml_path, 'rb') {|f| f.read } }
+  let(:axmlparser){ Android::AXMLParser.new(bin_xml) }
+
+  describe "#parse" do
+
+    subject { axmlparser.parse }
+    context 'with sample_AndroidManifest.xml' do
+      it { should be_instance_of(REXML::Document) }
+      specify 'root element should be <manifest> element' do
+        subject.root.name.should eq 'manifest'
+      end
+      specify 'should have 2 <uses-permission> elements' do
+        subject.get_elements('/manifest/uses-permission').should have(2).items
+      end
+    end
+
+    context 'with nil data as binary xml' do
+      let(:bin_xml) { nil }
+      specify { expect{ subject }.to raise_error }
+    end
+
+  end
+
+  describe "#strings" do
+    context 'with sample_AndroidManifest.xml' do
+      subject { axmlparser.strings }
+      before do
+        axmlparser.parse
+      end
+      it { should be_instance_of(Array) }
+
+      # ugh!! the below test cases depend on sample_AndroidManifest.xml
+      it { should have(26).items} # in sample manifest.
+      it { should include("versionCode") }
+      it { should include("versionName") }
+      it { should include("minSdkVersion") }
+      it { should include("package") }
+      it { should include("manifest") }
+    end
+  end
+end

data/spec/dex/access_flag_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Android::Dex::AccessFlag do
+  let(:flag) { 0x01 }
+  subject { Android::Dex::AccessFlag.new(flag) }
+  its(:flag) { should eq flag }
+end
+
+describe Android::Dex::ClassAccessFlag do
+  let(:accessor) { Android::Dex::ClassAccessFlag.new(flags) }
+
+  subject { accessor.to_s }
+  context 'flags are 0x19(public static final)' do
+    let(:flags) { 0x19 }
+    it { should eq 'public static final' }
+  end
+  context 'flags are 0xc0(volatile transient)' do
+    let(:flags) { 0xc0 }
+    it { should eq 'volatile transient' }
+  end
+  context 'flags are 0x22(private synchronized)' do
+    let(:flags) { 0x22 }
+    it { should eq 'private synchronized' }
+  end
+end
+
+describe Android::Dex::MethodAccessFlag do
+  let(:accessor) { Android::Dex::MethodAccessFlag.new(flags) }
+  subject { accessor.to_s }
+  context 'flags are 0x19(public static final)' do
+    let(:flags) { 0x19 }
+    it { should eq 'public static final' }
+  end
+  context 'flags are 0xc0(bridge varargs)' do
+    let(:flags) { 0xc0 }
+    it { should eq 'bridge varargs' }
+  end
+  context 'flags are 0x22(private synchronized)' do
+    let(:flags) { 0x22 }
+    it { should eq 'private synchronized' }
+  end
+end

data/spec/dex/dex_object_spec.rb

@@ -0,0 +1,103 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Android::Dex do
+  describe Android::Dex::DexObject::Header do
+    let(:header_sample) {
+      "\x64\x65\x78\x0A\x30\x33\x35\x00\x3F\x14\x98\x2C\x25\x77\x9B\x8D" +
+      "\x7C\xF0\x0B\xFA\x4D\x7B\x03\xAD\x4C\x15\xBC\x31\x4F\xD3\x4B\x71" +
+      "\x58\x18\x00\x00\x70\x00\x00\x00\x78\x56\x34\x12\x00\x00\x00\x00" +
+      "\x00\x00\x00\x00\x88\x17\x00\x00\x7A\x00\x00\x00\x70\x00\x00\x00" +
+      "\x23\x00\x00\x00\x58\x02\x00\x00\x0E\x00\x00\x00\xE4\x02\x00\x00" +
+      "\x10\x00\x00\x00\x8C\x03\x00\x00\x2C\x00\x00\x00\x0C\x04\x00\x00" +
+      "\x0A\x00\x00\x00\x6C\x05\x00\x00\xAC\x11\x00\x00\xAC\x06\x00\x00"
+    }
+    let(:header) { Android::Dex::DexObject::Header.new(header_sample) }
+    describe "#symbols" do
+      subject { header.symbols }
+      it { should be_kind_of(Array) }
+      it { should have(23).items }
+      it { should include(:magic) }
+      it { should include(:checksum) }
+      it { should include(:signature) }
+      it { should include(:file_size) }
+      it { should include(:header_size) }
+      it { should include(:endian_tag) }
+      it { should include(:link_size) }
+      it { should include(:link_off) }
+      it { should include(:map_off) }
+      it { should include(:string_ids_size) }
+      it { should include(:string_ids_off) }
+      it { should include(:type_ids_size) }
+      it { should include(:type_ids_off) }
+      it { should include(:proto_ids_size) }
+      it { should include(:proto_ids_off) }
+      it { should include(:field_ids_size) }
+      it { should include(:field_ids_off) }
+      it { should include(:method_ids_size) }
+      it { should include(:method_ids_off) }
+      it { should include(:class_defs_size) }
+      it { should include(:class_defs_off) }
+      it { should include(:data_size) }
+      it { should include(:data_off) }
+    end
+
+    describe "#[]" do
+      subject { header }
+      it ':magic should be "dex\n035\0"' do 
+        subject[:magic].should ==  "dex\n035\0"
+      end
+      it ":checksum should be 748164159(this value depends on sample_classes.dex)" do
+        subject[:checksum].should == 748164159
+      end
+      it ":signature should be 20byte string" do
+        subject[:signature].should be_kind_of String
+        subject[:signature].length == 20
+      end
+      it ":file_size should be classes.dex file size" do
+        subject[:file_size].should == 6232
+      end
+      it ":header_size should be 0x70" do
+        subject[:header_size].should == 0x70
+      end
+      it "should have integer params" do
+        subject[:header_size].should == 0x70
+      end
+      context "with int symbols" do
+        before do
+          @params = [
+            :link_size,
+            :link_off,
+            :map_off,
+            :string_ids_size,
+            :string_ids_off,
+            :type_ids_size,
+            :type_ids_off,
+            :proto_ids_size,
+            :proto_ids_off,
+            :field_ids_size,
+            :field_ids_off,
+            :method_ids_size,
+            :method_ids_off,
+            :class_defs_size,
+            :class_defs_off,
+            :data_size,
+            :data_off,
+          ]
+        end
+        it "should have integer value" do
+          @params.each do |sym|
+            subject[sym].should be_kind_of Integer
+          end
+        end
+      end
+      context "with unkown params" do
+        it { subject[:unkown].should be_nil }
+      end
+    end
+
+    describe "#inspect" do
+      subject { header.inspect }
+      it { should match(/\A<Android::Dex::DexObject::Header.*>\Z/m) }
+    end
+  end
+end

data/spec/dex/info_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+shared_context 'with sample_classes.dex', with: :sample_dex do
+  let(:dex_path){ File.expand_path(File.dirname(__FILE__) + '/../data/sample_classes.dex') }
+  let(:dex_bin){ File.open(dex_path, 'rb') {|f| f.read } }
+  let(:dex){ Android::Dex.new(dex_bin) }
+  let(:last_class) { dex.classes.last }
+end
+describe Android::Dex::ClassInfo do
+  include_context 'with sample_classes.dex'
+  context 'about the last class in Dex#classes with sample_classes.dex' do
+    let(:last_class) { dex.classes.last }
+    its(:name){ should eq 'Lexample/app/sample/SampleCode;' }
+    its(:access_flags){ should be_instance_of Android::Dex::ClassAccessFlag }
+    its(:super_class){ should eq 'Ljava/lang/Object;' }
+    its(:class_data){ should be_instance_of Android::Dex::DexObject::ClassDataItem }
+    its(:class_def){ should be_instance_of Android::Dex::DexObject::ClassDefItem }
+    its(:definition) { should eq 'public class Lexample/app/sample/SampleCode; extends Ljava/lang/Object;' }
+
+    subject { last_class }
+    describe '#static_fields' do
+      subject { last_class.static_fields }
+      it { should have(1).item }
+      specify { subject[0].should be_instance_of Android::Dex::FieldInfo }
+    end
+    describe '#instance_fields' do
+      subject { last_class.instance_fields }
+      it { should have(1).item }
+      specify { subject[0].should be_instance_of Android::Dex::FieldInfo }
+    end
+    describe '#direct_methods' do
+      subject { last_class.direct_methods }
+      it { should have(3).items }
+      specify { subject[0].should be_instance_of Android::Dex::MethodInfo }
+    end
+    describe '#virtual_methods' do
+      subject { last_class.virtual_methods }
+      it { should have(18).items }
+      specify { subject[0].should be_instance_of Android::Dex::MethodInfo }
+    end
+  end
+  context 'when class_data_item is nil' do
+    let(:mock_cls_def) {
+      s = double(Android::Dex::DexObject::ClassDefItem)
+      s.stub(:'[]').with(anything()).and_return(0)
+      s.stub(:class_data_item).and_return(nil)
+      s
+    }
+    let(:class_info) { Android::Dex::ClassInfo.new(mock_cls_def, nil) }
+    describe '#static_fields' do
+      subject { class_info.static_fields }
+      it { should be_kind_of Array }
+      it { should be_empty }
+    end
+    describe '#instance_fields' do
+      subject { class_info.instance_fields }
+      it { should be_kind_of Array }
+      it { should be_empty }
+    end
+    describe '#direct_methods' do
+      subject { class_info.direct_methods }
+      it { should be_kind_of Array }
+      it { should be_empty }
+    end
+    describe '#virtual_methods' do
+      subject { class_info.virtual_methods }
+      it { should be_kind_of Array }
+      it { should be_empty }
+    end
+  end
+end
+
+describe Android::Dex::FieldInfo do
+  include_context 'with sample_classes.dex'
+  context 'about the first static field of the last class with sample_classes.dex'do
+    let(:first_static_field) { last_class.static_fields.first }
+    subject { first_static_field }
+    its(:name) { should eq 'TAG' }
+    its(:type) { should eq 'Ljava/lang/String;' }
+    describe '#access_flags' do
+      subject { first_static_field.access_flags }
+      it { should be_instance_of Android::Dex::ClassAccessFlag }
+      specify { subject.to_s.should eq 'private static final' }
+    end
+    describe '#definition' do
+      subject { first_static_field.definition }
+      it { should eq 'private static final Ljava/lang/String; TAG' }
+    end
+  end
+end
+
+describe Android::Dex::MethodInfo do
+  include_context 'with sample_classes.dex'
+  context 'about the first direct method of the last class' do
+    let(:first_direct_method) { last_class.direct_methods.first }
+    subject { first_direct_method }
+    its(:name) { should eq '<init>' }
+  end
+  context 'about the first virtual method of the last class' do
+    let(:first_virtual_method) { last_class.virtual_methods.first }
+    subject { first_virtual_method }
+    its(:name) { should eq 'processDoWhile' }
+    its(:code_item) { should be_instance_of Android::Dex::DexObject::CodeItem }
+    describe '#parameters' do
+      subject { first_virtual_method.parameters }
+      it { should have(1).item }
+      it { should include('int') }
+    end
+  end
+  context 'about the 12th virtual method(processTryCatch) of the last class' do
+    let(:a_virtual_method) { last_class.virtual_methods[12]}
+    subject { a_virtual_method }
+    its(:name) { should eq 'processTryCatch' }
+    describe '#code_item' do
+      subject { a_virtual_method.code_item }
+      it { should be_instance_of Android::Dex::DexObject::CodeItem }
+      its(:debug_info_item) { should be_instance_of Android::Dex::DexObject::DebugInfoItem }
+    end
+  end
+end
+

data/spec/dex/utils_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Android::Dex do
+
+  describe ".uleb128" do
+    # @see http://en.wikipedia.org/wiki/LEB128
+    it "[0x00] should be 0" do
+      Android::Dex.uleb128("\x00").should == [0,1]
+    end
+    it "[0x01] should be 1" do
+      Android::Dex.uleb128("\x01").should == [1,1]
+    end
+    it "[0x7f] should be 127" do
+      Android::Dex.uleb128("\x7f").should == [127,1]
+    end
+    it "[0x80,0x7f] should be 16256" do
+      Android::Dex.uleb128("\x80\x7f").should == [16256,2]
+    end
+    it "[0xe5,0x8e,0x26] should be 624485" do
+      Android::Dex.uleb128("\xe5\x8e\x26").should == [624485,3]
+    end
+  end
+
+  describe ".uleb128p1" do
+    it "[0x00] should be -1" do
+      Android::Dex.uleb128p1("\x00").should == [-1,1]
+    end
+    it "[0x01] should be 0" do
+      Android::Dex.uleb128p1("\x01").should == [0,1]
+    end
+    it "[0x7f] should be 126" do
+      Android::Dex.uleb128p1("\x7f").should == [126,1]
+    end
+    it "[0x80,0x7f] should be 16255" do
+      Android::Dex.uleb128p1("\x80\x7f").should == [16255,2]
+    end
+    it "[0xe5,0x8e,0x26] should be 624485" do
+      Android::Dex.uleb128("\xe5\x8e\x26").should == [624485,3]
+    end
+  end
+  describe '.sleb128' do
+    it "[0x00] should be 0" do
+      Android::Dex.sleb128("\x00").should == [0,1]
+    end
+    it "[0x01] should be 1" do
+      Android::Dex.sleb128("\x01").should == [1,1]
+    end
+    it "[0x7f] should be -1" do
+      Android::Dex.sleb128("\x7f").should == [-1,1]
+    end
+    it "[0x80,0x7f] should be 127" do
+      Android::Dex.sleb128("\x80\x7f").should == [-128,2]
+    end
+  end
+end
+