xcmonkey 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d3bd605b57ec05a83a3cca39707b5c2fc9529828131b9ac872f3dc478180bbb
-  data.tar.gz: 8793e64f73775a2c8de84d1b79d0aebd258df7c22b9c8f43de2618f63f306d4e
+  metadata.gz: c93c94403332c085a393877d88d354b2736788f6e52d118eb8b9faa70c91b1e5
+  data.tar.gz: ee0f3bfcd014151b4821a6df50f601205581ebd480b5626e33588bda2928981a
 SHA512:
-  metadata.gz: 4e4634518e71dac0ed206d4fec26fc707fb9dbea8116c87db1959695261e8ee311246db203317790433d18b5e5250074f1f17bf567101dfec6767a1ed5db0670
-  data.tar.gz: 0e696e9804b94e6106f203b9bcda008f57dbe7fbda78a68ff7d57a8cfa980e4b691b533f430bac855ae8ed56ae0e7ac5085f305853bae8f03652095871287a94
+  metadata.gz: 0ab88db343b0e83363130a9e9c8ed965acbf9d58f56d597b301ff12da4df9d4e79b08c3b2284b870a65c9bfc3d05a8ba9df0d19409631620a28836c9d5785814
+  data.tar.gz: fe46af5c215273be9210f3c880617457a12c6063e0bd1901d6abbd10750f10935b77a4797ff374926c3f1cac6b1ef79032f210fb705e05917146e4c64cede97c

data/README.md

@@ -39,7 +39,7 @@ gem 'xcmonkey'
 ### To run a stress test
 
 ```bash
-xcmonkey test --udid "413EA256-CFFB-4312-94A6-12592BEE4CBA" --bundle-id "com.apple.Maps" --duration 100
+$ xcmonkey test --duration 100 --bundle-id "com.apple.Maps" --udid "413EA256-CFFB-4312-94A6-12592BEE4CBA"
 
 12:44:19.343: Device info: {
   "name": "iPhone 14 Pro",
@@ -106,9 +106,9 @@ require 'xcmonkey'
 
 lane :test do
   Xcmonkey.new(
-    udid: '413EA256-CFFB-4312-94A6-12592BEE4CBA',
+    duration: 100,
     bundle_id: 'com.apple.Maps',
-    duration: 100
+    udid: '413EA256-CFFB-4312-94A6-12592BEE4CBA'
   ).run
 end
 ```

data/lib/xcmonkey/driver.rb

@@ -16,15 +16,16 @@ class Driver
     puts
     ensure_device_exists
     ensure_app_installed
-    terminate_app
-    open_home_screen(with_tracker: true)
-    launch_app
+    terminate_app(bundle_id)
+    launch_app(target_bundle_id: bundle_id, wait_for_state_update: true)
+    @running_apps = list_running_apps
   end
 
   def monkey_test(gestures)
     monkey_test_precondition
     app_elements = describe_ui.shuffle
     current_time = Time.now
+    counter = 0
     while Time.now < current_time + session_duration
       el1_coordinates = central_coordinates(app_elements.first)
       el2_coordinates = central_coordinates(app_elements.last)
@@ -52,17 +53,17 @@ class Driver
       else
         next
       end
+      detect_app_state_change
+      track_running_apps if counter % 5 == 0 # Track running apps after every 5th action to speed up the test
+      counter += 1
       app_elements = describe_ui.shuffle
-      next unless app_elements.include?(@home_tracker)
-
-      save_session
-      Logger.error('App lost')
     end
     save_session
   end
 
   def repeat_monkey_test
     monkey_test_precondition
+    counter = 0
     session_actions.each do |action|
       case action['type']
       when 'tap'
@@ -78,15 +79,12 @@ class Driver
       else
         next
       end
-      Logger.error('App lost') if describe_ui.shuffle.include?(@home_tracker)
+      detect_app_state_change
+      track_running_apps if counter % 5 == 0
+      counter += 1
     end
   end
 
-  def open_home_screen(with_tracker: false)
-    `idb ui button --udid #{udid} HOME`
-    detect_home_unique_element if with_tracker
-  end
-
   def describe_ui
     JSON.parse(`idb ui describe-all --udid #{udid}`)
   end
@@ -97,13 +95,13 @@ class Driver
     point_info
   end
 
-  def launch_app
-    `idb launch --udid #{udid} #{bundle_id}`
-    wait_until_app_launched
+  def launch_app(target_bundle_id:, wait_for_state_update: false)
+    `idb launch --udid #{udid} #{target_bundle_id}`
+    wait_until_app_launched(target_bundle_id) if wait_for_state_update
   end
 
-  def terminate_app
-    `idb terminate --udid #{udid} #{bundle_id} 2>/dev/null`
+  def terminate_app(target_bundle_id)
+    `idb terminate --udid #{udid} #{target_bundle_id} 2>/dev/null`
   end
 
   def boot_simulator
@@ -130,6 +128,10 @@ class Driver
     `idb list-apps --udid #{udid} --json`.split("\n").map! { |app| JSON.parse(app) }
   end
 
+  def list_running_apps
+    list_apps.select { |app| app['process_state'] == 'Running' }
+  end
+
   def ensure_app_installed
     return if list_apps.any? { |app| app['bundle_id'] == bundle_id }
 
@@ -144,6 +146,9 @@ class Driver
     if device['type'] == 'simulator'
       configure_simulator_keyboard
       boot_simulator
+    else
+      Logger.error('xcmonkey does not support real devices yet. ' \
+                   'For more information see https://github.com/alteral/xcmonkey/issues/7')
     end
   end
 
@@ -220,28 +225,57 @@ class Driver
     File.write("#{session_path}/xcmonkey-session.json", JSON.pretty_generate(@session))
   end
 
-  private
+  # This function takes ≈200ms
+  def track_running_apps
+    current_list_of_running_apps = list_running_apps
+    if @running_apps != current_list_of_running_apps
+      currently_running_bundle_ids = current_list_of_running_apps.map { |app| app['bundle_id'] }
+      previously_running_bundle_ids = @running_apps.map { |app| app['bundle_id'] }
+      new_apps = currently_running_bundle_ids - previously_running_bundle_ids
 
-  def ensure_driver_installed
-    Logger.error("'idb' doesn't seem to be installed") if `which idb`.strip.empty?
+      return if new_apps.empty?
+
+      launch_app(target_bundle_id: bundle_id)
+      new_apps.each do |id|
+        Logger.warn("Shutting down: #{id}")
+        terminate_app(id)
+      end
+    end
   end
 
-  def detect_home_unique_element
-    @home_tracker ||= describe_ui.reverse.detect do |el|
-      sleep(1)
-      !el['AXUniqueId'].nil? && !el['AXUniqueId'].empty? && el['type'] == 'Button'
+  # This function takes ≈300ms
+  def detect_app_state_change
+    return unless detect_app_in_background
+
+    target_app_is_running = list_running_apps.any? { |app| app['bundle_id'] == bundle_id }
+
+    if target_app_is_running
+      launch_app(target_bundle_id: bundle_id)
+    else
+      save_session
+      Logger.error("Target app has crashed or been terminated")
     end
-    @home_tracker
   end
 
-  def wait_until_app_launched
+  def detect_app_in_background
+    current_app_label = describe_ui.detect { |el| el['type'] == 'Application' }['AXLabel']
+    current_app_label.nil? || current_app_label.strip.empty?
+  end
+
+  private
+
+  def ensure_driver_installed
+    Logger.error("'idb' doesn't seem to be installed") if `which idb`.strip.empty?
+  end
+
+  def wait_until_app_launched(target_bundle_id)
     app_is_running = false
     current_time = Time.now
     while !app_is_running && Time.now < current_time + 5
-      app_info = list_apps.detect { |app| app['bundle_id'] == bundle_id }
+      app_info = list_apps.detect { |app| app['bundle_id'] == target_bundle_id }
       app_is_running = app_info && app_info['process_state'] == 'Running'
     end
-    Logger.error("Can't run the app #{bundle_id}") unless app_is_running
+    Logger.error("Can't run the app #{target_bundle_id}") unless app_is_running
     Logger.info('App info:', payload: JSON.pretty_generate(app_info))
   end
 end

data/lib/xcmonkey/version.rb

@@ -1,3 +1,3 @@
 class Xcmonkey
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/spec/describer_spec.rb

@@ -2,15 +2,17 @@ describe Describer do
   let(:udid) { `xcrun simctl list | grep " iPhone 14 Pro Max"`.split("\n")[0].split('(')[1].split(')')[0] }
   let(:driver) { Driver.new(udid: udid) }
 
-  it 'verifies that point can be described (integer)' do
+  before do
     allow(Logger).to receive(:info)
+  end
+
+  it 'verifies that point can be described (integer)' do
     driver.boot_simulator
     point_info = described_class.new(udid: udid, x: 10, y: 10).run
     expect(point_info).not_to be_empty
   end
 
   it 'verifies that point can be described (string)' do
-    allow(Logger).to receive(:info)
     driver.boot_simulator
     point_info = described_class.new(udid: udid, x: '10', y: '10').run
     expect(point_info).not_to be_empty

data/spec/driver_spec.rb

@@ -4,6 +4,10 @@ describe Driver do
   let(:driver) { described_class.new(udid: udid, bundle_id: bundle_id, session_path: Dir.pwd) }
   let(:driver_with_session) { described_class.new(udid: udid, bundle_id: bundle_id, session_actions: [{ type: 'tap', x: 0, y: 0 }]) }
 
+  before do
+    allow(Logger).to receive(:info)
+  end
+
   it 'verifies that sumulator was booted' do
     error_message = "Failed to boot #{udid}"
     expect(Logger).not_to receive(:error).with(error_message, payload: nil)
@@ -16,18 +20,6 @@ describe Driver do
     expect(ui).not_to be_empty
   end
 
-  it 'verifies that home screen can be opened' do
-    driver.boot_simulator
-    home_tracker = driver.open_home_screen(with_tracker: true)
-    expect(home_tracker).not_to be_empty
-  end
-
-  it 'verifies that home screen can be opened without tracker' do
-    driver.boot_simulator
-    home_tracker = driver.open_home_screen(with_tracker: false)
-    expect(home_tracker).to be_nil
-  end
-
   it 'verifies that list of targets can be showed' do
     list_targets = driver.list_targets
     expect(list_targets).not_to be_empty
@@ -56,9 +48,7 @@ describe Driver do
   end
 
   it 'verifies that device exists' do
-    payload = driver.list_targets.detect { |target| target['udid'] == udid }
     expect(Logger).not_to receive(:error)
-    expect(Logger).to receive(:info).with('Device info:', payload: JSON.pretty_generate(payload))
     expect(driver).to receive(:boot_simulator)
     expect(driver).to receive(:configure_simulator_keyboard)
     expect { driver.ensure_device_exists }.not_to raise_error
@@ -137,18 +127,25 @@ describe Driver do
     expect(keyboard_state.first).to include('1')
   end
 
-  it 'verifies that app can be launched' do
+  it 'verifies that app can be launched with waiting' do
+    expect(Logger).not_to receive(:error)
+    expect(driver).to receive(:wait_until_app_launched)
+    driver.boot_simulator
+    driver.terminate_app(bundle_id)
+    expect { driver.launch_app(target_bundle_id: bundle_id, wait_for_state_update: true) }.not_to raise_error
+  end
+
+  it 'verifies that app can be launched without waiting' do
     expect(Logger).not_to receive(:error)
-    expect(Logger).to receive(:info)
+    expect(driver).not_to receive(:wait_until_app_launched)
     driver.boot_simulator
-    driver.terminate_app
-    expect { driver.launch_app }.not_to raise_error
+    driver.terminate_app(bundle_id)
+    expect { driver.launch_app(target_bundle_id: bundle_id) }.not_to raise_error
   end
 
   it 'verifies tap in new session' do
     driver.boot_simulator
     coordinates = { x: 1, y: 1 }
-    expect(Logger).to receive(:info).with('Tap:', payload: JSON.pretty_generate(coordinates))
     driver.tap(coordinates: coordinates)
     expect(driver.instance_variable_get(:@session)[:actions]).not_to be_empty
   end
@@ -156,7 +153,6 @@ describe Driver do
   it 'verifies tap in old session' do
     driver_with_session.boot_simulator
     coordinates = { x: 1, y: 1 }
-    expect(Logger).to receive(:info).with('Tap:', payload: JSON.pretty_generate(coordinates))
     driver_with_session.tap(coordinates: coordinates)
     expect(driver_with_session.instance_variable_get(:@session)[:actions]).to be_empty
   end
@@ -165,7 +161,6 @@ describe Driver do
     driver.boot_simulator
     duration = 0.5
     coordinates = { x: 1, y: 1 }
-    expect(Logger).to receive(:info).with("Press (#{duration}s):", payload: JSON.pretty_generate(coordinates))
     driver.press(coordinates: coordinates, duration: duration)
     expect(driver.instance_variable_get(:@session)[:actions]).not_to be_empty
   end
@@ -174,7 +169,6 @@ describe Driver do
     driver_with_session.boot_simulator
     duration = 0.5
     coordinates = { x: 1, y: 1 }
-    expect(Logger).to receive(:info).with("Press (#{duration}s):", payload: JSON.pretty_generate(coordinates))
     driver_with_session.press(coordinates: coordinates, duration: duration)
     expect(driver_with_session.instance_variable_get(:@session)[:actions]).to be_empty
   end
@@ -184,7 +178,6 @@ describe Driver do
     duration = 0.5
     start_coordinates = { x: 1, y: 1 }
     end_coordinates = { x: 2, y: 2 }
-    expect(Logger).to receive(:info).with("Swipe (#{duration}s):", payload: "#{JSON.pretty_generate(start_coordinates)} => #{JSON.pretty_generate(end_coordinates)}")
     driver.swipe(start_coordinates: start_coordinates, end_coordinates: end_coordinates, duration: duration)
     expect(driver.instance_variable_get(:@session)[:actions]).not_to be_empty
   end
@@ -194,7 +187,6 @@ describe Driver do
     duration = 0.5
     start_coordinates = { x: 1, y: 1 }
     end_coordinates = { x: 2, y: 2 }
-    expect(Logger).to receive(:info).with("Swipe (#{duration}s):", payload: "#{JSON.pretty_generate(start_coordinates)} => #{JSON.pretty_generate(end_coordinates)}")
     driver_with_session.swipe(start_coordinates: start_coordinates, end_coordinates: end_coordinates, duration: duration)
     expect(driver_with_session.instance_variable_get(:@session)[:actions]).to be_empty
   end
@@ -210,12 +202,12 @@ describe Driver do
     app_info = driver.list_apps.detect { |app| app['bundle_id'] == bundle_id }
     app_is_running = app_info && app_info['process_state'] == 'Running'
     expect(app_is_running).to be(true)
+    expect(driver.instance_variable_get(:@running_apps)).not_to be_nil
   end
 
   it 'verifies that monkey_test works fine' do
     params = { udid: udid, bundle_id: bundle_id, duration: 1, session_path: Dir.pwd }
     driver = described_class.new(params)
-    expect(driver).to receive(:monkey_test_precondition)
     driver.monkey_test(Xcmonkey.new(params).gestures)
     expect(driver.instance_variable_get(:@session)[:actions]).not_to be_empty
   end
@@ -227,8 +219,6 @@ describe Driver do
       { 'type' => 'swipe', 'x' => 12, 'y' => 12, 'endX' => 15, 'endY' => 15, 'duration' => 0.3 }
     ]
     driver = described_class.new(udid: udid, bundle_id: bundle_id, session_actions: session_actions)
-    allow(Logger).to receive(:info).twice
-    expect(driver).to receive(:monkey_test_precondition)
     expect(driver).to receive(:tap).with(coordinates: { x: 10, y: 10 })
     expect(driver).to receive(:press).with(coordinates: { x: 11, y: 11 }, duration: 1.4)
     expect(driver).to receive(:swipe).with(start_coordinates: { x: 12, y: 12 }, end_coordinates: { x: 15, y: 15 }, duration: 0.3)
@@ -238,7 +228,6 @@ describe Driver do
 
   it 'verifies that unknown actions does not break repeat_monkey_test' do
     driver = described_class.new(udid: udid, bundle_id: bundle_id, session_actions: [{ 'type' => 'test', 'x' => 10, 'y' => 10 }])
-    allow(Logger).to receive(:info).twice
     expect(driver).to receive(:monkey_test_precondition)
     expect(driver).not_to receive(:tap)
     expect(driver).not_to receive(:press)
@@ -247,6 +236,59 @@ describe Driver do
     expect(driver.instance_variable_get(:@session)[:actions]).to be_empty
   end
 
+  it 'verifies that running apps are tracked' do
+    new_app_bundle_id = 'com.apple.Preferences'
+    driver.terminate_app(new_app_bundle_id)
+    driver.monkey_test_precondition
+    driver.launch_app(target_bundle_id: new_app_bundle_id, wait_for_state_update: true)
+    expect(driver).to receive(:launch_app).with(target_bundle_id: bundle_id)
+    expect(driver).to receive(:terminate_app).with(new_app_bundle_id)
+    driver.track_running_apps
+  end
+
+  it 'verifies that running apps can be determined' do
+    driver.terminate_app(bundle_id)
+    sum = driver.list_running_apps.size
+    driver.launch_app(target_bundle_id: bundle_id)
+    expect(driver.list_running_apps.size).to eq(sum + 1)
+  end
+
+  it 'verifies that app state change can be determined' do
+    driver.launch_app(target_bundle_id: bundle_id)
+    allow(driver).to receive(:detect_app_in_background).and_return(true)
+    expect(driver).not_to receive(:save_session)
+    expect(driver).to receive(:launch_app)
+    expect { driver.detect_app_state_change }.not_to raise_error
+  end
+
+  it 'verifies that background is the invalid app state' do
+    driver.terminate_app(bundle_id)
+    expect(driver).to receive(:save_session)
+    expect { driver.detect_app_state_change }.to raise_error(SystemExit) { |e| expect(e.status).to eq(1) }
+  end
+
+  it 'verifies that foreground is the valid app state' do
+    driver.launch_app(target_bundle_id: bundle_id, wait_for_state_update: true)
+    expect { driver.detect_app_state_change }.not_to raise_error
+  end
+
+  it 'verifies that background state can be determined' do
+    driver.terminate_app(bundle_id)
+    expect(driver.detect_app_in_background).to be(true)
+  end
+
+  it 'verifies that foregroung state can be determined' do
+    driver.monkey_test_precondition
+    expect(driver.detect_app_in_background).to be(false)
+  end
+
+  it 'verifies that xcmonkey behaves as expected on real devices' do
+    udid = '1234-5678'
+    driver = described_class.new(udid: udid, bundle_id: bundle_id)
+    allow(driver).to receive(:list_targets).and_return([{ 'udid' => udid, 'type' => 'device' }])
+    expect { driver.ensure_device_exists }.to raise_error(SystemExit) { |e| expect(e.status).to eq(1) }
+  end
+
   it 'verifies that simulator was not booted' do
     driver.shutdown_simulator
     error_message = "Failed to boot #{udid}"

data/spec/xcmonkey_spec.rb

@@ -2,6 +2,10 @@ describe Xcmonkey do
   let(:params) { { udid: '123', bundle_id: 'example.com.app', duration: 10, session_path: Dir.pwd } }
   let(:duration_error_msg) { 'Duration must be Integer and not less than 1 second' }
 
+  before do
+    allow(Logger).to receive(:info)
+  end
+
   it 'verifies gestures' do
     gestures = described_class.new(params).gestures
     taps = [:precise_tap, :blind_tap] * 10

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcmonkey
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - alteral
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-20 00:00:00.000000000 Z
+date: 2023-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler