Style Auth Integration Tests (#9229)

Author: paulb777

FirebaseAuth/Tests/Sample/ApiTests/FIRAuthApiTestsBase.h

@@ -16,9 +16,9 @@
 
 #import <XCTest/XCTest.h>
 
+#import <FirebaseAuth/FirebaseAuth.h>
 #import <FirebaseCore/FIRApp.h>
 #import "AuthCredentials.h"
-#import <FirebaseAuth/FirebaseAuth.h>
 
 #ifdef NO_NETWORK
 #import "ITUIOSTestUtil.h"

FirebaseAuth/Tests/Sample/ApiTests/PhoneMultiFactorTests.swift

@@ -59,7 +59,7 @@ class PhoneMultiFactorTests: FIRAuthApiTestsBase {
                              "Phone multi factor enroll failed. Error: \(error!.localizedDescription)")
                 XCTAssertEqual(Auth.auth().currentUser?.multiFactor.enrolledFactors.first?
                   .displayName,
-                               kPhoneSecondFactorDisplayName)
+                  kPhoneSecondFactorDisplayName)
                 enrollExpectation.fulfill()
 
                 // Unenroll
@@ -70,7 +70,7 @@ class PhoneMultiFactorTests: FIRAuthApiTestsBase {
                                  "Phone multi factor unenroll failed. Error: \(error!.localizedDescription)")
                     XCTAssertEqual(Auth.auth().currentUser?.multiFactor.enrolledFactors.count, 0)
                     unenrollExpectation.fulfill()
-            })
+                  })
               }
           }
         }

FirebaseAuth/Tests/Sample/SwiftApiTests/AccountInfoTests.swift

@@ -1,18 +1,18 @@
 /*
-* Copyright 2020 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.
-*/
+ * Copyright 2020 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 FirebaseAuth
@@ -26,78 +26,78 @@ class AccountInfoTests: TestsBase {
 
   override func setUp() {
     let auth = Auth.auth()
-    let expectation1 = self.expectation(description: "Created account with email and password.")
+    let expectation1 = expectation(description: "Created account with email and password.")
     auth.createUser(withEmail: kOldUserEmail, password: "password") { user, error in
       // Succeed whether or not the user already exists.
       expectation1.fulfill()
     }
-    waitForExpectations(timeout:TestsBase.kExpectationsTimeout)
+    waitForExpectations(timeout: TestsBase.kExpectationsTimeout)
   }
 
   override func tearDown() {
     // Clean up the created Firebase user for future runs.
-    self.deleteCurrentUser()
+    deleteCurrentUser()
   }
 
   func testUpdatingUsersEmail() {
     let auth = Auth.auth()
-    let expectation1 = self.expectation(description: "Created account with email and password.")
+    let expectation1 = expectation(description: "Created account with email and password.")
     auth.createUser(withEmail: kOldUserEmail, password: "password") { user, error in
-      if let error = error  {
+      if let error = error {
         XCTAssertEqual((error as NSError).code,
-                     AuthErrorCode.emailAlreadyInUse.rawValue,
-                     "Created a user despite it already exiting.")
+                       AuthErrorCode.emailAlreadyInUse.rawValue,
+                       "Created a user despite it already exiting.")
       } else {
         XCTFail("Did not get error for recreating a user")
       }
       expectation1.fulfill()
     }
-    waitForExpectations(timeout:TestsBase.kExpectationsTimeout)
+    waitForExpectations(timeout: TestsBase.kExpectationsTimeout)
 
-    let expectation2 = self.expectation(description: "Sign in with email and password.")
+    let expectation2 = expectation(description: "Sign in with email and password.")
     auth.signIn(withEmail: kOldUserEmail, password: "password") { user, error in
       XCTAssertNil(error)
       XCTAssertEqual(auth.currentUser?.email,
                      self.kOldUserEmail,
                      "Signed user does not match request.")
       expectation2.fulfill()
     }
-    waitForExpectations(timeout:TestsBase.kExpectationsTimeout)
+    waitForExpectations(timeout: TestsBase.kExpectationsTimeout)
 
-    let expectation3 = self.expectation(description: "Update email address.")
+    let expectation3 = expectation(description: "Update email address.")
     auth.currentUser?.updateEmail(to: kNewUserEmail) { error in
       XCTAssertNil(error)
       XCTAssertEqual(auth.currentUser?.email,
                      self.kNewUserEmail,
                      "Signed user does not match change.")
       expectation3.fulfill()
     }
-    waitForExpectations(timeout:TestsBase.kExpectationsTimeout)
+    waitForExpectations(timeout: TestsBase.kExpectationsTimeout)
   }
 
-#if compiler(>=5.5) && canImport(_Concurrency)
-  @available(iOS 15, tvOS 15, macOS 12, watchOS 8, *)
-  func testUpdatingUsersEmailAsync() async throws {
-    let auth = Auth.auth()
-    do {
-      let _ = try await auth.createUser(withEmail: kOldUserEmail, password: "password")
-      XCTFail("Did not get error for recreating a user")
-    } catch {
+  #if compiler(>=5.5) && canImport(_Concurrency)
+    @available(iOS 15, tvOS 15, macOS 12, watchOS 8, *)
+    func testUpdatingUsersEmailAsync() async throws {
+      let auth = Auth.auth()
+      do {
+        _ = try await auth.createUser(withEmail: kOldUserEmail, password: "password")
+        XCTFail("Did not get error for recreating a user")
+      } catch {
         XCTAssertEqual((error as NSError).code,
-                     AuthErrorCode.emailAlreadyInUse.rawValue,
-                     "Created a user despite it already exiting.")
-    }
+                       AuthErrorCode.emailAlreadyInUse.rawValue,
+                       "Created a user despite it already exiting.")
+      }
 
-    let user = try await auth.signIn(withEmail: kOldUserEmail, password: "password")
-    XCTAssertEqual(user.user.email, kOldUserEmail)
-    XCTAssertEqual(auth.currentUser?.email,
-                   self.kOldUserEmail,
-                   "Signed user does not match request.")
+      let user = try await auth.signIn(withEmail: kOldUserEmail, password: "password")
+      XCTAssertEqual(user.user.email, kOldUserEmail)
+      XCTAssertEqual(auth.currentUser?.email,
+                     kOldUserEmail,
+                     "Signed user does not match request.")
 
-    try await auth.currentUser?.updateEmail(to: kNewUserEmail)
-    XCTAssertEqual(auth.currentUser?.email,
-                   self.kNewUserEmail,
-                   "Signed user does not match change.")
-  }
+      try await auth.currentUser?.updateEmail(to: kNewUserEmail)
+      XCTAssertEqual(auth.currentUser?.email,
+                     kNewUserEmail,
+                     "Signed user does not match change.")
+    }
   #endif
 }

FirebaseAuth/Tests/Sample/SwiftApiTests/AnonymousTests.swift

@@ -1,44 +1,44 @@
 /*
-* Copyright 2020 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.
-*/
+ * Copyright 2020 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 FirebaseAuth
 import XCTest
 
 class AnonymousTests: TestsBase {
   func testUpdatingUsersEmail() {
-    self.signInAnonymously()
+    signInAnonymously()
     if let isAnonymous = Auth.auth().currentUser?.isAnonymous {
       XCTAssertTrue(isAnonymous)
     } else {
       XCTFail("Missing currentUser after anonymous sign in")
     }
-    self.deleteCurrentUser()
+    deleteCurrentUser()
   }
 
-#if compiler(>=5.5) && canImport(_Concurrency)
-  @available(iOS 15, tvOS 15, macOS 12, watchOS 8, *)
-  func testUpdatingUsersEmailAsync() async throws {
-    try await self.signInAnonymouslyAsync()
-    if let isAnonymous = Auth.auth().currentUser?.isAnonymous {
-      XCTAssertTrue(isAnonymous)
-    } else {
-      XCTFail("Missing currentUser after anonymous sign in")
+  #if compiler(>=5.5) && canImport(_Concurrency)
+    @available(iOS 15, tvOS 15, macOS 12, watchOS 8, *)
+    func testUpdatingUsersEmailAsync() async throws {
+      try await signInAnonymouslyAsync()
+      if let isAnonymous = Auth.auth().currentUser?.isAnonymous {
+        XCTAssertTrue(isAnonymous)
+      } else {
+        XCTFail("Missing currentUser after anonymous sign in")
+      }
+      try await deleteCurrentUserAsync()
     }
-    try await self.deleteCurrentUserAsync()
-  }
   #endif
 }

FirebaseAuth/Tests/Sample/SwiftApiTests/EmailPasswordTests.swift

@@ -1,76 +1,76 @@
 /*
-* Copyright 2020 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.
-*/
+ * Copyright 2020 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 FirebaseAuth
 import XCTest
 
 class EmailPasswordTests: TestsBase {
-
-  ///** The testing email address for testCreateAccountWithEmailAndPassword. */
+  /// ** The testing email address for testCreateAccountWithEmailAndPassword. */
   let kNewEmailToCreateUser = "[email protected]"
 
-  ///** The testing email address for testSignInExistingUserWithEmailAndPassword. */
+  /// ** The testing email address for testSignInExistingUserWithEmailAndPassword. */
   let kExistingEmailToSignIn = "[email protected]"
 
   func testCreateAccountWithEmailAndPassword() {
     let auth = Auth.auth()
     let expectation = self.expectation(description: "Created account with email and password.")
-    auth.createUser(withEmail: kNewEmailToCreateUser, password: "password") { (result, error) in
+    auth.createUser(withEmail: kNewEmailToCreateUser, password: "password") { result, error in
       if let error = error {
         print("createUserWithEmail has error: \(error)")
       }
       expectation.fulfill()
     }
-    waitForExpectations(timeout:TestsBase.kExpectationsTimeout)
+    waitForExpectations(timeout: TestsBase.kExpectationsTimeout)
     XCTAssertEqual(auth.currentUser?.email, kNewEmailToCreateUser, "Expected email doesn't match")
-    self.deleteCurrentUser()
+    deleteCurrentUser()
   }
 
-#if compiler(>=5.5) && canImport(_Concurrency)
-  @available(iOS 15, tvOS 15, macOS 12, watchOS 8, *)
-  func testCreateAccountWithEmailAndPasswordAsync() async throws {
-    let auth = Auth.auth()
-    try await auth.createUser(withEmail: kNewEmailToCreateUser, password: "password")
-    XCTAssertEqual(auth.currentUser?.email, kNewEmailToCreateUser, "Expected email doesn't match")
-    try await self.deleteCurrentUserAsync()
-  }
+  #if compiler(>=5.5) && canImport(_Concurrency)
+    @available(iOS 15, tvOS 15, macOS 12, watchOS 8, *)
+    func testCreateAccountWithEmailAndPasswordAsync() async throws {
+      let auth = Auth.auth()
+      try await auth.createUser(withEmail: kNewEmailToCreateUser, password: "password")
+      XCTAssertEqual(auth.currentUser?.email, kNewEmailToCreateUser, "Expected email doesn't match")
+      try await deleteCurrentUserAsync()
+    }
   #endif
 
   func testSignInExistingUserWithEmailAndPassword() {
     let auth = Auth.auth()
-    let expectation = self.expectation(description: "Signed in existing account with email and password.")
+    let expectation = self
+      .expectation(description: "Signed in existing account with email and password.")
     auth.signIn(withEmail: kExistingEmailToSignIn, password: "password") { user, error in
       XCTAssertNil(error)
       XCTAssertEqual(auth.currentUser?.email,
                      self.kExistingEmailToSignIn,
                      "Signed user does not match request.")
       expectation.fulfill()
     }
-    waitForExpectations(timeout:TestsBase.kExpectationsTimeout)
+    waitForExpectations(timeout: TestsBase.kExpectationsTimeout)
   }
 
-#if compiler(>=5.5) && canImport(_Concurrency)
-  @available(iOS 15, tvOS 15, macOS 12, watchOS 8, *)
-  func testSignInExistingUserWithEmailAndPasswordAsync() async throws {
-    let auth = Auth.auth()
-    try await auth.signIn(withEmail: kExistingEmailToSignIn, password: "password")
-    XCTAssertEqual(auth.currentUser?.email,
-                   self.kExistingEmailToSignIn,
-                   "Signed user does not match request.")
-  }
+  #if compiler(>=5.5) && canImport(_Concurrency)
+    @available(iOS 15, tvOS 15, macOS 12, watchOS 8, *)
+    func testSignInExistingUserWithEmailAndPasswordAsync() async throws {
+      let auth = Auth.auth()
+      try await auth.signIn(withEmail: kExistingEmailToSignIn, password: "password")
+      XCTAssertEqual(auth.currentUser?.email,
+                     kExistingEmailToSignIn,
+                     "Signed user does not match request.")
+    }
   #endif
 }