/* tslint:disable: no-object-literal-type-assertion */
/**
 * DynamoGateway Unit Tests
 */
import * as AWS from "aws-sdk-mock";
import { DocumentClient } from "aws-sdk/lib/dynamodb/document_client";
import { expect } from "chai";
import { IDENTIFIERS } from "constant/Identifiers";
import { TABLE_RESOURCES } from "constant/Resources";
import { CONTAINER } from "infrastructure/Container";
import * as jsf from "json-schema-faker";
import mockerDataGenerator from "mocker-data-generator";
import * as path from "path";
import { IDynamoGateway } from "repository/IDynamoGateway";
import { createSandbox, SinonSandbox } from "sinon";
import { TransactionFetch } from "types/transaction_fetch";

const DYNAMO_DOC_CLIENT: string = "DynamoDB.DocumentClient";
let gateway: IDynamoGateway | undefined;
let gSandbox: SinonSandbox;
let gTransactionFetch: TransactionFetch;
let gScanOutput: { scanOutput: { Items: object[] }[] };

describe("DynamoGateway -", () => {
  beforeEach(async () => {
    gSandbox = createSandbox();
    gTransactionFetch = await jsf.resolve(
      {
        $ref: "transaction_fetch.json",
      },
      null,
      path.resolve("src/schema")
    );
    const item_data: object = {};
    const scan_output_schema: object = {
      Items: [
        {
          function: (): object => item_data,
          length: 10,
        },
      ],
    };

    gScanOutput = await mockerDataGenerator()
      .schema("scanOutput", scan_output_schema, 1)
      .build();
  });

  afterEach(() => {
    gSandbox.restore();
    AWS.restore(DYNAMO_DOC_CLIENT);
    gateway = undefined;
  });

  it("test put", (done: MochaDone) => {
    AWS.mock(
      DYNAMO_DOC_CLIENT,
      "put",
      (
        params: DocumentClient.PutItemInput,
        callback: (err: null, data: object) => void
      ) => {
        callback(null, params);
      }
    );
    gateway = CONTAINER.get<IDynamoGateway>(IDENTIFIERS.DynamoGateway);
    const put_data: object = { test: "hi!!", test2: "hello world" };

    gateway.put(put_data, "testTable").subscribe(
      (data: boolean) => {
        expect(data).to.be.true;
      },
      done,
      done
    );
  });

  it("test getItem", (done: MochaDone) => {
    AWS.mock(
      DYNAMO_DOC_CLIENT,
      "get",
      (
        _params: DocumentClient.GetItemOutput,
        callback: (err: null, data: object) => void
      ) => {
        callback(null, gTransactionFetch);
      }
    );
    gateway = CONTAINER.get<IDynamoGateway>(IDENTIFIERS.DynamoGateway);
    gateway.getItem("testTable", { key: "id" }).subscribe(
      () => {
        expect(gTransactionFetch).to.be.eql(gTransactionFetch);
      },
      done,
      done
    );
  });

  it("test query", (done: MochaDone) => {
    AWS.mock(
      "DynamoDB.DocumentClient",
      "query",
      (
        _params: DocumentClient.QueryInput,
        callback: (err: null, data: object) => void
      ) => {
        callback(null, gScanOutput.scanOutput[0]);
      }
    );
    let index: number = 0;

    gateway = CONTAINER.get<IDynamoGateway>(IDENTIFIERS.DynamoGateway);
    gateway
      .query({
        KeyConditionExpression: "id between :d and :e",
        IndexName: "ticketNumber-index",
        ExpressionAttributeValues: {
          ":d": "12345",
          ":e": "12345",
        },
        TableName: TABLE_RESOURCES.TransactionTable,
      })
      .subscribe(
        (data: object | undefined) => {
          expect(data).to.be.eq(gScanOutput.scanOutput[0]);
          index = index + 1;
        },
        done,
        () => {
          expect(index).to.be.eq(gScanOutput.scanOutput.length);
          done();
        }
      );
  });
});