Pourquoi le code à l'intérieur des tests unitaires ne peut-il pas trouver des ressources groupées?

Certains codes que je suis en test unitaire doivent charger un fichier de ressources. Il contient la ligne suivante:

NSString *path = [[NSBundle mainBundle] pathForResource:@"foo" ofType:@"txt"];

Dans l'application, il fonctionne très bien, mais lorsqu'il est exécuté par le cadre de test unitaire, il pathForResource:renvoie nil, ce qui signifie qu'il n'a pas pu le localiser foo.txt.

Je me suis assuré que cela foo.txtétait inclus dans la phase de création de Copy Bundle Resources de la cible de test unitaire, alors pourquoi ne trouve-t-il pas le fichier?

Lorsque le faisceau de tests unitaires exécute votre code, votre bundle de tests unitaires n'est PAS le bundle principal.

Même si vous exécutez des tests, pas votre application, votre bundle d'applications reste le bundle principal. (Vraisemblablement, cela empêche le code que vous testez de rechercher le mauvais bundle.) Ainsi, si vous ajoutez un fichier de ressources au bundle de test unitaire, vous ne le trouverez pas si vous recherchez le bundle principal. Si vous remplacez la ligne ci-dessus par:

NSBundle *bundle = [NSBundle bundleForClass:[self class]];
NSString *path = [bundle pathForResource:@"foo" ofType:@"txt"];

Ensuite, votre code recherchera le bundle dans lequel se trouve votre classe de test unitaire, et tout ira bien.

Une implémentation Swift:

Swift 2

let testBundle = NSBundle(forClass: self.dynamicType)
let fileURL = testBundle.URLForResource("imageName", withExtension: "png")
XCTAssertNotNil(fileURL)

Swift 3, Swift 4

let testBundle = Bundle(for: type(of: self))
let filePath = testBundle.path(forResource: "imageName", ofType: "png")
XCTAssertNotNil(filePath)

Bundle fournit des moyens de découvrir les chemins principaux et de test de votre configuration:

@testable import Example

class ExampleTests: XCTestCase {

    func testExample() {
        let bundleMain = Bundle.main
        let bundleDoingTest = Bundle(for: type(of: self ))
        let bundleBeingTested = Bundle(identifier: "com.example.Example")!

        print("bundleMain.bundlePath : \(bundleMain.bundlePath)")
        // …/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/Library/Xcode/Agents
        print("bundleDoingTest.bundlePath : \(bundleDoingTest.bundlePath)")
        // …/PATH/TO/Debug/ExampleTests.xctest
        print("bundleBeingTested.bundlePath : \(bundleBeingTested.bundlePath)")
        // …/PATH/TO/Debug/Example.app

        print("bundleMain = " + bundleMain.description) // Xcode Test Agent
        print("bundleDoingTest = " + bundleDoingTest.description) // Test Case Bundle
        print("bundleUnderTest = " + bundleBeingTested.description) // App Bundle

Dans Xcode 6 | 7 | 8 | 9, un chemin de bundle de test unitaire sera dans Developer/Xcode/DerivedDataquelque chose comme ...

/Users/
  UserName/
    Library/
      Developer/
        Xcode/
          DerivedData/
            App-qwertyuiop.../
              Build/
                Products/
                  Debug-iphonesimulator/
                    AppTests.xctest/
                      foo.txt

... qui est distinct du Developer/CoreSimulator/Devices chemin du bundle régulier (non-test unitaire) :

/Users/
  UserName/
    Library/
    Developer/
      CoreSimulator/
        Devices/
          _UUID_/
            data/
              Containers/
                Bundle/
                  Application/
                    _UUID_/
                      App.app/

Notez également que l'exécutable du test unitaire est, par défaut, lié au code de l'application. Cependant, le code de test unitaire ne doit avoir l'appartenance cible que dans l'ensemble de test. Le code d'application ne doit avoir l'appartenance cible que dans l'ensemble d'applications. Lors de l'exécution, le bundle cible de test unitaire est injecté dans le bundle d'application pour exécution .

Gestionnaire de paquets Swift (SPM) 4:

let testBundle = Bundle(for: type(of: self)) 
print("testBundle.bundlePath = \(testBundle.bundlePath) ")

Remarque: Par défaut, la ligne de commande swift testcréera un MyProjectPackageTests.xctestensemble de test. Et, le swift package generate-xcodeprojcréera un MyProjectTests.xctestbundle de test. Ces différents lots de tests ont des chemins différents . En outre, les différents ensembles de tests peuvent présenter des différences de structure de répertoire interne et de contenu .

Dans les deux cas, .bundlePathet .bundleURLrenverra le chemin du bundle de test en cours d'exécution sur macOS. Cependant, Bundlen'est actuellement pas implémenté pour Ubuntu Linux.

En outre, la ligne de commande swift buildet swift testne fournissent actuellement pas de mécanisme de copie des ressources.

Cependant, avec un peu d'effort, il est possible de configurer des processus pour utiliser Swift Package Manager avec des ressources dans les environnements de ligne de commande macOS Xcode, macOS et Ubuntu. Un exemple peut être trouvé ici: 004.4'2 SW Dev Swift Package Manager (SPM) With Resources Qref

Voir aussi: Utiliser des ressources dans des tests unitaires avec Swift Package Manager

Gestionnaire de paquets Swift (SPM) 4.2

Swift Package Manager PackageDescription 4.2 introduit la prise en charge des dépendances locales .

Les dépendances locales sont des packages sur disque qui peuvent être référencés directement en utilisant leurs chemins. Les dépendances locales ne sont autorisées que dans le package racine et elles remplacent toutes les dépendances portant le même nom dans le graphique du package.

Remarque: je m'attends, mais je n'ai pas encore testé, que quelque chose comme ce qui suit devrait être possible avec SPM 4.2:

// swift-tools-version:4.2
import PackageDescription

let package = Package(
    name: "MyPackageTestResources",
    dependencies: [
        .package(path: "../test-resources"),
    ],
    targets: [
        // ...
        .testTarget(
            name: "MyPackageTests",
            dependencies: ["MyPackage", "MyPackageTestResources"]
        ),
    ]
)

Avec Swift Swift 3, la syntaxe self.dynamicTypeest obsolète, utilisez-la à la place

let testBundle = Bundle(for: type(of: self))
let fooTxtPath = testBundle.path(forResource: "foo", ofType: "txt")

ou

let fooTxtURL = testBundle.url(forResource: "foo", withExtension: "txt")

Confirmez que la ressource est ajoutée à la cible de test.

si vous avez plusieurs cibles dans votre projet, vous devez ajouter des ressources entre différentes cibles disponibles dans l' appartenance cible et vous devrez peut-être basculer entre différentes cibles en 3 étapes illustrées dans la figure ci-dessous

Je devais m'assurer que cette case à cocher Test général était activée