Dactyloidae iOS initial commit

mobile/ios/SyncTests/StorageClientTests.swift

@@ -0,0 +1,108 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import Foundation
+import Shared
+@testable import Sync
+
+import XCTest
+import SwiftyJSON
+
+// Always return a gigantic encoded payload.
+func massivify(record: Record<CleartextPayloadJSON>) -> JSON? {
+    return JSON([
+        "id": record.id,
+        "foo": String(repeating: "X", count: Sync15StorageClient.maxRecordSizeBytes + 1)
+    ])
+}
+
+class StorageClientTests: XCTestCase {
+    func testPartialJSON() {
+        let body = "0"
+        let o: Any? = try! JSONSerialization.jsonObject(with: body.data(using: String.Encoding.utf8)!, options: JSONSerialization.ReadingOptions.allowFragments)
+        XCTAssertTrue(JSON(object: o!).isInt())
+    }
+
+    func testPOSTResult() {
+        // Pulled straight from <http://docs.services.mozilla.com/storage/apis-1.5.html>.
+        let r = "{" +
+            "\"success\": [\"GXS58IDC_12\", \"GXS58IDC_13\", \"GXS58IDC_15\"," +
+            "\"GXS58IDC_16\", \"GXS58IDC_18\", \"GXS58IDC_19\"]," +
+            "\"failed\": {\"GXS58IDC_11\": \"invalid ttl\"," +
+            "\"GXS58IDC_14\": \"invalid sortindex\"}" +
+        "}"
+
+        let p = POSTResult.fromJSON(JSON(parseJSON: r))
+        XCTAssertTrue(p != nil)
+        XCTAssertEqual(p!.success[0], "GXS58IDC_12")
+        XCTAssertEqual(p!.failed["GXS58IDC_14"]!, "invalid sortindex")
+
+        XCTAssertTrue(nil == POSTResult.fromJSON(JSON(parseJSON: "{\"foo\": 5}")))
+    }
+
+    func testNumeric() {
+        let m = ResponseMetadata(status: 200, headers: [
+            "X-Last-Modified": "2174380461.12",
+        ])
+        XCTAssertTrue(m.lastModifiedMilliseconds == 2174380461120)
+
+        XCTAssertEqual("2174380461.12", millisecondsToDecimalSeconds(2174380461120))
+    }
+
+    // Trivial test for struct semantics that we might want to pay attention to if they change,
+    // and for response header parsing.
+    func testResponseHeaders() {
+        let v: JSON = JSON(parseJSON: "{\"a:\": 2}")
+        let m = ResponseMetadata(status: 200, headers: [
+            "X-Weave-Timestamp": "1274380461.12",
+            "X-Last-Modified": "2174380461.12",
+            "X-Weave-Next-Offset": "abdef",
+            ])
+
+        XCTAssertTrue(m.lastModifiedMilliseconds == 2174380461120)
+        XCTAssertTrue(m.timestampMilliseconds    == 1274380461120)
+        XCTAssertTrue(m.nextOffset == "abdef")
+
+        // Just to avoid consistent overflow allowing ==.
+        XCTAssertTrue(m.lastModifiedMilliseconds?.description == "2174380461120")
+        XCTAssertTrue(m.timestampMilliseconds.description == "1274380461120")
+
+        let x: StorageResponse<JSON> = StorageResponse<JSON>(value: v, metadata: m)
+
+        func doTesting(y: StorageResponse<JSON>) {
+            // Make sure that reference fields in a struct are copies of the same reference,
+            // not references to a copy.
+            XCTAssertTrue(x.value == y.value)
+
+            XCTAssertTrue(y.metadata.lastModifiedMilliseconds == x.metadata.lastModifiedMilliseconds, "lastModified is the same.")
+
+            XCTAssertTrue(x.metadata.quotaRemaining == nil, "No quota.")
+            XCTAssertTrue(y.metadata.lastModifiedMilliseconds == 2174380461120, "lastModified is correct.")
+            XCTAssertTrue(x.metadata.timestampMilliseconds == 1274380461120, "timestamp is correct.")
+            XCTAssertTrue(x.metadata.nextOffset == "abdef", "nextOffset is correct.")
+            XCTAssertTrue(x.metadata.records == nil, "No X-Weave-Records.")
+        }
+
+        doTesting(y: x)
+    }
+
+    func testOverSizeRecords() {
+        let delegate = MockSyncDelegate()
+
+        // We can use these useless values because we're directly injecting decrypted
+        // payloads; no need for real keys etc.
+        let prefs = MockProfilePrefs()
+        let scratchpad = Scratchpad(b: KeyBundle.random(), persistingTo: prefs)
+
+        let synchronizer = IndependentRecordSynchronizer(scratchpad: scratchpad, delegate: delegate, basePrefs: prefs, why: .scheduled, collection: "foo")
+        let jA = "{\"id\":\"aaaaaa\",\"histUri\":\"http://foo.com/\",\"title\": \"ñ\",\"visits\":[{\"date\":1222222222222222,\"type\":1}]}"
+        let rA = Record<CleartextPayloadJSON>(id: "aaaaaa", payload: CleartextPayloadJSON(JSON(parseJSON: jA)), modified: 10000, sortindex: 123, ttl: 1000000)
+
+        let storageClient = Sync15StorageClient(serverURI: "http://example.com/".asURL!, authorizer: identity, workQueue: DispatchQueue.main, resultQueue: DispatchQueue.main, backoff: MockBackoffStorage())
+        let collectionClient = storageClient.clientForCollection("foo", encrypter: RecordEncrypter<CleartextPayloadJSON>(serializer: massivify, factory: { CleartextPayloadJSON($0) }))
+        let result = synchronizer.uploadRecords([rA], lastTimestamp: Date.now(), storageClient: collectionClient, onUpload: { _ in deferMaybe(Date.now()) })
+
+        XCTAssertTrue(result.value.failureValue is RecordTooLargeError)
+    }
+}