How to use the aws-sdk-mock.mock function in aws-sdk-mock

// tslint:disable:no-expression-statement
import * as AWS from 'aws-sdk'
import * as mockAWS from 'aws-sdk-mock'

mockAWS.setSDKInstance(AWS)

mockAWS.mock('KMS', 'decrypt', (params: any, callback: any) => {
  const plain = params.CiphertextBlob.toString()

  return plain === 'mockError'
    ? callback(null, {})
    : callback(null, { Plaintext: plain })
})

mockAWS.mock(
  'KMS',
  'encrypt',
  ({ Plaintext: plaintext }: any, callback: any) => {
    return plaintext === 'mockError'
      ? callback(null, {})
      : callback(null, {
          CiphertextBlob: Buffer.from(plaintext),
        })
  },
)

const _mockSetting = () => {
  awsMock.mock('CloudWatchEvents', 'putRule', (params, callback) => {
    callback(null, {})
  })
  awsMock.mock('CloudWatchEvents', 'putTargets', (params, callback) => {
    callback(null, {})
  })
  awsMock.mock('CloudWatchLogs', 'createLogGroup', (params, callback) => {
    callback(null, {})
  })
  awsMock.mock('CloudWatchLogs', 'putRetentionPolicy', (params, callback) => {
    callback(null, {})
  })
  awsMock.mock('S3', 'putBucketNotificationConfiguration', (params, callback) => {
    callback(null, {})
  })
  awsMock.mock('S3', 'putObject', (params, callback) => {
    callback(null, { test: 'putObject' })
  })

  Object.keys(lambdaMockSettings).forEach((method) => {
    awsMock.mock('Lambda', method, (params, callback) => {
      callback(null, lambdaMockSettings[method])
    })
  })

  return require('aws-sdk')
}

beforeEach(() => {
      invokeMock = jest.fn();
      AWSMock.mock("Lambda", "invoke", invokeMock);

      itemListener = jest.fn();
      stopListener = jest.fn();
      endListener = jest.fn();
      startListener = jest.fn();
      event = {};
      context = {
        functionName: "blah",
        getRemainingTimeInMillis: () => 100000
      };
      callback = jest.fn();
    });

awsMock.mock('CloudWatchEvents', 'putRule', (params, callback) => {
    callback(null, {})
  })
  awsMock.mock('CloudWatchEvents', 'putTargets', (params, callback) => {
    callback(null, {})
  })
  awsMock.mock('CloudWatchLogs', 'createLogGroup', (params, callback) => {
    callback(null, {})
  })
  awsMock.mock('CloudWatchLogs', 'putRetentionPolicy', (params, callback) => {
    callback(null, {})
  })
  awsMock.mock('S3', 'putBucketNotificationConfiguration', (params, callback) => {
    callback(null, {})
  })
  awsMock.mock('S3', 'putObject', (params, callback) => {
    callback(null, { test: 'putObject' })
  })

  Object.keys(lambdaMockSettings).forEach((method) => {
    awsMock.mock('Lambda', method, (params, callback) => {
      callback(null, lambdaMockSettings[method])
    })
  })

  return require('aws-sdk')
}

it('returns data when its gets an endpoint', async () => {
    const data = {
      Endpoints: [{ Url: 'https://test.mediaconvert.eu-west-1.amazonaws.com' }],
    };

    AWS.mock('MediaConvert', 'describeEndpoints', callback =>
      callback(null, data),
    );

    const result = await lambda.MediaConvertEndPoint();
    expect(result.EndpointUrl).toEqual(
      'https://test.mediaconvert.eu-west-1.amazonaws.com',
    );
  });

it('should return "responseData" on mediapackage delete channel',async () => {

		AWS.mock('MediaPackage', 'listOriginEndpoints', Promise.resolve(data));
    AWS.mock('MediaPackage', 'deleteOriginEndpoint');
    AWS.mock('MediaPackage', 'deleteChannel');

    let response = await lambda.deleteChannel(ChannelId)
    expect(response).to.equal('success');
	});

it('should return "responseData" when create input is successful', async () => {

		AWS.mock('MediaLive', 'createInput', Promise.resolve(input_data));
    AWS.mock('SSM', 'putParameter');

    let response = await lambda.createInput(pull_config)
    expect(response.Id).to.equal('2468');
	});

it('should fail when createJob throws an exception', async () => {
        AWS.mock('MediaConvert', 'getJobTemplate', Promise.resolve(tmpl));
        AWS.mock('MediaConvert', 'createJob', Promise.reject('JOB ERROR'));
        AWS.mock('Lambda', 'invoke', Promise.resolve());

        await lambda.handler(_event).catch(err => {
            expect(err).to.equal('JOB ERROR');
        });
    });
});

activate = () => {
    AWSMock.mock('S3', 'getObject', this.getObject)
    AWSMock.mock('S3', 'listObjectsV2', this.listObjectsV2)
    AWSMock.mock('S3', 'putObject', this.putObject)
    AWSMock.mock('S3', 'deleteObject', this.deleteObject)
    return this
  }

},
                    Version: '2'
                }
            };
            callback(null, result);
        });

        AWS.mock('Glue', 'getTables', function(params, callback) {
            callback(null, listGlueTables);
        });

        AWS.mock('Glue', 'updateCrawler', function (params, callback) {
            callback(null, {});
        });

        AWS.mock('Glue', 'startCrawler', function(params, callback) {
            callback(null, {});
        });

        AWS.mock('Glue', 'createCrawler', function(params, callback) {
            callback(null, {});
        });

        AWS.mock('Athena', 'startQueryExecution', function(params, callback) {
            callback(null, { QueryExecutionId: 'QueryExecutionId'});
        });
    });