// Copyright 2014 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 {

DecorateRequestOptions,

ServiceObject,

ServiceObjectConfig,

util,

} from '@google-cloud/common';

import {GoogleErrorBody} from '@google-cloud/common/build/src/util';

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

import {File} from '@google-cloud/storage';

import arrify = require('arrify');

import * as assert from 'assert';

import {describe, it} from 'mocha';

import Big from 'big.js';

import {EventEmitter} from 'events';

import * as extend from 'extend';

import * as proxyquire from 'proxyquire';

import * as sinon from 'sinon';

import * as stream from 'stream';

import * as uuid from 'uuid';

import {BigQuery, Query} from '../src/bigquery';

import {Job, JobOptions} from '../src/job';

import {

CopyTableMetadata,

JobLoadMetadata,

Table,

TableMetadata,

ViewDefinition,

} from '../src/table';

import bigquery from '../src/types';

let promisified = false;

let makeWritableStreamOverride: Function | null;

let isCustomTypeOverride: Function | null;

const fakeUtil = extend({}, util, {

isCustomType: (...args: Array<{}>) => {

return (isCustomTypeOverride || util.isCustomType).apply(null, args);

},

makeWritableStream: (...args: Array<{}>) => {

(makeWritableStreamOverride || util.makeWritableStream).apply(null, args);

},

noop: () => {},

});

const fakePfy = extend({}, pfy, {

promisifyAll: (c: Function) => {

if (c.name === 'Table') {

promisified = true;

}

},

});

let extended = false;

const fakePaginator = {

paginator: {

extend: (c: Function, methods: string[]) => {

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

return;

}

methods = arrify(methods);

assert.strictEqual(c.name, 'Table');

assert.deepStrictEqual(methods, ['getRows']);

extended = true;

},

streamify: (methodName: string) => {

return methodName;

},

},

};

// tslint:disable-next-line no-any

let fakeUuid: any = extend(true, {}, uuid);

class FakeServiceObject extends ServiceObject {

calledWith_: IArguments;

constructor(config: ServiceObjectConfig) {

super(config);

this.calledWith_ = arguments;

}

}

interface MakeWritableStreamOptions {

metadata: bigquery.IJob;

request: {uri: string};

}

let sandbox: sinon.SinonSandbox;

beforeEach(() => (sandbox = sinon.createSandbox()));

afterEach(() => sandbox.restore());

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

const DATASET = {

id: 'dataset-id',

createTable: util.noop,

bigQuery: {

projectId: 'project-id',

job: (id: string) => {

return {id};

},

apiEndpoint: 'bigquery.googleapis.com',

request: util.noop,

},

};

const SCHEMA_OBJECT = {

fields: [

{name: 'id', type: 'INTEGER'},

{name: 'name', type: 'STRING'},

{name: 'dob', type: 'TIMESTAMP'},

{name: 'has_claws', type: 'BOOLEAN'},

{name: 'hair_count', type: 'FLOAT'},

{name: 'numeric_col', type: 'NUMERIC'},

],

};

const SCHEMA_STRING = [

'id:integer',

'name',

'dob:timestamp',

'has_claws:boolean',

'hair_count:float',

'numeric_col:numeric',

].join(',');

const LOCATION = 'asia-northeast1';

// tslint:disable-next-line no-any variable-name

let Table: any;

const TABLE_ID = 'kittens';

// tslint:disable-next-line no-any

let table: any;

// tslint:disable-next-line no-any

let tableOverrides: any = {};

before(() => {

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

uuid: fakeUuid,

'@google-cloud/common': {

ServiceObject: FakeServiceObject,

util: fakeUtil,

},

'@google-cloud/paginator': fakePaginator,

'@google-cloud/promisify': fakePfy,

}).Table;

const tableCached = extend(true, {}, Table);

// Override all util methods, allowing them to be mocked. Overrides are

// removed before each test.

Object.keys(Table).forEach(tableMethod => {

if (typeof Table[tableMethod] !== 'function') {

return;

}

// tslint:disable-next-line no-any

Table[tableMethod] = (...args: any[]) => {

const method = tableOverrides[tableMethod] || tableCached[tableMethod];

return method(...args);

};

});

});

beforeEach(() => {

fakeUuid = extend(fakeUuid, uuid);

isCustomTypeOverride = null;

makeWritableStreamOverride = null;

tableOverrides = {};

table = new Table(DATASET, TABLE_ID);

table.bigQuery.request = util.noop;

table.bigQuery.createJob = util.noop;

sandbox.stub(BigQuery, 'mergeSchemaWithRows_').callsFake((schema, rows) => {

return rows;

});

});

describe('instantiation', () => {

it('should extend the correct methods', () => {

assert(extended); // See `fakePaginator.extend`

});

it('should streamify the correct methods', () => {

assert.strictEqual(table.createReadStream, 'getRows');

});

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

assert(promisified);

});

it('should inherit from ServiceObject', done => {

const datasetInstance = extend({}, DATASET, {

createTable: {

bind: (context: {}) => {

assert.strictEqual(context, datasetInstance);

done();

},

},

});

const table = new Table(datasetInstance, TABLE_ID);

assert(table instanceof ServiceObject);

const calledWith = table.calledWith_[0];

assert.strictEqual(calledWith.parent, datasetInstance);

assert.strictEqual(calledWith.baseUrl, '/tables');

assert.strictEqual(calledWith.id, TABLE_ID);

assert.deepStrictEqual(calledWith.methods, {

create: true,

delete: true,

exists: true,

get: true,

getMetadata: true,

});

});

it('should capture the location', () => {

const options = {location: LOCATION};

const table = new Table(DATASET, TABLE_ID, options);

assert.strictEqual(table.location, LOCATION);

});

describe('etag interceptor', () => {

const FAKE_ETAG = 'abc';

it('should apply the If-Match header', () => {

const interceptor = table.interceptors.pop();

const fakeReqOpts = {

method: 'PATCH',

json: {

etag: FAKE_ETAG,

},

};

const reqOpts = interceptor.request(fakeReqOpts);

assert.deepStrictEqual(reqOpts.headers, {'If-Match': FAKE_ETAG});

});

it('should respect already existing headers', () => {

const interceptor = table.interceptors.pop();

const fakeReqOpts = {

method: 'PATCH',

headers: {

'Content-Type': 'application/json',

},

json: {

etag: FAKE_ETAG,

},

};

const expectedHeaders = extend({}, fakeReqOpts.headers, {

'If-Match': FAKE_ETAG,

});

const reqOpts = interceptor.request(fakeReqOpts);

assert.deepStrictEqual(reqOpts.headers, expectedHeaders);

});

it('should not apply the header if method is not patch', () => {

const interceptor = table.interceptors.pop();

const fakeReqOpts = {

method: 'POST',

json: {

etag: FAKE_ETAG,

},

};

const reqOpts = interceptor.request(fakeReqOpts);

assert.deepStrictEqual(reqOpts.headers, undefined);

});

});

});

describe('createSchemaFromString_', () => {

it('should create a schema object from a string', () => {

assert.deepStrictEqual(

Table.createSchemaFromString_(SCHEMA_STRING),

SCHEMA_OBJECT

);

});

it('should trim names', () => {

const schema = Table.createSchemaFromString_(' name :type');

assert.strictEqual(schema.fields[0].name, 'name');

});

it('should trim types', () => {

const schema = Table.createSchemaFromString_('name: type ');

assert.strictEqual(schema.fields[0].type, 'TYPE');

});

});

describe('encodeValue_', () => {

it('should return null if null or undefined', () => {

assert.strictEqual(Table.encodeValue_(null), null);

assert.strictEqual(Table.encodeValue_(undefined), null);

});

it('should properly encode values', () => {

const buffer = Buffer.from('test');

assert.strictEqual(Table.encodeValue_(buffer), buffer.toString('base64'));

const date = new Date();

assert.strictEqual(Table.encodeValue_(date), date.toJSON());

});

it('should properly encode custom types', () => {

class BigQueryDate {

value: {};

constructor(value: {}) {

this.value = value;

}

}

class BigQueryDatetime {

value: {};

constructor(value: {}) {

this.value = value;

}

}

class BigQueryTime {

value: {};

constructor(value: {}) {

this.value = value;

}

}

class BigQueryTimestamp {

value: {};

constructor(value: {}) {

this.value = value;

}

}

const date = new BigQueryDate('date');

const datetime = new BigQueryDatetime('datetime');

const time = new BigQueryTime('time');

const timestamp = new BigQueryTimestamp('timestamp');

assert.strictEqual(Table.encodeValue_(date), 'date');

assert.strictEqual(Table.encodeValue_(datetime), 'datetime');

assert.strictEqual(Table.encodeValue_(time), 'time');

assert.strictEqual(Table.encodeValue_(timestamp), 'timestamp');

});

it('should properly encode arrays', () => {

const buffer = Buffer.from('test');

const date = new Date();

const array = [buffer, date];

assert.deepStrictEqual(Table.encodeValue_(array), [

buffer.toString('base64'),

date.toJSON(),

]);

});

it('should properly encode objects', () => {

const buffer = Buffer.from('test');

const date = new Date();

const object = {

nested: {

array: [buffer, date],

},

};

assert.deepStrictEqual(Table.encodeValue_(object), {

nested: {

array: [buffer.toString('base64'), date.toJSON()],

},

});

});

it('should properly encode numerics', () => {

assert.strictEqual(Table.encodeValue_(new Big('123.456')), '123.456');

assert.strictEqual(Table.encodeValue_(new Big('-123.456')), '-123.456');

assert.strictEqual(

Table.encodeValue_(new Big('99999999999999999999999999999.999999999')),

'99999999999999999999999999999.999999999'

);

assert.strictEqual(

Table.encodeValue_(new Big('-99999999999999999999999999999.999999999')),

'-99999999999999999999999999999.999999999'

);

});

});

describe('formatMetadata_', () => {

it('should return a deep copy', () => {

const metadata = {

a: {

b: 'c',

},

};

const formatted = Table.formatMetadata_(metadata);

assert.deepStrictEqual(metadata, formatted);

assert.notStrictEqual(metadata, formatted);

});

it('should format the name option', () => {

const NAME = 'name';

const formatted = Table.formatMetadata_({name: NAME});

assert.strictEqual(formatted.name, undefined);

assert.strictEqual(formatted.friendlyName, NAME);

});

it('should format the schema string option', () => {

const fakeSchema = {};

Table.createSchemaFromString_ = (schema: string) => {

assert.strictEqual(schema, SCHEMA_STRING);

return fakeSchema;

};

const formatted = Table.formatMetadata_({schema: SCHEMA_STRING});

assert.strictEqual(formatted.schema, fakeSchema);

});

it('should accept an array of schema fields', () => {

const fields = ['a', 'b', 'c'];

const formatted = Table.formatMetadata_({schema: fields});

assert.deepStrictEqual(formatted.schema.fields, fields);

});

it('should format the schema fields option', () => {

const metadata = {

schema: {

fields: ['a', {fields: []}, 'b'],

},

};

const expectedFields = ['a', {fields: [], type: 'RECORD'}, 'b'];

const formatted = Table.formatMetadata_(metadata);

assert.deepStrictEqual(formatted.schema.fields, expectedFields);

});

it('should format the time partitioning option', () => {

const formatted = Table.formatMetadata_({partitioning: 'abc'});

assert.strictEqual(formatted.timePartitioning.type, 'ABC');

});

it('should format the table view option', () => {

const VIEW = 'abc';

const formatted = Table.formatMetadata_({view: VIEW});

assert.strictEqual(formatted.view.query, VIEW);

assert.strictEqual(formatted.view.useLegacySql, false);

});

it('should allow the view option to be passed as a pre-formatted object', () => {

const view: ViewDefinition = {query: 'abc', useLegacySql: false};

const {view: formattedView} = Table.formatMetadata_({view});

assert.deepStrictEqual(formattedView, view);

});

});

describe('copy', () => {

// tslint:disable-next-line no-any

let fakeJob: any;

beforeEach(() => {

fakeJob = new EventEmitter();

table.createCopyJob = (

destination: {},

metadata: {},

callback: Function

) => {

callback(null, fakeJob);

};

});

it('should pass the arguments to createCopyJob', done => {

const fakeDestination = {};

const fakeMetadata: CopyTableMetadata = {

createDisposition: 'CREATE_NEVER',

writeDisposition: 'WRITE_TRUNCATE',

};

table.createCopyJob = (destination: {}, metadata: {}) => {

assert.strictEqual(destination, fakeDestination);

assert.strictEqual(metadata, fakeMetadata);

done();

};

table.copy(fakeDestination, fakeMetadata, assert.ifError);

});

it('should optionally accept metadata', done => {

table.createCopyJob = (destination: {}, metadata: {}) => {

assert.deepStrictEqual(metadata, {});

done();

};

table.copy({}, assert.ifError);

});

it('should return any createCopyJob errors', done => {

const error = new Error('err');

const response = {};

table.createCopyJob = (

destination: {},

metadata: {},

callback: Function

) => {

callback(error, null, response);

};

table.copy({}, (err: Error, resp: {}) => {

assert.strictEqual(err, error);

assert.strictEqual(resp, response);

done();

});

});

it('should return any job errors', done => {

const error = new Error('err');

table.copy({}, (err: Error) => {

assert.strictEqual(err, error);

done();

});

fakeJob.emit('error', error);

});

it('should return the metadata on complete', done => {

const metadata = {};

table.copy({}, (err: Error, resp: {}) => {

assert.ifError(err);

assert.strictEqual(resp, metadata);

done();

});

fakeJob.emit('complete', metadata);

});

});

describe('copyFrom', () => {

// tslint:disable-next-line no-any

let fakeJob: any;

beforeEach(() => {

fakeJob = new EventEmitter();

table.createCopyFromJob = (

sourceTables: {},

metadata: {},

callback: Function

) => {

callback(null, fakeJob);

};

});

it('should pass the arguments to createCopyFromJob', done => {

const fakeSourceTables = {};

const fakeMetadata = {};

table.createCopyFromJob = (sourceTables: {}, metadata: {}) => {

assert.strictEqual(sourceTables, fakeSourceTables);

assert.strictEqual(metadata, fakeMetadata);

done();

};

table.copyFrom(fakeSourceTables, fakeMetadata, assert.ifError);

});

it('should optionally accept metadata', done => {

table.createCopyFromJob = (sourceTables: {}, metadata: {}) => {

assert.deepStrictEqual(metadata, {});

done();

};

table.copyFrom({}, assert.ifError);

});

it('should return any createCopyFromJob errors', done => {

const error = new Error('err');

const response = {};

table.createCopyFromJob = (

sourceTables: {},

metadata: {},

callback: Function

) => {

callback(error, null, response);

};

table.copyFrom({}, (err: Error, resp: {}) => {

assert.strictEqual(err, error);

assert.strictEqual(resp, response);

done();

});

});

it('should return any job errors', done => {

const error = new Error('err');

table.copyFrom({}, (err: Error) => {

assert.strictEqual(err, error);

done();

});

fakeJob.emit('error', error);

});

it('should return the metadata on complete', done => {

const metadata = {};

table.copyFrom({}, (err: Error, resp: {}) => {

assert.ifError(err);

assert.strictEqual(resp, metadata);

done();

});

fakeJob.emit('complete', metadata);

});

});

describe('createCopyJob', () => {

let DEST_TABLE: Table;

before(() => {

DEST_TABLE = new Table(DATASET, 'destination-table');

});

it('should throw if a destination is not a Table', () => {

assert.throws(() => {

table.createCopyJob();

}, /Destination must be a Table/);

assert.throws(() => {

table.createCopyJob({});

}, /Destination must be a Table/);

assert.throws(() => {

table.createCopyJob(() => {});

}, /Destination must be a Table/);

});

it('should send correct request to the API', done => {

table.bigQuery.createJob = (reqOpts: JobOptions) => {

assert.deepStrictEqual(reqOpts, {

configuration: {

copy: {

a: 'b',

c: 'd',

destinationTable: {

datasetId: DEST_TABLE.dataset.id,

projectId: DEST_TABLE.bigQuery.projectId,

tableId: DEST_TABLE.id,

},

sourceTable: {

datasetId: table.dataset.id,

projectId: table.bigQuery.projectId,

tableId: table.id,

},

},

},

});

done();

};

table.createCopyJob(DEST_TABLE, {a: 'b', c: 'd'}, assert.ifError);

});

it('should accept a job prefix', done => {

const fakeJobPrefix = 'abc-';

const options = {

jobPrefix: fakeJobPrefix,

};

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

assert.strictEqual(reqOpts.jobPrefix, fakeJobPrefix);

assert.strictEqual(

// tslint:disable-next-line no-any

(reqOpts.configuration!.copy as any).jobPrefix,

undefined

);

callback(); // the done fn

};

table.createCopyJob(DEST_TABLE, options, done);

});

it('should use the default location', done => {

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

assert.strictEqual(reqOpts.location, LOCATION);

callback(); // the done fn

};

table.location = LOCATION;

table.createCopyJob(DEST_TABLE, done);

});

it('should accept a job id', done => {

const jobId = 'job-id';

const options = {jobId};

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

assert.strictEqual(reqOpts.jobId, jobId);

assert.strictEqual(

// tslint:disable-next-line no-any

(reqOpts.configuration!.copy as any).jobId,

undefined

);

callback(); // the done fn

};

table.createCopyJob(DEST_TABLE, options, done);

});

it('should pass the callback to createJob', done => {

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

assert.strictEqual(done, callback);

callback(); // the done fn

};

table.createCopyJob(DEST_TABLE, {}, done);

});

it('should optionally accept metadata', done => {

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

assert.strictEqual(done, callback);

callback(); // the done fn

};

table.createCopyJob(DEST_TABLE, done);

});

});

describe('createCopyFromJob', () => {

let SOURCE_TABLE: Table;

before(() => {

SOURCE_TABLE = new Table(DATASET, 'source-table');

});

it('should throw if a source is not a Table', () => {

assert.throws(() => {

table.createCopyFromJob(['table']);

}, /Source must be a Table/);

assert.throws(() => {

table.createCopyFromJob([SOURCE_TABLE, 'table']);

}, /Source must be a Table/);

assert.throws(() => {

table.createCopyFromJob({});

}, /Source must be a Table/);

assert.throws(() => {

table.createCopyFromJob(() => {});

}, /Source must be a Table/);

});

it('should send correct request to the API', done => {

table.bigQuery.createJob = (reqOpts: JobOptions) => {

assert.deepStrictEqual(reqOpts, {

configuration: {

copy: {

a: 'b',

c: 'd',

destinationTable: {

datasetId: table.dataset.id,

projectId: table.bigQuery.projectId,

tableId: table.id,

},

sourceTables: [

{

datasetId: SOURCE_TABLE.dataset.id,

projectId: SOURCE_TABLE.bigQuery.projectId,

tableId: SOURCE_TABLE.id,

},

],

},

},

});

done();

};

table.createCopyFromJob(SOURCE_TABLE, {a: 'b', c: 'd'}, assert.ifError);

});

it('should accept multiple source tables', done => {

table.bigQuery.createJob = (reqOpts: JobOptions) => {

assert.deepStrictEqual(reqOpts.configuration!.copy!.sourceTables, [

{

datasetId: SOURCE_TABLE.dataset.id,

projectId: SOURCE_TABLE.bigQuery.projectId,

tableId: SOURCE_TABLE.id,

},

{

datasetId: SOURCE_TABLE.dataset.id,

projectId: SOURCE_TABLE.bigQuery.projectId,

tableId: SOURCE_TABLE.id,

},

]);

done();

};

table.createCopyFromJob([SOURCE_TABLE, SOURCE_TABLE], assert.ifError);

});

it('should accept a job prefix', done => {

const fakeJobPrefix = 'abc-';

const options = {

jobPrefix: fakeJobPrefix,

};

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

assert.strictEqual(reqOpts.jobPrefix, fakeJobPrefix);

assert.strictEqual(

// tslint:disable-next-line no-any

(reqOpts.configuration!.copy as any).jobPrefix,

undefined

);

callback(); // the done fn

};

table.createCopyFromJob(SOURCE_TABLE, options, done);

});

it('should use the default location', done => {

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

assert.strictEqual(reqOpts.location, LOCATION);

callback(); // the done fn

};

table.location = LOCATION;

table.createCopyFromJob(SOURCE_TABLE, done);

});

it('should accept a job id', done => {

const jobId = 'job-id';

const options = {jobId};

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

assert.strictEqual(reqOpts.jobId, jobId);

assert.strictEqual(

// tslint:disable-next-line no-any

(reqOpts.configuration!.copy as any).jobId,

undefined

);

callback(); // the done fn

};

table.createCopyFromJob(SOURCE_TABLE, options, done);

});

it('should pass the callback to createJob', done => {

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

assert.strictEqual(done, callback);

callback(); // the done fn

};

table.createCopyFromJob(SOURCE_TABLE, {}, done);

});

it('should optionally accept options', done => {

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

assert.strictEqual(done, callback);

callback(); // the done fn

};

table.createCopyFromJob(SOURCE_TABLE, done);

});

});

describe('createExtractJob', () => {

const FILE = {

name: 'file-name.json',

bucket: {

name: 'bucket-name',

},

};

beforeEach(() => {

isCustomTypeOverride = () => {

return true;

};

table.bigQuery.job = (id: string) => {

return {id};

};

table.bigQuery.createJob = () => {};

});

it('should call createJob correctly', done => {

table.bigQuery.createJob = (reqOpts: JobOptions) => {

assert.deepStrictEqual(reqOpts.configuration!.extract!.sourceTable, {

datasetId: table.dataset.id,

projectId: table.bigQuery.projectId,

tableId: table.id,

});

done();

};

table.createExtractJob(FILE, assert.ifError);

});

it('should accept just a destination and a callback', done => {

table.bigQuery.createJob = (reqOpts: JobOptions, callback: Function) => {

callback(null, {jobReference: {jobId: 'job-id'}});

};

table.createExtractJob(FILE, done);

});

describe('formats', () => {

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

table.bigQuery.createJob = (reqOpts: JobOptions) => {

const extract = reqOpts.configuration!.extract!;

assert.strictEqual(extract.destinationFormat, 'CSV');

done();

};

table.createExtractJob(FILE, {format: 'csv'}, assert.ifError);

});

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

table.bigQuery.createJob = (reqOpts: JobOptions) => {

const extract = reqOpts.configuration!.extract!;

assert.strictEqual(

extract.destinationFormat,

'NEWLINE_DELIMITED_JSON'

);

done();

};

table.createExtractJob(FILE, {format: 'json'}, assert.ifError);

});

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

table.bigQuery.createJob = (reqOpts: JobOptions) => {

const extract = reqOpts.configuration!.extract!;

assert.strictEqual(extract.destinationFormat, 'AVRO');

done();

};

table.createExtractJob(FILE, {format: 'avro'}, assert.ifError);

});

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

table.bigQuery.createJob = (reqOpts: JobOptions) => {

const extract = reqOpts.configuration!.extract!;

assert.strictEqual(extract.destinationFormat, 'ORC');

done();

};

table.createExtractJob(FILE, {format: 'orc'}, assert.ifError);

});

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

table.bigQuery.createJob = (reqOpts: JobOptions) => {

const extract = reqOpts.configuration!.extract!;

assert.strictEqual(extract.destinationFormat, 'PARQUET');

done();

};

table.createExtractJob(FILE, {format: 'parquet'}, assert.ifError);

});

});

it('should parse out full gs:// urls from files', done => {

table.bigQuery.createJob = (reqOpts: JobOptions) => {

assert.deepStrictEqual(