Pierwsze kroki z testami pętli gry na iOS

Dzięki testom pętli gry możesz pisać testy natywne dla silnika gry, a następnie uruchamiać je w Test Lab na wybranych urządzeniach. Dzięki temu nie musisz się martwić o pisanie kodu dla różnych interfejsów czy platform testowych. Test pętli gry symuluje działania prawdziwego gracza, a gdy uruchomisz go w Test Lab, możesz szybko i w skalowalny sposób sprawdzić, czy gra działa prawidłowo u użytkowników.

Na tej stronie dowiesz się, jak przeprowadzić test pętli gry, a następnie wyświetlić wyniki testu i zarządzać nimi na stronie Test Lab w konsoli Firebase. Możesz też dostosować testy za pomocą opcjonalnych funkcji, takich jak pisanie niestandardowych wyników testu lub wcześniejsze zakończenie testu.

Czym jest test pętli gry?

Pętla to pełne lub częściowe uruchomienie testu w grze mobilnej. Możesz uruchomić test pętli gry lokalnie w symulatorze lub na zestawie urządzeń w Test Lab. Testy pętli gry można wykorzystać do:

• Przejdź grę tak, jakby grał w nią użytkownik. Możesz zapisać dane wejściowe użytkownika, pozostawić użytkownika bezczynnego lub zastąpić go AI (np. jeśli wdrożysz AI w grze wyścigowej, możesz powierzyć kierowcy AI dane wejściowe użytkownika).

• Uruchom grę z najwyższymi ustawieniami jakości, aby sprawdzić, które urządzenia ją obsługują.

• Przeprowadź test techniczny, np. skompiluj kilka obiektów cieniujących, wykonaj je i sprawdź, czy dane wyjściowe są zgodne z oczekiwaniami.

Krok 1. Zarejestruj niestandardowy schemat URI adresu URL aplikacji Test Lab

Najpierw musisz zarejestrować niestandardowy schemat URI adresu URL aplikacji Firebase Test Lab w swojej aplikacji:

1. W Xcode wybierz cel projektu.

2. Kliknij kartę Informacje, a następnie dodaj nowy typ adresu URL.

3. W polu Schematy adresów URL wpisz firebase-game-loop. Możesz też zarejestrować niestandardowy schemat URI adresu URL, dodając go do pliku konfiguracji Info.plist projektu w dowolnym miejscu w tagu <dict>:

   <key>CFBundleURLTypes</key>
    <array>
        <dict>
            <key>CFBundleURLName</key>
            <string></string>
            <key>CFBundleTypeRole</key>
            <string>Editor</string>
            <key>CFBundleURLSchemes</key>
            <array>
                <string>firebase-game-loop</string>
            </array>
        </dict>
    </array>
   

Twoja aplikacja jest teraz skonfigurowana do przeprowadzenia testu za pomocą Test Lab.

Krok 2 (opcjonalny): skonfiguruj aplikację tak, aby uruchamiała wiele pętli

Jeśli aplikacja ma zarejestrowanych kilka niestandardowych schematów URI adresu URL i planujesz uruchomić w teście kilka pętli (scenariuszy), musisz określić, które pętle chcesz uruchomić w aplikacji w momencie jej uruchomienia.

W delegacie aplikacji zastąp metodę application(_:open:options:):

func application(_app: UIApplication,
                 open url: URL
                 options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
    let components = URLComponents(url: url, resolvingAgainstBaseURL: true)!
    if components.scheme == "firebase-game-loop" {
        // ...Enter Game Loop Test logic to override application(_:open:options:).
    }
    return true
}

- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary <UIApplicationOpenURLOptionsKey, id> *)options {
  if ([url.scheme isEqualToString:(@"firebase-game-loop")]) {
      // ...Enter Game Loop Test logic to override application(_:open:options:).
  }
}

Gdy w teście uruchamiasz kilka pętli, bieżąca pętla jest przekazywana jako parametr do adresu URL używanego do uruchamiania aplikacji. Możesz też uzyskać bieżący numer pętli, analizując obiekt URLComponents używany do pobierania niestandardowego schematu URI adresu URL:

if components.scheme == "firebase-game-loop" {
    // Iterate over all parameters and find the one with the key "scenario".
    let scenarioNum = Int(components.queryItems!.first(where: { $0.name == "scenario" })!.value!)!
    // ...Write logic specific to the current loop (scenarioNum).
}

if ([url.scheme isEqualToString:(@"firebase-game-loop")]) {
    // Launch the app as part of a game loop.
    NSURLComponents *components = [NSURLComponents componentsWithURL:url
                                             resolvingAgainstBaseURL:YES];
    for (NSURLQueryItem *item in [components queryItems]) {
        if ([item.name isEqualToString:@"scenario"]) {
            NSInteger scenarioNum = [item.value integerValue];
            // ...Write logic specific to the current loop (scenarioNum).
        }
    }
}

Krok 3. Utwórz i przeprowadź test

Po zarejestrowaniu niestandardowego schematu URI adresu URL aplikacji Test Lab możesz uruchomić test w konsoli Firebase lub za pomocą interfejsu wiersza poleceń gcloud w wersji beta. Jeśli jeszcze nie masz pliku IPA aplikacji, wygeneruj go (będzie potrzebny później).

Uruchamianie testu w konsoli Firebase

1. W konsoli Firebase kliknij DevOps i zaangażowanie > Test Lab.

2. Kliknij Run Your First Test > Run an iOS Game Loop (Uruchom pierwszy test > Uruchom pętlę gry na iOS).

3. W sekcji Załaduj aplikację kliknij Przeglądaj, a następnie wybierz plik IPA aplikacji (jeśli jeszcze nie masz takiego pliku, wygeneruj go).

4. (Opcjonalnie) Jeśli chcesz uruchomić kilka pętli (scenariuszy) naraz lub wybrać konkretne pętle do uruchomienia, wpisz numery pętli w polu Scenariusze.

   Jeśli na przykład wpiszesz 1-3, 5, Test Lab uruchomi pętle 1, 2, 3 i 5. Domyślnie (jeśli nie wpiszesz niczego w polu Scenariusze) Test Lab uruchamia tylko pętlę 1.

5. W sekcji Urządzenia wybierz co najmniej 1 urządzenie fizyczne, na którym chcesz przetestować aplikację, a następnie kliknij Rozpocznij testy.

Uruchamianie testu za pomocą interfejsu wiersza poleceń gcloud beta

1. Jeśli jeszcze nie masz skonfigurowanego lokalnego środowiska gcloud SDK, zrób to, a następnie zainstaluj komponent gcloud beta.

2. Uruchom polecenie gcloud beta firebase test ios run i użyj tych flag, aby skonfigurować uruchomienie:

Na przykład to polecenie uruchamia test pętli gry, który wykonuje pętle 1, 4, 6, 7 i 8 na iPhonie 8 Plus:

gcloud beta firebase test ios run
 --type game-loop --app path/to/my/App.ipa --scenario-numbers 1,4,6-8
 --device-model=iphone8plus

Więcej informacji o gcloud CLI znajdziesz w dokumentacji referencyjnej.

Lokalne przeprowadzanie testu

Aby przeprowadzić test lokalnie, wczytaj grę mobilną w symulatorze i uruchom:

xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://

• Identyfikator UDID symulatora możesz znaleźć, uruchamiając polecenie instruments -s devices.

• Jeśli działa tylko jeden symulator, zamiast SIMULATOR_UDID wpisz ciąg znaków "booted".

Jeśli test zawiera wiele pętli, możesz określić, którą pętlę chcesz uruchomić, przekazując numer pętli do flagi scenario. Pamiętaj, że podczas testowania lokalnego możesz uruchomić tylko jedną pętlę naraz. Jeśli na przykład chcesz uruchomić pętle 1, 2 i 5, musisz uruchomić osobne polecenie dla każdej pętli:

xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://?scenario=1
xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://?scenario=2
xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://?scenario=5

Wcześniejsze zakończenie testu

Domyślnie test pętli gry jest uruchamiany, dopóki nie upłynie limit czasu wynoszący 5 minut, nawet jeśli wszystkie pętle zostały wykonane. Po upływie limitu czasu test się kończy, a wszystkie oczekujące pętle zostają anulowane. Możesz przyspieszyć test lub zakończyć go wcześniej, wywołując niestandardowy schemat URI adresu URL aplikacji Test Lab (firebase-game-loop-complete) w metodzie AppDelegate aplikacji. Na przykład:

/// End the loop by calling our custom url scheme.
func finishLoop() {
    let url = URL(string: "firebase-game-loop-complete://")!
    UIApplication.shared.open(url)
}

- (void)finishLoop {
  UIApplication *app = [UIApplication sharedApplication];
  [app openURL:[NSURL URLWithString:@"firebase-game-loop-complete://"]
      options:@{}
completionHandler:^(BOOL success) {}];
}

Test pętli gry zakończy bieżącą pętlę i wykona następną. Gdy nie ma już pętli do uruchomienia, test się kończy.

Zapisywanie niestandardowych wyników testów

Możesz skonfigurować test pętli gry, aby zapisywać niestandardowe wyniki testów w systemie plików urządzenia. Dzięki temu po rozpoczęciu testu Test Lab zapisze pliki wyników w katalogu GameLoopsResults na urządzeniu testowym (który musisz utworzyć samodzielnie). Po zakończeniu testu Test Lab przenosi wszystkie pliki z katalogu GameLoopResults do zasobnika projektu. Podczas konfigurowania testu pamiętaj o tych kwestiach:

• Przesyłane są wszystkie pliki wyników, niezależnie od ich typu, rozmiaru i liczby.

• Test Lab nie przetwarza wyników testu, dopóki nie zakończą się wszystkie pętle w teście. Jeśli więc test zawiera wiele pętli, które zapisują dane wyjściowe, pamiętaj, aby dołączyć je do unikalnego pliku wyników lub utworzyć plik wyników dla każdej pętli. Dzięki temu unikniesz zastąpienia wyników z poprzedniej pętli.

Aby skonfigurować test pod kątem zapisywania niestandardowych wyników:

1. W katalogu Documents aplikacji utwórz katalog o nazwie GameLoopResults.

2. W dowolnym miejscu w kodzie aplikacji (np. w delegacie aplikacji) dodaj:

   Swift

   /// Write to a results file.
   func writeResults() {
     let text = "Greetings from game loops!"
     let fileName = "results.txt"
     let fileManager = FileManager.default
     do {
   
     let docs = try fileManager.url(for: .documentDirectory,
                                    in: .userDomainMask,
                                    appropriateFor: nil,
                                    create: true)
     let resultsDir = docs.appendingPathComponent("GameLoopResults")
     try fileManager.createDirectory(
         at: resultsDir,
         withIntermediateDirectories: true,
         attributes: nil)
     let fileURL = resultsDir.appendingPathComponent(fileName)
     try text.write(to: fileURL, atomically: false, encoding: .utf8)
     } catch {
       // ...Handle error writing to file.
     }
   }
   

   Objective-C

   /// Write to a results file.
   - (void)writeResults:(NSString *)message {
       // Locate and create the results directory (if it doesn't exist already).
       NSFileManager *manager = [NSFileManager defaultManager];
       NSURL* url = [[manager URLsForDirectory:NSDocumentDirectory
                                     inDomains:NSUserDomainMask] lastObject];
       NSURL* resultsDir = [url URLByAppendingPathComponent:@"GameLoopResults"
                                                isDirectory:YES];
       [manager createDirectoryAtURL:resultsDir
         withIntermediateDirectories:NO
                          attributes:nil
                               error:nil];
   
       // Write the result message to a text file.
       NSURL* resultFile = [resultsDir URLByAppendingPathComponent:@"result.txt"];
       if ([manager fileExistsAtPath:[resultFile path]]) {
           // Append to the existing file
           NSFileHandle *handle = [NSFileHandle fileHandleForWritingToURL:resultFile
                                                                    error:nil];
           [handle seekToEndOfFile];
           [handle writeData:[message dataUsingEncoding:NSUTF8StringEncoding]];
           [handle closeFile];
       } else {
           // Create and write to the file.
           [message writeToURL:resultFile
                    atomically:NO
                      encoding:NSUTF8StringEncoding error:nil];
       }
   }