import actions import logger import testsamples import test_engine from test_engine import Table, Column log = logger.Logger(__name__, logger.INFO) class TestDocModel(test_engine.EngineTestCase): def test_meta_tables(self): """ Test changes to records accessed via lookup. """ self.load_sample(testsamples.sample_students) self.assertPartialData("_grist_Tables", ["id", "columns"], [ [1, [1,2,4,5,6]], [2, [10,12]], [3, [21]], ]) # Test that adding a column produces a change to 'columns' without emitting an action. out_actions = self.add_column('Students', 'test', type='Text', isFormula=False) self.assertPartialData("_grist_Tables", ["id", "columns"], [ [1, [1,2,4,5,6,22]], [2, [10,12]], [3, [21]], ]) self.assertPartialOutActions(out_actions, { "calc": [], "stored": [ ["AddColumn", "Students", "test", {"formula": "", "isFormula": False, "type": "Text"} ], ["AddRecord", "_grist_Tables_column", 22, {"colId": "test", "formula": "", "isFormula": False, "label": "test", "parentId": 1, "parentPos": 6.0, "type": "Text", "widgetOptions": ""} ], ], "undo": [ ["RemoveColumn", "Students", "test"], ["RemoveRecord", "_grist_Tables_column", 22], ] }) # Undo the AddColumn action. Check that actions are in correct order, and still produce undos. out_actions = self.apply_user_action( ['ApplyUndoActions', [actions.get_action_repr(a) for a in out_actions.undo]]) self.assertPartialOutActions(out_actions, { "calc": [], "stored": [ ["RemoveRecord", "_grist_Tables_column", 22], ["RemoveColumn", "Students", "test"], ], "undo": [ ["AddRecord", "_grist_Tables_column", 22, {"colId": "test", "label": "test", "parentId": 1, "parentPos": 6.0, "type": "Text"}], ["AddColumn", "Students", "test", {"formula": "", "isFormula": False, "type": "Text"}], ] }) # Test that when we add a table, .column is set correctly. out_actions = self.apply_user_action(['AddTable', 'Test2', [ {'id': 'A', 'type': 'Text'}, {'id': 'B', 'type': 'Numeric'}, {'id': 'C', 'type': 'Numeric', 'formula': 'len($A)', 'isFormula': True} ]]) self.assertPartialData("_grist_Tables", ["id", "columns"], [ [1, [1,2,4,5,6]], [2, [10,12]], [3, [21]], [4, [22,23,24,25]], ]) self.assertPartialData("_grist_Tables_column", ["id", "colId", "parentId"], [ [1, "firstName", 1], [2, "lastName", 1], [4, "schoolName", 1], [5, "schoolIds", 1], [6, "schoolCities", 1], [10, "name", 2], [12, "address", 2], [21, "city", 3], # Newly added columns: [22, 'manualSort', 4], [23, 'A', 4], [24, 'B', 4], [25, 'C', 4], ]) def test_add_column_position(self): self.load_sample(testsamples.sample_students) # Client may send AddColumn actions with fractional positions. Test that it works. # TODO: this should probably use parentPos in the future and be done via metadata AddRecord. out_actions = self.add_column('Students', 'test', type='Text', _position=2.75) self.assertPartialData("_grist_Tables", ["id", "columns"], [ [1, [1,2,22,4,5,6]], [2, [10,12]], [3, [21]], ]) out_actions = self.add_column('Students', None, type='Text', _position=6) self.assertPartialData("_grist_Tables", ["id", "columns"], [ [1, [1,2,22,4,5,6,23]], [2, [10,12]], [3, [21]], ]) self.assertPartialData("_grist_Tables_column", ["id", "colId", "parentId"], [ [1, "firstName", 1], [2, "lastName", 1], [4, "schoolName", 1], [5, "schoolIds", 1], [6, "schoolCities", 1], [10, "name", 2], [12, "address", 2], [21, "city", 3], [22, "test", 1], [23, "A", 1], ]) def assertRecordSet(self, record_set, expected_row_ids): self.assertEqual(list(record_set.id), expected_row_ids) def test_lookup_recompute(self): self.load_sample(testsamples.sample_students) self.apply_user_action(['AddTable', 'Test2', [ {'id': 'A', 'type': 'Text'}, {'id': 'B', 'type': 'Numeric'}, ]]) self.apply_user_action(['AddTable', 'Test3', [ {'id': 'A', 'type': 'Text'}, {'id': 'B', 'type': 'Numeric'}, ]]) self.apply_user_action(['AddViewSection', 'Section2', 'record', 1, 'Test2']) self.apply_user_action(['AddViewSection', 'Section3', 'record', 1, 'Test3']) self.assertPartialData('_grist_Views', ["id"], [ [1], [2], ]) self.assertPartialData('_grist_Views_section', ["id", "parentId", "tableRef"], [ [1, 1, 4], [2, 2, 5], [3, 1, 4], [4, 1, 5], ]) self.assertPartialData('_grist_Views_section_field', ["id", "parentId", "parentPos"], [ [1, 1, 1.0], [2, 1, 2.0], [3, 2, 3.0], [4, 2, 4.0], [5, 3, 5.0], [6, 3, 6.0], [7, 4, 7.0], [8, 4, 8.0], ]) table = self.engine.docmodel.tables.lookupOne(tableId='Test2') self.assertRecordSet(table.viewSections, [1,3]) self.assertRecordSet(list(table.viewSections)[0].fields, [1,2]) self.assertRecordSet(list(table.viewSections)[1].fields, [5,6]) view = self.engine.docmodel.views.lookupOne(id=1) self.assertRecordSet(view.viewSections, [1,3,4]) self.engine.docmodel.remove(f for vs in table.viewSections for f in vs.fields) self.engine.docmodel.remove(table.viewSections) self.assertRecordSet(view.viewSections, [4]) def test_modifications(self): # Test the add/remove/update methods of DocModel. self.load_sample(testsamples.sample_students) table = self.engine.docmodel.get_table('Students') records = table.lookupRecords(lastName='Bush') self.assertEqual([r.id for r in records], [2, 4]) self.assertEqual([r.schoolName for r in records], ["Yale", "Yale"]) self.assertEqual([r.firstName for r in records], ["George W", "George H"]) # Test the update() method. self.engine.docmodel.update(records, schoolName="Test", firstName=["george w", "george h"]) self.assertEqual([r.schoolName for r in records], ["Test", "Test"]) self.assertEqual([r.firstName for r in records], ["george w", "george h"]) # Test the remove() method. self.engine.docmodel.remove(records) records = table.lookupRecords(lastName='Bush') self.assertEqual(list(records), []) self.assertTableData("Students", cols="subset", data=[ ["id","firstName","lastName", "schoolName" ], [1, "Barack", "Obama", "Columbia" ], [3, "Bill", "Clinton", "Columbia" ], [5, "Ronald", "Reagan", "Eureka" ], [6, "Gerald", "Ford", "Yale" ]]) # Test the add() method. self.engine.docmodel.add(table, schoolName="Foo", firstName=["X", "Y"]) self.assertTableData("Students", cols="subset", data=[ ["id","firstName","lastName", "schoolName" ], [1, "Barack", "Obama", "Columbia" ], [3, "Bill", "Clinton", "Columbia" ], [5, "Ronald", "Reagan", "Eureka" ], [6, "Gerald", "Ford", "Yale" ], [7, "X", "", "Foo" ], [8, "Y", "", "Foo" ], ]) def test_inserts(self): # Test the insert() method. We do this on the columns metadata table, so that we can sort by # a PositionNumber column. self.load_sample(testsamples.sample_students) student_columns = self.engine.docmodel.tables.lookupOne(tableId='Students').columns school_columns = self.engine.docmodel.tables.lookupOne(tableId='Schools').columns # Should go at the end of the Students table. cols = self.engine.docmodel.insert(student_columns, None, colId=["a", "b"], type="Text") # Should go at the start of the Schools table. self.engine.docmodel.insert_after(school_columns, None, colId="foo", type="Int") # Should go before the new "a", "b" columns of the Students table. self.engine.docmodel.insert(student_columns, cols[0].parentPos, colId="bar", type="Date") # Verify that the right columns were added to the right tables. This doesn't check positions. self.assertTables([ Table(1, "Students", 0, 0, columns=[ Column(1, "firstName", "Text", False, "", 0), Column(2, "lastName", "Text", False, "", 0), Column(4, "schoolName", "Text", False, "", 0), Column(5, "schoolIds", "Text", True, "':'.join(str(id) for id in Schools.lookupRecords(name=$schoolName).id)", 0), Column(6, "schoolCities", "Text", True, "':'.join(r.address.city for r in Schools.lookupRecords(name=$schoolName))", 0), Column(22, "a", "Text", False, "", 0), Column(23, "b", "Text", False, "", 0), Column(25, "bar", "Date", False, "", 0), ]), Table(2, "Schools", 0, 0, columns=[ Column(10, "name", "Text", False, "", 0), Column(12, "address", "Ref:Address",False, "", 0), Column(24, "foo", "Int", False, "", 0), ]), Table(3, "Address", 0, 0, columns=[ Column(21, "city", "Text", False, "", 0), ]) ]) # Verify that positions are set such that the order is what we asked for. student_columns = self.engine.docmodel.tables.lookupOne(tableId='Students').columns self.assertEqual(list(map(int, student_columns)), [1,2,4,5,6,25,22,23]) school_columns = self.engine.docmodel.tables.lookupOne(tableId='Schools').columns self.assertEqual(list(map(int, school_columns)), [24,10,12])