Add signInAnonymously to auth-next

Author: avolkovi

packages-exp/auth-exp/src/core/strategies/anonymous.test.ts

@@ -0,0 +1,65 @@
+/**
+ * @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 { expect } from 'chai';
+import { mockEndpoint } from '../../../test/api/helper';
+import { mockAuth } from "../../../test/mock_auth";
+import * as mockFetch from '../../../test/mock_fetch';
+import { Endpoint } from '../../api';
+import { OperationType } from '../../model/user_credential';
+import { ProviderId, SignInMethod } from '../providers';
+import { signInAnonymously } from './anonymous';
+import { APIUserInfo } from '../../api/account_management/account';
+
+describe('core/strategies/anonymous', () => {
+  const serverUser: APIUserInfo = {
+    localId: 'local-id',
+  };
+
+  beforeEach(() => {
+    mockFetch.setUp();
+    mockEndpoint(Endpoint.SIGN_UP, {
+      idToken: 'id-token',
+      refreshToken: 'refresh-token',
+      expiresIn: '1234',
+      localId: serverUser.localId!
+    });
+    mockEndpoint(Endpoint.GET_ACCOUNT_INFO, {
+      users: [serverUser]
+    });
+  });
+  afterEach(mockFetch.tearDown);
+
+  describe('signInAnonymously', () => {
+    it('should sign in an anonymous user', async () => {
+      const { credential, user, operationType } = await signInAnonymously(mockAuth);
+      expect(credential?.providerId).to.eq(ProviderId.ANONYMOUS);
+      expect(credential?.signInMethod).to.eq(SignInMethod.ANONYMOUS);
+      expect(operationType).to.eq(OperationType.SIGN_IN);
+      expect(user.uid).to.eq(serverUser.localId);
+      expect(user.isAnonymous).to.be.true;
+    });
+
+    context('already signed in anonymousl', () => {
+
+    });
+
+    context('already signed in with a non-anonymous account', () => {
+
+    });
+  });
+ });

packages-exp/auth-exp/src/core/strategies/anonymous.ts

@@ -0,0 +1,34 @@
+/**
+ * @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 { Auth } from '../../model/auth';
+import { OperationType, UserCredential } from '../../model/user_credential';
+import { AnonymousProvider } from '../providers/anonymous';
+import { UserCredentialImpl } from '../user/user_credential_impl';
+import { signInWithCredential } from './credential';
+export async function signInAnonymously(auth: Auth): Promise<UserCredential> {
+  const credential = AnonymousProvider.credential();
+  if (auth.currentUser?.isAnonymous) {
+    // If an anonymous user is already signed in, no need to sign them in again.
+    return new UserCredentialImpl(
+      auth.currentUser,
+      credential,
+      OperationType.SIGN_IN
+    );
+  }
+  return signInWithCredential(auth, credential);
+}

packages-exp/auth-exp/src/core/user/user_impl.ts

@@ -59,6 +59,7 @@ export class UserImpl implements User {
   tenantId = null;
   metadata = {};
   providerData = [];
+  isAnonymous = false;
 
   // Optional fields from UserInfo
   displayName: string | null;

packages-exp/auth-exp/src/model/user.d.ts

@@ -34,6 +34,7 @@ export interface User extends externs.User {
   tenantId: string | null;
   providerData: externs.UserInfo[];
   metadata: externs.UserMetadata;
+  isAnonymous: boolean;
 
   getIdToken(forceRefresh?: boolean): Promise<string>;
   getIdTokenResult(forceRefresh?: boolean): Promise<externs.IdTokenResult>;

packages-exp/auth-exp/test/anonymous.test.ts

@@ -0,0 +1,72 @@
+/**
+ * @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 { expect, use } from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+import { ProviderId, SignInMethod } from '.';
+import { mockAuth } from '../../../test/mock_auth';
+import { AnonymousCredential, AnonymousProvider } from "./anonymous";
+
+use(chaiAsPromised);
+
+describe('core/providers/anonymous', () => {
+  describe('AnonymousCredential', () => {
+    const credential = new AnonymousCredential();
+    
+    it('should have an anonymous provider', () => {
+      expect(credential.providerId).to.eq(ProviderId.ANONYMOUS);
+    });
+
+    it('should have an anonymous sign in method', () => {
+      expect(credential.signInMethod).to.eq(SignInMethod.ANONYMOUS);
+    });
+
+    describe('#toJSON', () => {
+      it('throws', () => {
+        expect(credential.toJSON).to.throw(Error);
+      });    
+    });
+
+    describe('#_getIdTokenResponse', () => {
+      it('throws', async () => {
+        await expect(credential._getIdTokenResponse(mockAuth)).to.be.rejectedWith(Error);
+      });    
+    });
+
+    describe('#_linkToIdToken', () => {
+      it('throws', async () => {
+        await expect(credential._linkToIdToken(mockAuth,'id-token')).to.be.rejectedWith(Error);
+      });   
+    });
+
+    describe('#_matchIdTokenWithUid', () => {
+      it('throws', () => {
+        expect(() => credential._matchIdTokenWithUid(mockAuth, 'other-uid')).to.throw(Error);
+      });   
+    });
+  });
+
+  describe('AnonymousProvider', () => {
+    describe('.credential', () => {
+      it('should return an anonymous credential', () => {
+        const credential = AnonymousProvider.credential();
+        expect(credential.providerId).to.eq(ProviderId.ANONYMOUS);
+        expect(credential.signInMethod).to.eq(SignInMethod.ANONYMOUS);
+      });
+    });
+  });
+ });

packages-exp/auth-exp/test/anonymous.ts

@@ -0,0 +1,54 @@
+/**
+ * @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 { AuthProvider, ProviderId, SignInMethod } from '.';
+import { signUp } from '../../api/authentication/sign_up';
+import { Auth } from '../../model/auth';
+import { AuthCredential } from '../../model/auth_credential';
+import { IdTokenResponse } from '../../model/id_token';
+import { debugFail } from '../util/assert';
+
+export class AnonymousCredential implements AuthCredential {
+  providerId = ProviderId.ANONYMOUS;
+  signInMethod = SignInMethod.ANONYMOUS;
+  
+  toJSON(): never {
+    debugFail('Method not implemented.');
+  }
+  
+  async _getIdTokenResponse(auth: Auth): Promise<IdTokenResponse> {
+    return signUp(auth, {
+      returnSecureToken: true
+    });
+  }
+  
+  async _linkToIdToken(_auth: Auth, _idToken: string): Promise<never> {
+    debugFail("Can't link to an anonymous credential");
+  }
+
+  _matchIdTokenWithUid(_auth: Auth, _uid: string): Promise<never> {
+    debugFail('Method not implemented.');
+  }
+}
+
+export class AnonymousProvider implements AuthProvider {
+  providerId = ProviderId.ANONYMOUS;
+  
+  static credential(): AnonymousCredential {
+    return new AnonymousCredential();
+  }
+}

packages-exp/auth-exp/test/jwt.ts

@@ -35,3 +35,10 @@ export enum SignInMethod {
   PHONE = 'phone',
   TWITTER = 'twitter.com'
 }
+
+/**
+ * A provider for generating credentials
+ */
+export interface AuthProvider {
+  readonly providerId: ProviderId;
+}