Add Google Signin (#7969)

* Start adding google login

* fix local js issue

* implement syntax suggestions

* fix delete social tests

* Add service for authentication alerts

* fix social login tests

* make suggested google sign in changes

* fix accidentally deleted code

* refactor social network sign in

* fix incorrect find

* implement suggested google sign in changes

* fix(tests): Inject fake Auth module for auth controller

* fix(test): prevent social service from causing page reload

* fix loading user info

* Use lodash's implimentation of find for IE compatibility

* chore: increase test coverage around deletion route

* chore: clean up social auth test

* chore: Fix social login tests

* remove profile from login scope

* fix(api): Allow social accounts to deregister as user has auth backup

* temporarily disable google login button

test/api/v3/integration/user/auth/POST-user_auth_social.test.js

@@ -12,58 +12,132 @@ describe('POST /user/auth/social', () => {
   let endpoint = '/user/auth/social';
   let randomAccessToken = '123456';
   let facebookId = 'facebookId';
-  let network = 'facebook';
+  let googleId = 'googleId';
+  let network = 'NoNetwork';
 
-  before(async () => {
+  beforeEach(async () => {
     api = requester();
     user = await generateUser();
-
-    let expectedResult = {id: facebookId};
-    let passportFacebookProfile = sandbox.stub(passport._strategies.facebook, 'userProfile');
-    passportFacebookProfile.yields(null, expectedResult);
   });
 
-  it('fails if network is not facebook', async () => {
+  it('fails if network is not supported', async () => {
     await expect(api.post(endpoint, {
       authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
-      network: 'NotFacebook',
+      network,
     })).to.eventually.be.rejected.and.eql({
-      code: 401,
-      error: 'NotAuthorized',
-      message: t('onlyFbSupported'),
+      code: 400,
+      error: 'BadRequest',
+      message: t('unsupportedNetwork'),
     });
   });
 
-  it('registers a new user', async () => {
-    let response = await api.post(endpoint, {
-      authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
-      network,
+  describe('facebook', () => {
+    before(async () => {
+      let expectedResult = {id: facebookId};
+      sandbox.stub(passport._strategies.facebook, 'userProfile').yields(null, expectedResult);
+      network = 'facebook';
     });
 
-    expect(response.apiToken).to.exist;
-    expect(response.id).to.exist;
-    expect(response.newUser).to.be.true;
+    it('registers a new user', async () => {
+      let response = await api.post(endpoint, {
+        authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
+        network,
+      });
+
+      expect(response.apiToken).to.exist;
+      expect(response.id).to.exist;
+      expect(response.newUser).to.be.true;
+    });
+
+    it('logs an existing user in', async () => {
+      let registerResponse = await api.post(endpoint, {
+        authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
+        network,
+      });
+
+      let response = await api.post(endpoint, {
+        authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
+        network,
+      });
+
+      expect(response.apiToken).to.eql(registerResponse.apiToken);
+      expect(response.id).to.eql(registerResponse.id);
+      expect(response.newUser).to.be.false;
+    });
+
+    it('add social auth to an existing user', async () => {
+      let response = await user.post(endpoint, {
+        authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
+        network,
+      });
+
+      expect(response.apiToken).to.exist;
+      expect(response.id).to.exist;
+      expect(response.newUser).to.be.false;
+    });
+
+    it('enrolls a new user in an A/B test', async () => {
+      await api.post(endpoint, {
+        authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
+        network,
+      });
+
+      await expect(getProperty('users', user._id, '_ABtest')).to.eventually.be.a('string');
+    });
   });
 
-  it('enrolls a new user in an A/B test', async () => {
-    await api.post(endpoint, {
-      authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
-      network,
+  describe('google', () => {
+    before(async () => {
+      let expectedResult = {id: googleId};
+      sandbox.stub(passport._strategies.google, 'userProfile').yields(null, expectedResult);
+      network = 'google';
     });
 
-    await expect(getProperty('users', user._id, '_ABtest')).to.eventually.be.a('string');
-  });
+    it('registers a new user', async () => {
+      let response = await api.post(endpoint, {
+        authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
+        network,
+      });
 
-  it('logs an existing user in', async () => {
-    await user.update({ 'auth.facebook.id': facebookId });
-
-    let response = await api.post(endpoint, {
-      authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
-      network,
+      expect(response.apiToken).to.exist;
+      expect(response.id).to.exist;
+      expect(response.newUser).to.be.true;
     });
 
-    expect(response.apiToken).to.eql(user.apiToken);
-    expect(response.id).to.eql(user._id);
-    expect(response.newUser).to.be.false;
+    it('logs an existing user in', async () => {
+      let registerResponse = await api.post(endpoint, {
+        authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
+        network,
+      });
+
+      let response = await api.post(endpoint, {
+        authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
+        network,
+      });
+
+      expect(response.apiToken).to.eql(registerResponse.apiToken);
+      expect(response.id).to.eql(registerResponse.id);
+      expect(response.newUser).to.be.false;
+    });
+
+    it('add social auth to an existing user', async () => {
+      let response = await user.post(endpoint, {
+        authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
+        network,
+      });
+
+      expect(response.apiToken).to.exist;
+      expect(response.id).to.exist;
+      expect(response.newUser).to.be.false;
+    });
+
+    it('enrolls a new user in an A/B test', async () => {
+      await api.post(endpoint, {
+        authResponse: {access_token: randomAccessToken}, // eslint-disable-line camelcase
+        network,
+      });
+
+      await expect(getProperty('users', user._id, '_ABtest')).to.eventually.be.a('string');
+    });
   });
 });