refactor

Author: dblythy

package-lock.json

@@ -18,7 +18,7 @@ const responses = {
   microsoft: { id: 'userId', mail: 'userMail' },
 };
 
-fdescribe('AuthenticationProviders', function () {
+describe('AuthenticationProviders', function () {
   [
     'apple',
     'gcenter',
@@ -357,7 +357,7 @@ fdescribe('AuthenticationProviders', function () {
     expect(typeof authAdapter.validateAppId).toBe('function');
   }
 
-  it('properly loads custom adapter', async () => {
+  it('properly loads custom adapter', done => {
     const validAuthData = {
       id: 'hello',
       token: 'world',
@@ -377,8 +377,6 @@ fdescribe('AuthenticationProviders', function () {
     const authDataSpy = spyOn(adapter, 'validateAuthData').and.callThrough();
     const appIdSpy = spyOn(adapter, 'validateAppId').and.callThrough();
 
-    await reconfigureServer({ auth: { customAuthentication: adapter } });
-
     const authenticationHandler = authenticationLoader({
       customAuthentication: adapter,
     });
@@ -387,56 +385,98 @@ fdescribe('AuthenticationProviders', function () {
     const { validator } = authenticationHandler.getValidatorForProvider('customAuthentication');
     validateValidator(validator);
 
-    await validator(validAuthData, {}, {});
-    expect(authDataSpy).toHaveBeenCalled();
-
-    expect(appIdSpy).not.toHaveBeenCalled();
+    validator(validAuthData, {}, {}).then(
+      () => {
+        expect(authDataSpy).toHaveBeenCalled();
+        // AppIds are not provided in the adapter, should not be called
+        expect(appIdSpy).not.toHaveBeenCalled();
+        done();
+      },
+      err => {
+        jfail(err);
+        done();
+      }
+    );
   });
 
-  it('properly loads custom adapter module object', async () => {
-    await reconfigureServer({
-      auth: {
-        customAuthentication: {
-          validateAppId() {},
-          validateAuthData() {},
-        },
+  it('should cache adapter', async () => {
+    const adapter = {
+      validateAppId() {
+        return Promise.resolve();
+      },
+      validateAuthData() {
+        return Promise.resolve();
       },
+      validateOptions() {},
+    };
+
+    const authDataSpy = spyOn(adapter, 'validateAuthData').and.callThrough();
+    const optionsSpy = spyOn(adapter, 'validateOptions').and.callThrough();
+
+    await reconfigureServer({ auth: { customAuthentication: adapter } });
+
+    expect(optionsSpy).toHaveBeenCalled();
+    await Parse.User.logInWith('customAuthentication', {
+      authData: { id: 'user1', token: 'fakeToken1' },
+    });
+    await Parse.User.logInWith('customAuthentication', {
+      authData: { id: 'user2', token: 'fakeToken2' },
+    });
+    expect(authDataSpy).toHaveBeenCalled();
+    expect(optionsSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('properly loads custom adapter module object', done => {
+    const authenticationHandler = authenticationLoader({
+      customAuthentication: path.resolve('./spec/support/CustomAuth.js'),
     });
-    const authenticationHandler = authenticationLoader();
 
     validateAuthenticationHandler(authenticationHandler);
     const { validator } = authenticationHandler.getValidatorForProvider('customAuthentication');
     validateValidator(validator);
-    await validator(
+    validator(
       {
         token: 'my-token',
       },
       {},
       {}
+    ).then(
+      () => {
+        done();
+      },
+      err => {
+        jfail(err);
+        done();
+      }
     );
   });
 
-  it('properly loads custom adapter module object (again)', async () => {
-    await reconfigureServer({
-      auth: {
-        customAuthentication: {
-          validateAppId() {},
-          validateAuthData() {},
-        },
+  it('properly loads custom adapter module object (again)', done => {
+    const authenticationHandler = authenticationLoader({
+      customAuthentication: {
+        module: path.resolve('./spec/support/CustomAuthFunction.js'),
+        options: { token: 'valid-token' },
       },
     });
-    const authenticationHandler = authenticationLoader();
 
     validateAuthenticationHandler(authenticationHandler);
     const { validator } = authenticationHandler.getValidatorForProvider('customAuthentication');
     validateValidator(validator);
 
-    await validator(
+    validator(
       {
         token: 'valid-token',
       },
       {},
       {}
+    ).then(
+      () => {
+        done();
+      },
+      err => {
+        jfail(err);
+        done();
+      }
     );
   });
 

spec/AuthenticationAdapters.spec.js

@@ -4,7 +4,6 @@ const semver = require('semver');
 const CurrentSpecReporter = require('./support/CurrentSpecReporter.js');
 const { SpecReporter } = require('jasmine-spec-reporter');
 const SchemaCache = require('../lib/Adapters/Cache/SchemaCache').default;
-const AuthAdapters = require('../lib/Adapters/Auth');
 
 // Ensure localhost resolves to ipv4 address first on node v17+
 if (dns.setDefaultResultOrder) {
@@ -211,7 +210,6 @@ afterEach(function (done) {
     destroyAliveConnections();
     await TestUtils.destroyAllDataPermanently(true);
     SchemaCache.clear();
-    AuthAdapters.validateAuthConfig(defaultConfiguration.auth);
     if (didChangeConfiguration) {
       await reconfigureServer();
     } else {

spec/helper.js

@@ -1,7 +1,6 @@
 import loadAdapter from '../AdapterLoader';
 import Parse from 'parse/node';
 import AuthAdapter from './AuthAdapter';
-import Config from '../../Config';
 const apple = require('./apple');
 const gcenter = require('./gcenter');
 const gpgames = require('./gpgames');
@@ -135,9 +134,8 @@ function authDataValidator(provider, adapter, appIds, options) {
   };
 }
 
-function loadAuthAdapter(provider, authOptions, cached) {
-  const config = Config.get(Parse.applicationId);
-  if (!cached) {
+function loadAuthAdapter(provider, authOptions, adapter) {
+  if (!adapter) {
     let defaultAdapter = providers[provider];
     // authOptions can contain complete custom auth adapters or
     // a default auth adapter like Facebook
@@ -167,7 +165,7 @@ function loadAuthAdapter(provider, authOptions, cached) {
       'afterFind',
     ];
 
-    let adapter = Object.assign({}, defaultAdapter);
+    adapter = Object.assign({}, defaultAdapter);
     if (defaultAdapter instanceof AuthAdapter) {
       adapter = new defaultAdapter.constructor();
       defaultAdapter._clearDefaultKeys(keys);
@@ -188,13 +186,8 @@ function loadAuthAdapter(provider, authOptions, cached) {
       if (adapter.validateOptions) {
         adapter.validateOptions(providerOptions);
       }
-      if (!config.authCache) {
-        config.authCache = new Map();
-      }
-      config.authCache.set(provider, adapter);
     }
   }
-  const adapter = config.authCache?.get(provider);
   if (!adapter) {
     return;
   }
@@ -209,8 +202,8 @@ function validateAuthConfig(auth) {
     auth.anonymous = { enabled: true };
   }
   Object.keys(auth).forEach(key => {
-    const adapter = loadAuthAdapter(key, auth);
-    authCache.set(key, adapter);
+    const authObject = loadAuthAdapter(key, auth);
+    authCache.set(key, authObject.adapter);
   });
   return authCache;
 }
@@ -220,12 +213,13 @@ module.exports = function (authOptions = {}, enableAnonymousUsers = true) {
   const setEnableAnonymousUsers = function (enable) {
     _enableAnonymousUsers = enable;
   };
+  const authCache = validateAuthConfig(authOptions);
   // To handle the test cases on configuration
   const getValidatorForProvider = function (provider) {
     if (provider === 'anonymous' && !_enableAnonymousUsers) {
       return { validator: undefined };
     }
-    const authAdapter = loadAuthAdapter(provider, authOptions, true);
+    const authAdapter = loadAuthAdapter(provider, authOptions, authCache.get(provider));
     if (!authAdapter) {
       return { validator: undefined };
     }
@@ -267,8 +261,8 @@ module.exports = function (authOptions = {}, enableAnonymousUsers = true) {
     getValidatorForProvider,
     setEnableAnonymousUsers,
     runAfterFind,
+    authCache,
   });
 };
 
 module.exports.loadAuthAdapter = loadAuthAdapter;
-module.exports.validateAuthConfig = validateAuthConfig;

src/Adapters/Auth/index.js

@@ -7,7 +7,6 @@ import net from 'net';
 import AppCache from './cache';
 import DatabaseController from './Controllers/DatabaseController';
 import { logLevels as validLogLevels } from './Controllers/LoggerController';
-import AuthAdapter from './Adapters/Auth';
 import {
   AccountLockoutOptions,
   DatabaseOptions,
@@ -58,9 +57,6 @@ export class Config {
     Config.validateControllers(serverConfiguration);
     AppCache.put(serverConfiguration.appId, serverConfiguration);
     Config.setupPasswordValidator(serverConfiguration.passwordPolicy);
-    if (serverConfiguration.auth) {
-      serverConfiguration.authStore = AuthAdapter.validateAuthConfig(serverConfiguration.auth);
-    }
     return serverConfiguration;
   }