Error when attempting to update ParseFile (#144)

* Error when attempting to update ParseFile

* add changelog

Author: cbaker6

CHANGELOG.md

@@ -5,6 +5,7 @@
 * _Contributing to this repo? Add info about your change here to be included in the next release_
 
 __Fixes__
+- ParseFiles can't be updated from the client and will now throw an error if attempted. Instead another file should be created and the older file should be deleted by the developer. ([#144](https://github.com/parse-community/Parse-Swift/pull/144)), thanks to [Corey Baker](https://github.com/cbaker6).
 - Fixed issue where Swift SDK prevented fetching of Parse objects when custom objectId was enabled ([#139](https://github.com/parse-community/Parse-Swift/pull/139)), thanks to [Corey Baker](https://github.com/cbaker6).
 
 __Improvements__

Sources/ParseSwift/API/API+Commands.swift

@@ -254,11 +254,13 @@ internal extension API {
 
 internal extension API.Command {
     // MARK: Uploading File
-    static func uploadFileCommand(_ object: ParseFile) -> API.Command<ParseFile, ParseFile> {
-        if object.isSaved {
-            return updateFileCommand(object)
+    static func uploadFileCommand(_ object: ParseFile) throws -> API.Command<ParseFile, ParseFile> {
+        if !object.isSaved {
+            return createFileCommand(object)
+        } else {
+            throw ParseError(code: .unknownError,
+                             message: "File is already saved and cannot be updated.")
         }
-        return createFileCommand(object)
     }
 
     // MARK: Uploading File - private
@@ -271,15 +273,6 @@ internal extension API.Command {
         }
     }
 
-    private static func updateFileCommand(_ object: ParseFile) -> API.Command<ParseFile, ParseFile> {
-        API.Command(method: .PUT,
-                    path: .file(fileName: object.name),
-                    uploadData: object.data,
-                    uploadFile: object.localURL) { (data) -> ParseFile in
-            try ParseCoding.jsonDecoder().decode(FileUploadResponse.self, from: data).apply(to: object)
-        }
-    }
-
     // MARK: Downloading File
     static func downloadFileCommand(_ object: ParseFile) -> API.Command<ParseFile, ParseFile> {
         API.Command(method: .GET,

Sources/ParseSwift/Types/ParseFile.swift

@@ -427,35 +427,57 @@ extension ParseFile {
                 switch result {
 
                 case .success(let fetched):
-                    fetched.uploadFileCommand()
-                        .executeAsync(options: options,
+                    do {
+                        try fetched.uploadFileCommand()
+                            .executeAsync(options: options,
                                       callbackQueue: callbackQueue,
                                       uploadProgress: progress) { result in
-                            callbackQueue.async {
-                                completion(result)
+                                callbackQueue.async {
+                                    completion(result)
+                                }
+                            }
+                    } catch {
+                        callbackQueue.async {
+                            if let parseError = error as? ParseError {
+                                completion(.failure(parseError))
+                            } else {
+                                let parseError = ParseError(code: .unknownError, message: error.localizedDescription)
+                                completion(.failure(parseError))
                             }
                         }
+                    }
                 case .failure(let error):
                     callbackQueue.async {
                         completion(.failure(error))
                     }
                 }
             }
         } else {
-            uploadFileCommand()
-                .executeAsync(options: options,
-                              callbackQueue: callbackQueue,
-                              uploadProgress: progress) { result in
-                    callbackQueue.async {
-                        completion(result)
+            do {
+                try uploadFileCommand()
+                    .executeAsync(options: options,
+                                  callbackQueue: callbackQueue,
+                                  uploadProgress: progress) { result in
+                        callbackQueue.async {
+                            completion(result)
+                        }
+                    }
+            } catch {
+                callbackQueue.async {
+                    if let parseError = error as? ParseError {
+                        completion(.failure(parseError))
+                    } else {
+                        let parseError = ParseError(code: .unknownError, message: error.localizedDescription)
+                        completion(.failure(parseError))
                     }
                 }
+            }
         }
 
     }
 
-    internal func uploadFileCommand() -> API.Command<Self, Self> {
-        return API.Command<Self, Self>.uploadFileCommand(self)
+    internal func uploadFileCommand() throws -> API.Command<Self, Self> {
+        try API.Command<Self, Self>.uploadFileCommand(self)
     }
 }
 

Tests/ParseSwiftTests/ParseFileTests.swift

@@ -68,14 +68,14 @@ class ParseFileTests: XCTestCase { // swiftlint:disable:this type_body_length
         wait(for: [expectation1, expectation2], timeout: 20.0)
     }
 
-    func testUploadCommand() {
+    func testUploadCommand() throws {
         guard let url = URL(string: "http://localhost/") else {
             XCTFail("Should have created url")
             return
         }
         let file = ParseFile(name: "a", cloudURL: url)
 
-        let command = file.uploadFileCommand()
+        let command = try file.uploadFileCommand()
         XCTAssertNotNil(command)
         XCTAssertEqual(command.path.urlComponent, "/files/a")
         XCTAssertEqual(command.method, API.Method.POST)
@@ -84,14 +84,25 @@ class ParseFileTests: XCTestCase { // swiftlint:disable:this type_body_length
 
         let file2 = ParseFile(cloudURL: url)
 
-        let command2 = file2.uploadFileCommand()
+        let command2 = try file2.uploadFileCommand()
         XCTAssertNotNil(command2)
         XCTAssertEqual(command2.path.urlComponent, "/files/file")
         XCTAssertEqual(command2.method, API.Method.POST)
         XCTAssertNil(command2.params)
         XCTAssertNil(command2.body)
     }
 
+    func testUploadCommandDontAllowUpdate() throws {
+        guard let url = URL(string: "http://localhost/") else {
+            XCTFail("Should have created url")
+            return
+        }
+
+        var file = ParseFile(cloudURL: url)
+        file.url = url
+        XCTAssertThrowsError(try file.uploadFileCommand())
+    }
+
     func testDeleteCommand() {
         guard let url = URL(string: "http://localhost/") else {
             XCTFail("Should have created url")
@@ -375,6 +386,19 @@ class ParseFileTests: XCTestCase { // swiftlint:disable:this type_body_length
         }
     }
 
+    func testUpdateFileError() throws {
+        guard let sampleData = "Hello World".data(using: .utf8) else {
+            throw ParseError(code: .unknownError, message: "Should have converted to data")
+        }
+        var parseFile = ParseFile(name: "sampleData.txt",
+                                  data: sampleData,
+                                  metadata: ["Testing": "123"],
+                                  tags: ["Hey": "now"])
+        parseFile.url = URL(string: "http://localhost/")
+
+        XCTAssertThrowsError(try parseFile.save())
+    }
+
     func testFetchFileStream() throws {
         let tempFilePath = URL(fileURLWithPath: "\(temporaryDirectory)sampleData.dat")
         guard let sampleData = "Hello World".data(using: .utf8) else {
@@ -642,6 +666,28 @@ class ParseFileTests: XCTestCase { // swiftlint:disable:this type_body_length
         wait(for: [expectation1], timeout: 20.0)
     }
 
+    func testUpdateErrorAysnc() throws {
+
+        guard let sampleData = "Hello World".data(using: .utf8) else {
+            throw ParseError(code: .unknownError, message: "Should have converted to data")
+        }
+        var parseFile = ParseFile(name: "sampleData.txt", data: sampleData)
+        parseFile.url = URL(string: "http://localhost/")
+
+        let expectation1 = XCTestExpectation(description: "ParseFile async")
+        parseFile.save { result in
+
+            switch result {
+            case .success:
+                XCTFail("Should have returned error")
+            case .failure(let error):
+                XCTAssertTrue(error.message.contains("File is already"))
+            }
+            expectation1.fulfill()
+        }
+        wait(for: [expectation1], timeout: 20.0)
+    }
+
     #if !os(Linux) && !os(Android)
     // swiftlint:disable:next inclusive_language
     func testDeleteNoMasterKeyFileAysnc() throws {