class TestFlexibleTable(unittest.TestCase):
def setUp(self):
self.table = FlexibleTable()
def test_FlexibleTable_is_present_on_main_namespace(self):
self.assertIn("FlexibleTable", dir(rows))
self.assertIs(FlexibleTable, rows.FlexibleTable)
def test_inheritance(self):
self.assertTrue(issubclass(FlexibleTable, Table))
def test_flexible_append_detect_field_type(self):
self.assertEqual(len(self.table.fields), 0)
self.table.append({"a": 123, "b": 3.14})
self.assertEqual(self.table[0].a, 123)
self.assertEqual(self.table[0].b, 3.14)
self.assertEqual(self.table.fields["a"], fields.IntegerField)
self.assertEqual(self.table.fields["b"], fields.FloatField)
# Values are checked based on field types when appending
with self.assertRaises(ValueError):
self.table.append({
"a": "spam",
"b": 1.23
}) # invalid value for 'a'
with self.assertRaises(ValueError):
self.table.append({"a": 42, "b": "ham"}) # invalid value or 'b'
# Values are converted
self.table.append({"a": "42", "b": "2.71"})
self.assertEqual(self.table[1].a, 42)
self.assertEqual(self.table[1].b, 2.71)
def test_flexible_insert_row(self):
self.table.append({"a": 123, "b": 3.14})
self.table.insert(0, {"a": 2357, "b": 1123})
self.assertEqual(self.table[0].a, 2357)
def test_flexible_update_row(self):
self.table.append({"a": 123, "b": 3.14})
self.table[0] = {"a": 2357, "b": 1123}
self.assertEqual(self.table[0].a, 2357)
def test_table_slicing(self):
self.table.append({"a": 123, "b": 3.14})
self.table.append({"a": 2357, "b": 1123})
self.table.append({"a": 8687, "b": 834798})
self.assertEqual(len(self.table[::2]), 2)
self.assertEqual(self.table[::2][0].a, 123)
def test_table_slicing_error(self):
self.table.append({"a": 123, "b": 3.14})
self.table.append({"a": 2357, "b": 1123})
self.table.append({"a": 8687, "b": 834798})
with self.assertRaises(ValueError) as context_manager:
self.table[[1]]
self.assertEqual(type(context_manager.exception), ValueError)
def test_table_iadd(self):
table = rows.Table(fields={
"f1": rows.fields.IntegerField,
"f2": rows.fields.FloatField
})
table.append({"f1": 1, "f2": 2})
table.append({"f1": 3, "f2": 4})
self.assertEqual(len(table), 2)
table += table
self.assertEqual(len(table), 4)
data_rows = list(table)
self.assertEqual(data_rows[0], data_rows[2])
self.assertEqual(data_rows[1], data_rows[3])
def test_table_name(self):
table = rows.Table(
fields=collections.OrderedDict([("a", fields.TextField)]))
self.assertTrue("filename" not in table.meta)
self.assertEqual(table.name, "table1")
table.meta["filename"] = "This is THE name.csv"
self.assertTrue("filename" in table.meta)
self.assertEqual(table.name, "this_is_the_name")
def setUp(self):
self.table = FlexibleTable()
class TestFlexibleTable(unittest.TestCase):
def setUp(self):
self.table = FlexibleTable()
def test_FlexibleTable_is_present_on_main_namespace(self):
self.assertIn('FlexibleTable', dir(rows))
self.assertIs(FlexibleTable, rows.FlexibleTable)
def test_inheritance(self):
self.assertTrue(issubclass(FlexibleTable, Table))
def test_flexible_append_detect_field_type(self):
self.assertEqual(len(self.table.fields), 0)
self.table.append({
'a': 123,
'b': 3.14,
})
self.assertEqual(self.table[0].a, 123)
self.assertEqual(self.table[0].b, 3.14)
self.assertEqual(self.table.fields['a'], fields.IntegerField)
self.assertEqual(self.table.fields['b'], fields.FloatField)
# Values are checked based on field types when appending
with self.assertRaises(ValueError):
self.table.append({
'a': 'spam',
'b': 1.23
}) # invalid value for 'a'
with self.assertRaises(ValueError):
self.table.append({'a': 42, 'b': 'ham'}) # invalid value or 'b'
# Values are converted
self.table.append({'a': '42', 'b': '2.71'})
self.assertEqual(self.table[1].a, 42)
self.assertEqual(self.table[1].b, 2.71)
def test_flexible_insert_row(self):
self.table.append({
'a': 123,
'b': 3.14,
})
self.table.insert(0, {'a': 2357, 'b': 1123})
self.assertEqual(self.table[0].a, 2357)
def test_flexible_update_row(self):
self.table.append({
'a': 123,
'b': 3.14,
})
self.table[0] = {'a': 2357, 'b': 1123}
self.assertEqual(self.table[0].a, 2357)
def test_table_slicing(self):
self.table.append({
'a': 123,
'b': 3.14,
})
self.table.append({'a': 2357, 'b': 1123})
self.table.append({'a': 8687, 'b': 834798})
self.assertEqual(len(self.table[::2]), 2)
self.assertEqual(self.table[::2][0].a, 123)
def test_table_slicing_error(self):
self.table.append({
'a': 123,
'b': 3.14,
})
self.table.append({'a': 2357, 'b': 1123})
self.table.append({'a': 8687, 'b': 834798})
with self.assertRaises(ValueError) as context_manager:
self.table[[1]]
self.assertEqual(type(context_manager.exception), ValueError)
def setUp(self):
self.table = FlexibleTable()
class TestFlexibleTable(unittest.TestCase):
def setUp(self):
self.table = FlexibleTable()
def test_FlexibleTable_is_present_on_main_namespace(self):
self.assertIn("FlexibleTable", dir(rows))
self.assertIs(FlexibleTable, rows.FlexibleTable)
def test_inheritance(self):
self.assertTrue(issubclass(FlexibleTable, Table))
def test_flexible_append_detect_field_type(self):
self.assertEqual(len(self.table.fields), 0)
self.table.append({"a": 123, "b": 3.14})
self.assertEqual(self.table[0].a, 123)
self.assertEqual(self.table[0].b, 3.14)
self.assertEqual(self.table.fields["a"], fields.IntegerField)
self.assertEqual(self.table.fields["b"], fields.FloatField)
# Values are checked based on field types when appending
with self.assertRaises(ValueError):
self.table.append({"a": "spam", "b": 1.23}) # invalid value for 'a'
with self.assertRaises(ValueError):
self.table.append({"a": 42, "b": "ham"}) # invalid value or 'b'
# Values are converted
self.table.append({"a": "42", "b": "2.71"})
self.assertEqual(self.table[1].a, 42)
self.assertEqual(self.table[1].b, 2.71)
def test_flexible_insert_row(self):
self.table.append({"a": 123, "b": 3.14})
self.table.insert(0, {"a": 2357, "b": 1123})
self.assertEqual(self.table[0].a, 2357)
def test_flexible_update_row(self):
self.table.append({"a": 123, "b": 3.14})
self.table[0] = {"a": 2357, "b": 1123}
self.assertEqual(self.table[0].a, 2357)
def test_table_slicing(self):
self.table.append({"a": 123, "b": 3.14})
self.table.append({"a": 2357, "b": 1123})
self.table.append({"a": 8687, "b": 834798})
self.assertEqual(len(self.table[::2]), 2)
self.assertEqual(self.table[::2][0].a, 123)
def test_table_slicing_error(self):
self.table.append({"a": 123, "b": 3.14})
self.table.append({"a": 2357, "b": 1123})
self.table.append({"a": 8687, "b": 834798})
with self.assertRaises(ValueError) as context_manager:
self.table[[1]]
self.assertEqual(type(context_manager.exception), ValueError)
def test_table_iadd(self):
table = rows.Table(
fields={"f1": rows.fields.IntegerField, "f2": rows.fields.FloatField}
)
table.append({"f1": 1, "f2": 2})
table.append({"f1": 3, "f2": 4})
self.assertEqual(len(table), 2)
table += table
self.assertEqual(len(table), 4)
data_rows = list(table)
self.assertEqual(data_rows[0], data_rows[2])
self.assertEqual(data_rows[1], data_rows[3])
def test_table_name(self):
table = rows.Table(fields=collections.OrderedDict([("a", fields.TextField)]))
self.assertTrue("filename" not in table.meta)
self.assertEqual(table.name, "table1")
table.meta["filename"] = "This is THE name.csv"
self.assertTrue("filename" in table.meta)
self.assertEqual(table.name, "this_is_the_name")
class TestFlexibleTable(unittest.TestCase):
def setUp(self):
self.table = FlexibleTable()
def test_FlexibleTable_is_present_on_main_namespace(self):
self.assertIn('FlexibleTable', dir(rows))
self.assertIs(FlexibleTable, rows.FlexibleTable)
def test_inheritance(self):
self.assertTrue(issubclass(FlexibleTable, Table))
def test_flexible_append_detect_field_type(self):
self.assertEqual(len(self.table.fields), 0)
self.table.append({'a': 123, 'b': 3.14, })
self.assertEqual(self.table[0].a, 123)
self.assertEqual(self.table[0].b, 3.14)
self.assertEqual(self.table.fields['a'], fields.IntegerField)
self.assertEqual(self.table.fields['b'], fields.FloatField)
# Values are checked based on field types when appending
with self.assertRaises(ValueError):
self.table.append({'a': 'spam', 'b': 1.23}) # invalid value for 'a'
with self.assertRaises(ValueError):
self.table.append({'a': 42, 'b': 'ham'}) # invalid value or 'b'
# Values are converted
self.table.append({'a': '42', 'b': '2.71'})
self.assertEqual(self.table[1].a, 42)
self.assertEqual(self.table[1].b, 2.71)
def test_flexible_insert_row(self):
self.table.append({'a': 123, 'b': 3.14, })
self.table.insert(0, {'a': 2357, 'b': 1123})
self.assertEqual(self.table[0].a, 2357)
def test_flexible_update_row(self):
self.table.append({'a': 123, 'b': 3.14, })
self.table[0] = {'a': 2357, 'b': 1123}
self.assertEqual(self.table[0].a, 2357)
def test_table_slicing(self):
self.table.append({'a': 123, 'b': 3.14, })
self.table.append({'a': 2357, 'b': 1123})
self.table.append({'a': 8687, 'b': 834798})
self.assertEqual(len(self.table[::2]), 2)
self.assertEqual(self.table[::2][0].a, 123)
def test_table_slicing_error(self):
self.table.append({'a': 123, 'b': 3.14, })
self.table.append({'a': 2357, 'b': 1123})
self.table.append({'a': 8687, 'b': 834798})
with self.assertRaises(ValueError) as context_manager:
self.table[[1]]
self.assertEqual(type(context_manager.exception), ValueError)
class TestFlexibleTable(unittest.TestCase):
def setUp(self):
self.table = FlexibleTable()
def test_FlexibleTable_is_present_on_main_namespace(self):
self.assertIn('FlexibleTable', dir(rows))
self.assertIs(FlexibleTable, rows.FlexibleTable)
def test_inheritance(self):
self.assertTrue(issubclass(FlexibleTable, Table))
def test_flexible_append_detect_field_type(self):
self.assertEqual(len(self.table.fields), 0)
self.table.append({
'a': 123,
'b': 3.14,
})
self.assertEqual(self.table[0].a, 123)
self.assertEqual(self.table[0].b, 3.14)
self.assertEqual(self.table.fields['a'], fields.IntegerField)
self.assertEqual(self.table.fields['b'], fields.FloatField)
# Values are checked based on field types when appending
with self.assertRaises(ValueError):
self.table.append({
'a': 'spam',
'b': 1.23
}) # invalid value for 'a'
with self.assertRaises(ValueError):
self.table.append({'a': 42, 'b': 'ham'}) # invalid value or 'b'
# Values are converted
self.table.append({'a': '42', 'b': '2.71'})
self.assertEqual(self.table[1].a, 42)
self.assertEqual(self.table[1].b, 2.71)
def test_flexible_insert_row(self):
self.table.append({
'a': 123,
'b': 3.14,
})
self.table.insert(0, {'a': 2357, 'b': 1123})
self.assertEqual(self.table[0].a, 2357)
def test_flexible_update_row(self):
self.table.append({
'a': 123,
'b': 3.14,
})
self.table[0] = {'a': 2357, 'b': 1123}
self.assertEqual(self.table[0].a, 2357)
def test_table_slicing(self):
self.table.append({
'a': 123,
'b': 3.14,
})
self.table.append({'a': 2357, 'b': 1123})
self.table.append({'a': 8687, 'b': 834798})
self.assertEqual(len(self.table[::2]), 2)
self.assertEqual(self.table[::2][0].a, 123)
def test_table_slicing_error(self):
self.table.append({
'a': 123,
'b': 3.14,
})
self.table.append({'a': 2357, 'b': 1123})
self.table.append({'a': 8687, 'b': 834798})
with self.assertRaises(ValueError) as context_manager:
self.table[[1]]
self.assertEqual(type(context_manager.exception), ValueError)
def test_table_iadd(self):
table = rows.Table(fields={
'f1': rows.fields.IntegerField,
'f2': rows.fields.FloatField
})
table.append({'f1': 1, 'f2': 2})
table.append({'f1': 3, 'f2': 4})
self.assertEqual(len(table), 2)
table += table
self.assertEqual(len(table), 4)
data_rows = list(table)
self.assertEqual(data_rows[0], data_rows[2])
self.assertEqual(data_rows[1], data_rows[3])
def test_table_name(self):
table = rows.Table(fields=collections.OrderedDict([
('a', fields.TextField),
]))
self.assertTrue('filename' not in table.meta)
self.assertEqual(table.name, 'table1')
table.meta['filename'] = 'This is THE name.csv'
self.assertTrue('filename' in table.meta)
self.assertEqual(table.name, 'this_is_the_name')