{
  "configs": [
    {
      "automock": false,
      "browser": false,
      "cache": true,
      "cacheDirectory": "/tmp/jest_rs",
      "clearMocks": false,
      "coveragePathIgnorePatterns": [
        "/node_modules/"
      ],
      "detectLeaks": false,
      "detectOpenHandles": false,
      "errorOnDeprecated": false,
      "filter": null,
      "forceCoverageMatch": [],
      "globals": {},
      "haste": {
        "providesModuleNodeModules": []
      },
      "moduleDirectories": [
        "node_modules"
      ],
      "moduleFileExtensions": [
        "js",
        "json",
        "jsx",
        "node"
      ],
      "moduleNameMapper": {},
      "modulePathIgnorePatterns": [],
      "name": "9f5155d702743ad8d949d6d219c1bc22",
      "prettierPath": null,
      "resetMocks": false,
      "resetModules": false,
      "resolver": null,
      "restoreMocks": false,
      "rootDir": "/home/mauricio/work/growthbond/gbnd1",
      "roots": [
        "/home/mauricio/work/growthbond/gbnd1"
      ],
      "runner": "jest-runner",
      "setupFiles": [
        "/home/mauricio/work/growthbond/gbnd1/node_modules/regenerator-runtime/runtime.js"
      ],
      "setupTestFrameworkScriptFile": "/home/mauricio/work/growthbond/gbnd1/testConfig/setupScript.js",
      "skipFilter": false,
      "snapshotSerializers": [],
      "testEnvironment": "/home/mauricio/work/growthbond/gbnd1/testConfig/mongo-environment.js",
      "testEnvironmentOptions": {},
      "testLocationInResults": false,
      "testMatch": [
        "**/__tests__/**/*.js?(x)",
        "**/?(*.)+(spec|test).js?(x)"
      ],
      "testPathIgnorePatterns": [
        "/node_modules/"
      ],
      "testRegex": "",
      "testRunner": "/home/mauricio/work/growthbond/gbnd1/node_modules/jest-jasmine2/build/index.js",
      "testURL": "http://localhost",
      "timers": "real",
      "transform": [
        [
          "^.+\.jsx?$",
          "/home/mauricio/work/growthbond/gbnd1/node_modules/babel-jest/build/index.js"
        ]
      ],
      "transformIgnorePatterns": [
        "/node_modules/"
      ],
      "watchPathIgnorePatterns": []
    }
  ],
  "globalConfig": {
    "bail": false,
    "changedFilesWithAncestor": false,
    "collectCoverage": false,
    "collectCoverageFrom": null,
    "coverageDirectory": "/home/mauricio/work/growthbond/gbnd1/coverage",
    "coverageReporters": [
      "json",
      "text",
      "lcov",
      "clover"
    ],
    "coverageThreshold": null,
    "detectLeaks": false,
    "detectOpenHandles": false,
    "errorOnDeprecated": false,
    "expand": false,
    "filter": null,
    "globalSetup": "/home/mauricio/work/growthbond/gbnd1/testConfig/setup.js",
    "globalTeardown": "/home/mauricio/work/growthbond/gbnd1/testConfig/teardown.js",
    "listTests": false,
    "maxWorkers": 3,
    "noStackTrace": false,
    "nonFlagArgs": [],
    "notify": false,
    "notifyMode": "always",
    "passWithNoTests": false,
    "projects": null,
    "rootDir": "/home/mauricio/work/growthbond/gbnd1",
    "runTestsByPath": false,
    "skipFilter": false,
    "testFailureExitCode": 1,
    "testPathPattern": "",
    "testResultsProcessor": null,
    "updateSnapshot": "new",
    "useStderr": false,
    "verbose": true,
    "watch": false,
    "watchman": true
  },
  "version": "23.6.0"
}

"testMatch": [
        "**/__tests__/**/*.js?(x)",
        "**/?(*.)+(spec|test).js?(x)"
      ],

module.exports = {
    globalSetup: './testConfig/setup.js',
    globalTeardown: './testConfig/teardown.js',
    testEnvironment: './testConfig/mongo-environment.js',
    setupTestFrameworkScriptFile: './testConfig/setupScript.js',
    verbose: true
}

const path = require('path');
const fs = require('fs');
const MongodbMemoryServer = require('mongodb-memory-server');
const globalConfigPath = path.join(__dirname, 'globalConfig.json');

const mongod = new MongodbMemoryServer.default({
  instance: {
    dbName: 'jest'
  },
  binary: {
    version: '3.2.18'
  },
  autoStart: false,
});

module.exports = async () => {
  if (!mongod.isRunning) {
    await mongod.start();
  }

  const mongoConfig = {
    mongoDBName: 'jest',
    mongoUri: await mongod.getConnectionString()
  };

  // Write global config to disk because all tests run in different contexts.
  fs.writeFileSync(globalConfigPath, JSON.stringify(mongoConfig));
  console.log('Config is written');

  // Set reference to mongod in order to close the server during teardown.
  global.__MONGOD__ = mongod;
  process.env.MONGO_URL = mongoConfig.mongoUri;
};

module.exports = async function() {
    await global.__MONGOD__.stop();
  };

const NodeEnvironment = require('jest-environment-node');
const path = require('path');
const fs = require('fs');
const globalConfigPath = path.join(__dirname, 'globalConfig.json');

module.exports = class MongoEnvironment extends NodeEnvironment {
  constructor(config) {
    super(config);
  }

  async setup() {
    console.log('Setup MongoDB Test Environment');

    const globalConfig = JSON.parse(fs.readFileSync(globalConfigPath, 'utf-8'));

    this.global.__MONGO_URI__ = globalConfig.mongoUri;
    this.global.__MONGO_DB_NAME__ = globalConfig.mongoDBName;

    await super.setup();
  }

  async teardown() {
    console.log('Teardown MongoDB Test Environment');

    await super.teardown();
  }

  runScript(script) {
    return super.runScript(script);
  }
};

const MongoClient= require('mongodb');
const User = require('../../db/models/user');
let connection;
let db;

beforeAll(async () => {
  connection = await MongoClient.connect(global.__MONGO_URI__);
  db = await connection.db(global.__MONGO_DB_NAME__);
});

afterAll(async () => {
  await connection.close();
  await db.close();
});


describe('Password Encription', async () => {

    const uEmail = 'test@a.com';
    const uPass = '123test';
    var testUser = new User({
        email:uEmail ,
        password: uPass
    });

    await testUser.save()

    test('Encripted password string is different to plain password', async () => {
      user = await User.findOne({ email: uEmail });
      expect(user.password).not.toEqual(uPass);
    });

    test('ComparePassword method verify that plain password is the same that encrypted password', async () => {
      rightPassword = await user.comparePassword(uPass);
      expect(rightPassword).toBeTrue();
    });

    test('ComparePassword method verify that altered plain password is not the same that encrypted password', async () => {
      wrongPassword = await user.comparePassword(uPass+'random');
      expect(rightPassword).not.toBeTrue();
    });


});

require('dotenv').config()
const authS = require('../../services/authService');
const jwt = require('jsonwebtoken');

describe('Auth Services',()=>{
    const payload = {test:'This is a test'}
    const user = {id:101}
    const mockSecret = 'SECRET123HAAJAHJSoafdafda'
    const token = authS.jwtSign(user,payload)
    test('JWT sign', () => {
        expect(authS.jwtSign(user,payload)).toBeString();
    });

    test('JWT verify different secret', ()=>{
        badToken = jwt.sign(
            payload,
            mockSecret,
            { subject:String(user.id),
              expiresIn:'1h'
            }
        );
        expect(()=>authS.jwtVerify(badToken)).toThrowError(jwt.JsonWebTokenError)
    })

    test('JWT verify payload', ()=>{
        expect(authS.jwtVerify(authS.jwtSign(user,payload))).toMatchObject(payload)
    })

})

globalSetup: './testConfig/setup.js',
globalTeardown: './testConfig/teardown.js',
testEnvironment: './testConfig/mongo-environment.js',