How to detect if iOS app is running in UI Testing mode

I would like my app to run special code (e.g. resetting its state) when running in UI Testing mode. I looked at environment variables that are set when the app is running from UI Testing and there aren’t any obvious parameters to differentiate between the app running normally vs in UI Testing. Is there a way to find out?

Two workarounds that I’m not satisfied with are:

  • Handler of addUIInterruptionMonitor is not called for Alert related to Photos
  • Xcode UI Tests can't find views that are added programatically
  • Xcode UI Test example
  • Xcode 7 UI Tests , Recording button is greyed out
  • How do I mock network requests in Xcode UI tests while the tests are running?
  • Possible to bring the app from background to foreground?
    1. Set XCUIApplication.launchEnvironment with some variable that I later check in the app. This isn’t good because you have to set it in the setUp method of each test file. I tried setting the environment variable from the scheme settings but that doesn’t propagate to the app itself when running UI Testing tests.
    2. Check for the lack of existence of the environment variable __XPC_DYLD_LIBRARY_PATH. This seems very hacky and might only be working now because of a coincidence in how we have our target build settings set up.

    7 Solutions Collect From Internet About “How to detect if iOS app is running in UI Testing mode”

    I’ve been researching this myself and came across this question. I ended up going with @LironYahdav’s first workaround:

    In your UI test:

    - (void)setUp
    {
        [super setUp];
    
        XCUIApplication *app = [[XCUIApplication alloc] init];
        app.launchEnvironment = @{@"isUITest": @YES};
        [app launch];
    }
    

    In your app:

    NSDictionary *environment = [[NSProcessInfo processInfo] environment];
    if (environment[@"isUITest"]) {
        // Running in a UI test
    }
    

    @JoeMasilotti’s solutions are useful for unit tests, because they share the same runtime as the app being tested, but are not relevant for UI tests.

    You can use Preprocessor Macros for this. I found that you have couple of choices:

    New Target

    Make a copy of the App’s target and use this as the Target to be Tested. Any preproocessor macro in this target copy is accessible in code.

    One drawback is you will have to add new classes / resources to the copy target as well and sometimes it very easy to forget.

    New Build Configuration

    Make a duplicate of the Debug build configuration , set any preprocessor macro to this configuration and use it for your test (See screenshots below).

    A minor gotcha: whenever you want to record a UI Testing session you need to change the Run to use the new testing configuration.

    Add a duplicate configuration:

    Add a duplicate conf

    Use it for your Test:

    Use it for your *Test*

    I didn’t succeed with setting a launch environment, but got it to work with launch arguments.

    In your tests setUp() function add:

      let app = XCUIApplication()
      app.launchArguments = ["testMode"]
      app.launch()
    

    In your production code add a check like:

    let testMode =  NSProcessInfo.processInfo().arguments.contains("testMode")
    if testMode {
      // Do stuff
    }
    

    Verified using XCode 7.1.1.

    I’ve just added this extension

     @available(iOS 9, *)
     extension XCUIApplication {
    
     func test(){
       launchEnvironment = ["TEST":"true"]
       launch()
      }
     }
    

    So I can just use test() instead of launch()

    In Swift 3 you can check for the XCInjectBundleInto key, or something that starts with XC.

    let isInTestMode = ProcessInfo.processInfo.environment["XCInjectBundleInto"] != nil
    

    This works in OS X as well.

    Swift 3 based on previous answers.

    class YourApplicationUITests: XCTestCase {
    
        override func setUp() {
            super.setUp()
    
            // Put setup code here. This method is called before the invocation of each test method in the class.
    
            // In UI tests it is usually best to stop immediately when a failure occurs.
            continueAfterFailure = false
            // UI tests must launch the application that they test. Doing this in setup will make sure it happens for each test method.
            let app = XCUIApplication()
            app.launchArguments = ["testMode"]
            app.launch()
    
            // In UI tests it’s important to set the initial state - such as interface orientation - required for your tests before they run. The setUp method is a good place to do this.
        }
    
        override func tearDown() {
            // Put teardown code here. This method is called after the invocation of each test method in the class.
            super.tearDown()
        }
    
        func testExample() {
            // Use recording to get started writing UI tests.
            // Use XCTAssert and related functions to verify your tests produce the correct results.
        }
    
    }
    
    
    extension UIApplication {
        public static var isRunningTest: Bool {
            return ProcessInfo().arguments.contains("testMode")
        }
    }
    

    Then just call UIApplication.isRunningTest in your code.

    I think the easiest thing to do is put some kind of easter egg in your user interface right after the application launches and then check for that easter egg in the app. So if tapping on a certain button 10X is done first, then that will set a user setting or environment variable or whatever that can then be checked subsequently in the app. This does seem kind of hacky but I could not figure any other way to do it.

    The two processes have their own sets of environment variables, user defaults and launch options.