Fix iOS Simulator tests

Author: dtopuzov

core/device/simulator.py

@@ -1,116 +1,132 @@
-"""
+'''
 Helper for working with simulator
-"""
+'''
 
 import time
 
 from core.osutils.command import run
+from core.osutils.command_log_level import CommandLogLevel
 from core.osutils.process import Process
 from core.settings.settings import SIMULATOR_NAME
 
 
 class Simulator(object):
     @staticmethod
     def create(name, device_type, ios_version):
-        """Create simulator"""
-
-        print "~~~ Create simulator \"{0}\".".format(name)
-        output = run(
-                "xcrun simctl create \"{0}\" \"{1}\" \"{2}\"".format(name, device_type, ios_version))
-        print "~~~ Simulator \"{0}\" created successfully.".format(name)
-        print "~~~ Simulator \"{0}\" id: ".format(name) + output
+        """
+        Create iOS Simulator.
+        :param name: Simulator name.
+        :param device_type: Device type, example: 'iPhone 7'
+        :param ios_version: iOS Version, example: '10.0'
+        """
+        ios_version = ios_version.replace('.', '-')
+        sdk = "com.apple.CoreSimulator.SimRuntime.iOS-{0}".format(ios_version)
+        create_command = 'xcrun simctl create "{0}" "{1}" "{2}"'.format(name, device_type, sdk)
+        output = run(command=create_command, log_level=CommandLogLevel.SILENT)
+        assert 'Invalid' not in output, 'Failed to create simulator. \n ' + output
+        assert 'error' not in output.lower(), 'Failed to create simulator. \n ' + output
+        assert '-' in output, 'Failed to create simulator. Output is not GUID. \n' + output
+        print 'iOS Simulator created: ' + name
 
     @staticmethod
-    def start(name, sdk=None, timeout=300, wait_for=True):
-        """Start iOS Simulator"""
-
+    def start(name, sdk=None, timeout=300):
+        """
+        Start iOS Simulator
+        :param name: Simulator name.
+        :param sdk: iOS Version, example '10.0'
+        :param timeout: Timeout for starting simulator.
+        """
+
+        # Generate simulator name based on version
         if sdk is not None:
-            name = "{0} ({1})".format(name, sdk)
-        print "~~~ Start simulator \"{0}\".".format(name)
-        start_command = "instruments -w \"{0}\"".format(name)
-        output = run(start_command, timeout)
-        assert "Waiting for device to boot..." in output
-
-        if wait_for:
-            if Simulator.wait_for_simulator(timeout):
-                print "~~~ Simulator \"{0}\" started successfully.".format(name)
-            else:
-                raise NameError("Waiting for simulator \"{0}\" failed!".format(name))
+            name = '{0} ({1})'.format(name, sdk)
+
+        # Fire start command
+        start_command = 'instruments -w "{0}"'.format(name)
+        output = run(command=start_command, timeout=timeout, log_level=CommandLogLevel.SILENT)
+        assert 'Unknown device' not in output, "Can not find simulator with name " + name
+        assert 'Waiting for device to boot...' in output
+        print 'Simulator {0} is booting now...'.format(name)
+
+        # Wait until simulator boot
+        if Simulator.wait_for_simulator(timeout):
+            print 'Simulator {0} is up and running!'.format(name)
+        else:
+            raise NameError('Failed to boot {0}!'.format(name))
 
     @staticmethod
     def wait_for_simulator(timeout=300):
-        """Wait for simulator"""
-
+        """
+        Wait until simulator boot.
+        :param timeout: Timeout in seconds.
+        :return: True if booted, False if it fails to boot.
+        """
         found = False
         start_time = time.time()
         end_time = start_time + timeout
         while not found:
-            time.sleep(2)
-            output = run("xcrun simctl list devices")
-            if "Booted" in output:
+            output = run(command='xcrun simctl list devices', log_level=CommandLogLevel.SILENT)
+            if 'Booted' in output:
                 found = True
                 break
             if time.time() > end_time:
                 break
+            time.sleep(5)
         return found
 
     @staticmethod
-    def stop_simulators():
-        """Stop running simulators"""
-        Process.kill("Simulator")
+    def stop():
+        """
+        Stop all running simulators.
+        """
+        Process.kill('Simulator')
         time.sleep(1)
 
     @staticmethod
-    def reset_simulators():
-        """Reset settings and storage of all simulators"""
-        Simulator.stop_simulators()
-        run("xcrun simctl erase all", timeout=60)
+    def reset():
+        """
+        Reset settings and storage of all simulators.
+        """
+        Simulator.stop()
+        run(command='xcrun simctl erase all', timeout=60, log_level=CommandLogLevel.SILENT)
+        print 'Reset settings and storage of all simulators.'
 
     @staticmethod
     def delete(name):
-        """Delete simulator"""
-
-        output = run("xcrun simctl list | grep \"{0}\"".format(name))
-        while (SIMULATOR_NAME in output) and ("Invalid" not in output):
-            if "Booted" in output:
-                run("xcrun simctl shutdown \"{0}\"".format(name))
-                Simulator.stop_simulators()
-            run("xcrun simctl delete \"{0}\"".format(name))
-            print "~~~ Simulator \"{0}\" deleted.".format(name)
-            output = run("xcrun simctl list | grep \"{0}\"".format(name))
-
-    @staticmethod
-    def find_between(string, first, last):
-        """Find string between two substrings"""
-        try:
-            start = string.index(first) + len(first)
-            end = string.index(last, start)
-            return string[start:end]
-        except ValueError:
-            return "ValueError!"
+        """
+        Delete simulator.
+        :param name: Simulator name.
+        """
+        output = run(command='xcrun simctl list | grep \'{0}\''.format(name), log_level=CommandLogLevel.SILENT)
+        while (SIMULATOR_NAME in output) and ('Invalid' not in output):
+            if 'Booted' in output:
+                run('xcrun simctl shutdown \'{0}\''.format(name), log_level=CommandLogLevel.SILENT)
+                Simulator.stop()
+            output = run('xcrun simctl delete \'{0}\''.format(name), log_level=CommandLogLevel.SILENT)
+            assert "Unable to delete" not in output, "Failed to delete simulator {0}".format(name)
+            print 'Simulator \'{0}\' deleted.'.format(name)
+            output = run('xcrun simctl list | grep \'{0}\''.format(name), log_level=CommandLogLevel.SILENT)
 
     @staticmethod
     def uninstall_app(app_name):
-        app_name = app_name.replace("_", "")
-        app_name = app_name.replace(" ","")
-        run("xcrun simctl uninstall booted org.nativescript.{0}".format(app_name))
+        app_name = app_name.replace('_', '')
+        app_name = app_name.replace(' ', '')
+        run('xcrun simctl uninstall booted org.nativescript.{0}'.format(app_name))
 
     @staticmethod
     def cat_app_file(app_name, file_path):
-        """Return content of file on booted simulator"""
-        app_name = app_name.replace("_", "")
-        app_name = app_name.replace(" ","")
-        app_path = run("xcrun simctl get_app_container booted org.nativescript.{0}".format(app_name))
-        print "Get content of: " + app_path
-        output = run("cat {0}/{1}".format(app_path, file_path))
+        app_name = app_name.replace('_', '')
+        app_name = app_name.replace(' ', '')
+        app_path = run('xcrun simctl get_app_container booted org.nativescript.{0}'.format(app_name))
+        print 'Get content of: ' + app_path
+        output = run('cat {0}/{1}'.format(app_path, file_path))
         return output
 
     @staticmethod
     def file_contains(app_name, file_path, text):
-        """Assert file on booted simulator contains text"""
         output = Simulator.cat_app_file(app_name, file_path)
         if text in output:
-            print("{0} exists in {1}".format(text, file_path))
+            print('{0} exists in {1}'.format(text, file_path))
         else:
-            print("{0} does not exists in {1}".format(text, file_path))
+            print('{0} does not exists in {1}'.format(text, file_path))
         assert text in output

core/settings/settings.py

@@ -63,7 +63,9 @@
 EMULATOR_NAME = "Emulator-Api19-Default"
 EMULATOR_PORT = "5554"
 EMULATOR_ID = "emulator-{0}".format(EMULATOR_PORT)
-SIMULATOR_NAME = "iPhone7100"
+SIMULATOR_NAME = "iPhone7N"
+SIMULATOR_TYPE = 'iPhone 7'
+SIMULATOR_SDK = '10.1'
 
 # Android Build Settings
 ANDROID_KEYSTORE_PATH = os.environ.get("ANDROID_KEYSTORE_PATH")

runNose.py

@@ -102,7 +102,7 @@ def get_repos():
     # Copy test packages and cleanup
     if CURRENT_OS == OSType.OSX:
         get_test_packages(platform=Platforms.BOTH)
-        Simulator.stop_simulators()  # Stop running simulators
+        Simulator.stop()  # Stop running simulators
         Xcode.cleanup_cache()  # Clean Xcode cache folders
     else:
         get_test_packages(platform=Platforms.ANDROID)

tests/debug/DebugSimulator_Tests.py

@@ -27,13 +27,13 @@ def setUpClass(cls):
 
     def setUp(self):
         BaseClass.setUp(self)
-        Simulator.stop_simulators()
+        Simulator.stop()
         Process.kill("Safari")
         Process.kill("Inspector")
 
     def tearDown(self):
         BaseClass.tearDown(self)
-        Simulator.stop_simulators()
+        Simulator.stop()
         Process.kill("Safari")
         Process.kill("Inspector")
 

tests/debug/debug_ios.py

@@ -17,7 +17,7 @@ class DebugiOS(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         Emulator.stop()
-        Simulator.stop_simulators()
+        Simulator.stop()
         Folder.cleanup('./TNS_App')
         Tns.create_app_platform_add(app_name="TNS_App", platform="ios", framework_path=IOS_RUNTIME_SYMLINK_PATH)
 

tests/run/simulator/EmulateiOS_Tests.py

@@ -7,7 +7,7 @@
 from core.device.simulator import Simulator
 from core.osutils.folder import Folder
 from core.osutils.process import Process
-from core.settings.settings import IOS_RUNTIME_PATH, SIMULATOR_NAME
+from core.settings.settings import IOS_RUNTIME_PATH, SIMULATOR_NAME, SIMULATOR_TYPE, SIMULATOR_SDK
 from core.tns.tns import Tns
 from core.settings.strings import *
 
@@ -17,9 +17,9 @@ class EmulateiOSTests(BaseClass):
     def setUpClass(cls):
         logfile = os.path.join("out", cls.__name__ + ".txt")
         BaseClass.setUpClass(logfile)
-        Simulator.stop_simulators()
+        Simulator.stop()
         Simulator.delete(SIMULATOR_NAME)
-        Simulator.create(SIMULATOR_NAME, 'iPhone 6', '9.1')
+        Simulator.create(SIMULATOR_NAME, SIMULATOR_TYPE, SIMULATOR_SDK)
 
         Tns.create_app(cls.app_name)
         Tns.platform_add_ios(attributes={"--path": cls.app_name,
@@ -36,13 +36,21 @@ def tearDownClass(cls):
         Folder.cleanup('./' + cls.app_name)
 
     def test_001_emulate_list_devices(self):
+        """
+        `tns emulate ios --availableDevices` should list all available iOS Simulators.
+        """
         output = Tns.run_tns_command("emulate ios", attributes={"--availableDevices": "",
                                                                 "--path": self.app_name,
                                                                 "--justlaunch": ""
                                                                 })
+        assert "Available emulators" in output
         assert SIMULATOR_NAME in output
 
     def test_002_emulate_ios(self):
+        """
+        `tns emulate ios` should build the project and run it in simulator.
+        If simulator is not running `tns` should start it.
+        """
         output = Tns.run_tns_command("emulate ios", attributes={"--path": self.app_name,
                                                                 "--device": SIMULATOR_NAME,
                                                                 "--justlaunch": ""
@@ -84,4 +92,3 @@ def test_400_emulate_invalid_device(self):
                                                                 "--justlaunch": ""
                                                                 })
         assert "Cannot resolve the specified connected device by the provided index or identifier." in output
-        assert "Cannot find device with name: " + invalid in output

tests/unittests/UnittestsSimulator_Tests.py

@@ -18,7 +18,7 @@ def setUpClass(cls):
         logfile = os.path.join("out", cls.__name__ + ".txt")
         BaseClass.setUpClass(logfile)
         Emulator.stop()
-        Simulator.stop_simulators()
+        Simulator.stop()
         Simulator.start(SIMULATOR_NAME, '9.1')
 
     def setUp(self):
@@ -32,7 +32,7 @@ def tearDown(self):
 
     @classmethod
     def tearDownClass(cls):
-        Simulator.stop_simulators()
+        Simulator.stop()
 
     @timed(360)
     def test_010_test_jasmine_ios_simulator(self):