xcmonkey 0.3.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48bd9b79b2370e4f20366973e689af344f6c75729b361658fbc5bb2c02c38253
-  data.tar.gz: c207e8dbe7c820623f60a9c0b9e8ea8a7e5bce18bfe10f9d5c27e8928829889d
+  metadata.gz: 7d3bd605b57ec05a83a3cca39707b5c2fc9529828131b9ac872f3dc478180bbb
+  data.tar.gz: 8793e64f73775a2c8de84d1b79d0aebd258df7c22b9c8f43de2618f63f306d4e
 SHA512:
-  metadata.gz: 9c0f1f52ad5e8118799556e4e1ba3a49574c504cf2a840fe0369e06c6dbab260fd0a9c275ada9efb789a865759ac48f7d46f9348cde5b2cb53a44969b5189cf9
-  data.tar.gz: 761ffee247c8646bc24dee5fd3f473414402033d3c9a773fe87623579aef93155ecbafc3d412111396945ae485d74b28d6916e5e287754a82b15fcfc792b0c47
+  metadata.gz: 4e4634518e71dac0ed206d4fec26fc707fb9dbea8116c87db1959695261e8ee311246db203317790433d18b5e5250074f1f17bf567101dfec6767a1ed5db0670
+  data.tar.gz: 0e696e9804b94e6106f203b9bcda008f57dbe7fbda78a68ff7d57a8cfa980e4b691b533f430bac855ae8ed56ae0e7ac5085f305853bae8f03652095871287a94

data/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,26 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+## What did you do?
+
+
+## What did you expect to happen?
+
+
+## What happened instead?
+
+
+## Environment
+
+- `xcmonkey` version:
+- `idb` version:
+- `xcode` version:
+- `macOS` version:
+
+## Additional context

data/.github/ISSUE_TEMPLATE/feature-request.md

@@ -0,0 +1,26 @@
+---
+name: Feature request
+about: Got any ideas about new features? Let us know!
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+## What are you trying to achieve?
+
+
+## If possible, how can you achieve this currently?
+
+
+## What would be the better way?
+
+
+## Environment
+
+- `xcmonkey` version:
+- `idb` version:
+- `xcode` version:
+- `macOS` version:
+
+## Additional context

data/.github/pull_request_template.md

@@ -1,9 +1,14 @@
 # Changes
 
 ## References
+
 - https://github.com/alteral/xcmonkey/issues/XXX
 
+## Description
+
+
 ## Risks
+
 - [ ] None
 - [ ] Low
 - [ ] High

data/.github/workflows/test.yml

@@ -17,10 +17,11 @@ jobs:
     env:
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+      PR_NUMBER: ${{ github.event.number }}
     steps:
-      - uses: actions/checkout@v3.2.0
+      - uses: actions/checkout@v3.3.0
 
-      - uses: actions/setup-python@v4.4.0
+      - uses: actions/setup-python@v4.5.0
         with:
           python-version: 3.11
           cache: 'pip'

data/.gitignore

@@ -39,3 +39,6 @@ DerivedData
 
 # Sonar
 .scannerwork
+
+# Cache
+xcmonkey-session.json

data/README.md

@@ -11,7 +11,7 @@
 
 ## Description
 
-*xcmonkey* is a tool for doing randomised UI testing of iOS apps. It's inspired by and has similar goals to [*monkey*](https://developer.android.com/studio/test/monkey) on Android.
+*xcmonkey* is a tool for doing stress testing of iOS apps. It's inspired by and has similar goals to [*monkey*](https://developer.android.com/studio/test/monkey) on Android.
 
 Under the hood, *xcmonkey* uses [iOS Development Bridge](https://fbidb.io/) as a driver, that's why it's pretty smart and can do a lot of things, such as taps, swipes and presses. All that comes «pseudo-random» because it has access to the screen hierarchy, and so can either do actions blindly (like tapping on random points) or precisely (like tapping on the existing elements).
 
@@ -39,10 +39,32 @@ gem 'xcmonkey'
 ### To run a stress test
 
 ```bash
-$ xcmonkey test --udid "413EA256-CFFB-4312-94A6-12592BEE4CBA" --bundle-id "com.apple.Maps" --duration 100
-12:44:19.343: Device info: iPhone 14 Pro | 413EA256-CFFB-4312-94A6-12592BEE4CBA | Booted | simulator | iOS 16.2 | x86_64 | /tmp/idb/413EA256-CFFB-4312-94A6-12592BEE4CBA_companion.sock
+xcmonkey test --udid "413EA256-CFFB-4312-94A6-12592BEE4CBA" --bundle-id "com.apple.Maps" --duration 100
+
+12:44:19.343: Device info: {
+  "name": "iPhone 14 Pro",
+  "udid": "413EA256-CFFB-4312-94A6-12592BEE4CBA",
+  "state": "Booted",
+  "type": "simulator",
+  "os_version": "iOS 16.2",
+  "architecture": "x86_64",
+  "path": "/tmp/idb/413EA256-CFFB-4312-94A6-12592BEE4CBA_companion.sock",
+  "is_local": true,
+  "companion": "/tmp/idb/413EA256-CFFB-4312-94A6-12592BEE4CBA_companion.sock"
+}
 
-12:44:22.550: App info: com.apple.Maps | Maps | system | arm64, x86_64 | Running | Not Debuggable | pid=74636
+12:44:22.550: App info: {
+  "bundle_id": "com.apple.Maps",
+  "name": "Maps",
+  "install_type": "system",
+  "architectures": [
+    "x86_64",
+    "arm64"
+  ],
+  "process_state": "Running",
+  "debuggable": false,
+  "pid": "49186"
+}
 
 12:44:23.203: Tap: {
   "x": 53,
@@ -63,35 +85,32 @@ $ xcmonkey test --udid "413EA256-CFFB-4312-94A6-12592BEE4CBA" --bundle-id "com.a
 }
 ```
 
+### To repeat the stress test from generated session
+
+```bash
+xcmonkey repeat --session-path "./xcmonkey-session.json"
+```
+
 ### To describe the required point
 
 ```bash
-$ xcmonkey describe -x 20 -y 625 --udid "413EA256-CFFB-4312-94A6-12592BEE4CBA"
-20:05:20.212: Device info: iPhone 14 Pro | 413EA256-CFFB-4312-94A6-12592BEE4CBA | Booted | simulator | iOS 16.2 | x86_64 | /tmp/idb/413EA256-CFFB-4312-94A6-12592BEE4CBA_companion.sock
-
-20:05:21.713: x:20 y:625 point info: {
-  "AXFrame": "{{19, 624.3}, {86, 130.6}}",
-  "AXUniqueId": "ShortcutsRowCell",
-  "frame": {
-    "y": 624.3,
-    "x": 19,
-    "width": 86,
-    "height": 130.6
-  },
-  "role_description": "button",
-  "AXLabel": "Home",
-  "content_required": false,
-  "type": "Button",
-  "title": null,
-  "help": null,
-  "custom_actions": [
+xcmonkey describe -x 20 -y 625 --udid "413EA256-CFFB-4312-94A6-12592BEE4CBA"
+```
 
-  ],
-  "AXValue": "Add",
-  "enabled": true,
-  "role": "AXButton",
-  "subrole": null
-}
+## [fastlane](https://github.com/fastlane/fastlane) integration
+
+To run *xcmonkey* from *fastlane*, add the following code to your `Fastfile`:
+
+```ruby
+require 'xcmonkey'
+
+lane :test do
+  Xcmonkey.new(
+    udid: '413EA256-CFFB-4312-94A6-12592BEE4CBA',
+    bundle_id: 'com.apple.Maps',
+    duration: 100
+  ).run
+end
 ```
 
 ## Code of Conduct

data/bin/xcmonkey

@@ -3,11 +3,12 @@
 require 'commander/import'
 require_relative '../lib/xcmonkey'
 require_relative '../lib/xcmonkey/describer'
+require_relative '../lib/xcmonkey/repeater'
 require_relative '../lib/xcmonkey/logger'
 require_relative '../lib/xcmonkey/driver'
 require_relative '../lib/xcmonkey/version'
 
-module Xcmonkey
+class Xcmonkey
   program :version, VERSION
   program :description, 'xcmonkey is a tool for doing randomised UI testing of iOS apps'
 
@@ -18,25 +19,36 @@ module Xcmonkey
     c.option('-b', '--bundle-id STRING', String, 'Set target bundle identifier')
     c.option('-d', '--duration SECONDS', Integer, 'Test duration in seconds. Defaults to `60`')
     c.option('-k', '--enable-simulator-keyboard', 'Should simulator keyboard be enabled? Defaults to `true`')
-    c.action do |args, options|
-      options.default(duration: 60, enable_simulator_keyboard: true)
+    c.option('-s', '--session-path STRING', String, 'Path where monkey testing session should be saved. Defaults to current directory')
+    c.action do |_, options|
       params = {
         udid: options.udid,
         bundle_id: options.bundle_id,
         duration: options.duration,
-        simulator_keyboard: options.enable_simulator_keyboard
+        session_path: options.session_path,
+        enable_simulator_keyboard: options.enable_simulator_keyboard
       }
       Xcmonkey.new(params).run
     end
   end
 
+  command :repeat do |c|
+    c.syntax = 'xcmonkey repeat [options]'
+    c.description = 'Repeats given session'
+    c.option('-s', '--session-path STRING', String, 'Path to monkey testing session')
+    c.action do |_, options|
+      params = { session_path: options.session_path }
+      Repeater.new(params).run
+    end
+  end
+
   command :describe do |c|
     c.syntax = 'xcmonkey describe [options]'
     c.description = 'Describes given point'
     c.option('-u', '--udid STRING', String, 'Set device UDID')
     c.option('-x', '--x STRING', 'Point `x` coordinate')
     c.option('-y', '--y STRING', 'Point `y` coordinate')
-    c.action do |args, options|
+    c.action do |_, options|
       params = {
         udid: options.udid,
         x: options.x,

data/lib/xcmonkey/describer.rb

@@ -1,22 +1,21 @@
 class Describer
-	attr_accessor :udid, :x, :y, :driver
+  attr_accessor :x, :y, :driver
 
-	def initialize(params)
-		ensure_required_params(params)
-		self.udid = params[:udid]
-		self.x = params[:x]
-		self.y = params[:y]
-		self.driver = Driver.new(params)
-	end
+  def initialize(params)
+    ensure_required_params(params)
+    self.x = params[:x]
+    self.y = params[:y]
+    self.driver = Driver.new(params)
+  end
 
-	def run
-		driver.ensure_device_exists
-		driver.describe_point(x, y)
-	end
+  def run
+    driver.ensure_device_exists
+    driver.describe_point(x, y)
+  end
 
-	def ensure_required_params(params)
-		Logger.error('UDID should be provided') if params[:udid].nil?
-		Logger.error('`x` point coordinate should be provided') if params[:x].nil? || params[:x].to_i.to_s != params[:x].to_s
-		Logger.error('`y` point coordinate should be provided') if params[:y].nil? || params[:y].to_i.to_s != params[:y].to_s
-	end
+  def ensure_required_params(params)
+    Logger.error('UDID should be provided') if params[:udid].nil?
+    Logger.error('`x` point coordinate should be provided') if params[:x].nil? || params[:x].to_i.to_s != params[:x].to_s
+    Logger.error('`y` point coordinate should be provided') if params[:y].nil? || params[:y].to_i.to_s != params[:y].to_s
+  end
 end

data/lib/xcmonkey/driver.rb

@@ -1,18 +1,31 @@
 class Driver
-  attr_accessor :udid, :bundle_id, :duration, :enable_simulator_keyboard
+  attr_accessor :udid, :bundle_id, :enable_simulator_keyboard, :session_duration, :session_path, :session_actions
 
   def initialize(params)
     self.udid = params[:udid]
     self.bundle_id = params[:bundle_id]
-    self.duration = params[:duration]
+    self.session_duration = params[:duration]
+    self.session_path = params[:session_path]
     self.enable_simulator_keyboard = params[:enable_simulator_keyboard]
+    self.session_actions = params[:session_actions]
+    @session = { params: params, actions: [] }
     ensure_driver_installed
   end
 
+  def monkey_test_precondition
+    puts
+    ensure_device_exists
+    ensure_app_installed
+    terminate_app
+    open_home_screen(with_tracker: true)
+    launch_app
+  end
+
   def monkey_test(gestures)
+    monkey_test_precondition
     app_elements = describe_ui.shuffle
     current_time = Time.now
-    while Time.now < current_time + duration
+    while Time.now < current_time + session_duration
       el1_coordinates = central_coordinates(app_elements.first)
       el2_coordinates = central_coordinates(app_elements.last)
       case gestures.sample
@@ -40,7 +53,32 @@ class Driver
         next
       end
       app_elements = describe_ui.shuffle
-      Logger.error('App lost') if app_elements.include?(@home_tracker)
+      next unless app_elements.include?(@home_tracker)
+
+      save_session
+      Logger.error('App lost')
+    end
+    save_session
+  end
+
+  def repeat_monkey_test
+    monkey_test_precondition
+    session_actions.each do |action|
+      case action['type']
+      when 'tap'
+        tap(coordinates: { x: action['x'], y: action['y'] })
+      when 'press'
+        press(coordinates: { x: action['x'], y: action['y'] }, duration: action['duration'])
+      when 'swipe'
+        swipe(
+          start_coordinates: { x: action['x'], y: action['y'] },
+          end_coordinates: { x: action['endX'], y: action['endY'] },
+          duration: action['duration']
+        )
+      else
+        next
+      end
+      Logger.error('App lost') if describe_ui.shuffle.include?(@home_tracker)
     end
   end
 
@@ -84,40 +122,40 @@ class Driver
   end
 
   def list_targets
-    @list_targets ||= `idb list-targets`.split("\n")
-    @list_targets
+    @targets ||= `idb list-targets --json`.split("\n").map! { |target| JSON.parse(target) }
+    @targets
   end
 
-  def list_booted_simulators
-    `idb list-targets`.split("\n").grep(/Booted/)
+  def list_apps
+    `idb list-apps --udid #{udid} --json`.split("\n").map! { |app| JSON.parse(app) }
   end
 
   def ensure_app_installed
-    Logger.error("App #{bundle_id} is not installed on device #{udid}") unless list_apps.include?(bundle_id)
+    return if list_apps.any? { |app| app['bundle_id'] == bundle_id }
+
+    Logger.error("App #{bundle_id} is not installed on device #{udid}")
   end
 
   def ensure_device_exists
-    device = list_targets.detect { |target| target.include?(udid) }
+    device = list_targets.detect { |target| target['udid'] == udid }
     Logger.error("Can't find device #{udid}") if device.nil?
 
-    Logger.info('Device info:', payload: device)
-    if device.include?('simulator')
+    Logger.info('Device info:', payload: JSON.pretty_generate(device))
+    if device['type'] == 'simulator'
       configure_simulator_keyboard
       boot_simulator
     end
   end
 
-  def list_apps
-    `idb list-apps --udid #{udid}`
-  end
-
   def tap(coordinates:)
     Logger.info('Tap:', payload: JSON.pretty_generate(coordinates))
+    @session[:actions] << { type: :tap, x: coordinates[:x], y: coordinates[:y] } unless session_actions
     `idb ui tap --udid #{udid} #{coordinates[:x]} #{coordinates[:y]}`
   end
 
   def press(coordinates:, duration:)
     Logger.info("Press (#{duration}s):", payload: JSON.pretty_generate(coordinates))
+    @session[:actions] << { type: :press, x: coordinates[:x], y: coordinates[:y], duration: duration } unless session_actions
     `idb ui tap --udid #{udid} --duration #{duration} #{coordinates[:x]} #{coordinates[:y]}`
   end
 
@@ -126,6 +164,16 @@ class Driver
       "Swipe (#{duration}s):",
       payload: "#{JSON.pretty_generate(start_coordinates)} => #{JSON.pretty_generate(end_coordinates)}"
     )
+    unless session_actions
+      @session[:actions] << {
+        type: :swipe,
+        x: start_coordinates[:x],
+        y: start_coordinates[:y],
+        endX: end_coordinates[:x],
+        endY: end_coordinates[:y],
+        duration: duration
+      }
+    end
     coordinates = "#{start_coordinates[:x]} #{start_coordinates[:y]} #{end_coordinates[:x]} #{end_coordinates[:y]}"
     `idb ui swipe --udid #{udid} --duration #{duration} #{coordinates}`
   end
@@ -168,6 +216,10 @@ class Driver
     rand(0.5..1.5).ceil(1)
   end
 
+  def save_session
+    File.write("#{session_path}/xcmonkey-session.json", JSON.pretty_generate(@session))
+  end
+
   private
 
   def ensure_driver_installed
@@ -183,14 +235,13 @@ class Driver
   end
 
   def wait_until_app_launched
-    app_info = nil
+    app_is_running = false
     current_time = Time.now
-    while app_info.nil? && Time.now < current_time + 5
-      app_info = list_apps.split("\n").detect do |app|
-        app =~ /#{bundle_id}.*Running/
-      end
+    while !app_is_running && Time.now < current_time + 5
+      app_info = list_apps.detect { |app| app['bundle_id'] == bundle_id }
+      app_is_running = app_info && app_info['process_state'] == 'Running'
     end
-    Logger.error("Can't run the app #{bundle_id}") if app_info.nil?
-    Logger.info('App info:', payload: app_info)
+    Logger.error("Can't run the app #{bundle_id}") unless app_is_running
+    Logger.info('App info:', payload: JSON.pretty_generate(app_info))
   end
 end

data/lib/xcmonkey/repeater.rb

@@ -0,0 +1,39 @@
+class Repeater
+  attr_accessor :udid, :bundle_id, :enable_simulator_keyboard, :actions
+
+  def initialize(params)
+    validate_session(params[:session_path])
+  end
+
+  def run
+    params = {
+      udid: udid,
+      bundle_id: bundle_id,
+      enable_simulator_keyboard: enable_simulator_keyboard,
+      session_actions: actions
+    }
+    Driver.new(params).repeat_monkey_test
+  end
+
+  def validate_session(session_path)
+    Logger.error("Provided session can't be found: #{session_path}") unless File.exist?(session_path)
+
+    session = JSON.parse(File.read(session_path))
+
+    if session['params'].nil?
+      Logger.error('Provided session is not valid: `params` should not be `nil`')
+      return
+    end
+
+    self.actions = session['actions']
+    Logger.error('Provided session is not valid: `actions` should not be `nil` or `empty`') if actions.nil? || actions.empty?
+
+    self.udid = session['params']['udid']
+    Logger.error('Provided session is not valid: `udid` should not be `nil`') if udid.nil?
+
+    self.bundle_id = session['params']['bundle_id']
+    Logger.error('Provided session is not valid: `bundle_id` should not be `nil`') if bundle_id.nil?
+
+    self.enable_simulator_keyboard = session['params']['enable_simulator_keyboard']
+  end
+end

data/lib/xcmonkey/version.rb

@@ -1,4 +1,3 @@
-module Xcmonkey
-  VERSION = '0.3.0'
-  GEM_NAME = 'xcmonkey'
+class Xcmonkey
+  VERSION = '1.1.0'
 end

data/lib/xcmonkey.rb

@@ -1,44 +1,42 @@
 require 'json'
 require 'colorize'
 require_relative 'xcmonkey/describer'
+require_relative 'xcmonkey/repeater'
 require_relative 'xcmonkey/version'
 require_relative 'xcmonkey/logger'
 require_relative 'xcmonkey/driver'
 
-module Xcmonkey
-	class Xcmonkey
-	  attr_accessor :udid, :bundle_id, :duration, :driver
-
-	  def initialize(params)
-			ensure_required_params(params)
-	    self.udid = params[:udid]
-	    self.bundle_id = params[:bundle_id]
-	    self.duration = params[:duration]
-			self.driver = Driver.new(params)
-	  end
-
-    def run
-			driver.ensure_device_exists
-			driver.ensure_app_installed
-			driver.terminate_app
-			driver.open_home_screen(with_tracker: true)
-			driver.launch_app
-			driver.monkey_test(gestures)
-    end
+class Xcmonkey
+  attr_accessor :driver
+
+  def initialize(params)
+    params[:session_path] = Dir.pwd if params[:session_path].nil?
+    params[:duration] = 60 if params[:duration].nil?
+    params[:enable_simulator_keyboard] = true if params[:enable_simulator_keyboard].nil?
+    ensure_required_params(params)
+    self.driver = Driver.new(params)
+  end
+
+  def run
+    driver.monkey_test(gestures)
+  end
+
+  def gestures
+    taps = [:precise_tap, :blind_tap] * 10
+    swipes = [:precise_swipe, :blind_swipe] * 5
+    presses = [:precise_press, :blind_press]
+    taps + swipes + presses
+  end
 
-		def gestures
-			taps = [:precise_tap, :blind_tap] * 10
-			swipes = [:precise_swipe, :blind_swipe] * 5
-			presses = [:precise_press, :blind_press]
-			taps + swipes + presses
-		end
-
-		def ensure_required_params(params)
-			Logger.error('UDID should be provided') if params[:udid].nil?
-			Logger.error('Bundle identifier should be provided') if params[:bundle_id].nil?
-			if params[:duration].nil? || !params[:duration].kind_of?(Integer) || !params[:duration].positive?
-				Logger.error('Duration must be Integer and not less than 1 second')
-			end
-		end
-	end
+  def ensure_required_params(params)
+    Logger.error('UDID should be provided') if params[:udid].nil?
+
+    Logger.error('Bundle identifier should be provided') if params[:bundle_id].nil?
+
+    Logger.error('Session path should be a directory') if params[:session_path].nil? || !File.directory?(params[:session_path])
+
+    if params[:duration].nil? || !params[:duration].kind_of?(Integer) || !params[:duration].positive?
+      Logger.error('Duration must be Integer and not less than 1 second')
+    end
+  end
 end

data/spec/driver_spec.rb

@@ -1,7 +1,8 @@
 describe Driver do
   let(:udid) { `xcrun simctl list | grep " iPhone 14 Pro Max"`.split("\n")[0].split('(')[1].split(')')[0] }
   let(:bundle_id) { 'com.apple.Maps' }
-  let(:driver) { described_class.new(udid: udid, bundle_id: bundle_id) }
+  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 }]) }
 
   it 'verifies that sumulator was booted' do
     error_message = "Failed to boot #{udid}"
@@ -9,12 +10,6 @@ describe Driver do
     expect { driver.boot_simulator }.not_to raise_error
   end
 
-  it 'verifies that there are booted simulators' do
-    driver.boot_simulator
-    booted_simulators = driver.list_booted_simulators
-    expect(booted_simulators).not_to be_empty
-  end
-
   it 'verifies that ui can be described' do
     driver.boot_simulator
     ui = driver.describe_ui
@@ -40,8 +35,8 @@ describe Driver do
 
   it 'verifies that list of apps can be showed' do
     driver.boot_simulator
-    list_apps = driver.list_apps
-    expect(list_apps).to include(bundle_id)
+    app_exists = driver.list_apps.any? { |app| app['bundle_id'] == bundle_id }
+    expect(app_exists).to be(true)
   end
 
   it 'verifies that app installed' do
@@ -61,11 +56,11 @@ describe Driver do
   end
 
   it 'verifies that device exists' do
-    error_message = "Can't find device #{udid}"
-    payload = driver.list_targets.detect { |target| target.include?(udid) }
-    expect(Logger).not_to receive(:error).with(error_message, payload: nil)
-    expect(Logger).to receive(:info).with('Device info:', payload: payload)
+    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
   end
 
@@ -150,28 +145,106 @@ describe Driver do
     expect { driver.launch_app }.not_to raise_error
   end
 
-  it 'verifies tap' do
+  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
+
+  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
 
-  it 'verifies press' do
+  it 'verifies press in new session' 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
+
+  it 'verifies press in old session' 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
 
-  it 'verifies swipe' do
+  it 'verifies swipe in new session' do
     driver.boot_simulator
     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
+
+  it 'verifies swipe in old session' do
+    driver_with_session.boot_simulator
+    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
+
+  it 'verifies that session can be saved' do
+    expect(File).to receive(:write)
+    driver.instance_variable_set(:@session, { params: {}, actions: [] })
+    driver.save_session
+  end
+
+  it 'verifies that monkey_test_precondition works fine' do
+    driver.monkey_test_precondition
+    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)
+  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
+
+  it 'verifies that repeat_monkey_test works fine' do
+    session_actions = [
+      { 'type' => 'tap', 'x' => 10, 'y' => 10 },
+      { 'type' => 'press', 'x' => 11, 'y' => 11, 'duration' => 1.4 },
+      { '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)
+    driver.repeat_monkey_test
+    expect(driver.instance_variable_get(:@session)[:actions]).to be_empty
+  end
+
+  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)
+    expect(driver).not_to receive(:swipe)
+    driver.repeat_monkey_test
+    expect(driver.instance_variable_get(:@session)[:actions]).to be_empty
   end
 
   it 'verifies that simulator was not booted' do

data/spec/repeater_spec.rb

@@ -0,0 +1,51 @@
+describe Repeater do
+  let(:session_path) { 'test/path/session.json' }
+  let(:session_file_content_full) { '{ "params": {"udid": "0", "bundle_id": "0", "enable_simulator_keyboard": true}, "actions": [{ "type": "tap", "x": 0, "y": 0 }] }' }
+  let(:session_file_content_without_params) { '{ "actions": [{ "type": "tap", "x": 0, "y": 0 }] }' }
+  let(:session_file_content_with_empty_actions) { '{ "params": {"udid": "0", "bundle_id": "0", "enable_simulator_keyboard": true}, "actions": [] }' }
+  let(:session_file_content_without_actions) { '{ "params": {"udid": "0", "bundle_id": "0", "enable_simulator_keyboard": true} }' }
+  let(:session_file_content_without_bundle_id) { '{ "params": {"udid": "0", "enable_simulator_keyboard": true}, "actions": [{ "type": "tap", "x": 0, "y": 0 }] }' }
+  let(:session_file_content_without_udid) { '{ "params": {"bundle_id": "0", "enable_simulator_keyboard": true}, "actions": [{ "type": "tap", "x": 0, "y": 0 }] }' }
+
+  it 'verifies that session cannot be validated without params' do
+    allow(File).to receive(:exist?).and_return(true)
+    allow(File).to receive(:read).and_return(session_file_content_without_params)
+    expect(Logger).to receive(:error).with('Provided session is not valid: `params` should not be `nil`')
+    described_class.new(session_path: session_path)
+  end
+
+  it 'verifies that session cannot be validated without actions' do
+    allow(File).to receive(:exist?).and_return(true)
+    allow(File).to receive(:read).and_return(session_file_content_without_actions)
+    expect(Logger).to receive(:error).with('Provided session is not valid: `actions` should not be `nil` or `empty`')
+    described_class.new(session_path: session_path)
+  end
+
+  it 'verifies that session cannot be validated with empty actions' do
+    allow(File).to receive(:exist?).and_return(true)
+    allow(File).to receive(:read).and_return(session_file_content_with_empty_actions)
+    expect(Logger).to receive(:error).with('Provided session is not valid: `actions` should not be `nil` or `empty`')
+    described_class.new(session_path: session_path)
+  end
+
+  it 'verifies that session cannot be validated without bundle id' do
+    allow(File).to receive(:exist?).and_return(true)
+    allow(File).to receive(:read).and_return(session_file_content_without_bundle_id)
+    expect(Logger).to receive(:error).with('Provided session is not valid: `bundle_id` should not be `nil`')
+    described_class.new(session_path: session_path)
+  end
+
+  it 'verifies that session cannot be validated without udid' do
+    allow(File).to receive(:exist?).and_return(true)
+    allow(File).to receive(:read).and_return(session_file_content_without_udid)
+    expect(Logger).to receive(:error).with('Provided session is not valid: `udid` should not be `nil`')
+    described_class.new(session_path: session_path)
+  end
+
+  it 'verifies that session validation can pass' do
+    allow(File).to receive(:exist?).and_return(true)
+    allow(File).to receive(:read).and_return(session_file_content_full)
+    expect(Logger).not_to receive(:error)
+    described_class.new(session_path: session_path)
+  end
+end

data/spec/xcmonkey_spec.rb

@@ -1,58 +1,52 @@
 describe Xcmonkey do
-  describe Xcmonkey::Xcmonkey do
-    let(:params) { { udid: '123', bundle_id: 'example.com.app', duration: 10 } }
-    let(:duration_error_msg) { 'Duration must be Integer and not less than 1 second' }
-
-    it 'verifies gestures' do
-      gestures = described_class.new(params).gestures
-      taps = [:precise_tap, :blind_tap] * 10
-      swipes = [:precise_swipe, :blind_swipe] * 5
-      presses = [:precise_press, :blind_press]
-      expect(gestures) =~ presses + taps + swipes
-    end
-
-    it 'verifies required params' do
-      expect(Logger).not_to receive(:error)
-      described_class.new(params)
-    end
-
-    it 'verifies `udid` param is required' do
-      params[:udid] = nil
-      expect(Logger).to receive(:error).with('UDID should be provided')
-      described_class.new(params)
-    end
-
-    it 'verifies `bundle_id` param is required' do
-      params[:bundle_id] = nil
-      expect(Logger).to receive(:error).with('Bundle identifier should be provided')
-      described_class.new(params)
-    end
-
-    it 'verifies `duration` param is required' do
-      params[:duration] = nil
-      expect(Logger).to receive(:error).with(duration_error_msg)
-      described_class.new(params)
-    end
-
-    it 'verifies `duration` param cannot be equal to zero' do
-      params[:duration] = 0
-      expect(Logger).to receive(:error).with(duration_error_msg)
-      described_class.new(params)
-    end
-
-    it 'verifies `duration` param cannot be negative' do
-      params[:duration] = -1
-      expect(Logger).to receive(:error).with(duration_error_msg)
-      described_class.new(params)
-    end
-
-    it 'verifies version' do
-      current_version = Gem::Version.new(Xcmonkey::VERSION)
-      expect(current_version).to be > Gem::Version.new('0.1.0')
-    end
-
-    it 'verifies gem name' do
-      expect(Xcmonkey::GEM_NAME).to eq('xcmonkey')
-    end
+  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' }
+
+  it 'verifies gestures' do
+    gestures = described_class.new(params).gestures
+    taps = [:precise_tap, :blind_tap] * 10
+    swipes = [:precise_swipe, :blind_swipe] * 5
+    presses = [:precise_press, :blind_press]
+    expect(gestures) =~ presses + taps + swipes
+  end
+
+  it 'verifies required params' do
+    expect(Logger).not_to receive(:error)
+    described_class.new(params)
+  end
+
+  it 'verifies `udid` param is required' do
+    params[:udid] = nil
+    expect(Logger).to receive(:error).with('UDID should be provided')
+    described_class.new(params)
+  end
+
+  it 'verifies `bundle_id` param is required' do
+    params[:bundle_id] = nil
+    expect(Logger).to receive(:error).with('Bundle identifier should be provided')
+    described_class.new(params)
+  end
+
+  it 'verifies `duration` param is optional' do
+    params[:duration] = nil
+    expect(Logger).not_to receive(:error)
+    described_class.new(params)
+  end
+
+  it 'verifies `duration` param cannot be equal to zero' do
+    params[:duration] = 0
+    expect(Logger).to receive(:error).with(duration_error_msg)
+    described_class.new(params)
+  end
+
+  it 'verifies `duration` param cannot be negative' do
+    params[:duration] = -1
+    expect(Logger).to receive(:error).with(duration_error_msg)
+    described_class.new(params)
+  end
+
+  it 'verifies version' do
+    current_version = Gem::Version.new(Xcmonkey::VERSION)
+    expect(current_version).to be > Gem::Version.new('0.1.0')
   end
 end

data/xcmonkey.gemspec

@@ -3,7 +3,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "xcmonkey/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = Xcmonkey::GEM_NAME
+  spec.name          = "xcmonkey"
   spec.version       = Xcmonkey::VERSION
   spec.authors       = ["alteral"]
   spec.email         = ["a.alterpesotskiy@mail.ru"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcmonkey
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.1.0
 platform: ruby
 authors:
 - alteral
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-08 00:00:00.000000000 Z
+date: 2023-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -216,6 +216,8 @@ extra_rdoc_files: []
 files:
 - ".fasterer.yml"
 - ".github/FUNDING.yml"
+- ".github/ISSUE_TEMPLATE/bug_report.md"
+- ".github/ISSUE_TEMPLATE/feature-request.md"
 - ".github/dependabot.yml"
 - ".github/pull_request_template.md"
 - ".github/workflows/test.yml"
@@ -236,12 +238,14 @@ files:
 - lib/xcmonkey/describer.rb
 - lib/xcmonkey/driver.rb
 - lib/xcmonkey/logger.rb
+- lib/xcmonkey/repeater.rb
 - lib/xcmonkey/version.rb
 - requirements.txt
 - sonar-project.properties
 - spec/describer_spec.rb
 - spec/driver_spec.rb
 - spec/logger_spec.rb
+- spec/repeater_spec.rb
 - spec/spec_helper.rb
 - spec/xcmonkey_spec.rb
 - xcmonkey.gemspec