// @ts-nocheck

import { expect } from 'chai';
import * as sinon from 'sinon';

import { Session } from '../../src/session';
import { TestConfiguration } from '../../src/configuration';

describe('Session SDK', () => {
	const mockUserId = '0000-0000-0000-0000';
	const mockToken = 'XXXX.XXXX.XXXX.XXXX';
	const mockSessionInfo = {
			creationTime: '1575555032068',
			mfa: false,
			rememberMe: true,
			uuid: 'mock-user-id'
	};

	let sandbox;
	let instance;
	let config;

	beforeEach(() => {
		sandbox = sinon.createSandbox();
		config = new TestConfiguration({
			sessionApiKey: 'secret',
			originSystemId: 'n-membership-sdk test',
		});
		instance = new Session(config);
		sandbox.stub(instance, 'requestPost').resolves(mockToken);
		sandbox.stub(instance, 'requestGet').resolves(mockSessionInfo);
	});

	afterEach(() => {
		sandbox.restore();
	});

	it('requires host and key configuration properties', () => {
		try {
			new Session({});
			expect.fail('It should throw');
		} catch (error) { }
	});

	describe('createSessionToken', () => {

		it('passes correct parameters to requestPost', async () => {
			await instance.createSessionToken(mockUserId);
			const postParams = instance.requestPost.getCall(0).args[0];

			// Path checks
			expect(postParams).to.have.property('url');
			expect(postParams.url).to.equal('https://sessionapi-test.memb.ft.com/membership/sessions');

			// Body checks
			expect(postParams).to.have.property('body');
			expect(postParams.body).to.have.property('creationTime');
			expect(postParams.body.mfa).to.equal('false');
			expect(postParams.body.rememberMe).to.equal('true');
			expect(postParams.body.uuid).to.equal(mockUserId);
		});

		context('when an error is thrown', () => {
			const errorResponse = new Error('Test failure');
			beforeEach(() => {
				instance.requestPost.rejects(errorResponse);
			});

			it('throws an error', async () => {
				await expect(instance.createSessionToken(mockUserId)).to.be.rejectedWith('Test failure');
			});

		});

		it('creates the session token', async () => {
			const actualToken = await instance.createSessionToken(mockUserId);

			// Response checks
			expect(actualToken).to.equal(mockToken);
		});
	});

	describe('createSecureSessionToken', () => {

		it('passes correct parameters to requestPost', async () => {
			await instance.createSecureSessionToken(mockUserId);
			const postParams = instance.requestPost.getCall(0).args[0];

			// Path checks
			expect(postParams).to.have.property('url');
			expect(postParams.url).to.equal('https://sessionapi-test.memb.ft.com/membership/sessions/s');

			// Body checks
			expect(postParams).to.have.property('body');
			expect(postParams.body).to.have.property('creationTime');
			expect(postParams.body.mfa).to.equal('false');
			expect(postParams.body.rememberMe).to.equal('true');
			expect(postParams.body.uuid).to.equal(mockUserId);
		});

		context('when an error is thrown', () => {
			const errorResponse = new Error('Test failure');
			beforeEach(() => {
				instance.requestPost.rejects(errorResponse);
			});

			it('throws an error', async () => {
				await expect(instance.createSecureSessionToken(mockUserId)).to.be.rejectedWith('Test failure');
			});

		});

		it('creates the session token', async () => {
			const actualToken = await instance.createSecureSessionToken(mockUserId);

			// Response checks
			expect(actualToken).to.equal(mockToken);
		});
	});

	describe('fetchSessionInfo', () =>{
		it('should pass correct parameters to requestGet', async () => {
			const url = 'https://api-t.ft.com/sessions/s/mock-session-id';

			await instance.fetchSessionInfo('mock-session-id');
			const getParams = instance.requestGet.getCall(0).args[0];

			// Path checks
			expect(getParams).to.have.property('url');
			expect(getParams.url).to.equal(url);
		});
	
		it('responds with expected reply', async () => {
			const details = await instance.fetchSessionInfo('mock-session-id');

			expect(details.creationTime).to.equal('1575555032068');
			expect(details.mfa).to.equal(false);
			expect(details.rememberMe).to.equal(true);
			expect(details.uuid).to.equal('mock-user-id');
		});

	});
});