// Copyright 2016 Google LLC

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

import * as promisify from '@google-cloud/promisify';

import * as assert from 'assert';

import {afterEach, before, beforeEach, describe, it} from 'mocha';

import * as proxyquire from 'proxyquire';

import * as pumpify from 'pumpify';

import * as sinon from 'sinon';

import {PassThrough, Writable, Duplex} from 'stream';

import {ServiceError} from 'google-gax';

import * as inst from '../src/instance';

import {ChunkTransformer} from '../src/chunktransformer.js';

import {Family} from '../src/family.js';

import {Mutation} from '../src/mutation.js';

import {Row} from '../src/row.js';

import * as tblTypes from '../src/table';

import {Bigtable, RequestOptions} from '../src';

import {EventEmitter} from 'events';

import {TableUtils} from '../src/utils/table';

import {ClientSideMetricsConfigManager} from '../src/client-side-metrics/metrics-config-manager';

import {OperationMetricsCollector} from '../src/client-side-metrics/operation-metrics-collector';

import {SinonSpy} from 'sinon';

import {TabularApiSurface} from '../src/tabular-api-surface';

import {GetRowsOptions} from '../src/table';

import {mutateInternal} from '../src/utils/mutateInternal';

const sandbox = sinon.createSandbox();

const noop = () => {};

let promisified = false;

const fakePromisify = Object.assign({}, promisify, {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

promisifyAll(klass: Function, options: any) {

if (klass.name !== 'Table') {

return;

}

promisified = true;

assert.deepStrictEqual(options.exclude, ['family', 'row']);

},

});

// eslint-disable-next-line @typescript-eslint/no-explicit-any

function createFake(klass: any) {

return class Fake extends klass {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

calledWith_: any[];

// eslint-disable-next-line @typescript-eslint/no-explicit-any

constructor(...args: any[]) {

super(...args);

this.calledWith_ = args;

}

};

}

class FakeMetricsCollector {

onOperationStart() {}

onOperationComplete() {}

onResponse() {}

onAttemptStart() {}

onAttemptComplete() {}

onMetadataReceived() {}

wrapRequest() {}

onStatusMetadataReceived() {}

onRowReachesUser() {}

}

class FakeMetricsConfigManager extends ClientSideMetricsConfigManager {

createOperation() {

return new FakeMetricsCollector() as unknown as OperationMetricsCollector;

}

}

const FakeFamily = createFake(Family);

FakeFamily.formatRule_ = sinon.spy(rule => rule);

const FakeRow = createFake(Row);

FakeRow.formatChunks_ = sinon.spy(chunks => {

return chunks;

});

const FakeChunkTransformer = createFake(ChunkTransformer);

FakeChunkTransformer.prototype._transform = function (

rows: Row[],

enc: {},

next: Function,

) {

rows.forEach(row => this.push(row));

next();

};

const FakeMutation = {

methods: Mutation.methods,

convertToBytes: sinon.spy(value => {

return value;

}),

convertFromBytes: sinon.spy(value => {

return value;

}),

parse: sinon.spy(value => {

return value;

}),

};

const FakeFilter = {

parse: sinon.spy(value => {

return value;

}),

createRange: () => {

return {};

},

};

function getTableMock(

createReadStreamInternal: (

table: TabularApiSurface,

singleRow: boolean,

opts?: GetRowsOptions,

) => PassThrough,

) {

const FakeGetRows = proxyquire('../src/utils/getRowsInternal.js', {

'./createReadStreamInternal': {

createReadStreamInternal: createReadStreamInternal,

},

});

const FakeMutateInternal = proxyquire('../src/utils/mutateInternal.js', {

'../row.js': {Row: FakeRow},

'../chunktransformer.js': {ChunkTransformer: FakeChunkTransformer},

'../filter.js': {Filter: FakeFilter},

'../mutation.js': {Mutation: FakeMutation},

pumpify,

}).mutateInternal;

const FakeTabularApiSurface = proxyquire('../src/tabular-api-surface.js', {

'@google-cloud/promisify': fakePromisify,

'./family.js': {Family: FakeFamily},

'./mutation.js': {Mutation: FakeMutation},

'./filter.js': {Filter: FakeFilter},

pumpify,

'./row.js': {Row: FakeRow},

'./chunktransformer.js': {ChunkTransformer: FakeChunkTransformer},

'./utils/createReadStreamInternal': {

createReadStreamInternal,

},

'./utils/mutateInternal': {

mutateInternal: FakeMutateInternal,

},

'./utils/getRowsInternal': {

getRowsInternal: FakeGetRows.getRowsInternal,

},

}).TabularApiSurface;

const Table = proxyquire('../src/table.js', {

'@google-cloud/promisify': fakePromisify,

'./family.js': {Family: FakeFamily},

'./mutation.js': {Mutation: FakeMutation},

'./row.js': {Row: FakeRow},

'./tabular-api-surface': {TabularApiSurface: FakeTabularApiSurface},

}).Table;

return Table;

}

describe('Bigtable/Table', () => {

const TABLE_ID = 'my-table';

let INSTANCE: inst.Instance;

let TABLE_NAME: string;

let Table: typeof tblTypes.Table;

// eslint-disable-next-line @typescript-eslint/no-explicit-any

let table: any;

before(() => {

const FakeCreateReadStreamInternal = proxyquire(

'../src/utils/createReadStreamInternal.js',

{

'../row.js': {Row: FakeRow},

'../chunktransformer.js': {ChunkTransformer: FakeChunkTransformer},

'../filter.js': {Filter: FakeFilter},

'../mutation.js': {Mutation: FakeMutation},

pumpify,

},

).createReadStreamInternal;

Table = getTableMock(FakeCreateReadStreamInternal);

});

beforeEach(() => {

INSTANCE = {

bigtable: {

_metricsConfigManager: new FakeMetricsConfigManager(

[],

) as ClientSideMetricsConfigManager,

} as Bigtable,

name: 'a/b/c/d',

} as inst.Instance;

TABLE_NAME = INSTANCE.name + '/tables/' + TABLE_ID;

table = new Table(INSTANCE, TABLE_ID);

});

afterEach(() => {

Object.keys(FakeMutation).forEach(spy => {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

if ((FakeMutation as any)[spy].reset) {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

(FakeMutation as any)[spy].resetHistory();

}

});

FakeFilter.parse.resetHistory();

sandbox.restore();

});

describe('instantiation', () => {

it('should promisify all the things', () => {

assert(promisified);

});

it('should localize Bigtable instance', () => {

assert.strictEqual(table.bigtable, INSTANCE.bigtable);

});

it('should localize Instance instance', () => {

assert.strictEqual(table.instance, INSTANCE);

});

it('should localize ID', () => {

assert.strictEqual(table.id, TABLE_ID);

});

it('should localize table name', () => {

assert.strictEqual(table.name, TABLE_NAME);

});

it('should leave full table name unaltered and localize the id from the name', () => {

const table = new Table(INSTANCE, TABLE_NAME);

assert.strictEqual(table.name, TABLE_NAME);

assert.strictEqual(table.id, TABLE_ID);

});

it('should throw if table id in wrong format', () => {

const id = `tables/${TABLE_ID}`;

assert.throws(() => {

new Table(INSTANCE, id);

}, Error);

});

});

describe('VIEWS', () => {

const views = {

unspecified: 0,

name: 1,

schema: 2,

replication: 3,

full: 4,

};

it('should export the table views', () => {

assert.deepStrictEqual(views, Table.VIEWS);

});

});

describe('formatName_', () => {

it('should format the table name to include the cluster name', () => {

const tableName = Table.formatName_(INSTANCE.name, TABLE_ID);

assert.strictEqual(tableName, TABLE_NAME);

});

it('should not re-format the table name', () => {

const tableName = Table.formatName_(INSTANCE.id, TABLE_NAME);

assert.strictEqual(tableName, TABLE_NAME);

});

});

describe('create', () => {

it('should call createTable from instance', done => {

const options = {};

table.instance.createTable = (

id: string,

options_: {},

callback: Function,

) => {

assert.strictEqual(id, table.id);

assert.strictEqual(options_, options);

callback(); // done()

};

table.create(options, done);

});

it('should not require options', done => {

table.instance.createTable = (

id: string,

options: {},

callback: Function,

) => {

assert.deepStrictEqual(options, {});

callback(); // done()

};

table.create(done);

});

});

describe('createBackup', () => {

const BACKUP_ID = 'backup-id';

const CONFIG = {a: 'b'};

const READY_CLUSTER_ID = 'cluster-id';

const REPLICATION_STATES = new Map();

REPLICATION_STATES.set('a', {replicationState: 'NOT_READY'});

REPLICATION_STATES.set(READY_CLUSTER_ID, {replicationState: 'READY'});

it('should throw if an id is not provided', () => {

assert.throws(() => {

table.createBackup();

}, /An id is required to create a backup\./);

});

it('should throw if a configuration object is not provided', () => {

assert.throws(() => {

table.createBackup(BACKUP_ID);

}, /A configuration object is required\./);

});

it('should get replication states', done => {

table.getReplicationStates = () => {

done();

};

table.createBackup(BACKUP_ID, CONFIG, assert.ifError);

});

it('should pass gaxOptions when getting replication states', done => {

const config = {gaxOptions: {}};

table.getReplicationStates = (gaxOptions: {}) => {

assert.strictEqual(gaxOptions, config.gaxOptions);

done();

};

table.createBackup(BACKUP_ID, config, assert.ifError);

});

it('should execute callback with error if getting replication states fails', done => {

const error = new Error('Error.');

table.getReplicationStates = (gaxOptions: {}, callback: Function) => {

callback(error);

};

table.createBackup(BACKUP_ID, CONFIG, (err: Error) => {

assert.strictEqual(err, error);

done();

});

});

it('should create a Cluster with the id of the first available cluster', done => {

table.instance.cluster = (id: string) => {

assert.strictEqual(id, READY_CLUSTER_ID);

setImmediate(done);

return {createBackup: () => {}};

};

table.getReplicationStates = (gaxOptions: {}, callback: Function) => {

callback(null, REPLICATION_STATES);

};

table.createBackup(BACKUP_ID, CONFIG, assert.ifError);

});

it('should accept READY_OPTIMIZING status', done => {

const readyClusterId = 'unique-cluster-id';

const replicationStates = new Map();

replicationStates.set('a', {replicationState: 'NOT_READY'});

replicationStates.set(readyClusterId, {

replicationState: 'READY_OPTIMIZING',

});

table.instance.cluster = (id: string) => {

assert.strictEqual(id, readyClusterId);

setImmediate(done);

return {createBackup: () => {}};

};

table.getReplicationStates = (gaxOptions: {}, callback: Function) => {

callback(null, replicationStates);

};

table.createBackup(BACKUP_ID, CONFIG, assert.ifError);

});

it('should return error if no clusters are available', done => {

const replicationStates = new Map();

replicationStates.set('a', {replicationState: 'NOT_READY'});

replicationStates.set('b', {replicationState: 'NOT_READY'});

table.getReplicationStates = (gaxOptions: {}, callback: Function) => {

callback(null, replicationStates);

};

table.createBackup(BACKUP_ID, CONFIG, (err: Error) => {

assert.strictEqual(

err.message,

'No ready clusters eligible for backup.',

);

done();

});

});

it('should correctly create a Backup from the Cluster', done => {

table.instance.cluster = () => {

return {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

createBackup: (id: string, config: any, callback: Function) => {

assert.strictEqual(id, BACKUP_ID);

assert.deepStrictEqual(config, {

table: table.name,

...CONFIG,

});

callback(); // done()

},

};

};

table.getReplicationStates = (gaxOptions: {}, callback: Function) => {

callback(null, REPLICATION_STATES);

};

table.createBackup(BACKUP_ID, CONFIG, done);

});

});

describe('createPrefixRange', () => {

it('should create a range from the prefix', () => {

assert.deepStrictEqual(Table.createPrefixRange('start'), {

start: 'start',

end: {

value: 'staru',

inclusive: false,

},

});

assert.deepStrictEqual(Table.createPrefixRange('X\xff'), {

start: 'X\xff',

end: {

value: 'Y',

inclusive: false,

},

});

assert.deepStrictEqual(Table.createPrefixRange('xoo\xff'), {

start: 'xoo\xff',

end: {

value: 'xop',

inclusive: false,

},

});

assert.deepStrictEqual(Table.createPrefixRange('a\xffb'), {

start: 'a\xffb',

end: {

value: 'a\xffc',

inclusive: false,

},

});

assert.deepStrictEqual(Table.createPrefixRange('com.google.'), {

start: 'com.google.',

end: {

value: 'com.google/',

inclusive: false,

},

});

});

it('should create an inclusive bound when the prefix is empty', () => {

assert.deepStrictEqual(Table.createPrefixRange('\xff'), {

start: '\xff',

end: {

value: '',

inclusive: true,

},

});

assert.deepStrictEqual(Table.createPrefixRange(''), {

start: '',

end: {

value: '',

inclusive: true,

},

});

});

});

describe('createFamily', () => {

const COLUMN_ID = 'my-column';

const FAMILY_ID = 'test-family';

it('should throw if a id is not provided', () => {

assert.throws(() => {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

(table as any).createFamily();

}, /An id is required to create a family\./);

});

it('should provide the proper request options', done => {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.strictEqual(config.client, 'BigtableTableAdminClient');

assert.strictEqual(config.method, 'modifyColumnFamilies');

assert.strictEqual(config.reqOpts.name, TABLE_NAME);

assert.deepStrictEqual(config.reqOpts.modifications, [

{

id: COLUMN_ID,

create: {},

},

]);

assert.strictEqual(config.gaxOpts, undefined);

done();

};

table.createFamily(COLUMN_ID, assert.ifError);

});

it('should accept gaxOptions', done => {

const gaxOptions = {};

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.strictEqual(config.gaxOpts, gaxOptions);

done();

};

table.createFamily(COLUMN_ID, {gaxOptions}, assert.ifError);

});

it('should respect the gc rule option', done => {

const rule = {

a: 'a',

b: 'b',

};

const convertedRule = {

c: 'c',

d: 'd',

};

const spy = (FakeFamily.formatRule_ = sinon.spy(() => {

return convertedRule;

}));

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

const modification = config.reqOpts.modifications[0];

assert.strictEqual(modification.create.gcRule, convertedRule);

assert.strictEqual(spy.callCount, 1);

// eslint-disable-next-line @typescript-eslint/no-explicit-any

assert.strictEqual((spy as any).getCall(0).args[0], rule);

done();

};

table.createFamily(COLUMN_ID, {rule}, assert.ifError);

});

it('should return an error to the callback', done => {

const error = new Error('err');

const response = {};

table.bigtable.request = (config: {}, callback: Function) => {

callback(error, response);

};

table.createFamily(

COLUMN_ID,

(err: Error, family: Family, apiResponse: {}) => {

assert.strictEqual(error, err);

assert.strictEqual(family, null);

assert.strictEqual(response, apiResponse);

done();

},

);

});

it('should return a Family object', done => {

const response = {

name: 'response-family-name',

};

const fakeFamily = {} as Family;

table.bigtable.request = (config: {}, callback: Function) => {

callback(null, response);

};

sandbox.stub(table, 'family').callsFake(id => {

assert.strictEqual(id, FAMILY_ID);

return fakeFamily;

});

table.createFamily(

FAMILY_ID,

(err: Error, family: Family, apiResponse: {}) => {

assert.ifError(err);

assert.strictEqual(family, fakeFamily);

assert.strictEqual(family.metadata, response);

assert.strictEqual(apiResponse, response);

done();

},

);

});

});

describe('createReadStream', () => {

it('should provide the proper request options', done => {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.strictEqual(config.client, 'BigtableClient');

assert.strictEqual(config.method, 'readRows');

assert.strictEqual(config.reqOpts.tableName, TABLE_NAME);

assert.strictEqual(config.reqOpts.appProfileId, undefined);

assert.deepStrictEqual(config.gaxOpts, {

otherArgs: {headers: {'bigtable-attempt': 0}},

});

done();

};

table.createReadStream();

});

it('should use an appProfileId', done => {

const bigtableInstance = table.bigtable;

bigtableInstance.appProfileId = 'app-profile-id-12345';

// eslint-disable-next-line @typescript-eslint/no-explicit-any

bigtableInstance.request = (config: any) => {

assert.strictEqual(

config.reqOpts.appProfileId,

bigtableInstance.appProfileId,

);

done();

};

table.createReadStream();

});

it('should abort request on end', done => {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = () => {

const requestStream = new PassThrough({

objectMode: true,

});

// eslint-disable-next-line @typescript-eslint/no-explicit-any

(requestStream as any).abort = () => {

done();

};

return requestStream;

};

table.createReadStream().end();

});

describe('options', () => {

it('should accept gaxOptions', done => {

const gaxOptions = {};

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.strictEqual(config.gaxOpts, gaxOptions);

done();

};

table.createReadStream({gaxOptions});

});

it('should retrieve a range of rows', done => {

const options = {

start: 'gwashington',

end: 'alincoln',

};

const fakeRange = {

start: 'a',

end: 'b',

};

const formatSpy = (FakeFilter.createRange = sinon.spy(() => {

return fakeRange;

}));

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.deepStrictEqual(config.reqOpts.rows.rowRanges[0], fakeRange);

assert.strictEqual(formatSpy.callCount, 1);

assert.deepStrictEqual(formatSpy.getCall(0).args, [

options.start,

options.end,

'Key',

]);

done();

};

table.createReadStream(options);

});

it('should retrieve multiple rows', done => {

const options = {

keys: ['gwashington', 'alincoln'],

};

const convertedKeys = ['a', 'b'];

const convertSpy = (FakeMutation.convertToBytes = sinon.spy(key => {

const keyIndex = options.keys.indexOf(key);

return convertedKeys[keyIndex];

}));

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.deepStrictEqual(config.reqOpts.rows.rowKeys, convertedKeys);

assert.strictEqual(convertSpy.callCount, 2);

assert.strictEqual(convertSpy.getCall(0).args[0], options.keys[0]);

assert.strictEqual(convertSpy.getCall(1).args[0], options.keys[1]);

done();

};

table.createReadStream(options);

});

it('should retrieve multiple ranges', done => {

const options = {

ranges: [

{

start: 'a',

end: 'b',

},

{

start: 'c',

end: 'd',

},

],

};

const fakeRanges = [

{

start: 'e',

end: 'f',

},

{

start: 'g',

end: 'h',

},

];

const formatSpy = (FakeFilter.createRange = sinon.spy(() => {

return fakeRanges[formatSpy.callCount - 1];

})) as sinon.SinonSpy;

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.deepStrictEqual(config.reqOpts.rows.rowRanges, fakeRanges);

assert.strictEqual(formatSpy.callCount, 2);

assert.deepStrictEqual(formatSpy.getCall(0).args, [

options.ranges[0].start,

options.ranges[0].end,

'Key',

]);

assert.deepStrictEqual(formatSpy.getCall(1).args, [

options.ranges[1].start,

options.ranges[1].end,

'Key',

]);

done();

};

table.createReadStream(options);

});

it('should parse a filter object', done => {

const options = {

filter: [{}],

};

const fakeFilter = {};

// eslint-disable-next-line @typescript-eslint/no-explicit-any

const parseSpy = ((FakeFilter as any).parse = sinon.spy(() => {

return fakeFilter;

}));

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.strictEqual(config.reqOpts.filter, fakeFilter);

assert.strictEqual(parseSpy.callCount, 1);

assert.strictEqual(

// eslint-disable-next-line @typescript-eslint/no-explicit-any

(parseSpy as any).getCall(0).args[0],

options.filter,

);

done();

};

table.createReadStream(options);

});

it('should allow setting a row limit', done => {

const options = {

limit: 10,

};

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.strictEqual(config.reqOpts.rowsLimit, options.limit);

done();

};

table.createReadStream(options);

});

it('should throw if ranges and start is set together', () => {

const options = {

ranges: [

{

start: 'a',

end: 'b',

},

{

start: 'c',

end: 'd',

},

],

start: 'a',

};

assert.throws(() => {

table.createReadStream(options, assert.ifError);

}, /start\/end should be used exclusively to ranges\/prefix\/prefixes\./);

});

it('should throw if ranges and end is set together', () => {

const options = {

ranges: [

{

start: 'a',

end: 'b',

},

{

start: 'c',

end: 'd',

},

],

end: 'a',

};

assert.throws(() => {

table.createReadStream(options, assert.ifError);

}, /start\/end should be used exclusively to ranges\/prefix\/prefixes\./);

});

it('should throw if ranges and prefix is set together', () => {

const options = {

ranges: [

{

start: 'a',

end: 'b',

},

{

start: 'c',

end: 'd',

},

],

prefix: 'a',

};

assert.throws(() => {

table.createReadStream(options, assert.ifError);

}, /prefix should be used exclusively to ranges\/start\/end\/prefixes\./);

});

it('should throw if ranges and prefixes is set together', () => {

const options = {

ranges: [

{

start: 'a',

end: 'b',

},

{

start: 'c',

end: 'd',

},

],

prefixes: [{prefix: 'a'}],

};

assert.throws(() => {

table.createReadStream(options, assert.ifError);

}, /prefixes should be used exclusively to ranges\/start\/end\/prefix\./);

});

it('should throw if prefix and start is set together', () => {

const options = {

start: 'a',

prefix: 'a',

};

assert.throws(() => {

table.createReadStream(options, assert.ifError);

}, /start\/end should be used exclusively to ranges\/prefix\/prefixes\./);

});

describe('prefixes', () => {

beforeEach(() => {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

(FakeFilter as any).createRange = noop;

});

afterEach(() => {

// eslint-disable-next-line @typescript-eslint/no-explicit-any

(TableUtils as any).createPrefixRange.restore();

});

it('should transform the prefix into a range', done => {

const fakeRange = {};

const fakePrefixRange = {

start: 'a',

end: 'b',

} as {} as tblTypes.PrefixRange;

const fakePrefix = 'abc';

const prefixSpy = sandbox

.stub(TableUtils, 'createPrefixRange')

.returns(fakePrefixRange);

const rangeSpy = sandbox

.stub(FakeFilter, 'createRange')

.returns(fakeRange);

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.strictEqual(prefixSpy.getCall(0).args[0], fakePrefix);

assert.deepStrictEqual(config.reqOpts.rows.rowRanges, [fakeRange]);

assert.deepStrictEqual(rangeSpy.getCall(0).args, [

fakePrefixRange.start,

fakePrefixRange.end,

'Key',

]);

done();

};

table.createReadStream({prefix: fakePrefix});

});

it('should accept multiple prefixes', done => {

const prefixes = ['abc', 'def'];

const prefixRanges = [

{start: 'abc', end: 'abd'},

{start: 'def', end: 'deg'},

] as {} as tblTypes.PrefixRange[];

const prefixSpy = sandbox

.stub(TableUtils, 'createPrefixRange')

.callsFake(() => {

const callIndex = prefixSpy.callCount - 1;

return prefixRanges[callIndex];

});

const ranges = [{}, {}];

const rangeSpy = sandbox

.stub(FakeFilter, 'createRange')

.callsFake(() => {

const callIndex = rangeSpy.callCount - 1;

return ranges[callIndex];

});

// eslint-disable-next-line @typescript-eslint/no-explicit-any

table.bigtable.request = (config: any) => {

assert.strictEqual(prefixSpy.callCount, 2);

prefixes.forEach((prefix, i) => {

const prefixRange = prefixRanges[i];

assert.deepStrictEqual(prefixSpy.getCall(i).args, [prefix]);

assert.deepStrictEqual(rangeSpy.getCall(i).args, [

prefixRange.start,

prefixRange.end,

'Key',

]);

assert.strictEqual(config.reqOpts.rows.rowRanges[i], ranges[i]);

});

done();

};

table.createReadStream({prefixes});

});

});

});

describe('success', () => {

const fakeChunks = {

chunks: [

{

rowKey: 'a',

},

{

commitRow: true,

},

{

rowKey: 'b',