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)
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')