def __init__(self, status, reason='There was an error'):

"""

self.status = status

def setUp(self):

client._bq_client = None

self.mock_bq_service = mock.Mock()

self.mock_job_collection = mock.Mock()

self.mock_bq_service.jobs.return_value = self.mock_job_collection

self.client = client.BigQueryClient(self.mock_bq_service, 'project')

def test_no_credentials(self):

"""Ensure an Exception is raised when no credentials are provided."""

self.assertRaises(AssertionError, client.get_client, 'foo')

@mock.patch('bigquery.client._credentials')

@mock.patch('bigquery.client.build')

def test_initialize_readonly(self, mock_build, mock_return_cred):

"""Ensure that a BigQueryClient is initialized and returned with

from bigquery.client import BIGQUERY_SCOPE_READ_ONLY

mock_cred = mock.Mock()

mock_http = mock.Mock()

mock_service_url = mock.Mock()

mock_cred.from_p12_keyfile_buffer.return_value.authorize.return_value = mock_http

mock_bq = mock.Mock()

mock_build.return_value = mock_bq

key = 'key'

service_account = 'account'

project_id = 'project'

mock_return_cred.return_value = mock_cred

bq_client = client.get_client(

project_id, service_url=mock_service_url,

service_account=service_account, private_key=key,

readonly=True)

mock_return_cred.assert_called_once_with()

mock_cred.from_p12_keyfile_buffer.assert_called_once_with(

service_account, mock.ANY,

scopes=BIGQUERY_SCOPE_READ_ONLY)

self.assertTrue(

mock_cred.from_p12_keyfile_buffer.return_value.authorize.called)

mock_build.assert_called_once_with('bigquery', 'v2', http=mock_http,

discoveryServiceUrl=mock_service_url)

self.assertEquals(mock_bq, bq_client.bigquery)

self.assertEquals(project_id, bq_client.project_id)

@mock.patch('bigquery.client._credentials')

@mock.patch('bigquery.client.build')

def test_initialize_read_write(self, mock_build, mock_return_cred):

"""Ensure that a BigQueryClient is initialized and returned with

from bigquery.client import BIGQUERY_SCOPE

mock_cred = mock.Mock()

mock_http = mock.Mock()

mock_service_url = mock.Mock()

mock_cred.from_p12_keyfile_buffer.return_value.authorize.return_value = mock_http

mock_bq = mock.Mock()

mock_build.return_value = mock_bq

key = 'key'

service_account = 'account'

project_id = 'project'

mock_return_cred.return_value = mock_cred

bq_client = client.get_client(

project_id, service_url=mock_service_url,

service_account=service_account, private_key=key,

readonly=False)

mock_return_cred.assert_called_once_with()

mock_cred.from_p12_keyfile_buffer.assert_called_once_with(

service_account, mock.ANY, scopes=BIGQUERY_SCOPE)

self.assertTrue(

mock_cred.from_p12_keyfile_buffer.return_value.authorize.called)

mock_build.assert_called_once_with('bigquery', 'v2', http=mock_http,

discoveryServiceUrl=mock_service_url)

self.assertEquals(mock_bq, bq_client.bigquery)

self.assertEquals(project_id, bq_client.project_id)

@mock.patch('bigquery.client._credentials')

@mock.patch('bigquery.client.build')

def test_initialize_key_file(self, mock_build, mock_return_cred):

"""Ensure that a BigQueryClient is initialized and returned with

from bigquery.client import BIGQUERY_SCOPE

mock_cred = mock.Mock()

mock_http = mock.Mock()

mock_service_url = mock.Mock()

mock_cred.from_p12_keyfile.return_value.authorize.return_value = mock_http

mock_bq = mock.Mock()

mock_build.return_value = mock_bq

key_file = 'key.pem'

service_account = 'account'

project_id = 'project'

mock_return_cred.return_value = mock_cred

bq_client = client.get_client(

project_id, service_url=mock_service_url,

service_account=service_account,

private_key_file=key_file, readonly=False)

mock_return_cred.assert_called_once_with()

mock_cred.from_p12_keyfile.assert_called_once_with(service_account,

key_file,

scopes=BIGQUERY_SCOPE)

self.assertTrue(

mock_cred.from_p12_keyfile.return_value.authorize.called)

mock_build.assert_called_once_with('bigquery', 'v2', http=mock_http,

discoveryServiceUrl=mock_service_url)

self.assertEquals(mock_bq, bq_client.bigquery)

self.assertEquals(project_id, bq_client.project_id)

@mock.patch('bigquery.client._credentials')

@mock.patch('bigquery.client.build')

@mock.patch('__builtin__.open' if six.PY2 else 'builtins.open')

def test_initialize_json_key_file(self, mock_open, mock_build, mock_return_cred):

"""Ensure that a BigQueryClient is initialized and returned with

from bigquery.client import BIGQUERY_SCOPE

import json

mock_cred = mock.Mock()

mock_http = mock.Mock()

mock_service_url = mock.Mock()

mock_cred.from_json_keyfile_dict.return_value.authorize.return_value = mock_http

mock_bq = mock.Mock()

mock_build.return_value = mock_bq

json_key_file = 'key.json'

json_key = {'client_email': 'mail', 'private_key': 'pkey'}

mock_open.return_value.__enter__.return_value.read.return_value = json.dumps(json_key)

project_id = 'project'

mock_return_cred.return_value = mock_cred

bq_client = client.get_client(

project_id, service_url=mock_service_url,

json_key_file=json_key_file, readonly=False)

mock_return_cred.assert_called_once_with()

mock_cred.from_json_keyfile_dict.assert_called_once_with(json_key,

scopes=BIGQUERY_SCOPE)

self.assertTrue(

mock_cred.from_json_keyfile_dict.return_value.authorize.called)

mock_build.assert_called_once_with('bigquery', 'v2', http=mock_http,

discoveryServiceUrl=mock_service_url)

self.assertEquals(mock_bq, bq_client.bigquery)

self.assertEquals(project_id, bq_client.project_id)

@mock.patch('bigquery.client._credentials')

@mock.patch('bigquery.client.build')

@mock.patch('__builtin__.open' if six.PY2 else 'builtins.open')

def test_initialize_json_key_file_without_project_id(self, mock_open, mock_build,

mock_return_cred):

"""Ensure that a BigQueryClient is initialized and returned with

from bigquery.client import BIGQUERY_SCOPE

import json

mock_cred = mock.Mock()

mock_http = mock.Mock()

mock_service_url = mock.Mock()

mock_cred.from_json_keyfile_dict.return_value.authorize.return_value = mock_http

mock_bq = mock.Mock()

mock_build.return_value = mock_bq

json_key_file = 'key.json'

json_key = {'client_email': 'mail', 'private_key': 'pkey', 'project_id': 'project'}

mock_open.return_value.__enter__.return_value.read.return_value = json.dumps(json_key)

mock_return_cred.return_value = mock_cred

bq_client = client.get_client(

service_url=mock_service_url, json_key_file=json_key_file, readonly=False)

mock_open.assert_called_once_with(json_key_file, 'r')

mock_return_cred.assert_called_once_with()

mock_cred.from_json_keyfile_dict.assert_called_once_with(json_key,

scopes=BIGQUERY_SCOPE)

self.assertTrue(

mock_cred.from_json_keyfile_dict.return_value.authorize.called)

mock_build.assert_called_once_with('bigquery', 'v2', http=mock_http,

discoveryServiceUrl=mock_service_url)

self.assertEquals(mock_bq, bq_client.bigquery)

def test_get_project_ids(self):

mock_bq_service = mock.Mock()

mock_bq_service.projects().list().execute.return_value = {

'kind': 'bigquery#projectList',

'projects': [

{

'friendlyName': 'Big Query Test',

'id': 'big-query-test',

'kind': 'bigquery#project',

'numericId': '1435372465',

'projectReference': {'projectId': 'big-query-test'}

},

{

'friendlyName': 'BQ Company project',

'id': 'bq-project',

'kind': 'bigquery#project',

'numericId': '4263574685796',

'projectReference': {'projectId': 'bq-project'}

}

],

'totalItems': 2

}

projects = client.get_projects(mock_bq_service)

expected_projects_data = [

{'id': 'big-query-test', 'name': 'Big Query Test'},

{'id': 'bq-project', 'name': 'BQ Company project'}

]

def setUp(self):

client._bq_client = None

self.mock_bq_service = mock.Mock()

self.mock_job_collection = mock.Mock()

self.mock_bq_service.jobs.return_value = self.mock_job_collection

self.query = 'foo'

self.project_id = 'project'

self.external_udf_uris = ['gs://bucket/external_udf.js']

self.client = client.BigQueryClient(self.mock_bq_service,

self.project_id)

def test_query(self):

"""Ensure that we retrieve the job id from the query."""

mock_query_job = mock.Mock()

expected_job_id = 'spiderman'

expected_job_ref = {'jobId': expected_job_id}

mock_query_job.execute.return_value = {

'jobReference': expected_job_ref,

'jobComplete': True

}

self.mock_job_collection.query.return_value = mock_query_job

job_id, results = self.client.query(self.query, external_udf_uris=self.external_udf_uris)

self.mock_job_collection.query.assert_called_once_with(

projectId=self.project_id,

body={

'query': self.query,

'userDefinedFunctionResources': [ {'resourceUri': u} for u in self.external_udf_uris ],

'timeoutMs': 0,

'dryRun': False,

'maxResults': None

}

)

self.assertEquals(job_id, 'spiderman')

self.assertEquals(results, [])

def test_query_max_results_set(self):

"""Ensure that we retrieve the job id from the query and the maxResults

mock_query_job = mock.Mock()

expected_job_id = 'spiderman'

expected_job_ref = {'jobId': expected_job_id}

mock_query_job.execute.return_value = {

'jobReference': expected_job_ref,

'jobComplete': True,

}

self.mock_job_collection.query.return_value = mock_query_job

max_results = 10

job_id, results = self.client.query(self.query,

max_results=max_results)

self.mock_job_collection.query.assert_called_once_with(

projectId=self.project_id,

body={'query': self.query, 'timeoutMs': 0,

'maxResults': max_results, 'dryRun': False}

)

self.assertEquals(job_id, 'spiderman')

self.assertEquals(results, [])

def test_query_timeout_set(self):

"""Ensure that we retrieve the job id from the query and the timeoutMs

mock_query_job = mock.Mock()

expected_job_id = 'spiderman'

expected_job_ref = {'jobId': expected_job_id}

mock_query_job.execute.return_value = {

'jobReference': expected_job_ref,

'jobComplete': True,

}

self.mock_job_collection.query.return_value = mock_query_job

timeout = 5

job_id, results = self.client.query(self.query, timeout=timeout)

self.mock_job_collection.query.assert_called_once_with(

projectId=self.project_id,

body={'query': self.query, 'timeoutMs': timeout * 1000,

'dryRun': False, 'maxResults': None}

)

self.assertEquals(job_id, 'spiderman')

self.assertEquals(results, [])

def test_sync_query_timeout(self):

"""Ensure that exception is raise on timeout for synchronous query"""

mock_query_job = mock.Mock()

expected_job_id = 'spiderman'

expected_job_ref = {'jobId': expected_job_id}

mock_query_job.execute.return_value = {

'jobReference': expected_job_ref,

'jobComplete': False,

}

self.mock_job_collection.query.return_value = mock_query_job

timeout = 5

self.assertRaises(BigQueryTimeoutException, self.client.query,

self.query, None, timeout)

def test_async_query_timeout(self):

"""Ensure that exception is not raise on timeout

mock_query_job = mock.Mock()

expected_job_id = 'spiderman'

expected_job_ref = {'jobId': expected_job_id}

mock_query_job.execute.return_value = {

'jobReference': expected_job_ref,

'jobComplete': False,

}

self.mock_job_collection.query.return_value = mock_query_job

job_id, results = self.client.query(self.query)

self.assertEquals(job_id, 'spiderman')

self.assertEquals(results, [])

def test_query_dry_run_valid(self):

"""Ensure that None and an empty list is returned from the query when

mock_query_job = mock.Mock()

mock_query_job.execute.return_value = {'jobReference': {},

'jobComplete': True}

self.mock_job_collection.query.return_value = mock_query_job

job_id, results = self.client.query(self.query, dry_run=True)

self.mock_job_collection.query.assert_called_once_with(

projectId=self.project_id,

body={'query': self.query, 'timeoutMs': 0, 'maxResults': None,

'dryRun': True}

)

self.assertIsNone(job_id)

self.assertEqual([], results)

def test_query_dry_run_invalid(self):

"""Ensure that None and a dict is returned from the query when dry_run

mock_query_job = mock.Mock()

mock_query_job.execute.side_effect = HttpError(

'crap', '{"message": "Bad query"}'.encode('utf8'))

self.mock_job_collection.query.return_value = mock_query_job

job_id, results = self.client.query('%s blah' % self.query,

dry_run=True)

self.mock_job_collection.query.assert_called_once_with(

projectId=self.project_id,

body={'query': '%s blah' % self.query, 'timeoutMs': 0,

'maxResults': None,

'dryRun': True}

)

self.assertIsNone(job_id)

self.assertEqual({'message': 'Bad query'}, results)

def test_query_with_results(self):

"""Ensure that we retrieve the job id from the query and results if

mock_query_job = mock.Mock()

expected_job_id = 'spiderman'

expected_job_ref = {'jobId': expected_job_id}

mock_query_job.execute.return_value = {

'jobReference': expected_job_ref,

'schema': {'fields': [{'name': 'foo', 'type': 'INTEGER'}]},

'rows': [{'f': [{'v': 10}]}],

'jobComplete': True,

}

self.mock_job_collection.query.return_value = mock_query_job

job_id, results = self.client.query(self.query)

self.mock_job_collection.query.assert_called_once_with(

projectId=self.project_id,

body={'query': self.query, 'timeoutMs': 0, 'dryRun': False,

'maxResults': None}

)

self.assertEquals(job_id, 'spiderman')

self.assertEquals(results, [{'foo': 10}])

def test_query_with_using_legacy_sql(self):

"""Ensure that use_legacy_sql bool gets used"""

mock_query_job = mock.Mock()

expected_job_id = 'spiderman'

expected_job_ref = {'jobId': expected_job_id}

mock_query_job.execute.return_value = {

'jobReference': expected_job_ref,

'jobComplete': True

}

self.mock_job_collection.query.return_value = mock_query_job

job_id, results = self.client.query(self.query, use_legacy_sql=False)

self.mock_job_collection.query.assert_called_once_with(

projectId=self.project_id,

body={'query': self.query, 'timeoutMs': 0, 'dryRun': False,

'maxResults': None, 'useLegacySql': False}

)

self.assertEquals(job_id, 'spiderman')

def setUp(self):

client._bq_client = None

self.mock_bq_service = mock.Mock()

self.mock_job_collection = mock.Mock()

self.mock_bq_service.jobs.return_value = self.mock_job_collection

self.project_id = 'project'

self.client = client.BigQueryClient(self.mock_bq_service,

self.project_id)

def test_get_response(self):

"""Ensure that the query is executed and the query reply is returned.

job_id = 'bar'

mock_query_job = mock.Mock()

mock_query_reply = mock.Mock()

mock_query_job.execute.return_value = mock_query_reply

self.mock_job_collection.getQueryResults.return_value = mock_query_job

offset = 5

limit = 10

page_token = "token"

timeout = 1

actual = self.client.get_query_results(job_id, offset, limit,

page_token, timeout)

self.mock_job_collection.getQueryResults.assert_called_once_with(

projectId=self.project_id, jobId=job_id, startIndex=offset,

maxResults=limit, pageToken=page_token, timeoutMs=1000)

mock_query_job.execute.assert_called_once_with()

def setUp(self):

client._bq_client = None

self.mock_bq_service = mock.Mock()

self.mock_job_collection = mock.Mock()

self.mock_bq_service.jobs.return_value = self.mock_job_collection

self.project_id = 'project'

self.client = client.BigQueryClient(self.mock_bq_service,

self.project_id)

def test_transform_row(self):

"""Ensure that the row dict is correctly transformed to a log dict."""

schema = [{'name': 'foo', 'type': 'INTEGER'},

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

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

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

{'name': 'timestamp', 'type': 'TIMESTAMP'}]

row = {'f': [{'v': '42'}, {'v': None}, {'v': 'batman'},

{'v': 'True'}, {'v': '1.371145650319132E9'}]}

expected = {'foo': 42, 'bar': None, 'baz': 'batman', 'qux': True,

'timestamp': 1371145650.319132}

actual = self.client._transform_row(row, schema)

self.assertEquals(actual, expected)

def test_transform_row_with_nested(self):

"""Ensure that the row dict with nested records is correctly

schema = [{'name': 'foo', 'type': 'INTEGER'},

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

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

{'name': 'qux', 'type': 'RECORD', 'mode': 'SINGLE',

'fields': [{'name': 'foobar', 'type': 'INTEGER'},

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

row = {'f': [{'v': '42'}, {'v': '36.98'}, {'v': 'batman'},

{'v': {'f': [{'v': '120'}, {'v': 'robin'}]}}]}

expected = {'foo': 42, 'bar': 36.98, 'baz': 'batman',

'qux': {'foobar': 120, 'bazqux': 'robin'}}

actual = self.client._transform_row(row, schema)

self.assertEquals(actual, expected)

def test_transform_row_with_nested_repeated(self):

"""Ensure that the row dict with nested repeated records is correctly

schema = [{'name': 'foo', 'type': 'INTEGER'},

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

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

{'name': 'qux', 'type': 'RECORD', 'mode': 'REPEATED',

'fields': [{'name': 'foobar', 'type': 'INTEGER'},

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

row = {'f': [{'v': '42'}, {'v': '36.98'}, {'v': 'batman'},

{'v': [{'v': {'f': [{'v': '120'}, {'v': 'robin'}]}},

{'v': {'f': [{'v': '300'}, {'v': 'joker'}]}}]}]}

expected = {'foo': 42, 'bar': 36.98, 'baz': 'batman',

'qux': [{'foobar': 120, 'bazqux': 'robin'},

{'foobar': 300, 'bazqux': 'joker'}]}

actual = self.client._transform_row(row, schema)

def setUp(self):

client._bq_client = None

self.project_id = 'project'

self.client = client.BigQueryClient(mock.Mock(), self.project_id)

def test_job_incomplete(self, mock_exec):

"""Ensure that we return None if the job is not yet complete."""

mock_exec.return_value = {'jobComplete': False}

is_completed, total_rows = self.client.check_job(1)

self.assertFalse(is_completed)

self.assertEquals(total_rows, 0)

def test_query_complete(self, mock_exec):

"""Ensure that we can handle a normal query result."""

mock_exec.return_value = {

'jobComplete': True,

'rows': [

{'f': [{'v': 'bar'}, {'v': 'man'}]},

{'f': [{'v': 'abc'}, {'v': 'xyz'}]}

],

'schema': {

'fields': [

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

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

]

},

'totalRows': '2'

}

is_completed, total_rows = self.client.check_job(1)

self.assertTrue(is_completed)

def setUp(self):

client._bq_client = None

self.project_id = 'project'

self.api_mock = mock.Mock()

self.client = client.BigQueryClient(self.api_mock, self.project_id)

def test_completed_jobs(self):

"""Ensure we can detect completed jobs"""

return_values = [{'status': {'state': 'RUNNING'},

'jobReference': {'jobId': "testJob"}},

{'status': {'state': 'DONE'},

'jobReference': {'jobId': "testJob"}}]

def side_effect(*args, **kwargs):

return return_values.pop(0)

self.api_mock.jobs().get().execute.side_effect = side_effect

job_resource = self.client.wait_for_job(

{'jobReference': {'jobId': "testJob"},

'status': {'state': 'RUNNING'}},

interval=.01,

timeout=.05)

self.assertEqual(self.api_mock.jobs().get().execute.call_count, 2)

self.assertIsInstance(job_resource, dict)

def test_timeout_error(self):

"""Ensure that timeout raise exceptions"""

incomplete_job = {'status': {'state': 'RUNNING'},

'jobReference': {'jobId': "testJob"}}

self.api_mock.jobs().get().execute.return_value = incomplete_job

self.assertRaises(BigQueryTimeoutException, self.client.wait_for_job,

incomplete_job, .1, .25)

def test_wait_job_http_error(self):

""" Test wait job with http error"""

job = {'status': {'state': 'RUNNING'},

'jobReference': {'jobId': "testJob"}}

expected_result = {

"error": {

"errors": [{

"domain": "global",

"reason": "required",

"message": "Required parameter is missing"

}],

"code": 400,

"message": "Required parameter is missing"

}

}

self.api_mock.jobs().insert().execute.return_value = expected_result

self.assertRaises(JobExecutingException,

self.client.wait_for_job,

job,

interval=.01,

timeout=.01)

def test_wait_job_error_result(self):

""" Test wait job with error result"""

job = {'status': {'state': 'RUNNING'},

'jobReference': {'jobId': "testJob"}}

expected_result = {

"status": {

"state": "DONE",

"errorResult": {

"reason": "invalidQuery",

"location": "query",

"message": "Your Error Message Here "

},

},

}

self.api_mock.jobs().insert().execute.return_value = expected_result

self.assertRaises(JobExecutingException,

self.client.wait_for_job,

job,

interval=.01,

timeout=.01)

def test_accepts_job_id(self):

"""Ensure it accepts a job Id rather than a full job resource"""

return_values = [{'status': {'state': 'RUNNING'},

'jobReference': {'jobId': "testJob"}},

{'status': {'state': 'DONE'},

'jobReference': {'jobId': "testJob"}}]

def side_effect(*args, **kwargs):

return return_values.pop(0)

self.api_mock.jobs().get().execute.side_effect = side_effect

job_resource = self.client.wait_for_job("testJob",

interval=.01,

timeout=5)

self.assertEqual(self.api_mock.jobs().get().execute.call_count, 2)

self.assertIsInstance(job_resource, dict)

def test_accepts_integer_job_id(self):

return_values = [{'status': {'state': 'RUNNING'},

'jobReference': {'jobId': "testJob"}},

{'status': {'state': 'DONE'},

'jobReference': {'jobId': "testJob"}}]

def side_effect(*args, **kwargs):

return return_values.pop(0)

self.api_mock.jobs().get().execute.side_effect = side_effect

job_resource = self.client.wait_for_job(1234567,

interval=.01,

timeout=600)

self.assertEqual(self.api_mock.jobs().get().execute.call_count, 2)

def setUp(self):

client._bq_client = None

self.mock_api = mock.Mock()

self.query = 'foo'

self.project_id = 'project'

self.dataset_id = 'dataset'

self.table_id = 'table'

self.client = client.BigQueryClient(self.mock_api,

self.project_id)

def test_csv_job_body_constructed_correctly(self):

expected_result = {

'status': {'state': 'RUNNING'},

}

body = {

"jobReference": {

"projectId": self.project_id,

"jobId": "job"

},

"configuration": {

"load": {

"sourceUris": ["sourceuri"],

"schema": {"fields": ["schema"]},

"destinationTable": {

"projectId": self.project_id,

"datasetId": self.dataset_id,

"tableId": self.table_id

},

"createDisposition": "a",

"writeDisposition": "b",

"fieldDelimiter": "c",

"skipLeadingRows": "d",

"encoding": "e",

"quote": "f",

"maxBadRecords": "g",

"allowQuotedNewlines": "h",

"sourceFormat": "CSV",

"allowJaggedRows": "j",

"ignoreUnknownValues": "k"

}

}

}

self.mock_api.jobs().insert().execute.return_value = expected_result

result = self.client.import_data_from_uris(["sourceuri"],

self.dataset_id,

self.table_id,

["schema"],

job="job",

create_disposition="a",

write_disposition="b",

field_delimiter="c",

skip_leading_rows="d",

encoding="e",

quote="f",

max_bad_records="g",

allow_quoted_newlines="h",

source_format="CSV",

allow_jagged_rows="j",

ignore_unknown_values="k")

self.mock_api.jobs().insert.assert_called_with(

projectId=self.project_id,

body=body

)

self.assertEqual(result, expected_result)

def test_json_job_body_constructed_correctly(self):

expected_result = {

'status': {'state': 'RUNNING'},

}

body = {

"jobReference": {

"projectId": self.project_id,

"jobId": "job"

},

"configuration": {

"load": {

"sourceUris": ["sourceuri"],

"schema": {"fields": ["schema"]},

"destinationTable": {

"projectId": self.project_id,

"datasetId": self.dataset_id,

"tableId": self.table_id

},

"sourceFormat": "JSON"

}

}

}

self.mock_api.jobs().insert().execute.return_value = expected_result

result = self.client.import_data_from_uris(["sourceuri"],

self.dataset_id,

self.table_id,

["schema"],

job="job",

source_format="JSON")

self.mock_api.jobs().insert.assert_called_with(

projectId=self.project_id,

body=body

)

self.assertEqual(result, expected_result)

@raises(Exception)

def test_field_delimiter_exception_if_not_csv(self):

"""Raise exception if csv-only parameter is set inappropriately"""

self.client.import_data_from_uris(["sourceuri"],

self.dataset_id,

self.table_id,

["schema"],

job="job",

source_format="JSON",

field_delimiter=",")

@raises(Exception)

def test_allow_jagged_rows_exception_if_not_csv(self):

"""Raise exception if csv-only parameter is set inappropriately"""

self.client.import_data_from_uris(["sourceuri"],

self.dataset_id,

self.table_id,

["schema"],

job="job",

source_format="JSON",

allow_jagged_rows=True)

@raises(Exception)

def test_allow_quoted_newlines_exception_if_not_csv(self):

"""Raise exception if csv-only parameter is set inappropriately"""

self.client.import_data_from_uris(["sourceuri"],

self.dataset_id,

self.table_id,

["schema"],

job="job",

source_format="JSON",

allow_quoted_newlines=True)

@raises(Exception)

def test_quote_exception_if_not_csv(self):

"""Raise exception if csv-only parameter is set inappropriately"""

self.client.import_data_from_uris(["sourceuri"],

self.dataset_id,

self.table_id,

["schema"],

job="job",

source_format="JSON",

quote="'")

@raises(Exception)

def test_skip_leading_rows_exception_if_not_csv(self):

"""Raise exception if csv-only parameter is set inappropriately"""

self.client.import_data_from_uris(["sourceuri"],

self.dataset_id,

self.table_id,

["schema"],

"job",

source_format="JSON",

skip_leading_rows=10)

def test_accepts_single_source_uri(self):

"""Ensure that a source_uri accepts a non-list"""

expected_result = {

'status': {'state': 'RUNNING'},

}

body = {

"jobReference": {

"projectId": self.project_id,

"jobId": "job"

},

"configuration": {

"load": {

"sourceUris": ["sourceuri"],

"schema": {"fields": ["schema"]},

"destinationTable": {

"projectId": self.project_id,

"datasetId": self.dataset_id,

"tableId": self.table_id

}

}

}

}

self.mock_api.jobs().insert().execute.return_value = expected_result

result = self.client.import_data_from_uris("sourceuri", # not a list!

self.dataset_id,

self.table_id,

schema=["schema"],

job="job")

self.mock_api.jobs().insert.assert_called_with(

projectId=self.project_id,

body=body

)

self.assertEqual(result, expected_result)

def test_import_http_error(self):

""" Test import with http error"""

expected_result = {

"error": {

"errors": [{

"domain": "global",

"reason": "required",

"message": "Required parameter is missing"

}],

"code": 400,

"message": "Required parameter is missing"

}

}

self.mock_api.jobs().insert().execute.return_value = expected_result

self.assertRaises(JobInsertException,

self.client.import_data_from_uris,

["sourceuri"],

self.dataset_id,

self.table_id)

def test_import_error_result(self):

""" Test import with error result"""

expected_result = {

"status": {