Xcode 7 Uitesty ze zlokalizowanym interfejsem użytkownika

Opcja 1: Ustaw domyślny język

Utwórz nowy schemat testowania interfejsu użytkownika i Ustaw domyślny język aplikacji. Spowoduje to zablokowanie aplikacji w jednym zlokalizowanym pliku, dzięki czemu można zapisać wszystkie testy dla tego języka.

Ustaw opcję Z Product -> Scheme - > Manage Schemes lub ⌘⇧,. Następnie wybierz kartę Opcje i ustaw język.

Plusy : prosta, Jednorazowa zmiana.

Cons: nie może być użyty do twórz zlokalizowane zrzuty ekranu za pomocą migawki (narzędzia, które uruchamia aplikację za pomocą testowania interfejsu użytkownika i generuje zrzuty ekranu ze sklepu App Store).

Opcja 2: Użyj -accessibilityIdentifier dla zlokalizowanych łańcuchów

Zamiast uzyskiwania dostępu do elementów za pomocą wyświetlonego tekstu lub wartości, użyj accessibilityIdentifier. Jest to odczytywane przez interfejs Testing framework, ale nigdy nie pokazywane ani odczytywane użytkownikom (nawet przy włączonej dostępności). W starej dokumentacji UIAutomation Apple wspomina o używaniu tego dla funkcji programisty, które to szwy jak dobry przypadek użycia.

Możesz kontynuować ustawianie accessibilityLabel i accessibilityValue Jak zwykle, z zlokalizowanymi wersjami.

Plusy: może być używany do bardziej ogólnych rozwiązań, takich jak robienie automatycznych zrzutów ekranu.

Cons: może wymagać więcej pracy, zmieniając każdą etykietę, której potrzebujesz "unlocalized" do testowania.

MOŻESZ PONOWNIE WYKORZYSTAĆ PAKIETY LOKALIZACYJNE PROJEKTU!

Kiedy testujesz zachowanie skrzynek wiadomości, musisz dokładnie wiedzieć, które okno wiadomości właśnie się pojawiło. Musisz skopiować lokalizację z innego schematu podczas fazy budowania.

W interfejsie testowym target -> fazy budowania - > Kopiuj zasoby pakietu, dodaj potrzebne pliki lokalizacyjne (np. Localizable.struny).

Dodaj funkcję podobną do następującej:

func localizedString(key:String) -> String {
/*1*/ let localizationBundle = NSBundle(path: NSBundle(forClass: /*2 UITestsClass*/.self).pathForResource(deviceLanguage, ofType: "lproj")!) 
/*3*/ let result = NSLocalizedString(key, bundle:localizationBundle!, comment: "") // 
    return result
}

/*1 Gets correct bundle for the localization file, see here: http://stackoverflow.com/questions/33086266/cant-get-access-to-string-localizations-in-ui-test-xcode-7 */
/*2 Replace this with a class from your UI Tests 
/*3 Gets the localized string from the bundle */

Wtedy w kodzie możesz użyć app.przyciski [localizedString ("localized.sznurek.klucz")]

Pełny artykuł jest tutaj: https://github.com/fastlane-old/snapshot/issues/321#issuecomment-159660882

Jak dotąd najprostszym i niezawodnym sposobem jest odwoływanie się do elementów za pomocą elementBoundByIndex() Tak:

    let app = XCUIApplication()
    let tabBar = app.tabBars
    tabBar.buttons.elementBoundByIndex(2).tap()
    app.navigationBars.buttons.elementBoundByIndex(0).tap()
    app.tables.cells.elementBoundByIndex(2).tap()
    app.tables.elementBoundByIndex(1).cells.elementBoundByIndex(0).tap()

Możesz zgadywać / eksperymentować z tymi wartościami i znaleźć potrzebne elementy.

ODPOWIEDŹ Wołodymyra bardzo mi pomogła, ale może się nie udać, jeśli nazwa folderu pakietu lokalizacyjnego różni się od nazwy urządzenia ustawionego w Migawce. Ten fragment działa dobrze dla mnie w Swift 3.0 i z językami takimi jak włoski(gdzie obecne ustawienia regionalne to "it", ale język urządzenia to "it-IT").

    func localizedString(key:String) -> String {
      let languageBundlePath = Bundle(for: PlinthUITests.self).path(forResource: deviceLanguage, ofType: "lproj") ?? Bundle(for: PlinthUITests.self).path(forResource: NSLocale.current.languageCode!, ofType: "lproj")
      let localizationBundle = Bundle(path: languageBundlePath!)
      let result = NSLocalizedString(key, bundle:localizationBundle!, comment: "")
    return result
}

Jeśli robisz to w celu uruchomienia migawki (a nie rzeczywistego testowania interfejsu użytkownika), to uważam, że najprostszym rozwiązaniem jest oszukiwanie i używanie HSTestingBackchannel

Jest to narzędzie, które napisałem, które pozwala na wysyłanie powiadomień z klasy UITesting do aplikacji. Następnie piszesz kod w aplikacji, który odpowiada bezpośrednio na powiadomienia.

Oprócz odpowiedzi Joe możesz również wymusić język dla testów interfejsu użytkownika bezpośrednio w kodzie testowym bez edytowania takiego schematu:

- (void)setUp
{
    [super setUp];

    self.continueAfterFailure = NO;
    XCUIApplication *app = [[XCUIApplication alloc] init];
    app.launchArguments = @[@"-AppleLanguages", @"(en)", @"-AppleLocale", @"en_EN"];
    [app launch];
}

Odpowiedź SeanR jest świetna (+1), ale jest niewielka poprawa:

Jeśli używasz lokalizacji bazowej, twój Localizable.strings może nie być zlokalizowany w Twoim języku bazowym. Nie jest to konieczne, ponieważ język bazowy byłby używany w tym przypadku. Jeśli tak, Funkcja SeanR localizedString zwróci „?“.

Poniższa rozszerzona wersja sprawdza dodatkowo język podstawowy i zwraca zlokalizowany ciąg znaków w języku bazowym:

func localizedString(_ key: String) -> String {
    let testBundle = Bundle(for: ShopEasyUITests.self)
    guard let currentLanguage = currentLanguage else { return "?" }
    if let testBundlePath = testBundle.path(forResource: currentLanguage.localeCode, ofType: "lproj"),
        let localizedBundle = Bundle(path: testBundlePath) {
        return NSLocalizedString(key, bundle: localizedBundle, comment: "")
    }
    if let testBundlePath = testBundle.path(forResource: currentLanguage.langCode, ofType: "lproj"),
        let localizedBundle = Bundle(path: testBundlePath) {
        return NSLocalizedString(key, bundle: localizedBundle, comment: "")
    }
    if let testBundlePath = testBundle.path(forResource: "Base", ofType: "lproj"),
        let localizedBundle = Bundle(path: testBundlePath) {
        return NSLocalizedString(key, bundle: localizedBundle, comment: "")
    }
    return "?"
}

Dla funkcji migawki fastlane, SnapshotHelper.swift uruchamia aplikację z tymi argumentami. Tak więc interpretując te wartości, To rozwiązanie jest deterministyczne i byłem w stanie stworzyć poprawne migawki dla wielu języków: {]}

func getLocale(str: String) -> String {
    let start = str.index(str.startIndex, offsetBy: 1)
    let end = str.index(start, offsetBy: 2)
    let range = start..<end

    var locale = str.substring(with: range)
    if locale == "en" {
        return "Base"
    }
    return locale
}

func localizedString(_ key: String) -> String {
    print("app.launchArguments \(app.launchArguments)")
    guard let localeArgIdx = app.launchArguments.index(of: "-AppleLocale") else {
        return ""
    }
    if localeArgIdx >= app.launchArguments.count {
        return ""
    }
    let str = app.launchArguments[localeArgIdx + 1]
    let locale = getLocale(str: str)
    let testBundle = Bundle(for: Snapshot.self)
    if let testBundlePath = testBundle.path(forResource: locale, ofType: "lproj") ?? testBundle.path(forResource: locale, ofType: "lproj"),
        let localizedBundle = Bundle(path: testBundlePath)
    {
        return NSLocalizedString(key, bundle: localizedBundle, comment: "")
    }
    return ""
}

Hope this helps