kami-parse-server/spec/helper.js

'use strict';
const dns = require('dns');
const semver = require('semver');
const Parse = require('parse/node');
const CurrentSpecReporter = require('./support/CurrentSpecReporter.js');
const { SpecReporter } = require('jasmine-spec-reporter');
const SchemaCache = require('../lib/Adapters/Cache/SchemaCache').default;
const { sleep, Connections } = require('../lib/TestUtils');

const originalFetch = global.fetch;
let fetchWasMocked = false;

global.restoreFetch = () => {
  global.fetch = originalFetch;
  fetchWasMocked = false;
}


// Ensure localhost resolves to ipv4 address first on node v17+
if (dns.setDefaultResultOrder) {
  dns.setDefaultResultOrder('ipv4first');
}

// Sets up a Parse API server for testing.
jasmine.DEFAULT_TIMEOUT_INTERVAL = process.env.PARSE_SERVER_TEST_TIMEOUT || 10000;
jasmine.getEnv().addReporter(new CurrentSpecReporter());
jasmine.getEnv().addReporter(new SpecReporter());
global.retryFlakyTests();

global.on_db = (db, callback, elseCallback) => {
  if (process.env.PARSE_SERVER_TEST_DB == db) {
    return callback();
  } else if (!process.env.PARSE_SERVER_TEST_DB && db == 'mongo') {
    return callback();
  }
  if (elseCallback) {
    return elseCallback();
  }
};

if (global._babelPolyfill) {
  console.error('We should not use polyfilled tests');
  process.exit(1);
}
process.noDeprecation = true;

const cache = require('../lib/cache').default;
const defaults = require('../lib/defaults').default;
const ParseServer = require('../lib/index').ParseServer;
const loadAdapter = require('../lib/Adapters/AdapterLoader').loadAdapter;
const path = require('path');
const TestUtils = require('../lib/TestUtils');
const GridFSBucketAdapter = require('../lib/Adapters/Files/GridFSBucketAdapter')
  .GridFSBucketAdapter;
const FSAdapter = require('@parse/fs-files-adapter');
const PostgresStorageAdapter = require('../lib/Adapters/Storage/Postgres/PostgresStorageAdapter')
  .default;
const MongoStorageAdapter = require('../lib/Adapters/Storage/Mongo/MongoStorageAdapter').default;
const RedisCacheAdapter = require('../lib/Adapters/Cache/RedisCacheAdapter').default;
const RESTController = require('parse/lib/node/RESTController').default;
const { VolatileClassesSchemas } = require('../lib/Controllers/SchemaController');

const mongoURI = 'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase';
const postgresURI = 'postgres://localhost:5432/parse_server_postgres_adapter_test_database';
let databaseAdapter;
let databaseURI;

if (process.env.PARSE_SERVER_DATABASE_ADAPTER) {
  databaseAdapter = JSON.parse(process.env.PARSE_SERVER_DATABASE_ADAPTER);
  databaseAdapter = loadAdapter(databaseAdapter);
} else if (process.env.PARSE_SERVER_TEST_DB === 'postgres') {
  databaseURI = process.env.PARSE_SERVER_TEST_DATABASE_URI || postgresURI;
  databaseAdapter = new PostgresStorageAdapter({
    uri: databaseURI,
    collectionPrefix: 'test_',
  });
} else {
  databaseURI = mongoURI;
  databaseAdapter = new MongoStorageAdapter({
    uri: databaseURI,
    collectionPrefix: 'test_',
  });
}

const port = 8378;
const serverURL = `http://localhost:${port}/1`;
let filesAdapter;

on_db(
  'mongo',
  () => {
    filesAdapter = new GridFSBucketAdapter(mongoURI);
  },
  () => {
    filesAdapter = new FSAdapter();
  }
);

let logLevel;
let silent = true;
if (process.env.VERBOSE) {
  silent = false;
  logLevel = 'verbose';
}
if (process.env.PARSE_SERVER_LOG_LEVEL) {
  silent = false;
  logLevel = process.env.PARSE_SERVER_LOG_LEVEL;
}
// Default server configuration for tests.
const defaultConfiguration = {
  filesAdapter,
  serverURL,
  databaseAdapter,
  appId: 'test',
  javascriptKey: 'test',
  dotNetKey: 'windows',
  clientKey: 'client',
  restAPIKey: 'rest',
  webhookKey: 'hook',
  masterKey: 'test',
  maintenanceKey: 'testing',
  readOnlyMasterKey: 'read-only-test',
  fileKey: 'test',
  directAccess: true,
  silent,
  verbose: !silent,
  logLevel,
  liveQuery: {
    classNames: ['TestObject'],
  },
  startLiveQueryServer: true,
  fileUpload: {
    enableForPublic: true,
    enableForAnonymousUser: true,
    enableForAuthenticatedUser: true,
  },
  push: {
    android: {
      firebaseServiceAccount: {
        "type": "service_account",
        "project_id": "example-xxxx",
        "private_key_id": "xxxx",
        "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCxFcVMD9L2xJWW\nEMi4w/XIBPvX5bTStIEdt4GY+yfrmCHspaVdgpTcHlTLA60sAGTFdorPprOwAm6f\njaTG4j86zfW25GF6AlFO/8vE2B0tjreuQQtcP9gkWJmsTp8yzXDirDQ43Kv93Kbc\nUPmsyAN5WB8XiFjjWLnFCeDiOVdd8sHfG0HYldNzyYwXrOTLE5kOjASYSJDzdrfI\nwN9PzZC7+cCy/DDzTRKQCqfz9pEZmxqJk4Id5HLVNkGKgji3C3b6o3MXWPS+1+zD\nGheKC9WLDZnCVycAnNHFiPpsp7R82lLKC3Dth37b6qzJO+HwfTmzCb0/xCVJ0/mZ\nC4Mxih/bAgMBAAECggEACbL1DvDw75Yd0U3TCJenDxEC0DTjHgVH6x5BaWUcLyGy\nffkmoQQFbjb1Evd9FSNiYZRYDv6E6feAIpoJ8+CxcOGV+zHwCtQ0qtyExx/FHVkr\nQ06JtkBC8N6vcAoQWyJ4c9nVtGWVv/5FX1zKCAYedpd2gH31zGHwLtQXLpzQZbNO\nO/0rcggg4unGSUIyw5437XiyckJ3QdneSEPe9HvY2wxLn/f1PjMpRYiNLBSuaFBJ\n+MYXr//Vh7cMInQk5/pMFbGxugNb7dtjgvm3LKRssKnubEOyrKldo8DVJmAvjhP4\nWboOOBVEo2ZhXgnBjeMvI8btXlJ85h9lZ7xwqfWsjQKBgQDkrrLpA3Mm21rsP1Ar\nMLEnYTdMZ7k+FTm5pJffPOsC7wiLWdRLwwrtb0V3kC3jr2K4SZY/OEV8IAWHfut/\n8mP8cPQPJiFp92iOgde4Xq/Ycwx4ZAXUj7mHHgywFi2K0xATzgc9sgX3NCVl9utR\nIU/FbEDCLxyD4T3Jb5gL3xFdhwKBgQDGPS46AiHuYmV7OG4gEOsNdczTppBJCgTt\nKGSJOxZg8sQodNJeWTPP2iQr4yJ4EY57NQmH7WSogLrGj8tmorEaL7I2kYlHJzGm\nniwApWEZlFc00xgXwV5d8ATfmAf8W1ZSZ6THbHesDUGjXSoL95k3KKXhnztjUT6I\n8d5qkCygDQKBgFN7p1rDZKVZzO6UCntJ8lJS/jIJZ6nPa9xmxv67KXxPsQnWSFdE\nI9gcF/sXCnmlTF/ElXIM4+j1c69MWULDRVciESb6n5YkuOnVYuAuyPk2vuWwdiRs\nN6mpAa7C2etlM+hW/XO7aswdIE4B/1QF2i5TX6zEMB/A+aJw98vVqmw/AoGADOm9\nUiADb9DPBXjGi6YueYD756mI6okRixU/f0TvDz+hEXWSonyzCE4QXx97hlC2dEYf\nKdCH5wYDpJ2HRVdBrBABTtaqF41xCYZyHVSof48PIyzA/AMnj3zsBFiV5JVaiSGh\nNTBWl0mBxg9yhrcJLvOh4pGJv81yAl+m+lAL6B0CgYEArtqtQ1YVLIUn4Pb/HDn8\nN8o7WbhloWQnG34iSsAG8yNtzbbxdugFrEm5ejPSgZ+dbzSzi/hizOFS/+/fwEdl\nay9jqY1fngoqSrS8eddUsY1/WAcmd6wPWEamsSjazA4uxQERruuFOi94E4b895KA\nqYe0A3xb0JL2ieAOZsn8XNA=\n-----END PRIVATE KEY-----\n",
        "client_email": "test@example.com",
        "client_id": "1",
        "auth_uri": "https://example.com",
        "token_uri": "https://example.com",
        "auth_provider_x509_cert_url": "https://example.com",
        "client_x509_cert_url": "https://example.com",
        "universe_domain": "example.com"
      }

    },
  },
  auth: {
    // Override the facebook provider
    custom: mockCustom(),
    facebook: mockFacebook(),
    myoauth: {
      module: path.resolve(__dirname, 'support/myoauth'), // relative path as it's run from src
    },
    shortLivedAuth: mockShortLivedAuth(),
  },
  allowClientClassCreation: true,
};

if (silent) {
  defaultConfiguration.logLevels = {
    cloudFunctionSuccess: 'silent',
    cloudFunctionError: 'silent',
    triggerAfter: 'silent',
    triggerBeforeError: 'silent',
    triggerBeforeSuccess: 'silent',
  };
}

// Set up a default API server for testing with default configuration.
let parseServer;
let didChangeConfiguration = false;
const openConnections = new Connections();

const shutdownServer = async (_parseServer) => {
  await _parseServer.handleShutdown();
  // Connection close events are not immediate on node 10+, so wait a bit
  await sleep(0);
  expect(openConnections.count() > 0).toBeFalsy(`There were ${openConnections.count()} open connections to the server left after the test finished`);
  parseServer = undefined;
};

// Allows testing specific configurations of Parse Server
const reconfigureServer = async (changedConfiguration = {}) => {
  if (parseServer) {
    await shutdownServer(parseServer);
    return reconfigureServer(changedConfiguration);
  }
  didChangeConfiguration = Object.keys(changedConfiguration).length !== 0;
  databaseAdapter = new databaseAdapter.constructor({
    uri: databaseURI,
    collectionPrefix: 'test_',
  });
  defaultConfiguration.databaseAdapter = databaseAdapter;
  global.databaseAdapter = databaseAdapter;
  if (filesAdapter instanceof GridFSBucketAdapter) {
    defaultConfiguration.filesAdapter = new GridFSBucketAdapter(mongoURI);
  }
  if (process.env.PARSE_SERVER_TEST_CACHE === 'redis') {
    defaultConfiguration.cacheAdapter = new RedisCacheAdapter();
  }
  const newConfiguration = Object.assign({}, defaultConfiguration, changedConfiguration, {
    mountPath: '/1',
    port,
  });
  cache.clear();
  parseServer = await ParseServer.startApp(newConfiguration);
  Parse.CoreManager.setRESTController(RESTController);
  parseServer.expressApp.use('/1', err => {
    console.error(err);
    fail('should not call next');
  });
  openConnections.track(parseServer.server);
  if (parseServer.liveQueryServer?.server && parseServer.liveQueryServer.server !== parseServer.server) {
    openConnections.track(parseServer.liveQueryServer.server);
  }
  return parseServer;
};

beforeAll(async () => {
  global.restoreFetch();
  await reconfigureServer();
  Parse.initialize('test', 'test', 'test');
  Parse.serverURL = serverURL;
  Parse.User.enableUnsafeCurrentUser();
  Parse.CoreManager.set('REQUEST_ATTEMPT_LIMIT', 1);
});

beforeEach(async () => {
  if(fetchWasMocked) {
    global.restoreFetch();
  }
});

global.afterEachFn = async () => {
  // Restore fetch to prevent mock pollution between tests (only if it was mocked)
  if (fetchWasMocked) {
    global.restoreFetch();
  }

  Parse.Cloud._removeAllHooks();
  Parse.CoreManager.getLiveQueryController().setDefaultLiveQueryClient();
  defaults.protectedFields = { _User: { '*': ['email'] } };

  const allSchemas = await databaseAdapter.getAllClasses().catch(() => []);

  allSchemas.forEach(schema => {
    const className = schema.className;
    expect(className).toEqual({
      asymmetricMatch: className => {
        if (!className.startsWith('_')) {
          return true;
        }
        return [
          '_User',
          '_Installation',
          '_Role',
          '_Session',
          '_Product',
          '_Audience',
          '_Idempotency',
        ].includes(className);
      },
    });
  });
  await Parse.User.logOut().catch(() => {});
  await TestUtils.destroyAllDataPermanently(true);
  SchemaCache.clear();

  if (didChangeConfiguration) {
    await reconfigureServer();
  } else {
    await databaseAdapter.performInitialization({ VolatileClassesSchemas });
  }
}
afterEach(global.afterEachFn);

afterAll(() => {
  global.restoreFetch();
  global.displayTestStats();
});

const TestObject = Parse.Object.extend({
  className: 'TestObject',
});
const Item = Parse.Object.extend({
  className: 'Item',
});
const Container = Parse.Object.extend({
  className: 'Container',
});

// Convenience method to create a new TestObject with a callback
function create(options, callback) {
  const t = new TestObject(options);
  return t.save().then(callback);
}

function createTestUser() {
  const user = new Parse.User();
  user.set('username', 'test');
  user.set('password', 'moon-y');
  return user.signUp();
}

// Shims for compatibility with the old qunit tests.
function ok(bool, message) {
  expect(bool).toBeTruthy(message);
}
function equal(a, b, message) {
  expect(a).toEqual(b, message);
}
function strictEqual(a, b, message) {
  expect(a).toBe(b, message);
}
function notEqual(a, b, message) {
  expect(a).not.toEqual(b, message);
}

// Because node doesn't have Parse._.contains
function arrayContains(arr, item) {
  return -1 != arr.indexOf(item);
}

// Normalizes a JSON object.
function normalize(obj) {
  if (obj === null || typeof obj !== 'object') {
    return JSON.stringify(obj);
  }
  if (obj instanceof Array) {
    return '[' + obj.map(normalize).join(', ') + ']';
  }
  let answer = '{';
  for (const key of Object.keys(obj).sort()) {
    answer += key + ': ';
    answer += normalize(obj[key]);
    answer += ', ';
  }
  answer += '}';
  return answer;
}

// Asserts two json structures are equal.
function jequal(o1, o2) {
  expect(normalize(o1)).toEqual(normalize(o2));
}

function range(n) {
  const answer = [];
  for (let i = 0; i < n; i++) {
    answer.push(i);
  }
  return answer;
}

function mockCustomAuthenticator(id, password) {
  const custom = {};
  custom.validateAuthData = function (authData) {
    if (authData.id === id && authData.password.startsWith(password)) {
      return Promise.resolve();
    }
    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'not validated');
  };
  custom.validateAppId = function () {
    return Promise.resolve();
  };
  return custom;
}

function mockCustom() {
  return mockCustomAuthenticator('fastrde', 'password');
}

function mockFacebookAuthenticator(id, token) {
  const facebook = {};
  facebook.validateAuthData = function (authData) {
    if (authData.id === id && authData.access_token.startsWith(token)) {
      return Promise.resolve();
    } else {
      throw undefined;
    }
  };
  facebook.validateAppId = function (appId, authData) {
    if (authData.access_token.startsWith(token)) {
      return Promise.resolve();
    } else {
      throw undefined;
    }
  };
  return facebook;
}

function mockFacebook() {
  return mockFacebookAuthenticator('8675309', 'jenny');
}

function mockShortLivedAuth() {
  const auth = {};
  let accessToken;
  auth.setValidAccessToken = function (validAccessToken) {
    accessToken = validAccessToken;
  };
  auth.validateAuthData = function (authData) {
    if (authData.access_token == accessToken) {
      return Promise.resolve();
    } else {
      return Promise.reject('Invalid access token');
    }
  };
  auth.validateAppId = function () {
    return Promise.resolve();
  };
  return auth;
}

function mockFetch(mockResponses) {
  const spy = jasmine.createSpy('fetch');
  fetchWasMocked = true; // Track that fetch was mocked for cleanup

  global.fetch = (url, options = {}) => {
    // Allow requests to the Parse Server to pass through WITHOUT recording in spy
    // This prevents tests from failing when they check that fetch wasn't called
    // but the Parse SDK makes internal requests to the Parse Server
    if (typeof url === 'string' && url.includes(serverURL)) {
      return originalFetch(url, options);
    }

    // Record non-Parse-Server calls in the spy
    spy(url, options);

    options.method ||= 'GET';
    const mockResponse = mockResponses?.find(
      (mock) => mock.url === url && mock.method === options.method
    );

    if (mockResponse) {
      return Promise.resolve(mockResponse.response);
    }

    return Promise.resolve({
      ok: false,
      statusText: 'Unknown URL or method',
    });
  };

  // Expose spy methods for test assertions
  global.fetch.calls = spy.calls;
  global.fetch.and = spy.and;
}


// This is polluting, but, it makes it way easier to directly port old tests.
global.Parse = Parse;
global.TestObject = TestObject;
global.Item = Item;
global.Container = Container;
global.create = create;
global.createTestUser = createTestUser;
global.ok = ok;
global.equal = equal;
global.strictEqual = strictEqual;
global.notEqual = notEqual;
global.arrayContains = arrayContains;
global.jequal = jequal;
global.range = range;
global.reconfigureServer = reconfigureServer;
global.mockFetch = mockFetch;
global.defaultConfiguration = defaultConfiguration;
global.mockCustomAuthenticator = mockCustomAuthenticator;
global.mockFacebookAuthenticator = mockFacebookAuthenticator;
global.databaseAdapter = databaseAdapter;
global.databaseURI = databaseURI;
global.shutdownServer = shutdownServer;
global.jfail = function (err) {
  fail(JSON.stringify(err));
};

global.it_exclude_dbs = excluded => {
  if (excluded.indexOf(process.env.PARSE_SERVER_TEST_DB) >= 0) {
    return xit;
  } else {
    return it;
  }
};

let testExclusionList = [];
try {
  // Fetch test exclusion list
  testExclusionList = require('./testExclusionList.json');
  console.log(`Using test exclusion list with ${testExclusionList.length} entries`);
} catch (error) {
  if (error.code !== 'MODULE_NOT_FOUND') {
    throw error;
  }
}

/**
 * Assign ID to test and run it. Disable test if its UUID is found in testExclusionList.
 * @param {String} id The UUID of the test.
 */
global.it_id = id => {
  return testFunc => {
    if (testExclusionList.includes(id)) {
      return xit;
    } else {
      return testFunc;
    }
  };
};

global.it_only_db = db => {
  if (
    process.env.PARSE_SERVER_TEST_DB === db ||
    (!process.env.PARSE_SERVER_TEST_DB && db == 'mongo')
  ) {
    return it;
  } else {
    return xit;
  }
};

global.fit_only_db = db => {
  if (
    process.env.PARSE_SERVER_TEST_DB === db ||
    (!process.env.PARSE_SERVER_TEST_DB && db == 'mongo')
  ) {
    return fit;
  } else {
    return xit;
  }
};

global.it_only_mongodb_version = version => {
  if (!semver.validRange(version)) {
    throw new Error('Invalid version range');
  }
  const envVersion = process.env.MONGODB_VERSION;
  if (!envVersion || semver.satisfies(envVersion, version)) {
    return it;
  } else {
    return xit;
  }
};

global.it_only_postgres_version = version => {
  if (!semver.validRange(version)) {
    throw new Error('Invalid version range');
  }
  const envVersion = process.env.POSTGRES_VERSION;
  if (!envVersion || semver.satisfies(envVersion, version)) {
    return it;
  } else {
    return xit;
  }
};

global.it_only_node_version = version => {
  if (!semver.validRange(version)) {
    throw new Error('Invalid version range');
  }
  const envVersion = process.version;
  if (!envVersion || semver.satisfies(envVersion, version)) {
    return it;
  } else {
    return xit;
  }
};

global.fit_only_mongodb_version = version => {
  if (!semver.validRange(version)) {
    throw new Error('Invalid version range');
  }
  const envVersion = process.env.MONGODB_VERSION;
  if (!envVersion || semver.satisfies(envVersion, version)) {
    return fit;
  } else {
    return xit;
  }
};

global.fit_only_postgres_version = version => {
  if (!semver.validRange(version)) {
    throw new Error('Invalid version range');
  }
  const envVersion = process.env.POSTGRES_VERSION;
  if (!envVersion || semver.satisfies(envVersion, version)) {
    return fit;
  } else {
    return xit;
  }
};

global.fit_only_node_version = version => {
  if (!semver.validRange(version)) {
    throw new Error('Invalid version range');
  }
  const envVersion = process.version;
  if (!envVersion || semver.satisfies(envVersion, version)) {
    return fit;
  } else {
    return xit;
  }
};

global.fit_exclude_dbs = excluded => {
  if (excluded.indexOf(process.env.PARSE_SERVER_TEST_DB) >= 0) {
    return xit;
  } else {
    return fit;
  }
};

global.describe_only_db = db => {
  if (process.env.PARSE_SERVER_TEST_DB == db) {
    return describe;
  } else if (!process.env.PARSE_SERVER_TEST_DB && db == 'mongo') {
    return describe;
  } else {
    return xdescribe;
  }
};

global.fdescribe_only_db = db => {
  if (process.env.PARSE_SERVER_TEST_DB == db) {
    return fdescribe;
  } else if (!process.env.PARSE_SERVER_TEST_DB && db == 'mongo') {
    return fdescribe;
  } else {
    return xdescribe;
  }
};

global.describe_only = validator => {
  if (validator()) {
    return describe;
  } else {
    return xdescribe;
  }
};

global.fdescribe_only = validator => {
  if (validator()) {
    return fdescribe;
  } else {
    return xdescribe;
  }
};

const libraryCache = {};
jasmine.mockLibrary = function (library, name, mock) {
  const original = require(library)[name];
  if (!libraryCache[library]) {
    libraryCache[library] = {};
  }
  require(library)[name] = mock;
  libraryCache[library][name] = original;
};

jasmine.restoreLibrary = function (library, name) {
  if (!libraryCache[library] || !libraryCache[library][name]) {
    throw 'Can not find library ' + library + ' ' + name;
  }
  require(library)[name] = libraryCache[library][name];
};

jasmine.timeout = (t = 100) => new Promise(resolve => setTimeout(resolve, t));