test: failing test for PARSE_SERVER_AUTH_PROVIDERS env (string vs object)

Author: mattia1208

spec/AuthParserStandalone.spec.js

@@ -0,0 +1,121 @@
+// Test standalone per verificare il parsing di PARSE_SERVER_AUTH_PROVIDERS
+// Questo test NON avvia Parse Server e testa solo la funzione parser
+
+'use strict';
+
+// Non importiamo helper.js per evitare di avviare il server
+const parsers = require('../lib/Options/parsers');
+const definitions = require('../lib/Options/Definitions');
+
+describe('Auth Providers Parser (Standalone)', () => {
+  
+  it('should parse auth providers JSON string to object with objectParser', () => {
+    const authProvidersString = JSON.stringify({
+      facebook: {
+        appIds: ['test-facebook-app-id-1', 'test-facebook-app-id-2']
+      },
+      google: {
+        clientId: 'test-google-client-id',
+        clientSecret: 'test-google-client-secret'
+      }
+    });
+    
+    const result = parsers.objectParser(authProvidersString);
+    
+    expect(typeof result).toBe('object');
+    expect(result).not.toBeNull();
+    expect(result.facebook).toBeDefined();
+    expect(result.facebook.appIds).toEqual(['test-facebook-app-id-1', 'test-facebook-app-id-2']);
+    expect(result.google).toBeDefined();
+    expect(result.google.clientId).toBe('test-google-client-id');
+    expect(result.google.clientSecret).toBe('test-google-client-secret');
+  });
+
+  it('should accept auth providers as object directly with objectParser', () => {
+    const authProvidersObject = {
+      facebook: {
+        appIds: ['direct-facebook-app-id']
+      },
+      twitter: {
+        consumerKey: 'test-consumer-key',
+        consumerSecret: 'test-consumer-secret'
+      }
+    };
+    
+    const result = parsers.objectParser(authProvidersObject);
+    
+    expect(typeof result).toBe('object');
+    expect(result.facebook).toBeDefined();
+    expect(result.facebook.appIds).toEqual(['direct-facebook-app-id']);
+    expect(result.twitter).toBeDefined();
+    expect(result.twitter.consumerKey).toBe('test-consumer-key');
+  });
+
+  it('should throw error for invalid JSON string', () => {
+    expect(() => {
+      parsers.objectParser('invalid-json-string-not-json');
+    }).toThrow();
+    
+    expect(() => {
+      parsers.objectParser('just a plain string');
+    }).toThrow();
+  });
+
+  it('should verify auth definition in ParseServerOptions', () => {
+    const authDefinition = definitions.ParseServerOptions.auth;
+    
+    expect(authDefinition).toBeDefined();
+    expect(authDefinition.env).toBe('PARSE_SERVER_AUTH_PROVIDERS');
+    expect(authDefinition.help).toContain('authentication providers');
+  });
+
+  it('CRITICAL TEST: auth definition should have objectParser action', () => {
+    const authDefinition = definitions.ParseServerOptions.auth;
+    
+    // Questo è il test più importante: verifica che ci sia l'action parser
+    if (authDefinition.action) {
+      // Se c'è l'action, testiamo che funzioni correttamente
+      const testAuthString = JSON.stringify({ 
+        facebook: { appIds: ['test'] },
+        google: { clientId: 'test-client' }
+      });
+      const result = authDefinition.action(testAuthString);
+      
+      expect(typeof result).toBe('object');
+      expect(result.facebook).toBeDefined();
+      expect(result.google).toBeDefined();
+      
+      // Testa anche che accetti oggetti direttamente
+      const testAuthObject = { facebook: { appIds: ['test2'] } };
+      const result2 = authDefinition.action(testAuthObject);
+      expect(result2.facebook.appIds).toEqual(['test2']);
+      
+    } else {
+      // Se non c'è l'action, questo test fallisce intenzionalmente
+      // per evidenziare il problema
+      fail('PROBLEMA TROVATO: auth definition manca di action parser! ' +
+           'Quando PARSE_SERVER_AUTH_PROVIDERS viene passata come variabile d\'ambiente, ' +
+           'verrà trattata come stringa invece che come oggetto. ' +
+           'Aggiungi "action: parsers.objectParser" alla definizione di auth in Definitions.js');
+    }
+  });
+
+  it('should demonstrate the problem: environment variable stays as string without parser', () => {
+    const authDefinition = definitions.ParseServerOptions.auth;
+    
+    // Simula quello che succede quando viene passata una variabile d'ambiente
+    const envValue = '{"facebook":{"appIds":["test"]}}';
+    
+    if (!authDefinition.action) {
+      // Senza action parser, la stringa rimane stringa
+      expect(typeof envValue).toBe('string');
+      console.log('⚠️  PROBLEMA: La variabile d\'ambiente PARSE_SERVER_AUTH_PROVIDERS ' +
+                  'viene passata come stringa e non viene parsata in oggetto!');
+    } else {
+      // Con action parser, viene convertita in oggetto
+      const parsed = authDefinition.action(envValue);
+      expect(typeof parsed).toBe('object');
+      console.log('✓ OK: La variabile d\'ambiente viene correttamente parsata in oggetto');
+    }
+  });
+});

spec/CLI.spec.js

@@ -333,4 +333,25 @@ describe('execution', () => {
     handleStderr(childProcess, done);
     handleError(childProcess, done);
   });
+
+  it('should parse PARSE_SERVER_AUTH_PROVIDERS environment variable from JSON string to object', done => {
+    const env = { ...process.env };
+    env.NODE_OPTIONS = '--dns-result-order=ipv4first --trace-deprecation';
+    env.PARSE_SERVER_AUTH_PROVIDERS = JSON.stringify({
+      facebook: {
+        appIds: ['test-facebook-app-id']
+      },
+      google: {
+        clientId: 'test-google-client-id'
+      }
+    });
+    env.PARSE_SERVER_APPLICATION_ID = 'testAppId';
+    env.PARSE_SERVER_MASTER_KEY = 'testMasterKey';
+    env.PARSE_SERVER_DATABASE_URI = databaseURI;
+    
+    childProcess = spawn(binPath, [], { env });
+    handleStdout(childProcess, done, aggregatedData, ['parse-server running on']);
+    handleStderr(childProcess, done);
+    handleError(childProcess, done);
+  });
 });

spec/parsers.spec.js

@@ -80,4 +80,29 @@ describe('parsers', () => {
     expect(parser(1)).toEqual(1);
     expect(parser('blabla')).toEqual('blabla');
   });
+
+  it('parses auth providers JSON string with objectParser', () => {
+    const parser = objectParser;
+    const authProvidersString = JSON.stringify({
+      facebook: {
+        appIds: ['test-app-id-1', 'test-app-id-2']
+      },
+      google: {
+        clientId: 'test-client-id',
+        clientSecret: 'test-client-secret'
+      }
+    });
+    const expectedObject = {
+      facebook: {
+        appIds: ['test-app-id-1', 'test-app-id-2']
+      },
+      google: {
+        clientId: 'test-client-id',
+        clientSecret: 'test-client-secret'
+      }
+    };
+    
+    expect(parser(authProvidersString)).toEqual(expectedObject);
+    expect(parser(expectedObject)).toEqual(expectedObject);
+  });
 });