"use strict";

function _fsExtra() {
  const data = _interopRequireDefault(require("fs-extra"));

  _fsExtra = function () {
    return data;
  };

  return data;
}

function _path() {
  const data = _interopRequireDefault(require("path"));

  _path = function () {
    return data;
  };

  return data;
}

function _hashids() {
  const data = _interopRequireDefault(require("hashids"));

  _hashids = function () {
    return data;
  };

  return data;
}

function _uuid() {
  const data = _interopRequireDefault(require("uuid"));

  _uuid = function () {
    return data;
  };

  return data;
}

function _ApiV() {
  const data = _interopRequireDefault(require("../ApiV2"));

  _ApiV = function () {
    return data;
  };

  return data;
}

function _Api() {
  const data = _interopRequireDefault(require("../Api"));

  _Api = function () {
    return data;
  };

  return data;
}

function _User() {
  const data = require("../User");

  _User = function () {
    return data;
  };

  return data;
}

function _UserSettings() {
  const data = _interopRequireDefault(require("../UserSettings"));

  _UserSettings = function () {
    return data;
  };

  return data;
}

function _FormData() {
  const data = _interopRequireDefault(require("../tools/FormData"));

  _FormData = function () {
    return data;
  };

  return data;
}

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const _makeShortId = (salt, minLength = 10) => {
  const hashIds = new (_hashids().default)(salt, minLength);
  return hashIds.encode(Date.now());
};

describe('User Sessions', () => {
  let userForTest;
  let userForTestPassword;
  beforeAll(async () => {
    process.env.__UNSAFE_EXPO_HOME_DIRECTORY = _path().default.join('/', 'tmp', `.expo-${_makeShortId(_uuid().default.v1())}`);

    const UserManager = _newTestUserManager();

    const username = `xdl-test-${_makeShortId(_uuid().default.v1())}`;

    const password = _uuid().default.v1(); // Register a new user that we can use for this test run


    const newUser = await UserManager.registerAsync({
      username,
      password,
      email: `adam+${username}@getexponent.com`,
      givenName: 'XDL',
      familyName: 'Test User'
    });
    userForTest = newUser;
    userForTestPassword = password; // save password so we can use it to login

    await UserManager.logoutAsync(); // log us out so we're in a clean state for these tests
  });
  afterAll(async () => {
    if (process.env.__UNSAFE_EXPO_HOME_DIRECTORY) {
      _fsExtra().default.removeSync(process.env.__UNSAFE_EXPO_HOME_DIRECTORY);
    }

    const api = _ApiV().default.clientForUser(userForTest);

    try {
      await api.postAsync('auth/deleteUser');
    } catch (e) {
      console.error(e);
    }
  });
  it('should login successfully, and persist a session token upon login', async () => {
    const UserManager = _newTestUserManager();

    await UserManager.loginAsync('user-pass', {
      username: userForTest.username,
      password: userForTestPassword,
      testSession: true
    });
    const user = await UserManager.getCurrentUserAsync();
    expect(user).not.toBeNull();

    if (!user) {
      return;
    } // expect session to be cached


    expect(user.username).toBe(userForTest.username);
    expect(user.sessionSecret).not.toBe(undefined); // expect session to be in state.json

    let {
      sessionSecret
    } = await _UserSettings().default.getAsync('auth', {});
    expect(sessionSecret).not.toBe(undefined);
  });
  it('should remove a session token upon logout', async () => {
    const UserManager = _newTestUserManager();

    await UserManager.loginAsync('user-pass', {
      username: userForTest.username,
      password: userForTestPassword
    });
    await UserManager.logoutAsync(); // expect session to be removed

    let {
      sessionSecret
    } = await _UserSettings().default.getAsync('auth', {});
    expect(sessionSecret).toBe(undefined);
  });
  it('should use the token in apiv1', async () => {
    const UserManager = _newTestUserManager();

    await UserManager.loginAsync('user-pass', {
      username: userForTest.username,
      password: userForTestPassword
    });
    let formData = new (_FormData().default)();
    formData.append('queryType', 'history');
    formData.append('slug', 'foobar');
    let response = await _Api().default.callMethodAsync('publishInfo', [], 'post', null, {
      formData
    }, true);
    expect(response.status).toBe(200);
  });
  it('should use the token in apiv2', async () => {
    const UserManager = _newTestUserManager();

    await UserManager.loginAsync('user-pass', {
      username: userForTest.username,
      password: userForTestPassword
    });
    const user = await UserManager.getCurrentUserAsync();

    const api = _ApiV().default.clientForUser(user);

    const response = await api.getAsync('auth/intercomUserHash', {}, {}, true);
    expect(response.status).toBe(200);
  });
});

function _newTestUserManager() {
  const UserManager = new (_User().UserManagerInstance)();
  UserManager.initialize();
  return UserManager;
}
//# sourceMappingURL=../__sourcemaps__/__integration_tests__/UserSessions-test.js.map