inital_test.swift

class CatalogExportingTests: XCTestCase {

  var container: NSPersistentContainer!

  override func setUp() {
    guard
      let managedObjectModelURL =
        Bundle(for: Self.self).url(
          forResource: "GoShopping",
          withExtension: "momd"
        )
    else {
      XCTFail("Couldn't locate managed object model")
      return
    }

    guard
      let managedObjectModel =
        NSManagedObjectModel(contentsOf: managedObjectModelURL)
    else {
      XCTFail("Couldn't instantiate managed object model")
      return
    }

    container =
      NSPersistentContainer(
        name: "GoShopping",
        managedObjectModel: managedObjectModel
      )

    let storeLoadedAwaiter = XCTWaiter(delegate: nil)
    let storeLoadedExpectation = expectation(description: "Store Loaded")

    container.loadPersistentStores(
      completionHandler: { store, error in
        if let error = error {
          XCTFail("Couldn't load store: \(error)")
        }
        else {
          storeLoadedExpectation.fulfill()
        }
      }
    )

    storeLoadedAwaiter.wait(for: [storeLoadedExpectation], timeout: 0.1)
  }

  func test_Categories_Are_Exported_By_DisplayOrder() {
    let context = container.viewContext

    let barCategory = CatalogCategory(context: context)
    barCategory.name = "Bar"
    barCategory.displayOrder = Int32(2)

    let fooCategory = CatalogCategory(context: context)
    fooCategory.name = "Foo"
    fooCategory.displayOrder = Int32(1)

    do {
      try context.save()
    }
    catch {
      XCTFail("Couldn't save categories to catalog")
      return
    }

    let exportActivity = ExportCatalogActivity(persistentContainer: container)

    guard
      let exportedData = exportActivity.item as? Data
    else {
      XCTFail("Data was exported in unexpected type")
      return
    }

    let exportedCatalog: [ExportedCatalogCategory]

    do {
      exportedCatalog =
        try JSONDecoder().decode(
          [ExportedCatalogCategory].self,
          from: exportedData
        )
    }
    catch {
      XCTFail("Couldn't decode exported JSON")
      return
    }

    XCTAssertEqual(exportedCatalog.count, 2)
    XCTAssertEqual(exportedCatalog[0].name, "Foo")
    XCTAssertEqual(exportedCatalog[1].name, "Bar")
  }

  override func tearDown() {
    let storeCoordinator = container.persistentStoreCoordinator

    guard
      let store = storeCoordinator.persistentStores.first
    else {
      return
    }

    try? storeCoordinator.destroyPersistentStore(
      at: store.url!,
      ofType: store.type,
      options: nil
    )
  }
}