/*!
 * @license
 * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
 */

import { S3Client, S3ClientConfig } from '@aws-sdk/client-s3';
import { initIocContainer, iocContainer } from '../../../mocks/mockIoc';
import { S3RepositoryBase } from './S3RepositoryBase';

initIocContainer();

// Mock S3 Client
const mockOptions = {} as S3ClientConfig;
const mockClient = new S3Client(mockOptions);

const mockSend = jest.fn().mockResolvedValue({
  Body: { transformToString: jest.fn().mockResolvedValue('file') },
  $metadata: {},
});
mockClient.send = mockSend;

iocContainer.rebind<S3Client>(S3Client).toConstantValue(mockClient);

let s3Repository: S3RepositoryBase;

describe('S3RepositoryBase', (): void => {
  beforeAll((): void => {
    s3Repository = new S3RepositoryBase(mockClient, 'mock-bucket');
  });

  describe(`get`, (): void => {
    it(`should return a response for get`, async (): Promise<void> => {
      const mockKey = `mock`;
      mockSend.mockResolvedValueOnce({
        Body: { transformToString: jest.fn().mockResolvedValue('file') },
      });

      const response = await s3Repository.get(mockKey);
      expect(mockSend).toBeCalledTimes(1);
      expect(response).toStrictEqual('file');
    });

    it(`should return a null response if undefined`, async (): Promise<void> => {
      const mockKey = `mock`;
      const mockResponse = undefined;
      mockSend.mockResolvedValueOnce({
        Body: mockResponse,
      });

      const response = await s3Repository.get(mockKey);
      expect(mockSend).toBeCalledTimes(1);
      expect(response).toBeFalsy();
    });
  });

  describe(`put`, (): void => {
    it(`should return a response for get`, async (): Promise<void> => {
      const mockKey = `mock`;
      const mockObject = ``;
      mockSend.mockResolvedValueOnce({
        Body: { transformToString: jest.fn().mockResolvedValue(mockObject) },
      });

      const response = await s3Repository.put(mockKey, mockObject);
      expect(mockSend).toBeCalledTimes(1);
      expect(response).toBeFalsy();
    });
  });

  describe(`check`, (): void => {
    it(`should return a response if S3 object key exists`, async (): Promise<void> => {
      const mockKey = `mock`;
      mockSend.mockResolvedValueOnce({
        Body: {},
      });

      const response = await s3Repository.check(mockKey);
      expect(mockSend).toBeCalledTimes(1);
      expect(response).toBeTruthy();
    });
  });

  describe(`delete`, (): void => {
    it(`should delete the requested object`, async (): Promise<void> => {
      const mockKey = `mock`;
      const response = await s3Repository.delete(mockKey);
      expect(mockSend).toBeCalledTimes(1);
      expect(response).toBeFalsy();
    });
  });
});