Merge pull request #94 from Azure/feature/93-create-empty-child-directories

Create empty child directory for offline resources

Author: colbylwilliams

AzureData/Source/ResourceCache.swift

@@ -252,12 +252,20 @@ extension FileManager {
 
     fileprivate func fileUrl(for path: (directory:String, file:String)) throws -> URL {
 
-        let directory = try cacheFileUrl(for: path.directory)
-        
-        if !self.fileExists(atPath: directory.path) {
-            try self.createDirectory(at: directory, withIntermediateDirectories: true, attributes: nil)
+        let directoryUrl = try cacheFileUrl(for: path.directory)
+
+        // Create the directory for the resource if it does not exist.
+        if !self.fileExists(atPath: directoryUrl.path) {
+            try self.createDirectory(at: directoryUrl, withIntermediateDirectories: true, attributes: nil)
         }
-        
+
+        // Create empty child directories for the resource if they don't exist.
+        try path.directory.resourceType?
+            .children
+            .map { directoryUrl.appendingPathComponent($0.rawValue) }
+            .filter { !fileExists(atPath: $0.path) }
+            .forEach { try createDirectory(at: $0, withIntermediateDirectories: true, attributes: nil) }
+
         return try cacheFileUrl(for: path.file)
     }
 

AzureData/Source/ResourceType.swift

@@ -19,7 +19,7 @@ public enum ResourceType : String {
     case document           = "docs"
     case attachment         = "attachments"
     case offer              = "offers"
-    
+
     var path: String {
         return self.rawValue
     }
@@ -49,7 +49,22 @@ public enum ResourceType : String {
         case .collection, .document, .storedProcedure, .trigger, .udf, .attachment: return true
         }
     }
-    
+
+    var children: [ResourceType] {
+        switch self {
+        case .database:        return [.collection, .user]
+        case .user:            return [.permission]
+        case .permission:      return []
+        case .collection:      return [.document, .storedProcedure, .trigger, .udf]
+        case .document:        return [.attachment]
+        case .storedProcedure: return []
+        case .trigger:         return []
+        case .udf:             return []
+        case .attachment:      return []
+        case .offer:           return []
+        }
+    }
+
     static var ancestors: [ResourceType] {
         return [ .database, .user, .collection, .document ]
     }

AzureData/Source/UtilityExtensions.swift

@@ -108,6 +108,11 @@ extension String {
         return (ResourceType(rawValue: String(components[count - 4])), String(components[count - 3]))
     }
 
+    var resourceType: ResourceType? {
+        guard let (directory, _) = self.path else { return nil }
+        return ResourceType(rawValue: directory.lastPathComponent)
+    }
+
     /// "dbs/TC1AAA==/colls/TC1AAMDvwgA=".path = ("dbs/TC1AAA==/colls", "TC1AAMDvwgA=")
     var path: (directory: String, file: String)? {
         let components = self.split(separator: "/")

AzureData/Tests/OfflineReadTests.swift

@@ -281,6 +281,110 @@ class OfflineReadTests: _AzureDataTests {
         wait(for: [deleteExpectation], timeout: timeout)
     }
 
+    func testEmptyChildDirectoriesAreCreatedWhenANewDatabaseIsCachedOffline() {
+        let createExpectation = self.expectation(description: "empty child directories are created when a new database is cached offline.")
+
+        ensureDatabaseExists { database in
+            AzureData.get(databaseWithId: database.id) { r in
+                XCTAssertTrue(r.result.isSuccess)
+    
+                self.wait {
+                    let databaseDirectoryUrl = URL(string: "dbs/\(database.resourceId)/", relativeTo: self.cachesDirectoryURL)!
+                    let collectionsDirectoryUrl = URL(string: "colls/", relativeTo: databaseDirectoryUrl)!
+                    let usersDirectoryUrl = URL(string: "users/", relativeTo: databaseDirectoryUrl)!
+
+                    XCTAssertTrue(FileManager.default.fileExists(atPath: databaseDirectoryUrl.path))
+                    XCTAssertTrue(FileManager.default.fileExists(atPath: collectionsDirectoryUrl.path))
+                    XCTAssertTrue(FileManager.default.fileExists(atPath: usersDirectoryUrl.path))
+
+                    createExpectation.fulfill()
+                }
+            }
+        }
+        
+        wait(for: [createExpectation], timeout: timeout)
+    }
+
+    func testEmptyChildDirectoriesAreCreatedWhenANewCollectionIsCachedOffline() {
+        let createExpectation = self.expectation(description: "empty child directories are created when a new collection is cached offline.")
+
+        ensureDatabaseExists { database in
+            self.ensureCollectionExists { collection in
+                AzureData.get(collectionWithId: collection.id, inDatabase: database.id) { r in
+                    XCTAssertTrue(r.result.isSuccess)
+                    
+                    self.wait {
+                        let collectionDirectoryUrl = URL(string: "dbs/\(database.resourceId)/colls/\(collection.resourceId)/", relativeTo: self.cachesDirectoryURL)!
+                        let documentsDirectoryUrl = URL(string: "docs/", relativeTo: collectionDirectoryUrl)!
+                        let sprocsDirectoryUrl = URL(string: "sprocs/", relativeTo: collectionDirectoryUrl)!
+                        let triggersDirectoryUrl = URL(string: "triggers/", relativeTo: collectionDirectoryUrl)!
+                        let udfsDirectoryUrl = URL(string: "udfs/", relativeTo: collectionDirectoryUrl)!
+
+                        XCTAssertTrue(FileManager.default.fileExists(atPath: collectionDirectoryUrl.path))
+                        XCTAssertTrue(FileManager.default.fileExists(atPath: documentsDirectoryUrl.path))
+                        XCTAssertTrue(FileManager.default.fileExists(atPath: sprocsDirectoryUrl.path))
+                        XCTAssertTrue(FileManager.default.fileExists(atPath: triggersDirectoryUrl.path))
+                        XCTAssertTrue(FileManager.default.fileExists(atPath: udfsDirectoryUrl.path))
+
+                        createExpectation.fulfill()
+                    }
+                }
+            }
+        }
+        
+        wait(for: [createExpectation], timeout: timeout)
+    }
+
+    func testEmptyChildDirectoriesAreCreatedWhenANewDocumentIsCachedOffline() {
+        let createExpectation = self.expectation(description: "empty child directories are created when a new document is cached offline.")
+        
+        ensureDatabaseExists { database in
+            self.ensureCollectionExists { collection in
+                self.ensureDocumentExists { document in
+                    AzureData.get(documentWithId: document.id, as: Document.self, inCollection: collection.id, inDatabase: database.id) { r in
+                        XCTAssertTrue(r.result.isSuccess)
+                        
+                        self.wait {
+                            let documentDirectoryUrl = URL(string: "dbs/\(database.resourceId)/colls/\(collection.resourceId)/docs/\(document.resourceId)/", relativeTo: self.cachesDirectoryURL)!
+                            let attachments = URL(string: "attachments/", relativeTo: documentDirectoryUrl)!
+                            
+                            XCTAssertTrue(FileManager.default.fileExists(atPath: documentDirectoryUrl.path))
+                            XCTAssertTrue(FileManager.default.fileExists(atPath: attachments.path))
+                            
+                            createExpectation.fulfill()
+                        }
+                    }
+                }
+            }
+        }
+        
+        wait(for: [createExpectation], timeout: timeout)
+    }
+
+    func testEmptyChildDirectoriesAreCreatedWhenANewUserIsCachedOffline() {
+        let createExpectation = self.expectation(description: "empty child directories are created when a new user is cached offline.")
+        
+        ensureDatabaseExists { database in
+            self.ensureUserExists { user in
+                AzureData.get(userWithId: user.id, inDatabase: database.id) { r in
+                    XCTAssertTrue(r.result.isSuccess)
+                    
+                    self.wait {
+                        let userDirectoryUrl = URL(string: "dbs/\(database.resourceId)/users/\(user.resourceId)/", relativeTo: self.cachesDirectoryURL)!
+                        let permissionsDirectoryUrl = URL(string: "permissions/", relativeTo: userDirectoryUrl)!
+                        
+                        XCTAssertTrue(FileManager.default.fileExists(atPath: userDirectoryUrl.path))
+                        XCTAssertTrue(FileManager.default.fileExists(atPath: permissionsDirectoryUrl.path))
+                        
+                        createExpectation.fulfill()
+                    }
+                }
+            }
+        }
+        
+        wait(for: [createExpectation], timeout: timeout)
+    }
+
     // MARK: - Private helpers
 
     private func ensureResourcesAreCachedLocallyWhenNetworkIsReachable<T: CodableResource>(

AzureData/Tests/_AzureDataTests.swift

@@ -80,6 +80,16 @@ class _AzureDataTests: XCTestCase {
         )
     }
 
+    func ensureUserExists(completion: ((User) -> ())? = nil) {
+        ensureDatabaseExists()
+        ensureResourceExists(
+            type: User.self,
+            get: { AzureData.get(userWithId: self.userId, inDatabase: self.databaseId, callback: $0) },
+            create: { AzureData.create(userWithId: self.userId, inDatabase: self.databaseId, callback: $0) },
+            completion: completion
+        )
+    }
+
     func ensureDatabaseIsDeleted() {
         ensureResourceIsDeleted(Database.self, delete: { AzureData.delete(databaseWithId: self.databaseId, callback: $0) })
     }