Skip to content

Commit f0c5cec

Browse files
dhermesdhermes
committed
Changing all instances of _callFUT to _call_fut.
Done via: $ git grep -l _callFUT | \ > xargs sed -i s/_callFUT/_call_fut/g
1 parent 5fb31c8 commit f0c5cec

File tree

32 files changed

+410
-410
lines changed

32 files changed

+410
-410
lines changed

‎CONTRIBUTING.rst‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -174,7 +174,7 @@ Coding Style
174174

175175
Exceptions to PEP8:
176176

177-
- Many unit tests use a helper method, ``_callFUT`` ("FUT" is short for
177+
- Many unit tests use a helper method, ``_call_fut`` ("FUT" is short for
178178
"Function-Under-Test"), which is PEP8-incompliant, but more readable.
179179
Some also use a local variable, ``MUT`` (short for "Module-Under-Test").
180180

‎bigquery/unit_tests/test__helpers.py‎

Lines changed: 44 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -17,177 +17,177 @@
1717

1818
class Test_not_null(unittest.TestCase):
1919

20-
def _callFUT(self, value, field):
20+
def _call_fut(self, value, field):
2121
from google.cloud.bigquery._helpers import _not_null
2222
return _not_null(value, field)
2323

2424
def test_w_none_nullable(self):
25-
self.assertFalse(self._callFUT(None, _Field('NULLABLE')))
25+
self.assertFalse(self._call_fut(None, _Field('NULLABLE')))
2626

2727
def test_w_none_required(self):
28-
self.assertTrue(self._callFUT(None, _Field('REQUIRED')))
28+
self.assertTrue(self._call_fut(None, _Field('REQUIRED')))
2929

3030
def test_w_value(self):
31-
self.assertTrue(self._callFUT(object(), object()))
31+
self.assertTrue(self._call_fut(object(), object()))
3232

3333

3434
class Test_int_from_json(unittest.TestCase):
3535

36-
def _callFUT(self, value, field):
36+
def _call_fut(self, value, field):
3737
from google.cloud.bigquery._helpers import _int_from_json
3838
return _int_from_json(value, field)
3939

4040
def test_w_none_nullable(self):
41-
self.assertIsNone(self._callFUT(None, _Field('NULLABLE')))
41+
self.assertIsNone(self._call_fut(None, _Field('NULLABLE')))
4242

4343
def test_w_none_required(self):
4444
with self.assertRaises(TypeError):
45-
self._callFUT(None, _Field('REQUIRED'))
45+
self._call_fut(None, _Field('REQUIRED'))
4646

4747
def test_w_string_value(self):
48-
coerced = self._callFUT('42', object())
48+
coerced = self._call_fut('42', object())
4949
self.assertEqual(coerced, 42)
5050

5151
def test_w_float_value(self):
52-
coerced = self._callFUT(42, object())
52+
coerced = self._call_fut(42, object())
5353
self.assertEqual(coerced, 42)
5454

5555

5656
class Test_float_from_json(unittest.TestCase):
5757

58-
def _callFUT(self, value, field):
58+
def _call_fut(self, value, field):
5959
from google.cloud.bigquery._helpers import _float_from_json
6060
return _float_from_json(value, field)
6161

6262
def test_w_none_nullable(self):
63-
self.assertIsNone(self._callFUT(None, _Field('NULLABLE')))
63+
self.assertIsNone(self._call_fut(None, _Field('NULLABLE')))
6464

6565
def test_w_none_required(self):
6666
with self.assertRaises(TypeError):
67-
self._callFUT(None, _Field('REQUIRED'))
67+
self._call_fut(None, _Field('REQUIRED'))
6868

6969
def test_w_string_value(self):
70-
coerced = self._callFUT('3.1415', object())
70+
coerced = self._call_fut('3.1415', object())
7171
self.assertEqual(coerced, 3.1415)
7272

7373
def test_w_float_value(self):
74-
coerced = self._callFUT(3.1415, object())
74+
coerced = self._call_fut(3.1415, object())
7575
self.assertEqual(coerced, 3.1415)
7676

7777

7878
class Test_bool_from_json(unittest.TestCase):
7979

80-
def _callFUT(self, value, field):
80+
def _call_fut(self, value, field):
8181
from google.cloud.bigquery._helpers import _bool_from_json
8282
return _bool_from_json(value, field)
8383

8484
def test_w_none_nullable(self):
85-
self.assertIsNone(self._callFUT(None, _Field('NULLABLE')))
85+
self.assertIsNone(self._call_fut(None, _Field('NULLABLE')))
8686

8787
def test_w_none_required(self):
8888
with self.assertRaises(AttributeError):
89-
self._callFUT(None, _Field('REQUIRED'))
89+
self._call_fut(None, _Field('REQUIRED'))
9090

9191
def test_w_value_t(self):
92-
coerced = self._callFUT('T', object())
92+
coerced = self._call_fut('T', object())
9393
self.assertTrue(coerced)
9494

9595
def test_w_value_true(self):
96-
coerced = self._callFUT('True', object())
96+
coerced = self._call_fut('True', object())
9797
self.assertTrue(coerced)
9898

9999
def test_w_value_1(self):
100-
coerced = self._callFUT('1', object())
100+
coerced = self._call_fut('1', object())
101101
self.assertTrue(coerced)
102102

103103
def test_w_value_other(self):
104-
coerced = self._callFUT('f', object())
104+
coerced = self._call_fut('f', object())
105105
self.assertFalse(coerced)
106106

107107

108108
class Test_datetime_from_json(unittest.TestCase):
109109

110-
def _callFUT(self, value, field):
110+
def _call_fut(self, value, field):
111111
from google.cloud.bigquery._helpers import _datetime_from_json
112112
return _datetime_from_json(value, field)
113113

114114
def test_w_none_nullable(self):
115-
self.assertIsNone(self._callFUT(None, _Field('NULLABLE')))
115+
self.assertIsNone(self._call_fut(None, _Field('NULLABLE')))
116116

117117
def test_w_none_required(self):
118118
with self.assertRaises(TypeError):
119-
self._callFUT(None, _Field('REQUIRED'))
119+
self._call_fut(None, _Field('REQUIRED'))
120120

121121
def test_w_string_value(self):
122122
import datetime
123123
from google.cloud._helpers import _EPOCH
124-
coerced = self._callFUT('1.234567', object())
124+
coerced = self._call_fut('1.234567', object())
125125
self.assertEqual(
126126
coerced,
127127
_EPOCH + datetime.timedelta(seconds=1, microseconds=234567))
128128

129129
def test_w_float_value(self):
130130
import datetime
131131
from google.cloud._helpers import _EPOCH
132-
coerced = self._callFUT(1.234567, object())
132+
coerced = self._call_fut(1.234567, object())
133133
self.assertEqual(
134134
coerced,
135135
_EPOCH + datetime.timedelta(seconds=1, microseconds=234567))
136136

137137

138138
class Test_date_from_json(unittest.TestCase):
139139

140-
def _callFUT(self, value, field):
140+
def _call_fut(self, value, field):
141141
from google.cloud.bigquery._helpers import _date_from_json
142142
return _date_from_json(value, field)
143143

144144
def test_w_none_nullable(self):
145-
self.assertIsNone(self._callFUT(None, _Field('NULLABLE')))
145+
self.assertIsNone(self._call_fut(None, _Field('NULLABLE')))
146146

147147
def test_w_none_required(self):
148148
with self.assertRaises(TypeError):
149-
self._callFUT(None, _Field('REQUIRED'))
149+
self._call_fut(None, _Field('REQUIRED'))
150150

151151
def test_w_string_value(self):
152152
import datetime
153-
coerced = self._callFUT('1987-09-22', object())
153+
coerced = self._call_fut('1987-09-22', object())
154154
self.assertEqual(
155155
coerced,
156156
datetime.date(1987, 9, 22))
157157

158158

159159
class Test_record_from_json(unittest.TestCase):
160160

161-
def _callFUT(self, value, field):
161+
def _call_fut(self, value, field):
162162
from google.cloud.bigquery._helpers import _record_from_json
163163
return _record_from_json(value, field)
164164

165165
def test_w_none_nullable(self):
166-
self.assertIsNone(self._callFUT(None, _Field('NULLABLE')))
166+
self.assertIsNone(self._call_fut(None, _Field('NULLABLE')))
167167

168168
def test_w_none_required(self):
169169
with self.assertRaises(TypeError):
170-
self._callFUT(None, _Field('REQUIRED'))
170+
self._call_fut(None, _Field('REQUIRED'))
171171

172172
def test_w_nullable_subfield_none(self):
173173
subfield = _Field('NULLABLE', 'age', 'INTEGER')
174174
field = _Field('REQUIRED', fields=[subfield])
175175
value = {'f': [{'v': None}]}
176-
coerced = self._callFUT(value, field)
176+
coerced = self._call_fut(value, field)
177177
self.assertEqual(coerced, {'age': None})
178178

179179
def test_w_scalar_subfield(self):
180180
subfield = _Field('REQUIRED', 'age', 'INTEGER')
181181
field = _Field('REQUIRED', fields=[subfield])
182182
value = {'f': [{'v': 42}]}
183-
coerced = self._callFUT(value, field)
183+
coerced = self._call_fut(value, field)
184184
self.assertEqual(coerced, {'age': 42})
185185

186186
def test_w_repeated_subfield(self):
187187
subfield = _Field('REPEATED', 'color', 'STRING')
188188
field = _Field('REQUIRED', fields=[subfield])
189189
value = {'f': [{'v': ['red', 'yellow', 'blue']}]}
190-
coerced = self._callFUT(value, field)
190+
coerced = self._call_fut(value, field)
191191
self.assertEqual(coerced, {'color': ['red', 'yellow', 'blue']})
192192

193193
def test_w_record_subfield(self):
@@ -213,30 +213,30 @@ def test_w_record_subfield(self):
213213
'rank': 1,
214214
}
215215
}
216-
coerced = self._callFUT(value, person)
216+
coerced = self._call_fut(value, person)
217217
self.assertEqual(coerced, expected)
218218

219219

220220
class Test_string_from_json(unittest.TestCase):
221221

222-
def _callFUT(self, value, field):
222+
def _call_fut(self, value, field):
223223
from google.cloud.bigquery._helpers import _string_from_json
224224
return _string_from_json(value, field)
225225

226226
def test_w_none_nullable(self):
227-
self.assertIsNone(self._callFUT(None, _Field('NULLABLE')))
227+
self.assertIsNone(self._call_fut(None, _Field('NULLABLE')))
228228

229229
def test_w_none_required(self):
230-
self.assertIsNone(self._callFUT(None, _Field('RECORD')))
230+
self.assertIsNone(self._call_fut(None, _Field('RECORD')))
231231

232232
def test_w_string_value(self):
233-
coerced = self._callFUT('Wonderful!', object())
233+
coerced = self._call_fut('Wonderful!', object())
234234
self.assertEqual(coerced, 'Wonderful!')
235235

236236

237237
class Test_rows_from_json(unittest.TestCase):
238238

239-
def _callFUT(self, value, field):
239+
def _call_fut(self, value, field):
240240
from google.cloud.bigquery._helpers import _rows_from_json
241241
return _rows_from_json(value, field)
242242

@@ -281,7 +281,7 @@ def test_w_record_subfield(self):
281281
('Bharney Rhubble', bharney_phone, ['brown']),
282282
('Wylma Phlyntstone', None, []),
283283
]
284-
coerced = self._callFUT(rows, schema)
284+
coerced = self._call_fut(rows, schema)
285285
self.assertEqual(coerced, expected)
286286

287287
def test_w_int64_float64(self):
@@ -312,7 +312,7 @@ def test_w_int64_float64(self):
312312
('Bharney Rhubble', 4, 0.125),
313313
('Wylma Phlyntstone', 20, 0.625),
314314
]
315-
coerced = self._callFUT(rows, schema)
315+
coerced = self._call_fut(rows, schema)
316316
self.assertEqual(coerced, expected)
317317

318318

‎bigquery/unit_tests/test_table.py‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1768,7 +1768,7 @@ class _UploadConfig(object):
17681768

17691769
class Test_parse_schema_resource(unittest.TestCase, _SchemaBase):
17701770

1771-
def _callFUT(self, resource):
1771+
def _call_fut(self, resource):
17721772
from google.cloud.bigquery.table import _parse_schema_resource
17731773
return _parse_schema_resource(resource)
17741774

@@ -1782,7 +1782,7 @@ def _makeResource(self):
17821782

17831783
def test__parse_schema_resource_defaults(self):
17841784
RESOURCE = self._makeResource()
1785-
schema = self._callFUT(RESOURCE['schema'])
1785+
schema = self._call_fut(RESOURCE['schema'])
17861786
self._verifySchema(schema, RESOURCE)
17871787

17881788
def test__parse_schema_resource_subfields(self):
@@ -1797,7 +1797,7 @@ def test__parse_schema_resource_subfields(self):
17971797
{'name': 'number',
17981798
'type': 'STRING',
17991799
'mode': 'REQUIRED'}]})
1800-
schema = self._callFUT(RESOURCE['schema'])
1800+
schema = self._call_fut(RESOURCE['schema'])
18011801
self._verifySchema(schema, RESOURCE)
18021802

18031803
def test__parse_schema_resource_fields_without_mode(self):
@@ -1806,21 +1806,21 @@ def test__parse_schema_resource_fields_without_mode(self):
18061806
{'name': 'phone',
18071807
'type': 'STRING'})
18081808

1809-
schema = self._callFUT(RESOURCE['schema'])
1809+
schema = self._call_fut(RESOURCE['schema'])
18101810
self._verifySchema(schema, RESOURCE)
18111811

18121812

18131813
class Test_build_schema_resource(unittest.TestCase, _SchemaBase):
18141814

1815-
def _callFUT(self, resource):
1815+
def _call_fut(self, resource):
18161816
from google.cloud.bigquery.table import _build_schema_resource
18171817
return _build_schema_resource(resource)
18181818

18191819
def test_defaults(self):
18201820
from google.cloud.bigquery.table import SchemaField
18211821
full_name = SchemaField('full_name', 'STRING', mode='REQUIRED')
18221822
age = SchemaField('age', 'INTEGER', mode='REQUIRED')
1823-
resource = self._callFUT([full_name, age])
1823+
resource = self._call_fut([full_name, age])
18241824
self.assertEqual(len(resource), 2)
18251825
self.assertEqual(resource[0],
18261826
{'name': 'full_name',
@@ -1837,7 +1837,7 @@ def test_w_description(self):
18371837
full_name = SchemaField('full_name', 'STRING', mode='REQUIRED',
18381838
description=DESCRIPTION)
18391839
age = SchemaField('age', 'INTEGER', mode='REQUIRED')
1840-
resource = self._callFUT([full_name, age])
1840+
resource = self._call_fut([full_name, age])
18411841
self.assertEqual(len(resource), 2)
18421842
self.assertEqual(resource[0],
18431843
{'name': 'full_name',
@@ -1856,7 +1856,7 @@ def test_w_subfields(self):
18561856
ph_num = SchemaField('number', 'STRING', 'REQUIRED')
18571857
phone = SchemaField('phone', 'RECORD', mode='REPEATABLE',
18581858
fields=[ph_type, ph_num])
1859-
resource = self._callFUT([full_name, phone])
1859+
resource = self._call_fut([full_name, phone])
18601860
self.assertEqual(len(resource), 2)
18611861
self.assertEqual(resource[0],
18621862
{'name': 'full_name',

0 commit comments

Comments
 (0)