From 4320156da7dc4ceb94f3c02295440a0d03a6b3e4 Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Tue, 30 Jul 2024 16:15:19 -0700 Subject: [PATCH 01/11] Integration Test Setup - Initial Commit --- .../Tests/Integration/IntegrationTests.swift | 160 +++++++++++++++++- 1 file changed, 159 insertions(+), 1 deletion(-) diff --git a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift index 4711fcc1057..93bdfb0fdc6 100644 --- a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift +++ b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift @@ -14,8 +14,166 @@ import Foundation +@testable import FirebaseCore @testable import FirebaseDataConnect import XCTest -class IntegrationTests: XCTestCase {} +enum GQLData { + + static let schema = """ + type UUIDTest @table { + id: UUID! + } + """ + + static let operations = """ + mutation createUUIDTest($id: UUID!) @auth(level: PUBLIC) { + uuidtest_create(data : { + id: $id + } + } + + query getUUIDTest @auth(level: PUBLIC) { + uuidTests { + id + } + } +""" + + static let setupData = """ + { + "service_id": "kitchensink", + "schema": { + "files": [ + { + "path": "schema/post.gql", + "content": "type Post @table {content: String!}" + } + ] + }, + "connectors": { + "crud": { + "files": [ + { + "path": "operations/post.gql", + "content": "query getPost($id: UUID!) @auth(level: PUBLIC) {post(id: $id) {content}} query listPosts @auth(level: PUBLIC) {posts {content}} mutation createPost($id: UUID!, $content: String!) @auth(level: PUBLIC) {post_insert(data: {id: $id, content: $content})} mutation deletePost($id: UUID!) @auth(level: PUBLIC) { post_delete(id: $id)}" + } + ] + } + } + } + +""" + +} + +struct SetupServiceRequest: Codable { + + struct GQLFile: Codable { + var path: String + var content: String + } + + struct GQLContent: Codable { + var files = [GQLFile]() + } + + var serviceId: String + var schema: GQLContent + + // connectorId => GQLContent + var connectors = [String: GQLContent]() + +} + + +extension DataConnect { + +} + +public class TestConnectorClient { + + var dataConnect: DataConnect + + public static let connectorConfig = ConnectorConfig(serviceId: "kitchensink", location: "us-central1", connector: "crud") + + init(dataConnect: DataConnect) { + self.dataConnect = dataConnect + } + + public func useEmulator(host: String = DataConnect.EmulatorDefaults.host, port: Int = DataConnect.EmulatorDefaults.port) { + self.dataConnect.useEmulator(host: host, port: port) + } + +} + +enum CreatePost { + struct Variables: OperationVariable { + var id: UUID + var content: String + } + + + struct Data: Decodable { + struct PostInsert: Decodable { + var id: String + } + var post_insert: PostInsert + } +} + +extension TestConnectorClient { + +} + + +class IntegrationTests: XCTestCase { + + var dataConnect: DataConnect? + let connectorConfig = ConnectorConfig(serviceId: "kitchensink", location: "us-central1", connector: "crud") + + override func setUp(completion: @escaping ((any Error)?) -> Void) { + print("In Setup") + + let options = FirebaseOptions(googleAppID: "0:0000000000000:ios:0000000000000000", + gcmSenderID: "00000000000000000-00000000000-000000000") + options.projectID = "fdc-test" + FirebaseApp.configure(options: options) + + dataConnect = DataConnect.dataConnect(app: FirebaseApp.app(), connectorConfig: TestConnectorClient.connectorConfig) + dataConnect?.useEmulator() + + let url = URL(string: "http://127.0.0.1:9399/setupSchema")! + var urlRequest = URLRequest(url: url) + urlRequest.httpMethod = "POST" + let setupData = GQLData.setupData.data(using: .utf8)! + let task = URLSession.shared.uploadTask(with: urlRequest, from: setupData) { data, response, error in + print("uploadTask complete \(error)") + if let data { + print("response Data \(String(data: data, encoding: .utf8))") + } + completion(error) + } + task.resume() + + } + + func testCreatePost() async throws { + guard let dataConnect else { + XCTFail("DataConnect instance is not setup and is nil") + return + } + + let id = UUID() + let variables = CreatePost.Variables(id: id, content: "Hello World") + let request = MutationRequest(operationName: "createPost", variables: variables) + let ref = dataConnect.mutation(request: request, resultsDataType:CreatePost.Data.self) + let result = try await ref.execute() + let idString = result.data.post_insert.id + let uuidConverter = UUIDCodableConverter() + let uuid = try uuidConverter.decode(input: idString) + XCTAssertEqual(uuid, id) + } + +} From 485d83f8018244e7202f1c1e91ba6b57522aba12 Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Wed, 7 Aug 2024 12:20:38 -0700 Subject: [PATCH 02/11] Blank FDC Project in Resources --- .../Tests/Integration/IntegrationTests.swift | 179 ------------------ .../Tests/Resources/GoogleService-Info.plist | 28 --- .../Resources/fdc-kitchensink/.firebaserc | 8 + .../Resources/fdc-kitchensink/.gitignore | 69 +++++++ .../fdc-kitchensink/.vscode/settings.json | 5 + .../dataconnect/dataconnect.yaml | 11 ++ .../dataconnect/default/connector.yaml | 7 + .../dataconnect/default/mutations.gql | 0 .../dataconnect/default/queries.gql | 1 + .../dataconnect/schema/schema.gql | 0 .../Resources/fdc-kitchensink/firebase.json | 5 + Package.swift | 5 +- 12 files changed, 110 insertions(+), 208 deletions(-) delete mode 100644 FirebaseDataConnect/Tests/Integration/IntegrationTests.swift delete mode 100644 FirebaseDataConnect/Tests/Resources/GoogleService-Info.plist create mode 100644 FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.firebaserc create mode 100644 FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.gitignore create mode 100644 FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.vscode/settings.json create mode 100644 FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/dataconnect.yaml create mode 100644 FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml create mode 100644 FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql create mode 100644 FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/queries.gql create mode 100644 FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/schema/schema.gql create mode 100644 FirebaseDataConnect/Tests/Resources/fdc-kitchensink/firebase.json diff --git a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift deleted file mode 100644 index 93bdfb0fdc6..00000000000 --- a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift +++ /dev/null @@ -1,179 +0,0 @@ -// Copyright 2024 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -import Foundation - -@testable import FirebaseCore -@testable import FirebaseDataConnect - -import XCTest - -enum GQLData { - - static let schema = """ - type UUIDTest @table { - id: UUID! - } - """ - - static let operations = """ - mutation createUUIDTest($id: UUID!) @auth(level: PUBLIC) { - uuidtest_create(data : { - id: $id - } - } - - query getUUIDTest @auth(level: PUBLIC) { - uuidTests { - id - } - } -""" - - static let setupData = """ - { - "service_id": "kitchensink", - "schema": { - "files": [ - { - "path": "schema/post.gql", - "content": "type Post @table {content: String!}" - } - ] - }, - "connectors": { - "crud": { - "files": [ - { - "path": "operations/post.gql", - "content": "query getPost($id: UUID!) @auth(level: PUBLIC) {post(id: $id) {content}} query listPosts @auth(level: PUBLIC) {posts {content}} mutation createPost($id: UUID!, $content: String!) @auth(level: PUBLIC) {post_insert(data: {id: $id, content: $content})} mutation deletePost($id: UUID!) @auth(level: PUBLIC) { post_delete(id: $id)}" - } - ] - } - } - } - -""" - -} - -struct SetupServiceRequest: Codable { - - struct GQLFile: Codable { - var path: String - var content: String - } - - struct GQLContent: Codable { - var files = [GQLFile]() - } - - var serviceId: String - var schema: GQLContent - - // connectorId => GQLContent - var connectors = [String: GQLContent]() - -} - - -extension DataConnect { - -} - -public class TestConnectorClient { - - var dataConnect: DataConnect - - public static let connectorConfig = ConnectorConfig(serviceId: "kitchensink", location: "us-central1", connector: "crud") - - init(dataConnect: DataConnect) { - self.dataConnect = dataConnect - } - - public func useEmulator(host: String = DataConnect.EmulatorDefaults.host, port: Int = DataConnect.EmulatorDefaults.port) { - self.dataConnect.useEmulator(host: host, port: port) - } - -} - -enum CreatePost { - struct Variables: OperationVariable { - var id: UUID - var content: String - } - - - struct Data: Decodable { - struct PostInsert: Decodable { - var id: String - } - var post_insert: PostInsert - } -} - -extension TestConnectorClient { - -} - - -class IntegrationTests: XCTestCase { - - var dataConnect: DataConnect? - let connectorConfig = ConnectorConfig(serviceId: "kitchensink", location: "us-central1", connector: "crud") - - override func setUp(completion: @escaping ((any Error)?) -> Void) { - print("In Setup") - - let options = FirebaseOptions(googleAppID: "0:0000000000000:ios:0000000000000000", - gcmSenderID: "00000000000000000-00000000000-000000000") - options.projectID = "fdc-test" - FirebaseApp.configure(options: options) - - dataConnect = DataConnect.dataConnect(app: FirebaseApp.app(), connectorConfig: TestConnectorClient.connectorConfig) - dataConnect?.useEmulator() - - let url = URL(string: "http://127.0.0.1:9399/setupSchema")! - var urlRequest = URLRequest(url: url) - urlRequest.httpMethod = "POST" - let setupData = GQLData.setupData.data(using: .utf8)! - let task = URLSession.shared.uploadTask(with: urlRequest, from: setupData) { data, response, error in - print("uploadTask complete \(error)") - if let data { - print("response Data \(String(data: data, encoding: .utf8))") - } - completion(error) - } - task.resume() - - } - - func testCreatePost() async throws { - guard let dataConnect else { - XCTFail("DataConnect instance is not setup and is nil") - return - } - - let id = UUID() - let variables = CreatePost.Variables(id: id, content: "Hello World") - let request = MutationRequest(operationName: "createPost", variables: variables) - let ref = dataConnect.mutation(request: request, resultsDataType:CreatePost.Data.self) - let result = try await ref.execute() - let idString = result.data.post_insert.id - let uuidConverter = UUIDCodableConverter() - let uuid = try uuidConverter.decode(input: idString) - XCTAssertEqual(uuid, id) - } - -} diff --git a/FirebaseDataConnect/Tests/Resources/GoogleService-Info.plist b/FirebaseDataConnect/Tests/Resources/GoogleService-Info.plist deleted file mode 100644 index 488e58afc37..00000000000 --- a/FirebaseDataConnect/Tests/Resources/GoogleService-Info.plist +++ /dev/null @@ -1,28 +0,0 @@ - - - - - API_KEY - correct_api_key - TRACKING_ID - correct_tracking_id - CLIENT_ID - correct_client_id - REVERSED_CLIENT_ID - correct_reversed_client_id - GOOGLE_APP_ID - 1:123:ios:123abc - GCM_SENDER_ID - correct_gcm_sender_id - PLIST_VERSION - 1 - BUNDLE_ID - com.google.FirebaseDataConnectSDKTests - PROJECT_ID - abc-xyz-123 - DATABASE_URL - https://abc-xyz-123.firebaseio.com - STORAGE_BUCKET - project-id-123.storage.firebase.com - - diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.firebaserc b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.firebaserc new file mode 100644 index 00000000000..df639045c32 --- /dev/null +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.firebaserc @@ -0,0 +1,8 @@ +{ + "projects": { + "default": "atomic-legacy-426102-p5" + }, + "targets": {}, + "etags": {}, + "dataconnectEmulatorConfig": {} +} \ No newline at end of file diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.gitignore b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.gitignore new file mode 100644 index 00000000000..b17f6310755 --- /dev/null +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.gitignore @@ -0,0 +1,69 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +firebase-debug.log* +firebase-debug.*.log* + +# Firebase cache +.firebase/ + +# Firebase config + +# Uncomment this if you'd like others to create their own Firebase project. +# For a team working on the same Firebase project(s), it is recommended to leave +# it commented so all members can deploy to the same project(s) in .firebaserc. +# .firebaserc + +# Runtime data +pids +*.pid +*.seed +*.pid.lock + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage + +# nyc test coverage +.nyc_output + +# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +# Bower dependency directory (https://bower.io/) +bower_components + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (http://nodejs.org/api/addons.html) +build/Release + +# Dependency directories +node_modules/ + +# Optional npm cache directory +.npm + +# Optional eslint cache +.eslintcache + +# Optional REPL history +.node_repl_history + +# Output of 'npm pack' +*.tgz + +# Yarn Integrity file +.yarn-integrity + +# dotenv environment variables file +.env + +# dataconnect generated files +.dataconnect diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.vscode/settings.json b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.vscode/settings.json new file mode 100644 index 00000000000..32cfc61d281 --- /dev/null +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.vscode/settings.json @@ -0,0 +1,5 @@ +{ + "files.watcherExclude": { + "**/target": true + } +} \ No newline at end of file diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/dataconnect.yaml b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/dataconnect.yaml new file mode 100644 index 00000000000..c8c8aede07f --- /dev/null +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/dataconnect.yaml @@ -0,0 +1,11 @@ +specVersion: "v1alpha" +serviceId: "fdc-kitchensink" +location: "us-central1" +schema: + source: "./schema" + datasource: + postgresql: + database: "kitchensink" + cloudSql: + instanceId: "fdc-test" +connectorDirs: ["./default"] diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml new file mode 100644 index 00000000000..2feedf0b677 --- /dev/null +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml @@ -0,0 +1,7 @@ +connectorId: "kitchen-sink" +authMode: "PUBLIC" + +generate: + swiftSdk: + outputDir: "/Users/aashishp/Code/firebase-ios-sdk/FirebaseDataConnect/Tests/Integration/Gen" + package: "KitchenSink" diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql new file mode 100644 index 00000000000..e69de29bb2d diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/queries.gql b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/queries.gql new file mode 100644 index 00000000000..8b137891791 --- /dev/null +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/queries.gql @@ -0,0 +1 @@ + diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/schema/schema.gql b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/schema/schema.gql new file mode 100644 index 00000000000..e69de29bb2d diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/firebase.json b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/firebase.json new file mode 100644 index 00000000000..73f599717a9 --- /dev/null +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/firebase.json @@ -0,0 +1,5 @@ +{ + "dataconnect": { + "source": "dataconnect" + } +} diff --git a/Package.swift b/Package.swift index 11d5f13d364..56d5f323ce7 100644 --- a/Package.swift +++ b/Package.swift @@ -681,7 +681,10 @@ let package = Package( name: "FirebaseDataConnectTests", dependencies: ["FirebaseDataConnect"], path: "FirebaseDataConnect/Tests", - resources: [.process("Tests/Resources")] + resources: [ + .process("Resources/GoogleService-Info.plist"), + .copy("Resources/fdc-kitchensink") + ] ), .target( name: "FirebaseSharedSwift", From 851b88e543f990e1e5708156617fe0ec0a451bb5 Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Thu, 8 Aug 2024 15:51:27 -0700 Subject: [PATCH 03/11] Integration Tests for Scalars --- FirebaseDataConnect/Sources/CodecHelper.swift | 5 - .../Sources/Internal/CodableHelpers.swift | 12 +- .../Tests/Integration/ConfigSetup.swift | 50 ++++ .../Tests/Integration/IntegrationTests.swift | 229 ++++++++++++++++++ .../Resources/fdc-kitchensink/.firebaserc | 2 +- .../dataconnect/default/connector.yaml | 2 +- .../dataconnect/default/mutations.gql | 45 ++++ .../dataconnect/default/queries.gql | 31 +++ .../dataconnect/schema/schema.gql | 35 +++ .../Tests/Unit/CodecHelperTests.swift | 19 +- 10 files changed, 403 insertions(+), 27 deletions(-) create mode 100644 FirebaseDataConnect/Tests/Integration/ConfigSetup.swift create mode 100644 FirebaseDataConnect/Tests/Integration/IntegrationTests.swift diff --git a/FirebaseDataConnect/Sources/CodecHelper.swift b/FirebaseDataConnect/Sources/CodecHelper.swift index 9f1ba32553d..b387e8f5f31 100644 --- a/FirebaseDataConnect/Sources/CodecHelper.swift +++ b/FirebaseDataConnect/Sources/CodecHelper.swift @@ -42,8 +42,6 @@ public class CodecHelper { } } - - // MARK: Decoding public func decode(_ type: T.Type, forKey: K, @@ -63,8 +61,5 @@ public class CodecHelper { return try container.decode(type, forKey: forKey) } - - public init() {} } - diff --git a/FirebaseDataConnect/Sources/Internal/CodableHelpers.swift b/FirebaseDataConnect/Sources/Internal/CodableHelpers.swift index dedf0d009f5..41e4cae5380 100644 --- a/FirebaseDataConnect/Sources/Internal/CodableHelpers.swift +++ b/FirebaseDataConnect/Sources/Internal/CodableHelpers.swift @@ -15,7 +15,7 @@ import Foundation @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) -internal protocol CodableConverter { +protocol CodableConverter { associatedtype E: Encodable associatedtype D: Decodable @@ -24,8 +24,7 @@ internal protocol CodableConverter { } @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) -internal class Int64CodableConverter: CodableConverter { - +class Int64CodableConverter: CodableConverter { func encode(input: Int64?) throws -> String? { guard let input else { return nil @@ -47,15 +46,13 @@ internal class Int64CodableConverter: CodableConverter { } } - @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) -internal class UUIDCodableConverter: CodableConverter { - +class UUIDCodableConverter: CodableConverter { func encode(input: UUID?) throws -> String? { guard let input else { return nil } - + let uuidNoDashString = convertToNoDashUUID(uuid: input) return uuidNoDashString } @@ -68,7 +65,6 @@ internal class UUIDCodableConverter: CodableConverter { } return UUID(uuidString: dashesAddedUUID) - } private func convertToNoDashUUID(uuid: UUID) -> String { diff --git a/FirebaseDataConnect/Tests/Integration/ConfigSetup.swift b/FirebaseDataConnect/Tests/Integration/ConfigSetup.swift new file mode 100644 index 00000000000..b01ca88c4d4 --- /dev/null +++ b/FirebaseDataConnect/Tests/Integration/ConfigSetup.swift @@ -0,0 +1,50 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import Foundation + +import FirebaseCore +import FirebaseDataConnect + +enum KitchenSinkError: Error { + case configureFailed +} + +extension KitchenSinkClient { + func configureProject(useDummyEngine: Bool = true) async throws { + guard let resourcePath = Bundle.module.resourcePath + else { throw KitchenSinkError.configureFailed } + let projectDirPath = URL(fileURLWithPath: resourcePath) + .appendingPathComponent("fdc-kitchensink/dataconnect").path + + let configureBody = """ + { + "service_id": "\(KitchenSinkClient.connectorConfig.serviceId)", + "config_directory": "\(projectDirPath)", + "use_dummy": \(useDummyEngine) + }' + + """ + + let configureUrl = URL(string: "http://127.0.0.1:3628/emulator/configure")! + var configureRequest = URLRequest(url: configureUrl) + configureRequest.httpMethod = "POST" + + let (data, response) = try await URLSession.shared.upload( + for: configureRequest, + from: configureBody.data(using: .utf8)! + ) + print("responseData \(response)") + } +} diff --git a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift new file mode 100644 index 00000000000..27c575b1b39 --- /dev/null +++ b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift @@ -0,0 +1,229 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import XCTest + +import FirebaseCore +@testable import FirebaseDataConnect + +final class IntegrationTests: XCTestCase { + class func setupFirebaseApp() { + if FirebaseApp.app() == nil { + let options = FirebaseOptions(googleAppID: "0:0000000000000:ios:0000000000000000", + gcmSenderID: "00000000000000000-00000000000-000000000") + options.projectID = "fdc-test" + FirebaseApp.configure(options: options) + } + } + + private let setupQ = DispatchQueue( + label: "setupFDCIntegrationsTests", + autoreleaseFrequency: .workItem + ) + private var _setupComplete = false + private var setupComplete: Bool { + set { setupQ.sync { _setupComplete = newValue } } + get { setupQ.sync { _setupComplete }} + } + + override class func setUp() { + setupFirebaseApp() + DataConnect.kitchenSinkClient.useEmulator(port: 3628) + } + + override func setUp(completion: @escaping ((any Error)?) -> Void) { + Task { + print("setupComplete \(self.setupComplete) \(self)") + guard !self.setupComplete else { + // emulator already configured with test project + print("Project already configured") + return + } + + do { + try await DataConnect.kitchenSinkClient.configureProject() + self.setupComplete = true + print("setupComplete = true") + completion(nil) + } catch { + self.setupComplete = false + completion(error) + } + } + } + + // test to confirm that we can assign an explicit UUID + func testSpecifiedUUID() async throws { + let specifiedUUID = UUID() + let result = try await DataConnect.kitchenSinkClient.createTestIdMutationRef(id: specifiedUUID) + .execute() + XCTAssertEqual(result.data.testId_insert.id, specifiedUUID) + } + + // test for an auto generated UUID assignment + func testAutoId() async throws { + let result = try await DataConnect.kitchenSinkClient.createTestAutoIdMutationRef().execute() + _ = result.data.testAutoId_insert.id + // if we get till here - we have successfully got a UUID and decoded it. So test is successful + XCTAssert(true) + } + + func testStandardScalar() async throws { + let standardScalarUUID = UUID() + let testText = "Hello Firebase World" + let testDecimal = Double.random(in: 10.0 ... 999.0) + let testInt = Int(Int32.random(in: Int32.min ... Int32.max)) + // The following fails since server returns a different value. + // The value is outside the 32-bit range and GQL Int is 32-bits. + // let testInt = -6196243450739521536 + + let executeResult = try await DataConnect.kitchenSinkClient.createStandardScalarMutationRef( + id: standardScalarUUID, + number: testInt, + text: testText, + decimal: testDecimal + ).execute() + + XCTAssertEqual( + executeResult.data.standardScalars_insert.id, + standardScalarUUID, + "UUID mismatch between specified and returned" + ) + + let queryResult = try await DataConnect.kitchenSinkClient + .getStandardScalarQueryRef(id: standardScalarUUID).execute() + + let returnedDecimal = queryResult.data.standardScalars?.decimal + XCTAssertEqual( + returnedDecimal, + testDecimal, + "Decimal value mismatch between sent \(testDecimal) and received \(String(describing: returnedDecimal))" + ) + + let returnedNumber = queryResult.data.standardScalars?.number + XCTAssertEqual( + returnedNumber, + testInt, + "Int value mismatch between sent \(testInt) and received \(String(describing: returnedNumber))" + ) + + let returnedText = queryResult.data.standardScalars?.text + XCTAssertEqual( + returnedText, + testText, + "String value mismatch between sent \(testText) and received \(String(describing: returnedText))" + ) + } + + func testScalarBoundaries() async throws { + let scalaryBoundaryUUID = UUID() + + let maxInt = Int(Int32.max) + let minInt = Int(Int32.min) + let maxFloat = Double.greatestFiniteMagnitude + let minFloat = Double.leastNormalMagnitude + + _ = try await DataConnect.kitchenSinkClient.createScalarBoundaryMutationRef( + id: scalaryBoundaryUUID, + maxNumber: maxInt, + minNumber: minInt, + maxDecimal: maxFloat, + minDecimal: minFloat + ).execute() + + let queryResult = try await DataConnect.kitchenSinkClient + .getScalarBoundaryQueryRef(id: scalaryBoundaryUUID).execute() + + let returnedMaxInt = queryResult.data.scalarBoundary?.maxNumber + XCTAssertEqual( + returnedMaxInt, + maxInt, + "Returned maxInt \(String(describing: returnedMaxInt)) is not same as sent \(maxInt)" + ) + + let returnedMinInt = queryResult.data.scalarBoundary?.minNumber + XCTAssertEqual( + returnedMinInt, + minInt, + "Returned minInt \(minInt) is not same as sent \(minInt)" + ) + + let returnedMaxFloat = queryResult.data.scalarBoundary?.maxDecimal + XCTAssertEqual( + returnedMaxFloat, + maxFloat, + "Returned maxFloat \(String(describing: returnedMaxFloat)) is not same as sent \(maxFloat)" + ) + + let returnedMinFloat = queryResult.data.scalarBoundary?.minDecimal + XCTAssertEqual( + returnedMinFloat, + minFloat, + "Returned minFloat \(String(describing: returnedMinFloat)) is not same as sent \(minFloat)" + ) + } + + func testLargeNum() async throws { + let largeNumUUID = UUID() + let largeNum = Int64.random(in: Int64.min ... Int64.max) + let largeNumMax = Int64.max + let largeNumMin = Int64.min + + _ = try await DataConnect.kitchenSinkClient.createLargeNumMutationRef( + id: largeNumUUID, + num: largeNum, + maxNum: largeNumMax, + minNum: largeNumMin + ).execute() + + let result = try await DataConnect.kitchenSinkClient.getLargeNumQueryRef(id: largeNumUUID) + .execute() + + let returnedLargeNum = result.data.largeIntType?.num + XCTAssertEqual( + returnedLargeNum, + largeNum, + "Int64 returned \(String(describing: returnedLargeNum)) does not match sent \(largeNum)" + ) + + let returnedMax = result.data.largeIntType?.maxNum + XCTAssertEqual( + returnedMax, + largeNumMax, + "Int64 max returned \(String(describing: returnedMax)) does not match sent \(largeNumMax)" + ) + + let returnedMin = result.data.largeIntType?.minNum + XCTAssertEqual( + returnedMin, + largeNumMin, + "Int64 min returned \(String(describing: returnedMin)) does not match sent \(largeNumMin)" + ) + } + + func testLocalDateSerialization() async throws { + let localDateUUID = UUID() + let ld = try LocalDate(localDateString: "2024-11-01") + + _ = try await DataConnect.kitchenSinkClient.createLocalDateMutationRef( + id: localDateUUID, + localDate: ld + ).execute() + + let result = try await DataConnect.kitchenSinkClient.getLocalDateTypeQueryRef(id: localDateUUID) + .execute() + let returnedLd = result.data.localDateType?.localDate + XCTAssertEqual(ld, returnedLd) + } +} diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.firebaserc b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.firebaserc index df639045c32..a63fcf466b9 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.firebaserc +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/.firebaserc @@ -1,6 +1,6 @@ { "projects": { - "default": "atomic-legacy-426102-p5" + "default": "aa-scratchpad" }, "targets": {}, "etags": {}, diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml index 2feedf0b677..faf220eaeba 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml @@ -3,5 +3,5 @@ authMode: "PUBLIC" generate: swiftSdk: - outputDir: "/Users/aashishp/Code/firebase-ios-sdk/FirebaseDataConnect/Tests/Integration/Gen" + outputDir: "../../../Gen" package: "KitchenSink" diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql index e69de29bb2d..b27195b7d36 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql @@ -0,0 +1,45 @@ + +mutation createTestId($id: UUID!) @auth(level: PUBLIC) { + testId_insert(data: { + id: $id + }) +} + +mutation createTestAutoId @auth(level: PUBLIC) { + testAutoId_insert(data: {}) +} + +mutation createStandardScalar($id: UUID!, $number: Int!, $text: String!, $decimal: Float!) @auth(level: PUBLIC) { + standardScalars_insert(data: { + id: $id, + number: $number, + text: $text, + decimal: $decimal + }) +} + +mutation createScalarBoundary($id: UUID!, $maxNumber: Int!, $minNumber: Int!, $maxDecimal: Float!, $minDecimal: Float!) @auth(level: PUBLIC) { + scalarBoundary_insert(data: { + id: $id, + maxNumber: $maxNumber, + minNumber: $minNumber, + maxDecimal: $maxDecimal, + minDecimal: $minDecimal + }) +} + +mutation createLargeNum($id: UUID!, $num: Int64!, $maxNum: Int64!, $minNum: Int64!) @auth(level: PUBLIC) { + largeIntType_insert(data: { + id: $id, + num: $num, + maxNum: $maxNum, + minNum: $minNum + }) +} + +mutation createLocalDate($id: UUID!, $localDate: Date!) @auth(level: PUBLIC) { + localDateType_insert(data: { + id: $id + localDate: $localDate + }) +} \ No newline at end of file diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/queries.gql b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/queries.gql index 8b137891791..52344a30f14 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/queries.gql +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/queries.gql @@ -1 +1,32 @@ +query GetStandardScalar($id: UUID!) @auth(level: PUBLIC) { + standardScalars(id: $id) { + id + number + text + decimal + } +} + +query GetScalarBoundary($id: UUID!) @auth(level: PUBLIC) { + scalarBoundary(id: $id) { + maxNumber + minNumber + maxDecimal + minDecimal + } +} + +query GetLargeNum($id: UUID!) @auth(level: PUBLIC) { + largeIntType(id: $id) { + num + maxNum + minNum + } +} + +query GetLocalDateType($id: UUID!) @auth(level: PUBLIC) { + localDateType(id: $id) { + localDate + } +} \ No newline at end of file diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/schema/schema.gql b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/schema/schema.gql index e69de29bb2d..b5c5ac72ad0 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/schema/schema.gql +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/schema/schema.gql @@ -0,0 +1,35 @@ +#Types for Scalar Tests +type TestId @table { + id: UUID! +} + +type TestAutoId @table { + id: UUID! @default(expr: "uuidV4()") +} + +type StandardScalars @table { + id: UUID! + number: Int! + text: String! + decimal: Float! +} + +type ScalarBoundary @table { + id: UUID! + maxNumber: Int! + minNumber: Int! + maxDecimal: Float! + minDecimal: Float! +} + +type LargeIntType @table { + id: UUID! + num: Int64! + maxNum: Int64! + minNum: Int64! +} + +type LocalDateType @table { + id: UUID! + localDate: Date +} \ No newline at end of file diff --git a/FirebaseDataConnect/Tests/Unit/CodecHelperTests.swift b/FirebaseDataConnect/Tests/Unit/CodecHelperTests.swift index 1b939352660..e09428ea83e 100644 --- a/FirebaseDataConnect/Tests/Unit/CodecHelperTests.swift +++ b/FirebaseDataConnect/Tests/Unit/CodecHelperTests.swift @@ -27,7 +27,7 @@ final class CodecHelperTests: XCTestCase { let uuidStr = "B7ACD615-1140-48F6-A522-26260D5C9367" let uuid = UUID(uuidString: uuidStr) - //lowercase this for test since the UUID class converts uuid to lowercase + // lowercase this for test since the UUID class converts uuid to lowercase let uuidNoDashStr = "B7ACD615114048F6A52226260D5C9367".lowercased() let uuidConverter = UUIDCodableConverter() @@ -61,12 +61,11 @@ final class CodecHelperTests: XCTestCase { let uuidString: String? = nil let uuid: UUID? = try uuidConverter.decode(input: uuidString) XCTAssertNil(uuid) - } func testInt64ToString() throws { let int64Converter = Int64CodableConverter() - let int64Val: Int64 = 9223372036854775807 + let int64Val: Int64 = 9_223_372_036_854_775_807 let expectedVal = "9223372036854775807" let convertedVal = try int64Converter.encode(input: int64Val) @@ -75,7 +74,7 @@ final class CodecHelperTests: XCTestCase { func testStringToInt64() throws { let int64Converter = Int64CodableConverter() - let expectedVal: Int64 = 9223372036854775807 + let expectedVal: Int64 = 9_223_372_036_854_775_807 let stringVal = "9223372036854775807" let convertedVal = try int64Converter.decode(input: stringVal) @@ -92,18 +91,16 @@ final class CodecHelperTests: XCTestCase { let codecValsDecoded = try jsonDecoder.decode(TestCodecValues.self, from: jsonData) XCTAssertEqual(codecVals, codecValsDecoded) - } struct TestCodecValues: Codable, Equatable { - enum CodingKeys: String, CodingKey { case largeVal case uuidVal } - var largeVal: Int64 = 9223372036854775807 - var uuidVal: UUID = UUID() + var largeVal: Int64 = 9_223_372_036_854_775_807 + var uuidVal: UUID = .init() init() {} @@ -111,8 +108,8 @@ final class CodecHelperTests: XCTestCase { var container = try decoder.container(keyedBy: CodingKeys.self) let codecHelper = CodecHelper() - self.largeVal = try codecHelper.decode(Int64.self, forKey: .largeVal, container: &container) - self.uuidVal = try codecHelper.decode(UUID.self, forKey: .uuidVal, container: &container) + largeVal = try codecHelper.decode(Int64.self, forKey: .largeVal, container: &container) + uuidVal = try codecHelper.decode(UUID.self, forKey: .uuidVal, container: &container) } func encode(to encoder: any Encoder) throws { @@ -123,6 +120,4 @@ final class CodecHelperTests: XCTestCase { try codecHelper.encode(uuidVal, forKey: .uuidVal, container: &container) } } - } - From 422b46988e14fc07b8bdad13c239b50304e7fb18 Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Thu, 8 Aug 2024 15:52:04 -0700 Subject: [PATCH 04/11] Update Package.swift --- Package.swift | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/Package.swift b/Package.swift index 56d5f323ce7..bf1255da634 100644 --- a/Package.swift +++ b/Package.swift @@ -675,16 +675,20 @@ let package = Package( "FirebaseCoreExtension", "FirebaseSharedSwift", ], - path: "FirebaseDataConnect/Sources" + path: "FirebaseDataConnect/Sources", + swiftSettings: [ + .enableExperimentalFeature("StrictConcurrency"), + ] ), .testTarget( name: "FirebaseDataConnectTests", dependencies: ["FirebaseDataConnect"], path: "FirebaseDataConnect/Tests", + exclude: ["Gen/KitchenSink/Package.swift"], resources: [ .process("Resources/GoogleService-Info.plist"), - .copy("Resources/fdc-kitchensink") - ] + .copy("Resources/fdc-kitchensink"), + ] ), .target( name: "FirebaseSharedSwift", From d3fd9a3fe3c3c8755fc3e9e99925e74b8b78005c Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Fri, 9 Aug 2024 10:46:58 -0700 Subject: [PATCH 05/11] Fix trailing spaces --- .../fdc-kitchensink/dataconnect/default/connector.yaml | 2 +- .../fdc-kitchensink/dataconnect/default/mutations.gql | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml index faf220eaeba..218f20cdeec 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml @@ -1,5 +1,5 @@ connectorId: "kitchen-sink" -authMode: "PUBLIC" +authMode: "PUBLIC" generate: swiftSdk: diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql index b27195b7d36..acf60ce230c 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/mutations.gql @@ -31,8 +31,8 @@ mutation createScalarBoundary($id: UUID!, $maxNumber: Int!, $minNumber: Int!, $m mutation createLargeNum($id: UUID!, $num: Int64!, $maxNum: Int64!, $minNum: Int64!) @auth(level: PUBLIC) { largeIntType_insert(data: { id: $id, - num: $num, - maxNum: $maxNum, + num: $num, + maxNum: $maxNum, minNum: $minNum }) } From 56bc64eed364ff8795c6266f48e1575868eabd28 Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Fri, 9 Aug 2024 12:15:50 -0700 Subject: [PATCH 06/11] Remove print statements --- FirebaseDataConnect/Tests/Integration/IntegrationTests.swift | 3 --- 1 file changed, 3 deletions(-) diff --git a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift index 27c575b1b39..b736f635385 100644 --- a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift +++ b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift @@ -44,17 +44,14 @@ final class IntegrationTests: XCTestCase { override func setUp(completion: @escaping ((any Error)?) -> Void) { Task { - print("setupComplete \(self.setupComplete) \(self)") guard !self.setupComplete else { // emulator already configured with test project - print("Project already configured") return } do { try await DataConnect.kitchenSinkClient.configureProject() self.setupComplete = true - print("setupComplete = true") completion(nil) } catch { self.setupComplete = false From 74bda98b878077e27e6e0f68ab5a27d31b5b8fca Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Fri, 9 Aug 2024 14:33:53 -0700 Subject: [PATCH 07/11] Added tracking id --- FirebaseDataConnect/Tests/Integration/IntegrationTests.swift | 1 + 1 file changed, 1 insertion(+) diff --git a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift index b736f635385..48fa836d6f7 100644 --- a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift +++ b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift @@ -83,6 +83,7 @@ final class IntegrationTests: XCTestCase { let testInt = Int(Int32.random(in: Int32.min ... Int32.max)) // The following fails since server returns a different value. // The value is outside the 32-bit range and GQL Int is 32-bits. + // Tracked internally with issue - b/358198261 // let testInt = -6196243450739521536 let executeResult = try await DataConnect.kitchenSinkClient.createStandardScalarMutationRef( From 1901495ce22c021de4f994f71c4543b6c607e6b6 Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Fri, 9 Aug 2024 16:00:08 -0700 Subject: [PATCH 08/11] Singleton actor for configuration --- .../Tests/Integration/ConfigSetup.swift | 14 +++++++++++++- .../Tests/Integration/IntegrationTests.swift | 19 +------------------ .../dataconnect/default/connector.yaml | 2 +- 3 files changed, 15 insertions(+), 20 deletions(-) diff --git a/FirebaseDataConnect/Tests/Integration/ConfigSetup.swift b/FirebaseDataConnect/Tests/Integration/ConfigSetup.swift index b01ca88c4d4..f4b6bbeb583 100644 --- a/FirebaseDataConnect/Tests/Integration/ConfigSetup.swift +++ b/FirebaseDataConnect/Tests/Integration/ConfigSetup.swift @@ -21,8 +21,19 @@ enum KitchenSinkError: Error { case configureFailed } -extension KitchenSinkClient { +actor ProjectConfigurator { + static let shared = ProjectConfigurator() + + private init() {} + + private var setupComplete = false + func configureProject(useDummyEngine: Bool = true) async throws { + guard !setupComplete else { + // setup already complete + return + } + guard let resourcePath = Bundle.module.resourcePath else { throw KitchenSinkError.configureFailed } let projectDirPath = URL(fileURLWithPath: resourcePath) @@ -46,5 +57,6 @@ extension KitchenSinkClient { from: configureBody.data(using: .utf8)! ) print("responseData \(response)") + setupComplete = true } } diff --git a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift index 48fa836d6f7..228928af3e3 100644 --- a/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift +++ b/FirebaseDataConnect/Tests/Integration/IntegrationTests.swift @@ -27,16 +27,6 @@ final class IntegrationTests: XCTestCase { } } - private let setupQ = DispatchQueue( - label: "setupFDCIntegrationsTests", - autoreleaseFrequency: .workItem - ) - private var _setupComplete = false - private var setupComplete: Bool { - set { setupQ.sync { _setupComplete = newValue } } - get { setupQ.sync { _setupComplete }} - } - override class func setUp() { setupFirebaseApp() DataConnect.kitchenSinkClient.useEmulator(port: 3628) @@ -44,17 +34,10 @@ final class IntegrationTests: XCTestCase { override func setUp(completion: @escaping ((any Error)?) -> Void) { Task { - guard !self.setupComplete else { - // emulator already configured with test project - return - } - do { - try await DataConnect.kitchenSinkClient.configureProject() - self.setupComplete = true + try await ProjectConfigurator.shared.configureProject() completion(nil) } catch { - self.setupComplete = false completion(error) } } diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml index 218f20cdeec..4bad2b8b19a 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml @@ -3,5 +3,5 @@ authMode: "PUBLIC" generate: swiftSdk: - outputDir: "../../../Gen" + outputDir: "../../../../Gen" package: "KitchenSink" From 12402a0fee50cf6dba14a2beac66168a80528498 Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Mon, 12 Aug 2024 11:35:01 -0700 Subject: [PATCH 09/11] Add generated sources for the test project. --- .../Tests/Integration/KitchenSinkClient.swift | 28 + .../Tests/Integration/KitchenSinkKeys.swift | 243 +++++ .../Integration/KitchenSinkOperations.swift | 864 ++++++++++++++++++ .../dataconnect/default/connector.yaml | 7 +- Package.swift | 1 - 5 files changed, 1141 insertions(+), 2 deletions(-) create mode 100644 FirebaseDataConnect/Tests/Integration/KitchenSinkClient.swift create mode 100644 FirebaseDataConnect/Tests/Integration/KitchenSinkKeys.swift create mode 100644 FirebaseDataConnect/Tests/Integration/KitchenSinkOperations.swift diff --git a/FirebaseDataConnect/Tests/Integration/KitchenSinkClient.swift b/FirebaseDataConnect/Tests/Integration/KitchenSinkClient.swift new file mode 100644 index 00000000000..6b29c6768b0 --- /dev/null +++ b/FirebaseDataConnect/Tests/Integration/KitchenSinkClient.swift @@ -0,0 +1,28 @@ +import FirebaseDataConnect +import Foundation + +public extension DataConnect { + static var kitchenSinkClient: KitchenSinkClient = { + let dc = DataConnect.dataConnect(connectorConfig: KitchenSinkClient.connectorConfig) + return KitchenSinkClient(dataConnect: dc) + }() +} + +public class KitchenSinkClient { + var dataConnect: DataConnect + + public static let connectorConfig = ConnectorConfig( + serviceId: "fdc-kitchensink", + location: "us-central1", + connector: "kitchen-sink" + ) + + init(dataConnect: DataConnect) { + self.dataConnect = dataConnect + } + + public func useEmulator(host: String = DataConnect.EmulatorDefaults.host, + port: Int = DataConnect.EmulatorDefaults.port) { + dataConnect.useEmulator(host: host, port: port) + } +} diff --git a/FirebaseDataConnect/Tests/Integration/KitchenSinkKeys.swift b/FirebaseDataConnect/Tests/Integration/KitchenSinkKeys.swift new file mode 100644 index 00000000000..f076130f5fb --- /dev/null +++ b/FirebaseDataConnect/Tests/Integration/KitchenSinkKeys.swift @@ -0,0 +1,243 @@ +import Foundation + +import FirebaseDataConnect + +public struct LargeIntTypeKey { + public private(set) var id: UUID + + enum CodingKeys: String, CodingKey { + case id + } +} + +extension LargeIntTypeKey: Codable { + public init(from decoder: any Decoder) throws { + var container = try decoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + id = try codecHelper.decode(UUID.self, forKey: .id, container: &container) + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } +} + +extension LargeIntTypeKey: Equatable { + public static func == (lhs: LargeIntTypeKey, rhs: LargeIntTypeKey) -> Bool { + if lhs.id != rhs.id { + return false + } + + return true + } +} + +extension LargeIntTypeKey: Hashable { + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } +} + +public struct LocalDateTypeKey { + public private(set) var id: UUID + + enum CodingKeys: String, CodingKey { + case id + } +} + +extension LocalDateTypeKey: Codable { + public init(from decoder: any Decoder) throws { + var container = try decoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + id = try codecHelper.decode(UUID.self, forKey: .id, container: &container) + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } +} + +extension LocalDateTypeKey: Equatable { + public static func == (lhs: LocalDateTypeKey, rhs: LocalDateTypeKey) -> Bool { + if lhs.id != rhs.id { + return false + } + + return true + } +} + +extension LocalDateTypeKey: Hashable { + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } +} + +public struct ScalarBoundaryKey { + public private(set) var id: UUID + + enum CodingKeys: String, CodingKey { + case id + } +} + +extension ScalarBoundaryKey: Codable { + public init(from decoder: any Decoder) throws { + var container = try decoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + id = try codecHelper.decode(UUID.self, forKey: .id, container: &container) + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } +} + +extension ScalarBoundaryKey: Equatable { + public static func == (lhs: ScalarBoundaryKey, rhs: ScalarBoundaryKey) -> Bool { + if lhs.id != rhs.id { + return false + } + + return true + } +} + +extension ScalarBoundaryKey: Hashable { + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } +} + +public struct StandardScalarsKey { + public private(set) var id: UUID + + enum CodingKeys: String, CodingKey { + case id + } +} + +extension StandardScalarsKey: Codable { + public init(from decoder: any Decoder) throws { + var container = try decoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + id = try codecHelper.decode(UUID.self, forKey: .id, container: &container) + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } +} + +extension StandardScalarsKey: Equatable { + public static func == (lhs: StandardScalarsKey, rhs: StandardScalarsKey) -> Bool { + if lhs.id != rhs.id { + return false + } + + return true + } +} + +extension StandardScalarsKey: Hashable { + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } +} + +public struct TestAutoIdKey { + public private(set) var id: UUID + + enum CodingKeys: String, CodingKey { + case id + } +} + +extension TestAutoIdKey: Codable { + public init(from decoder: any Decoder) throws { + var container = try decoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + id = try codecHelper.decode(UUID.self, forKey: .id, container: &container) + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } +} + +extension TestAutoIdKey: Equatable { + public static func == (lhs: TestAutoIdKey, rhs: TestAutoIdKey) -> Bool { + if lhs.id != rhs.id { + return false + } + + return true + } +} + +extension TestAutoIdKey: Hashable { + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } +} + +public struct TestIdKey { + public private(set) var id: UUID + + enum CodingKeys: String, CodingKey { + case id + } +} + +extension TestIdKey: Codable { + public init(from decoder: any Decoder) throws { + var container = try decoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + id = try codecHelper.decode(UUID.self, forKey: .id, container: &container) + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } +} + +extension TestIdKey: Equatable { + public static func == (lhs: TestIdKey, rhs: TestIdKey) -> Bool { + if lhs.id != rhs.id { + return false + } + + return true + } +} + +extension TestIdKey: Hashable { + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } +} diff --git a/FirebaseDataConnect/Tests/Integration/KitchenSinkOperations.swift b/FirebaseDataConnect/Tests/Integration/KitchenSinkOperations.swift new file mode 100644 index 00000000000..1225789f196 --- /dev/null +++ b/FirebaseDataConnect/Tests/Integration/KitchenSinkOperations.swift @@ -0,0 +1,864 @@ +import FirebaseDataConnect +import Foundation + +// MARK: Connector Client Extension + +public extension KitchenSinkClient { + func createTestIdMutationRef(id: UUID) -> MutationRef< + CreateTestIdMutation.Data, + CreateTestIdMutation.Variables + > { + var variables = CreateTestIdMutation.Variables(id: id) + + let request = MutationRequest(operationName: "createTestId", variables: variables) + let ref = dataConnect.mutation( + request: request, + resultsDataType: CreateTestIdMutation.Data.self + ) + return ref as! MutationRef + } + + func createTestAutoIdMutationRef( + ) -> MutationRef { + var variables = CreateTestAutoIdMutation.Variables() + + let request = MutationRequest(operationName: "createTestAutoId", variables: variables) + let ref = dataConnect.mutation( + request: request, + resultsDataType: CreateTestAutoIdMutation.Data.self + ) + return ref as! MutationRef< + CreateTestAutoIdMutation.Data, + CreateTestAutoIdMutation.Variables + > + } + + func createStandardScalarMutationRef(id: UUID, + + number: Int, + + text: String, + + decimal: Double) + -> MutationRef { + var variables = CreateStandardScalarMutation.Variables( + id: id, + number: number, + text: text, + decimal: decimal + ) + + let request = MutationRequest(operationName: "createStandardScalar", variables: variables) + let ref = dataConnect.mutation( + request: request, + resultsDataType: CreateStandardScalarMutation.Data.self + ) + return ref as! MutationRef< + CreateStandardScalarMutation.Data, + CreateStandardScalarMutation.Variables + > + } + + func createScalarBoundaryMutationRef(id: UUID, + + maxNumber: Int, + + minNumber: Int, + + maxDecimal: Double, + + minDecimal: Double) + -> MutationRef { + var variables = CreateScalarBoundaryMutation.Variables( + id: id, + maxNumber: maxNumber, + minNumber: minNumber, + maxDecimal: maxDecimal, + minDecimal: minDecimal + ) + + let request = MutationRequest(operationName: "createScalarBoundary", variables: variables) + let ref = dataConnect.mutation( + request: request, + resultsDataType: CreateScalarBoundaryMutation.Data.self + ) + return ref as! MutationRef< + CreateScalarBoundaryMutation.Data, + CreateScalarBoundaryMutation.Variables + > + } + + func createLargeNumMutationRef(id: UUID, + + num: Int64, + + maxNum: Int64, + + minNum: Int64) + -> MutationRef { + var variables = CreateLargeNumMutation.Variables( + id: id, + num: num, + maxNum: maxNum, + minNum: minNum + ) + + let request = MutationRequest(operationName: "createLargeNum", variables: variables) + let ref = dataConnect.mutation( + request: request, + resultsDataType: CreateLargeNumMutation.Data.self + ) + return ref as! MutationRef + } + + func createLocalDateMutationRef(id: UUID, + + localDate: LocalDate) + -> MutationRef { + var variables = CreateLocalDateMutation.Variables(id: id, localDate: localDate) + + let request = MutationRequest(operationName: "createLocalDate", variables: variables) + let ref = dataConnect.mutation( + request: request, + resultsDataType: CreateLocalDateMutation.Data.self + ) + return ref as! MutationRef + } + + func getStandardScalarQueryRef(id: UUID) + -> QueryRefObservableObject { + var variables = GetStandardScalarQuery.Variables(id: id) + + let request = QueryRequest(operationName: "GetStandardScalar", variables: variables) + let ref = dataConnect.query( + request: request, + resultsDataType: GetStandardScalarQuery.Data.self, + publisher: .observableObject + ) + return ref as! QueryRefObservableObject< + GetStandardScalarQuery.Data, + GetStandardScalarQuery.Variables + > + } + + func getScalarBoundaryQueryRef(id: UUID) + -> QueryRefObservableObject { + var variables = GetScalarBoundaryQuery.Variables(id: id) + + let request = QueryRequest(operationName: "GetScalarBoundary", variables: variables) + let ref = dataConnect.query( + request: request, + resultsDataType: GetScalarBoundaryQuery.Data.self, + publisher: .observableObject + ) + return ref as! QueryRefObservableObject< + GetScalarBoundaryQuery.Data, + GetScalarBoundaryQuery.Variables + > + } + + func getLargeNumQueryRef(id: UUID) -> QueryRefObservableObject< + GetLargeNumQuery.Data, + GetLargeNumQuery.Variables + > { + var variables = GetLargeNumQuery.Variables(id: id) + + let request = QueryRequest(operationName: "GetLargeNum", variables: variables) + let ref = dataConnect.query( + request: request, + resultsDataType: GetLargeNumQuery.Data.self, + publisher: .observableObject + ) + return ref as! QueryRefObservableObject + } + + func getLocalDateTypeQueryRef(id: UUID) -> QueryRefObservableObject< + GetLocalDateTypeQuery.Data, + GetLocalDateTypeQuery.Variables + > { + var variables = GetLocalDateTypeQuery.Variables(id: id) + + let request = QueryRequest(operationName: "GetLocalDateType", variables: variables) + let ref = dataConnect.query( + request: request, + resultsDataType: GetLocalDateTypeQuery.Data.self, + publisher: .observableObject + ) + return ref as! QueryRefObservableObject< + GetLocalDateTypeQuery.Data, + GetLocalDateTypeQuery.Variables + > + } +} + +public enum CreateTestIdMutation { + public static let OperationName = "createTestId" + + public typealias Ref = MutationRef + + public struct Variables: OperationVariable { + public var + id: UUID + + public init(id: UUID) { + self.id = id + } + + public static func == (lhs: Variables, rhs: Variables) -> Bool { + return lhs.id == rhs.id + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } + + enum CodingKeys: String, CodingKey { + case id + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } + } + + public struct Data: Decodable { + public var + testId_insert: TestIdKey + } +} + +public enum CreateTestAutoIdMutation { + public static let OperationName = "createTestAutoId" + + public typealias Ref = MutationRef< + CreateTestAutoIdMutation.Data, + CreateTestAutoIdMutation.Variables + > + + public struct Variables: OperationVariable {} + + public struct Data: Decodable { + public var + testAutoId_insert: TestAutoIdKey + } +} + +public enum CreateStandardScalarMutation { + public static let OperationName = "createStandardScalar" + + public typealias Ref = MutationRef< + CreateStandardScalarMutation.Data, + CreateStandardScalarMutation.Variables + > + + public struct Variables: OperationVariable { + public var + id: UUID + + public var + number: Int + + public var + text: String + + public var + decimal: Double + + public init(id: UUID, + + number: Int, + + text: String, + + decimal: Double) { + self.id = id + self.number = number + self.text = text + self.decimal = decimal + } + + public static func == (lhs: Variables, rhs: Variables) -> Bool { + return lhs.id == rhs.id && + lhs.number == rhs.number && + lhs.text == rhs.text && + lhs.decimal == rhs.decimal + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + + hasher.combine(number) + + hasher.combine(text) + + hasher.combine(decimal) + } + + enum CodingKeys: String, CodingKey { + case id + + case number + + case text + + case decimal + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + + try codecHelper.encode(number, forKey: .number, container: &container) + + try codecHelper.encode(text, forKey: .text, container: &container) + + try codecHelper.encode(decimal, forKey: .decimal, container: &container) + } + } + + public struct Data: Decodable { + public var + standardScalars_insert: StandardScalarsKey + } +} + +public enum CreateScalarBoundaryMutation { + public static let OperationName = "createScalarBoundary" + + public typealias Ref = MutationRef< + CreateScalarBoundaryMutation.Data, + CreateScalarBoundaryMutation.Variables + > + + public struct Variables: OperationVariable { + public var + id: UUID + + public var + maxNumber: Int + + public var + minNumber: Int + + public var + maxDecimal: Double + + public var + minDecimal: Double + + public init(id: UUID, + + maxNumber: Int, + + minNumber: Int, + + maxDecimal: Double, + + minDecimal: Double) { + self.id = id + self.maxNumber = maxNumber + self.minNumber = minNumber + self.maxDecimal = maxDecimal + self.minDecimal = minDecimal + } + + public static func == (lhs: Variables, rhs: Variables) -> Bool { + return lhs.id == rhs.id && + lhs.maxNumber == rhs.maxNumber && + lhs.minNumber == rhs.minNumber && + lhs.maxDecimal == rhs.maxDecimal && + lhs.minDecimal == rhs.minDecimal + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + + hasher.combine(maxNumber) + + hasher.combine(minNumber) + + hasher.combine(maxDecimal) + + hasher.combine(minDecimal) + } + + enum CodingKeys: String, CodingKey { + case id + + case maxNumber + + case minNumber + + case maxDecimal + + case minDecimal + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + + try codecHelper.encode(maxNumber, forKey: .maxNumber, container: &container) + + try codecHelper.encode(minNumber, forKey: .minNumber, container: &container) + + try codecHelper.encode(maxDecimal, forKey: .maxDecimal, container: &container) + + try codecHelper.encode(minDecimal, forKey: .minDecimal, container: &container) + } + } + + public struct Data: Decodable { + public var + scalarBoundary_insert: ScalarBoundaryKey + } +} + +public enum CreateLargeNumMutation { + public static let OperationName = "createLargeNum" + + public typealias Ref = MutationRef + + public struct Variables: OperationVariable { + public var + id: UUID + + public var + num: Int64 + + public var + maxNum: Int64 + + public var + minNum: Int64 + + public init(id: UUID, + + num: Int64, + + maxNum: Int64, + + minNum: Int64) { + self.id = id + self.num = num + self.maxNum = maxNum + self.minNum = minNum + } + + public static func == (lhs: Variables, rhs: Variables) -> Bool { + return lhs.id == rhs.id && + lhs.num == rhs.num && + lhs.maxNum == rhs.maxNum && + lhs.minNum == rhs.minNum + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + + hasher.combine(num) + + hasher.combine(maxNum) + + hasher.combine(minNum) + } + + enum CodingKeys: String, CodingKey { + case id + + case num + + case maxNum + + case minNum + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + + try codecHelper.encode(num, forKey: .num, container: &container) + + try codecHelper.encode(maxNum, forKey: .maxNum, container: &container) + + try codecHelper.encode(minNum, forKey: .minNum, container: &container) + } + } + + public struct Data: Decodable { + public var + largeIntType_insert: LargeIntTypeKey + } +} + +public enum CreateLocalDateMutation { + public static let OperationName = "createLocalDate" + + public typealias Ref = MutationRef< + CreateLocalDateMutation.Data, + CreateLocalDateMutation.Variables + > + + public struct Variables: OperationVariable { + public var + id: UUID + + public var + localDate: LocalDate + + public init(id: UUID, + + localDate: LocalDate) { + self.id = id + self.localDate = localDate + } + + public static func == (lhs: Variables, rhs: Variables) -> Bool { + return lhs.id == rhs.id && + lhs.localDate == rhs.localDate + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + + hasher.combine(localDate) + } + + enum CodingKeys: String, CodingKey { + case id + + case localDate + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + + try codecHelper.encode(localDate, forKey: .localDate, container: &container) + } + } + + public struct Data: Decodable { + public var + localDateType_insert: LocalDateTypeKey + } +} + +public enum GetStandardScalarQuery { + public static let OperationName = "GetStandardScalar" + + public typealias Ref = QueryRefObservableObject< + GetStandardScalarQuery.Data, + GetStandardScalarQuery.Variables + > + + public struct Variables: OperationVariable { + public var + id: UUID + + public init(id: UUID) { + self.id = id + } + + public static func == (lhs: Variables, rhs: Variables) -> Bool { + return lhs.id == rhs.id + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } + + enum CodingKeys: String, CodingKey { + case id + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } + } + + public struct Data: Decodable { + public struct StandardScalars: Decodable, Hashable, Equatable, Identifiable { + public var + id: UUID + + public var + number: Int + + public var + text: String + + public var + decimal: Double + + public var standardScalarsKey: StandardScalarsKey { + return StandardScalarsKey( + id: id + ) + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } + + public static func == (lhs: StandardScalars, rhs: StandardScalars) -> Bool { + return lhs.id == rhs.id + } + + enum CodingKeys: String, CodingKey { + case id + + case number + + case text + + case decimal + } + + public init(from decoder: any Decoder) throws { + var container = try decoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + id = try codecHelper.decode(UUID.self, forKey: .id, container: &container) + + number = try codecHelper.decode(Int.self, forKey: .number, container: &container) + + text = try codecHelper.decode(String.self, forKey: .text, container: &container) + + decimal = try codecHelper.decode(Double.self, forKey: .decimal, container: &container) + } + } + + public var + standardScalars: StandardScalars? + } +} + +public enum GetScalarBoundaryQuery { + public static let OperationName = "GetScalarBoundary" + + public typealias Ref = QueryRefObservableObject< + GetScalarBoundaryQuery.Data, + GetScalarBoundaryQuery.Variables + > + + public struct Variables: OperationVariable { + public var + id: UUID + + public init(id: UUID) { + self.id = id + } + + public static func == (lhs: Variables, rhs: Variables) -> Bool { + return lhs.id == rhs.id + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } + + enum CodingKeys: String, CodingKey { + case id + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } + } + + public struct Data: Decodable { + public struct ScalarBoundary: Decodable { + public var + maxNumber: Int + + public var + minNumber: Int + + public var + maxDecimal: Double + + public var + minDecimal: Double + + enum CodingKeys: String, CodingKey { + case maxNumber + + case minNumber + + case maxDecimal + + case minDecimal + } + + public init(from decoder: any Decoder) throws { + var container = try decoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + maxNumber = try codecHelper.decode(Int.self, forKey: .maxNumber, container: &container) + + minNumber = try codecHelper.decode(Int.self, forKey: .minNumber, container: &container) + + maxDecimal = try codecHelper.decode(Double.self, forKey: .maxDecimal, container: &container) + + minDecimal = try codecHelper.decode(Double.self, forKey: .minDecimal, container: &container) + } + } + + public var + scalarBoundary: ScalarBoundary? + } +} + +public enum GetLargeNumQuery { + public static let OperationName = "GetLargeNum" + + public typealias Ref = QueryRefObservableObject + + public struct Variables: OperationVariable { + public var + id: UUID + + public init(id: UUID) { + self.id = id + } + + public static func == (lhs: Variables, rhs: Variables) -> Bool { + return lhs.id == rhs.id + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } + + enum CodingKeys: String, CodingKey { + case id + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } + } + + public struct Data: Decodable { + public struct LargeIntType: Decodable { + public var + num: Int64 + + public var + maxNum: Int64 + + public var + minNum: Int64 + + enum CodingKeys: String, CodingKey { + case num + + case maxNum + + case minNum + } + + public init(from decoder: any Decoder) throws { + var container = try decoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + num = try codecHelper.decode(Int64.self, forKey: .num, container: &container) + + maxNum = try codecHelper.decode(Int64.self, forKey: .maxNum, container: &container) + + minNum = try codecHelper.decode(Int64.self, forKey: .minNum, container: &container) + } + } + + public var + largeIntType: LargeIntType? + } +} + +public enum GetLocalDateTypeQuery { + public static let OperationName = "GetLocalDateType" + + public typealias Ref = QueryRefObservableObject< + GetLocalDateTypeQuery.Data, + GetLocalDateTypeQuery.Variables + > + + public struct Variables: OperationVariable { + public var + id: UUID + + public init(id: UUID) { + self.id = id + } + + public static func == (lhs: Variables, rhs: Variables) -> Bool { + return lhs.id == rhs.id + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(id) + } + + enum CodingKeys: String, CodingKey { + case id + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + try codecHelper.encode(id, forKey: .id, container: &container) + } + } + + public struct Data: Decodable { + public struct LocalDateType: Decodable { + public var + localDate: LocalDate? + + enum CodingKeys: String, CodingKey { + case localDate + } + + public init(from decoder: any Decoder) throws { + var container = try decoder.container(keyedBy: CodingKeys.self) + let codecHelper = CodecHelper() + + localDate = try codecHelper.decode( + LocalDate?.self, + forKey: .localDate, + container: &container + ) + } + } + + public var + localDateType: LocalDateType? + } +} diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml index 4bad2b8b19a..72fe524c0b2 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml @@ -1,7 +1,12 @@ connectorId: "kitchen-sink" authMode: "PUBLIC" +# If you are changing the fdc-kitchensink schem or operations +# Adjust the outputDir to your local path +# Copy the generated files from generated "Sources" folder +# into the FirebaseDataConnect/Tests/Integration folder +# In future, we can consider a Test only Swift build plugin to gen the files, to avoid this. generate: swiftSdk: - outputDir: "../../../../Gen" + outputDir: "/Users/aashishp/Scratchpad/KitchenSinkSwiftGen" package: "KitchenSink" diff --git a/Package.swift b/Package.swift index bf1255da634..69b6cd52a8e 100644 --- a/Package.swift +++ b/Package.swift @@ -686,7 +686,6 @@ let package = Package( path: "FirebaseDataConnect/Tests", exclude: ["Gen/KitchenSink/Package.swift"], resources: [ - .process("Resources/GoogleService-Info.plist"), .copy("Resources/fdc-kitchensink"), ] ), From 58d4960fa0717a71d117ae0279551a193ecaf024 Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Mon, 12 Aug 2024 13:55:08 -0700 Subject: [PATCH 10/11] Fix typo --- .../fdc-kitchensink/dataconnect/default/connector.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml index 72fe524c0b2..2f9f6ef0c2e 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml @@ -1,7 +1,7 @@ connectorId: "kitchen-sink" authMode: "PUBLIC" -# If you are changing the fdc-kitchensink schem or operations +# If you are changing the fdc-kitchensink schema or operations # Adjust the outputDir to your local path # Copy the generated files from generated "Sources" folder # into the FirebaseDataConnect/Tests/Integration folder From 901bc557e2d8799d6422d47a2fd0328df2e6a4f5 Mon Sep 17 00:00:00 2001 From: Aashish Patil Date: Mon, 12 Aug 2024 14:34:10 -0700 Subject: [PATCH 11/11] Remove swift concurrency checks, trailing whitespace. --- .../fdc-kitchensink/dataconnect/default/connector.yaml | 2 +- Package.swift | 5 +---- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml index 2f9f6ef0c2e..a91017ab824 100644 --- a/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml +++ b/FirebaseDataConnect/Tests/Resources/fdc-kitchensink/dataconnect/default/connector.yaml @@ -3,7 +3,7 @@ authMode: "PUBLIC" # If you are changing the fdc-kitchensink schema or operations # Adjust the outputDir to your local path -# Copy the generated files from generated "Sources" folder +# Copy the generated files from generated "Sources" folder # into the FirebaseDataConnect/Tests/Integration folder # In future, we can consider a Test only Swift build plugin to gen the files, to avoid this. generate: diff --git a/Package.swift b/Package.swift index 69b6cd52a8e..7b85234becd 100644 --- a/Package.swift +++ b/Package.swift @@ -675,10 +675,7 @@ let package = Package( "FirebaseCoreExtension", "FirebaseSharedSwift", ], - path: "FirebaseDataConnect/Sources", - swiftSettings: [ - .enableExperimentalFeature("StrictConcurrency"), - ] + path: "FirebaseDataConnect/Sources" ), .testTarget( name: "FirebaseDataConnectTests",