/* tslint:disable:no-multiline-string*/
/**
 * PseGateway test unit file
 */
import { KushkiError } from "@kushki/core";
import { expect, use } from "chai";
import { IDENTIFIERS } from "constant/Identifiers";
import * as faker from "faker";
import { CONTAINER } from "infrastructure/Container";
import { ProcessorTypeEnum } from "infrastructure/ProcessorTypeEnum";
import { PseErrorEnum } from "infrastructure/PseErrorEnum";
import * as jsf from "json-schema-faker";
import * as path from "path";
import { ILambdaGateway } from "repository/ILambdaGateway";
import { IPseGateway } from "repository/IPseGateway";
import { of, throwError } from "rxjs";
import { createSandbox, SinonSandbox, SinonStub } from "sinon";
import * as sinonChai from "sinon-chai";
import * as soap from "soap";
import { Mock } from "ts-mockery";
import { PseCreateTransaction } from "types/pse_create_transaction";
import { PseCreateTransactionRequest } from "types/pse_create_transaction_request";
import { PseFinalizeTransaction } from "types/pse_finalize_transaction";
import { PseGetBankList } from "types/pse_get_bank_list";
import { PseGetTransactionInformationRequest } from "types/pse_get_transaction_information_request";
import { PseGetTransactionInformationResponse } from "types/pse_get_transaction_information_response";

use(sinonChai);

let gateway: IPseGateway;
let gPseGetBankList: PseGetBankList;
let gPseCreateTransactionRequest: PseCreateTransactionRequest;
let gPseCreateTransactionResponse: PseCreateTransaction;
let gGetTransactionInfoRequest: PseGetTransactionInformationRequest;
let gGetTransactionInfoResponse: PseGetTransactionInformationResponse;
let gFinalizeTransaction: PseFinalizeTransaction;
let gSandbox: SinonSandbox;
let gMethodStub: SinonStub;
const SCHEMA_PATH: string = "src/schema";
const ERROR_MESSAGE: string = "this must throw an error";
const XML: string = `<?xml version='1.0' encoding='UTF-8'?>
<dataset>
<record>
<id>1</id><first_name>Holli</first_name><last_name>Weich</last_name><email>hweich0@oakley.com</email><gender>Female</gender>
<ip_address>131.241.254.201</ip_address></record><record>
<id>2</id><first_name>Marchall</first_name><last_name>Easdon</last_name><email>measdon1@studiopress.com</email><gender>Male</gender>
<ip_address>198.209.110.0</ip_address></record><record>
<id>3</id><first_name>Susannah</first_name><last_name>Janodet</last_name><email>sjanodet2@free.fr</email><gender>Female</gender>
<ip_address>244.176.41.51</ip_address></record><record>
<id>4</id><first_name>El</first_name><last_name>Harwick</last_name><email>eharwick3@paypal.com</email><gender>Male</gender><ip_address>31.54.251.93</ip_address>
</record>
</dataset>`;

describe("Pse Gateway", () => {
  beforeEach(async () => {
    CONTAINER.snapshot();
    process.env.PSE_STAGE = "test";
    gPseCreateTransactionResponse = await jsf.resolve(
      {
        $ref: "pse_create_transaction.json",
      },
      null,
      path.resolve(SCHEMA_PATH)
    );
    gPseCreateTransactionRequest = await jsf.resolve(
      {
        $ref: "pse_create_transaction_request.json",
      },
      null,
      path.resolve(SCHEMA_PATH)
    );
    gGetTransactionInfoRequest = await jsf.resolve(
      {
        $ref: "pse_get_transaction_information_request.json",
      },
      null,
      path.resolve(SCHEMA_PATH)
    );
    gGetTransactionInfoResponse = await jsf.resolve(
      {
        $ref: "pse_get_transaction_information_response.json",
      },
      null,
      path.resolve(SCHEMA_PATH)
    );
    gFinalizeTransaction = await jsf.resolve(
      {
        $ref: "pse_finalize_transaction.json",
      },
      null,
      path.resolve(SCHEMA_PATH)
    );
    gSandbox = createSandbox();
    gMethodStub = gSandbox.stub();
  });
  afterEach(() => {
    gSandbox.restore();
    CONTAINER.restore();
  });
  it("test getTransactionInformation - successful response", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gGetTransactionInfoResponse.getTransactionInformationResponseBody.transactionState =
      "OK";
    gMethodStub.returns(of([gGetTransactionInfoResponse]));
    CONTAINER.unbind(IDENTIFIERS.LambdaGateway);
    CONTAINER.bind<ILambdaGateway>(IDENTIFIERS.LambdaGateway).toConstantValue(
      Mock.of<ILambdaGateway>({
        invokeFunction: gMethodStub,
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .getTransactionInformation(
        gGetTransactionInfoRequest,
        ProcessorTypeEnum.AGGREGATOR
      )
      .subscribe(
        (data: PseGetTransactionInformationResponse) => {
          expect(gGetTransactionInfoResponse).to.be.eql(data);
        },
        done,
        done
      );
  });
  it("test getTransactionInformation - fail", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gGetTransactionInfoResponse.getTransactionInformationResponseBody.transactionState =
      "OK";
    gMethodStub.returns(throwError("error"));
    CONTAINER.unbind(IDENTIFIERS.LambdaGateway);
    CONTAINER.bind<ILambdaGateway>(IDENTIFIERS.LambdaGateway).toConstantValue(
      Mock.of<ILambdaGateway>({
        invokeFunction: gMethodStub,
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .getTransactionInformation(
        gGetTransactionInfoRequest,
        ProcessorTypeEnum.GATEWAY
      )
      .subscribe(
        () => {
          done(ERROR_MESSAGE);
        },
        (error: KushkiError) => {
          expect(error.code).to.be.eq("T006");
          done();
        },
        done
      );
  });
  it("test finalizeTransactionPayment - successful response aggregator", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gFinalizeTransaction.finalizeTransactionPaymentResponseInformation.returnCode =
      "SUCCESS";
    gMethodStub.returns(of(gFinalizeTransaction));
    CONTAINER.unbind(IDENTIFIERS.LambdaGateway);
    CONTAINER.bind<ILambdaGateway>(IDENTIFIERS.LambdaGateway).toConstantValue(
      Mock.of<ILambdaGateway>({
        invokeFunction: gMethodStub,
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .finalizeTransactionPayment(
        { entityCode: "", trazabilityCode: "" },
        ProcessorTypeEnum.AGGREGATOR
      )
      .subscribe(
        (data: boolean) => {
          expect(data).to.be.true;
        },
        done,
        done
      );
  });
  it("test finalizeTransactionPayment - successful response gateway", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gFinalizeTransaction.finalizeTransactionPaymentResponseInformation.returnCode =
      "SUCCESS";
    gMethodStub.returns(of(gFinalizeTransaction));
    CONTAINER.unbind(IDENTIFIERS.LambdaGateway);
    CONTAINER.bind<ILambdaGateway>(IDENTIFIERS.LambdaGateway).toConstantValue(
      Mock.of<ILambdaGateway>({
        invokeFunction: gMethodStub,
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .finalizeTransactionPayment(
        { entityCode: "", trazabilityCode: "" },
        ProcessorTypeEnum.GATEWAY
      )
      .subscribe(
        (data: boolean) => {
          expect(data).to.be.true;
        },
        done,
        done
      );
  });
});
describe("Pse Gateway - call", () => {
  beforeEach(async () => {
    CONTAINER.snapshot();
    process.env.PSE_STAGE = "test";
    gFinalizeTransaction = await jsf.resolve(
      {
        $ref: "pse_finalize_transaction.json",
      },
      null,
      path.resolve(SCHEMA_PATH)
    );
    gSandbox = createSandbox();
    gMethodStub = gSandbox.stub();
  });
  afterEach(() => {
    gSandbox.restore();
    CONTAINER.restore();
  });
  it("test call - successful response gateway", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gSandbox.stub(soap, "createClientAsync").returns(
      Promise.resolve({
        setSecurity: gSandbox.stub(),
        on: gSandbox.stub().callsArgWith(1, XML),
        queryAsync: gSandbox.stub().returns(
          Promise.resolve({
            lorem: "ipsum",
          })
        ),
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .call("query", { lorem: "123" }, ProcessorTypeEnum.GATEWAY)
      .subscribe(
        (data: object) => {
          expect(data).to.have.property("lorem", "ipsum");
        },
        done,
        done
      );
  });
  it("test call - successful response aggregator", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gFinalizeTransaction.finalizeTransactionPaymentResponseInformation.returnCode =
      "SUCCESS";
    gSandbox.stub(soap, "createClientAsync").returns(
      Promise.resolve({
        setSecurity: gSandbox.stub(),
        on: gSandbox.stub().callsArgWith(1, XML),
        queryAsync: gSandbox.stub().returns(
          Promise.resolve({
            lorem: "ipsum",
          })
        ),
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .call("query", { lorem: "123" }, ProcessorTypeEnum.AGGREGATOR)
      .subscribe(
        (data: object) => {
          expect(data).to.have.property("lorem", "ipsum");
        },
        done,
        done
      );
  });
  it("test call - error response", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gSandbox.stub(soap, "createClientAsync").returns(
      Promise.resolve({
        setSecurity: gSandbox.stub(),
        on: gSandbox.stub().callsArgWith(1, XML),
        queryAsync: gSandbox.stub().returns(Promise.reject("error")),
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .call("query", { lorem: "123" }, ProcessorTypeEnum.AGGREGATOR)
      .subscribe(
        () => {
          done("next should not be called");
        },
        (error: KushkiError) => {
          expect(error.code).to.be.eq("T006");
          expect(error.getMessage()).to.be.eq(PseErrorEnum.FAIL);
          done();
        }
      );
  });
});
describe("Pse Gateway - CreateTransaction", () => {
  beforeEach(async () => {
    CONTAINER.snapshot();
    process.env.PSE_STAGE = "test";
    gPseCreateTransactionResponse = await jsf.resolve(
      {
        $ref: "pse_create_transaction.json",
      },
      null,
      path.resolve(SCHEMA_PATH)
    );
    gPseCreateTransactionRequest = await jsf.resolve(
      {
        $ref: "pse_create_transaction_request.json",
      },
      null,
      path.resolve(SCHEMA_PATH)
    );
    gSandbox = createSandbox();
    gMethodStub = gSandbox.stub();
  });
  afterEach(() => {
    gSandbox.restore();
    CONTAINER.restore();
  });
  it("test createTransaction - successful response", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gPseCreateTransactionResponse.createTransactionPaymentResponseInformation.returnCode =
      "SUCCESS";
    gMethodStub.returns(of([gPseCreateTransactionResponse]));
    CONTAINER.unbind(IDENTIFIERS.LambdaGateway);
    CONTAINER.bind<ILambdaGateway>(IDENTIFIERS.LambdaGateway).toConstantValue(
      Mock.of<ILambdaGateway>({
        invokeFunction: gMethodStub,
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .createTransactionRequest(
        gPseCreateTransactionRequest,
        ProcessorTypeEnum.AGGREGATOR
      )
      .subscribe(
        (data: PseCreateTransaction) => {
          expect(gPseCreateTransactionResponse).to.be.eql(data);
        },
        done,
        done
      );
  });
  it("test createTransaction - error response FAIL_ENTITYNOTEXISTSORDISABLED", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gPseCreateTransactionResponse.createTransactionPaymentResponseInformation.returnCode =
      "FAIL_ENTITYNOTEXISTSORDISABLED";
    gMethodStub.returns(of([gPseCreateTransactionResponse]));
    CONTAINER.unbind(IDENTIFIERS.LambdaGateway);
    CONTAINER.bind<ILambdaGateway>(IDENTIFIERS.LambdaGateway).toConstantValue(
      Mock.of<ILambdaGateway>({
        invokeFunction: gMethodStub,
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .createTransactionRequest(
        gPseCreateTransactionRequest,
        ProcessorTypeEnum.GATEWAY
      )
      .subscribe(
        () => {
          done(ERROR_MESSAGE);
        },
        (error: KushkiError) => {
          expect(error.code).to.be.eq("T006");
          expect(error.getMessage()).to.be.eq(
            PseErrorEnum.FAIL_ENTITYNOTEXISTSORDISABLED
          );
          done();
        },
        done
      );
  });
  it("test createTransaction - error response FAIL_EXCEEDEDLIMIT", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gPseCreateTransactionResponse.createTransactionPaymentResponseInformation.returnCode =
      "FAIL_EXCEEDEDLIMIT";
    gMethodStub.returns(of([gPseCreateTransactionResponse]));
    CONTAINER.unbind(IDENTIFIERS.LambdaGateway);
    CONTAINER.bind<ILambdaGateway>(IDENTIFIERS.LambdaGateway).toConstantValue(
      Mock.of<ILambdaGateway>({
        invokeFunction: gMethodStub,
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .createTransactionRequest(
        gPseCreateTransactionRequest,
        ProcessorTypeEnum.GATEWAY
      )
      .subscribe(
        () => {
          done(ERROR_MESSAGE);
        },
        (error: KushkiError) => {
          expect(error.code).to.be.eq("T006");
          expect(error.getMessage()).to.be.eq(PseErrorEnum.FAIL_EXCEEDEDLIMIT);
          done();
        },
        done
      );
  });
  it("test createTransaction - error response NOT_AUTHORIZED", (done: Mocha.Done) => {
    process.env.PSE_URL = "pse-url";
    gPseCreateTransactionResponse.createTransactionPaymentResponseInformation.returnCode =
      "SUCCESS";
    gPseCreateTransactionResponse.createTransactionPaymentResponseInformation.transactionState =
      "NOT_AUTHORIZED";
    gMethodStub.returns(of([gPseCreateTransactionResponse]));
    CONTAINER.unbind(IDENTIFIERS.LambdaGateway);
    CONTAINER.bind<ILambdaGateway>(IDENTIFIERS.LambdaGateway).toConstantValue(
      Mock.of<ILambdaGateway>({
        invokeFunction: gMethodStub,
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .createTransactionRequest(
        gPseCreateTransactionRequest,
        ProcessorTypeEnum.AGGREGATOR
      )
      .subscribe(
        () => {
          done(ERROR_MESSAGE);
        },
        (error: KushkiError) => {
          expect(error.code).to.be.eq("T006");
          expect(error.getMessage()).to.be.eq(PseErrorEnum.NOT_AUTHORIZED);
          done();
        },
        done
      );
  });
});
describe("Pse Gateway - BankList", () => {
  beforeEach(async () => {
    process.env.PSE_STAGE = "test";
    gPseGetBankList = await jsf.resolve(
      {
        $ref: "pse_get_bank_list.json",
      },
      null,
      path.resolve(SCHEMA_PATH)
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gSandbox = createSandbox();
    gMethodStub = gSandbox.stub();
  });
  afterEach(() => {
    gSandbox.restore();
  });
  it("test getBankList - successful response aggregator", (done: Mocha.Done) => {
    const entity_code: string = faker.random
      .number({ min: 100000, max: 999999 })
      .toString();

    process.env.PSE_URL = "pse-url";
    gMethodStub.returns(of([gPseGetBankList]));
    CONTAINER.unbind(IDENTIFIERS.LambdaGateway);
    CONTAINER.bind<ILambdaGateway>(IDENTIFIERS.LambdaGateway).toConstantValue(
      Mock.of<ILambdaGateway>({
        invokeFunction: gMethodStub,
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .getBankListRequest(entity_code, ProcessorTypeEnum.AGGREGATOR)
      .subscribe(
        (data: PseGetBankList) => {
          expect(gPseGetBankList).to.be.eql(data);
        },
        done,
        done
      );
  });
  it("test getBankList - successful response gateway", (done: Mocha.Done) => {
    const entity_code: string = faker.random
      .number({ min: 100000, max: 999999 })
      .toString();

    process.env.PSE_URL = "pse-url";
    gMethodStub.returns(of([gPseGetBankList]));
    CONTAINER.unbind(IDENTIFIERS.LambdaGateway);
    CONTAINER.bind<ILambdaGateway>(IDENTIFIERS.LambdaGateway).toConstantValue(
      Mock.of<ILambdaGateway>({
        invokeFunction: gMethodStub,
      })
    );
    gateway = CONTAINER.get<IPseGateway>(IDENTIFIERS.PseGateway);
    gateway
      .getBankListRequest(entity_code, ProcessorTypeEnum.GATEWAY)
      .subscribe(
        (data: PseGetBankList) => {
          expect(gPseGetBankList).to.be.eql(data);
        },
        done,
        done
      );
  });
});