You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
834 lines
34 KiB
834 lines
34 KiB
import logging
|
|
import actions
|
|
|
|
import testsamples
|
|
import testutil
|
|
import test_engine
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
def _bulk_update(table_name, col_names, row_data):
|
|
return actions.BulkUpdateRecord(
|
|
*testutil.table_data_from_rows(table_name, col_names, row_data))
|
|
|
|
class TestLookups(test_engine.EngineTestCase):
|
|
|
|
def test_verify_sample(self):
|
|
self.load_sample(testsamples.sample_students)
|
|
self.assertPartialData("Students", ["id", "schoolIds", "schoolCities" ], [
|
|
[1, "1:2", "New York:Colombia" ],
|
|
[2, "3:4", "New Haven:West Haven" ],
|
|
[3, "1:2", "New York:Colombia" ],
|
|
[4, "3:4", "New Haven:West Haven" ],
|
|
[5, "", ""],
|
|
[6, "3:4", "New Haven:West Haven" ]
|
|
])
|
|
|
|
|
|
#----------------------------------------
|
|
def test_lookup_dependencies(self, pre_loaded=False):
|
|
"""
|
|
Test changes to records accessed via lookup.
|
|
"""
|
|
if not pre_loaded:
|
|
self.load_sample(testsamples.sample_students)
|
|
|
|
out_actions = self.update_record("Address", 14, city="Bedford")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.UpdateRecord("Address", 14, {"city": "Bedford"}),
|
|
_bulk_update("Students", ["id", "schoolCities" ], [
|
|
[2, "New Haven:Bedford" ],
|
|
[4, "New Haven:Bedford" ],
|
|
[6, "New Haven:Bedford" ]]
|
|
)
|
|
],
|
|
"calls": {"Students": {"schoolCities": 3}}
|
|
})
|
|
|
|
out_actions = self.update_record("Schools", 4, address=13)
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.UpdateRecord("Schools", 4, {"address": 13}),
|
|
_bulk_update("Students", ["id", "schoolCities" ], [
|
|
[2, "New Haven:New Haven" ],
|
|
[4, "New Haven:New Haven" ],
|
|
[6, "New Haven:New Haven" ]]
|
|
)
|
|
],
|
|
"calls": {"Students": {"schoolCities": 3}}
|
|
})
|
|
|
|
out_actions = self.update_record("Address", 14, city="Hartford")
|
|
# No schoolCities need to be recalculatd here, since nothing depends on Address 14 any more.
|
|
self.assertPartialOutActions(out_actions, {
|
|
"calls": {}
|
|
})
|
|
|
|
# Confirm the final result.
|
|
self.assertPartialData("Students", ["id", "schoolIds", "schoolCities" ], [
|
|
[1, "1:2", "New York:Colombia" ],
|
|
[2, "3:4", "New Haven:New Haven" ],
|
|
[3, "1:2", "New York:Colombia" ],
|
|
[4, "3:4", "New Haven:New Haven" ],
|
|
[5, "", ""],
|
|
[6, "3:4", "New Haven:New Haven" ]
|
|
])
|
|
|
|
#----------------------------------------
|
|
def test_dependency_reset(self, pre_loaded=False):
|
|
"""
|
|
A somewhat tricky case. We know that Student 2 depends on Schools 3,4 and on Address 13,14.
|
|
If we change Student 2 to depend on nothing, then changing Address 13 should not cause it to
|
|
recompute.
|
|
"""
|
|
if not pre_loaded:
|
|
self.load_sample(testsamples.sample_students)
|
|
|
|
out_actions = self.update_record("Address", 13, city="AAA")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"calls": {"Students": {"schoolCities": 3}} # Initially 3 students depend on Address 13.
|
|
})
|
|
|
|
out_actions = self.update_record("Students", 2, schoolName="Invalid")
|
|
|
|
out_actions = self.update_record("Address", 13, city="BBB")
|
|
# If the count below is 3, then the engine forgot to reset the dependencies of Students 2.
|
|
self.assertPartialOutActions(out_actions, {
|
|
"calls": {"Students": {"schoolCities": 2}} # Now only 2 Students depend on Address 13.
|
|
})
|
|
|
|
#----------------------------------------
|
|
def test_lookup_key_changes(self, pre_loaded=False):
|
|
"""
|
|
Test changes to lookup values in the target table. Note that student #3 does not depend on
|
|
any records, but depends on the value "Eureka", so gets updated when this value appears.
|
|
"""
|
|
if not pre_loaded:
|
|
self.load_sample(testsamples.sample_students)
|
|
|
|
out_actions = self.update_record("Schools", 2, name="Eureka")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.UpdateRecord("Schools", 2, {"name": "Eureka"}),
|
|
actions.BulkUpdateRecord("Students", [1,3,5], {
|
|
'schoolCities': ["New York", "New York", "Colombia"]
|
|
}),
|
|
actions.BulkUpdateRecord("Students", [1,3,5], {
|
|
'schoolIds': ["1", "1","2"]
|
|
}),
|
|
],
|
|
"calls": {"Students": { 'schoolCities': 3, 'schoolIds': 3 },
|
|
"Schools": {'#lookup#name': 1} },
|
|
})
|
|
|
|
# Test changes to lookup values in the table doing the lookup.
|
|
out_actions = self.update_records("Students", ["id", "schoolName"], [
|
|
[3, ""],
|
|
[5, "Yale"]
|
|
])
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.BulkUpdateRecord("Students", [3,5], {'schoolName': ["", "Yale"]}),
|
|
actions.BulkUpdateRecord("Students", [3,5], {'schoolCities': ["", "New Haven:West Haven"]}),
|
|
actions.BulkUpdateRecord("Students", [3,5], {'schoolIds': ["", "3:4"]}),
|
|
],
|
|
"calls": { "Students": { 'schoolCities': 2, 'schoolIds': 2 } },
|
|
})
|
|
|
|
# Confirm the final result.
|
|
self.assertPartialData("Students", ["id", "schoolIds", "schoolCities" ], [
|
|
[1, "1", "New York" ],
|
|
[2, "3:4", "New Haven:West Haven" ],
|
|
[3, "", "" ],
|
|
[4, "3:4", "New Haven:West Haven" ],
|
|
[5, "3:4", "New Haven:West Haven" ],
|
|
[6, "3:4", "New Haven:West Haven" ]
|
|
])
|
|
|
|
|
|
#----------------------------------------
|
|
def test_lookup_formula_after_schema_change(self):
|
|
self.load_sample(testsamples.sample_students)
|
|
self.add_column("Schools", "state", type="Text")
|
|
|
|
# Make a change that causes recomputation of a lookup formula after a schema change.
|
|
# We should NOT get attribute errors in the values.
|
|
out_actions = self.update_record("Schools", 4, address=13)
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.UpdateRecord("Schools", 4, {"address": 13}),
|
|
_bulk_update("Students", ["id", "schoolCities" ], [
|
|
[2, "New Haven:New Haven" ],
|
|
[4, "New Haven:New Haven" ],
|
|
[6, "New Haven:New Haven" ]]
|
|
)
|
|
],
|
|
"calls": { "Students": { 'schoolCities': 3 } }
|
|
})
|
|
|
|
|
|
#----------------------------------------
|
|
def test_lookup_formula_changes(self):
|
|
self.load_sample(testsamples.sample_students)
|
|
|
|
self.add_column("Schools", "state", type="Text")
|
|
self.update_records("Schools", ["id", "state"], [
|
|
[1, "NY"],
|
|
[2, "MO"],
|
|
[3, "CT"],
|
|
[4, "CT"]
|
|
])
|
|
|
|
# Verify that when we change a formula, we get appropriate changes.
|
|
out_actions = self.modify_column("Students", "schoolCities", formula=(
|
|
"','.join(Schools.lookupRecords(name=$schoolName).state)"))
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.ModifyColumn("Students", "schoolCities", {
|
|
"formula": "','.join(Schools.lookupRecords(name=$schoolName).state)",
|
|
}),
|
|
actions.UpdateRecord("_grist_Tables_column", 6, {
|
|
"formula": "','.join(Schools.lookupRecords(name=$schoolName).state)",
|
|
}),
|
|
_bulk_update("Students", ["id", "schoolCities" ], [
|
|
[1, "NY,MO" ],
|
|
[2, "CT,CT" ],
|
|
[3, "NY,MO" ],
|
|
[4, "CT,CT" ],
|
|
[6, "CT,CT" ]]
|
|
)
|
|
],
|
|
# Note that it got computed 6 times (once for each record), but one value remained unchanged
|
|
# (because no schools matched).
|
|
"calls": { "Students": { 'schoolCities': 6 } }
|
|
})
|
|
|
|
# Check that we've created new dependencies, and removed old ones.
|
|
out_actions = self.update_record("Schools", 4, address=13)
|
|
self.assertPartialOutActions(out_actions, {
|
|
"calls": {}
|
|
})
|
|
|
|
out_actions = self.update_record("Schools", 4, state="MA")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.UpdateRecord("Schools", 4, {"state": "MA"}),
|
|
_bulk_update("Students", ["id", "schoolCities" ], [
|
|
[2, "CT,MA" ],
|
|
[4, "CT,MA" ],
|
|
[6, "CT,MA" ]]
|
|
)
|
|
],
|
|
"calls": { "Students": { 'schoolCities': 3 } }
|
|
})
|
|
|
|
# If we change to look up uppercase values, we shouldn't find anything.
|
|
out_actions = self.modify_column("Students", "schoolCities", formula=(
|
|
"','.join(Schools.lookupRecords(name=$schoolName.upper()).state)"))
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.ModifyColumn("Students", "schoolCities", {
|
|
"formula": "','.join(Schools.lookupRecords(name=$schoolName.upper()).state)"
|
|
}),
|
|
actions.UpdateRecord("_grist_Tables_column", 6, {
|
|
"formula": "','.join(Schools.lookupRecords(name=$schoolName.upper()).state)"
|
|
}),
|
|
actions.BulkUpdateRecord("Students", [1,2,3,4,6],
|
|
{'schoolCities': ["","","","",""]})
|
|
],
|
|
"calls": { "Students": { 'schoolCities': 6 } }
|
|
})
|
|
|
|
# Changes to dependencies should cause appropriate recalculations.
|
|
out_actions = self.update_record("Schools", 4, state="KY", name="EUREKA")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.UpdateRecord("Schools", 4, {"state": "KY", "name": "EUREKA"}),
|
|
actions.UpdateRecord("Students", 5, {'schoolCities': "KY"}),
|
|
actions.BulkUpdateRecord("Students", [2,4,6], {'schoolIds': ["3","3","3"]}),
|
|
],
|
|
"calls": {"Students": { 'schoolCities': 1, 'schoolIds': 3 },
|
|
'Schools': {'#lookup#name': 1 } }
|
|
})
|
|
|
|
self.assertPartialData("Students", ["id", "schoolIds", "schoolCities" ], [
|
|
# schoolCities aren't found here because we changed formula to lookup uppercase names.
|
|
[1, "1:2", "" ],
|
|
[2, "3", "" ],
|
|
[3, "1:2", "" ],
|
|
[4, "3", "" ],
|
|
[5, "", "KY" ],
|
|
[6, "3", "" ]
|
|
])
|
|
|
|
def test_add_remove_lookup(self):
|
|
# Verify that when we add or remove a lookup formula, we get appropriate changes.
|
|
self.load_sample(testsamples.sample_students)
|
|
|
|
# Add another lookup formula.
|
|
out_actions = self.add_column("Schools", "lastNames", formula=(
|
|
"','.join(Students.lookupRecords(schoolName=$name).lastName)"))
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.AddColumn("Schools", "lastNames", {
|
|
"formula": "','.join(Students.lookupRecords(schoolName=$name).lastName)",
|
|
"isFormula": True, "type": "Any"
|
|
}),
|
|
actions.AddRecord("_grist_Tables_column", 22, {
|
|
"colId": "lastNames",
|
|
"formula": "','.join(Students.lookupRecords(schoolName=$name).lastName)",
|
|
"isFormula": True, "label": "lastNames", "parentId": 2, "parentPos": 6.0,
|
|
"type": "Any", "widgetOptions": ""
|
|
}),
|
|
_bulk_update("Schools", ["id", "lastNames"], [
|
|
[1, "Obama,Clinton"],
|
|
[2, "Obama,Clinton"],
|
|
[3, "Bush,Bush,Ford"],
|
|
[4, "Bush,Bush,Ford"]
|
|
]),
|
|
],
|
|
"calls": {"Schools": {"lastNames": 4}, "Students": {"#lookup#schoolName": 6}},
|
|
})
|
|
|
|
# Make sure it responds to changes.
|
|
out_actions = self.update_record("Students", 5, schoolName="Columbia")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.UpdateRecord("Students", 5, {"schoolName": "Columbia"}),
|
|
_bulk_update("Schools", ["id", "lastNames"], [
|
|
[1, "Obama,Clinton,Reagan"],
|
|
[2, "Obama,Clinton,Reagan"]]
|
|
),
|
|
actions.UpdateRecord("Students", 5, {"schoolCities": "New York:Colombia"}),
|
|
actions.UpdateRecord("Students", 5, {"schoolIds": "1:2"}),
|
|
],
|
|
"calls": {"Students": {'schoolCities': 1, 'schoolIds': 1, '#lookup#schoolName': 1},
|
|
"Schools": { 'lastNames': 2 }},
|
|
})
|
|
|
|
# Modify the column: in the process, the LookupMapColumn on Students.schoolName becomes unused
|
|
# while the old formula column is removed, but used again when it's added. It should not have
|
|
# to be rebuilt (so there should be no calls to recalculate the LookupMapColumn.
|
|
out_actions = self.modify_column("Schools", "lastNames", formula=(
|
|
"','.join(Students.lookupRecords(schoolName=$name).firstName)"))
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.ModifyColumn("Schools", "lastNames", {
|
|
"formula": "','.join(Students.lookupRecords(schoolName=$name).firstName)"
|
|
}),
|
|
actions.UpdateRecord("_grist_Tables_column", 22, {
|
|
"formula": "','.join(Students.lookupRecords(schoolName=$name).firstName)"
|
|
}),
|
|
_bulk_update("Schools", ["id", "lastNames"], [
|
|
[1, "Barack,Bill,Ronald"],
|
|
[2, "Barack,Bill,Ronald"],
|
|
[3, "George W,George H,Gerald"],
|
|
[4, "George W,George H,Gerald"]]
|
|
)
|
|
],
|
|
"calls": {"Schools": {"lastNames": 4}}
|
|
})
|
|
|
|
# Remove the new lookup formula.
|
|
out_actions = self.remove_column("Schools", "lastNames")
|
|
self.assertPartialOutActions(out_actions, {}) # No calc actions
|
|
|
|
# Make sure that changes still work without errors.
|
|
out_actions = self.update_record("Students", 5, schoolName="Eureka")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.UpdateRecord("Students", 5, {"schoolName": "Eureka"}),
|
|
actions.UpdateRecord("Students", 5, {"schoolCities": ""}),
|
|
actions.UpdateRecord("Students", 5, {"schoolIds": ""}),
|
|
],
|
|
# This should NOT have '#lookup#schoolName' recalculation because there are no longer any
|
|
# formulas which do such a lookup.
|
|
"calls": { "Students": {'schoolCities': 1, 'schoolIds': 1}}
|
|
})
|
|
|
|
|
|
def test_multi_column_lookups(self):
|
|
"""
|
|
Check that we can do lookups by multiple columns.
|
|
"""
|
|
self.load_sample(testsamples.sample_students)
|
|
|
|
# Add a lookup formula which looks up a student matching on both first and last names.
|
|
self.add_column("Schools", "bestStudent", type="Text")
|
|
self.update_record("Schools", 1, bestStudent="Bush,George W")
|
|
self.add_column("Schools", "bestStudentId", formula=("""
|
|
if not $bestStudent: return ""
|
|
ln, fn = $bestStudent.split(",")
|
|
return ",".join(str(r.id) for r in Students.lookupRecords(firstName=fn, lastName=ln))
|
|
"""))
|
|
|
|
# Check data so far: only one record is filled.
|
|
self.assertPartialData("Schools", ["id", "bestStudent", "bestStudentId" ], [
|
|
[1, "Bush,George W", "2" ],
|
|
[2, "", "" ],
|
|
[3, "", "" ],
|
|
[4, "", "" ],
|
|
])
|
|
|
|
# Fill a few more records and check that we find records we should, and don't find those we
|
|
# shouldn't.
|
|
out_actions = self.update_records("Schools", ["id", "bestStudent"], [
|
|
[2, "Clinton,Bill"],
|
|
[3, "Norris,Chuck"],
|
|
[4, "Bush,George H"],
|
|
])
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.BulkUpdateRecord("Schools", [2,3,4], {
|
|
"bestStudent": ["Clinton,Bill", "Norris,Chuck", "Bush,George H"]
|
|
}),
|
|
actions.BulkUpdateRecord("Schools", [2, 4], {"bestStudentId": ["3", "4"]})
|
|
],
|
|
"calls": {"Schools": {"bestStudentId": 3}}
|
|
})
|
|
self.assertPartialData("Schools", ["id", "bestStudent", "bestStudentId" ], [
|
|
[1, "Bush,George W", "2" ],
|
|
[2, "Clinton,Bill", "3" ],
|
|
[3, "Norris,Chuck", "" ],
|
|
[4, "Bush,George H", "4" ],
|
|
])
|
|
|
|
# Now add more records, first matching only some of the lookup fields.
|
|
out_actions = self.add_record("Students", firstName="Chuck", lastName="Morris")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"calls": {
|
|
# No calculations of anything Schools because nothing depends on the incomplete value.
|
|
"Students": {
|
|
"#lookup#firstName:lastName": 1, "schoolIds": 1, "schoolCities": 1, "#lookup#": 1
|
|
}
|
|
},
|
|
"retValues": [7],
|
|
})
|
|
|
|
# If we add a matching record, then we get a calculation of a record in Schools
|
|
out_actions = self.add_record("Students", firstName="Chuck", lastName="Norris")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"calls": {
|
|
"Students": {
|
|
"#lookup#firstName:lastName": 1, "schoolIds": 1, "schoolCities": 1, "#lookup#": 1
|
|
},
|
|
"Schools": {"bestStudentId": 1}
|
|
},
|
|
"retValues": [8],
|
|
})
|
|
|
|
# And the data should be correct.
|
|
self.assertPartialData("Schools", ["id", "bestStudent", "bestStudentId" ], [
|
|
[1, "Bush,George W", "2" ],
|
|
[2, "Clinton,Bill", "3" ],
|
|
[3, "Norris,Chuck", "8" ],
|
|
[4, "Bush,George H", "4" ],
|
|
])
|
|
|
|
def test_record_removal(self):
|
|
# Remove a record, make sure that lookup maps get updated.
|
|
self.load_sample(testsamples.sample_students)
|
|
|
|
out_actions = self.remove_record("Schools", 3)
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.RemoveRecord("Schools", 3),
|
|
actions.BulkUpdateRecord("Students", [2,4,6], {
|
|
"schoolCities": ["West Haven","West Haven","West Haven"]}),
|
|
actions.BulkUpdateRecord("Students", [2,4,6], {
|
|
"schoolIds": ["4","4","4"]}),
|
|
],
|
|
"calls": {
|
|
"Students": {"schoolIds": 3, "schoolCities": 3},
|
|
# LookupMapColumn is also updated but via a different path (unset() vs method() call), so
|
|
# it's not included in the count of formula calls.
|
|
}
|
|
})
|
|
|
|
self.assertPartialData("Students", ["id", "schoolIds", "schoolCities" ], [
|
|
[1, "1:2", "New York:Colombia" ],
|
|
[2, "4", "West Haven" ],
|
|
[3, "1:2", "New York:Colombia" ],
|
|
[4, "4", "West Haven" ],
|
|
[5, "", ""],
|
|
[6, "4", "West Haven" ]
|
|
])
|
|
|
|
def test_empty_relation(self):
|
|
# Make sure that when a relation becomes empty, it doesn't get messed up.
|
|
self.load_sample(testsamples.sample_students)
|
|
|
|
# Clear out dependencies.
|
|
self.update_records("Students", ["id", "schoolName"],
|
|
[ [i, ""] for i in [1,2,3,4,5,6] ])
|
|
self.assertPartialData("Students", ["id", "schoolIds", "schoolCities" ],
|
|
[ [i, "", ""] for i in [1,2,3,4,5,6] ])
|
|
|
|
# Make a number of changeas, to ensure they reuse rather than re-create _LookupRelations.
|
|
self.update_record("Students", 2, schoolName="Yale")
|
|
self.update_record("Students", 2, schoolName="Columbia")
|
|
self.update_record("Students", 3, schoolName="Columbia")
|
|
self.assertPartialData("Students", ["id", "schoolIds", "schoolCities" ], [
|
|
[1, "", ""],
|
|
[2, "1:2", "New York:Colombia" ],
|
|
[3, "1:2", "New York:Colombia" ],
|
|
[4, "", ""],
|
|
[5, "", ""],
|
|
[6, "", ""],
|
|
])
|
|
|
|
# When we messed up the dependencies, this change didn't cause a corresponding update. Check
|
|
# that it now does.
|
|
self.remove_record("Schools", 2)
|
|
self.assertPartialData("Students", ["id", "schoolIds", "schoolCities" ], [
|
|
[1, "", ""],
|
|
[2, "1", "New York" ],
|
|
[3, "1", "New York" ],
|
|
[4, "", ""],
|
|
[5, "", ""],
|
|
[6, "", ""],
|
|
])
|
|
|
|
def test_lookups_of_computed_values(self):
|
|
"""
|
|
Make sure that lookups get updated when the value getting looked up is a formula result.
|
|
"""
|
|
self.load_sample(testsamples.sample_students)
|
|
|
|
# Add a column like Schools.name, but computed, and change schoolIds to use that one instead.
|
|
self.add_column("Schools", "cname", formula="$name")
|
|
self.modify_column("Students", "schoolIds", formula=
|
|
"':'.join(str(id) for id in Schools.lookupRecords(cname=$schoolName).id)")
|
|
|
|
self.assertPartialData("Students", ["id", "schoolIds" ], [
|
|
[1, "1:2" ],
|
|
[2, "3:4" ],
|
|
[3, "1:2" ],
|
|
[4, "3:4" ],
|
|
[5, "" ],
|
|
[6, "3:4" ],
|
|
])
|
|
|
|
# Check that a change to School.name, which triggers a change to School.cname, causes a change
|
|
# to the looked-up ids. The changes here should be the same as in test_lookup_key_changes
|
|
# test, even though schoolIds depends on name indirectly.
|
|
out_actions = self.update_record("Schools", 2, name="Eureka")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.UpdateRecord("Schools", 2, {"name": "Eureka"}),
|
|
actions.UpdateRecord("Schools", 2, {"cname": "Eureka"}),
|
|
actions.BulkUpdateRecord("Students", [1,3,5], {
|
|
'schoolCities': ["New York", "New York", "Colombia"]
|
|
}),
|
|
actions.BulkUpdateRecord("Students", [1,3,5], {
|
|
'schoolIds': ["1", "1","2"]
|
|
}),
|
|
],
|
|
"calls": {"Students": { 'schoolCities': 3, 'schoolIds': 3 },
|
|
"Schools": {'#lookup#name': 1, '#lookup#cname': 1, "cname": 1} },
|
|
})
|
|
|
|
def use_saved_lookup_results(self):
|
|
"""
|
|
This sets up data so that lookupRecord results are stored in a column and used in another. Key
|
|
tests that check lookup dependencies should work unchanged with this setup.
|
|
"""
|
|
self.load_sample(testsamples.sample_students)
|
|
|
|
# Split up Students.schoolCities into Students.schools and Students.schoolCities.
|
|
self.add_column("Students", "schools", formula="Schools.lookupRecords(name=$schoolName)",
|
|
type="RefList:Schools")
|
|
self.modify_column("Students", "schoolCities",
|
|
formula="':'.join(r.address.city for r in $schools)")
|
|
|
|
# The following tests check correctness of dependencies when lookupResults are stored in one
|
|
# column and used in another. They reuse existing test cases with modified data.
|
|
def test_lookup_dependencies_reflist(self):
|
|
self.use_saved_lookup_results()
|
|
self.test_lookup_dependencies(pre_loaded=True)
|
|
|
|
# Confirm the final result including the additional 'schools' column.
|
|
self.assertPartialData("Students", ["id", "schools", "schoolIds", "schoolCities" ], [
|
|
[1, [1,2], "1:2", "New York:Colombia" ],
|
|
[2, [3,4], "3:4", "New Haven:New Haven" ],
|
|
[3, [1,2], "1:2", "New York:Colombia" ],
|
|
[4, [3,4], "3:4", "New Haven:New Haven" ],
|
|
[5, [], "", ""],
|
|
[6, [3,4], "3:4", "New Haven:New Haven" ]
|
|
])
|
|
|
|
def test_dependency_reset_reflist(self):
|
|
self.use_saved_lookup_results()
|
|
self.test_dependency_reset(pre_loaded=True)
|
|
|
|
def test_lookup_key_changes_reflist(self):
|
|
# We can't run this test case unchanged since our new column changes too in this test.
|
|
self.use_saved_lookup_results()
|
|
out_actions = self.update_record("Schools", 2, name="Eureka")
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.UpdateRecord('Schools', 2, {'name': "Eureka"}),
|
|
actions.BulkUpdateRecord("Students", [1,3,5], {
|
|
'schoolCities': ["New York", "New York", "Colombia"]
|
|
}),
|
|
actions.BulkUpdateRecord("Students", [1,3,5], {
|
|
'schoolIds': ["1", "1","2"]
|
|
}),
|
|
actions.BulkUpdateRecord('Students', [1,3,5], {'schools': [[1],[1],[2]]}),
|
|
],
|
|
"calls": {"Students": { 'schools': 3, 'schoolCities': 3, 'schoolIds': 3 },
|
|
"Schools": {'#lookup#name': 1} },
|
|
})
|
|
|
|
# Test changes to lookup values in the table doing the lookup.
|
|
out_actions = self.update_records("Students", ["id", "schoolName"], [
|
|
[3, ""],
|
|
[5, "Yale"]
|
|
])
|
|
self.assertPartialOutActions(out_actions, {
|
|
"stored": [
|
|
actions.BulkUpdateRecord("Students", [3,5], {'schoolName': ["", "Yale"]}),
|
|
actions.BulkUpdateRecord("Students", [3,5], {'schoolCities': ["", "New Haven:West Haven"]}),
|
|
actions.BulkUpdateRecord("Students", [3,5], {'schoolIds': ["", "3:4"]}),
|
|
actions.BulkUpdateRecord("Students", [3,5], {'schools': [[], [3,4]]}),
|
|
],
|
|
"calls": { "Students": { 'schools': 2, 'schoolCities': 2, 'schoolIds': 2 } },
|
|
})
|
|
|
|
# Confirm the final result.
|
|
self.assertPartialData("Students", ["id", "schools", "schoolIds", "schoolCities" ], [
|
|
[1, [1], "1", "New York" ],
|
|
[2, [3,4], "3:4", "New Haven:West Haven" ],
|
|
[3, [], "", "" ],
|
|
[4, [3,4], "3:4", "New Haven:West Haven" ],
|
|
[5, [3,4], "3:4", "New Haven:West Haven" ],
|
|
[6, [3,4], "3:4", "New Haven:West Haven" ]
|
|
])
|
|
|
|
def test_dependencies_relations_bug(self):
|
|
# We had a serious bug with dependencies, for which this test verifies a fix. Imagine Table2
|
|
# has a formula a=Table1.lookupOne(A=$A), and b=$a.foo. When col A changes in Table1, columns
|
|
# a and b in Table2 get recomputed. Each recompute triggers reset_rows() which is there to
|
|
# clear lookup relations (it actually triggers reset_dependencies() which resets rows for the
|
|
# relation on each dependency edge).
|
|
#
|
|
# The first recompute (of a) triggers reset_rows() on the LookupRelation, then recomputes the
|
|
# lookup formula which re-populates the relation correctly. The second recompute (of b) also
|
|
# triggers reset_rows(). The bug was that it was triggering it in the same LookupRelation, but
|
|
# since it doesn't get followed with recomputing the lookup formula, the relation remains
|
|
# incomplete.
|
|
#
|
|
# It's important that a formula like "b=$a.foo" doesn't reuse the LookupRelation by itself on
|
|
# the edge between b and $a, but a composition of IdentityRelation and LookupRelation. The
|
|
# composition will correctly forward reset_rows() to only the first half of the relation.
|
|
|
|
# Set up two tables with a situation as described above. Here, the role of column Table2.a
|
|
# above is taken by "Students.schools=Schools.lookupRecords(name=$schoolName)".
|
|
self.use_saved_lookup_results()
|
|
|
|
# We intentionally try behavior with type Any formulas too, without converting to a reference
|
|
# type, in case that affects relations.
|
|
self.modify_column("Students", "schools", type="Any")
|
|
self.add_column("Students", "schoolsCount", formula="len($schools.name)")
|
|
self.add_column("Students", "oneSchool", formula="Schools.lookupOne(name=$schoolName)")
|
|
self.add_column("Students", "oneSchoolName", formula="$oneSchool.name")
|
|
|
|
# A helper for comparing Record objects below.
|
|
schools_table = self.engine.tables['Schools']
|
|
def SchoolsRec(row_id):
|
|
return schools_table.Record(row_id, None)
|
|
|
|
# We'll play with schools "Columbia" and "Eureka", which are rows 1,3,5 in the Students table.
|
|
self.assertTableData("Students", cols="subset", rows="subset", data=[
|
|
["id", "schoolName", "schoolsCount", "oneSchool", "oneSchoolName"],
|
|
[1, "Columbia", 2, SchoolsRec(1), "Columbia"],
|
|
[3, "Columbia", 2, SchoolsRec(1), "Columbia"],
|
|
[5, "Eureka", 0, SchoolsRec(0), ""],
|
|
])
|
|
|
|
# Now change Schools.schoolName which should trigger recomputations.
|
|
self.update_record("Schools", 1, name="Eureka")
|
|
self.assertTableData("Students", cols="subset", rows="subset", data=[
|
|
["id", "schoolName", "schoolsCount", "oneSchool", "oneSchoolName"],
|
|
[1, "Columbia", 1, SchoolsRec(2), "Columbia"],
|
|
[3, "Columbia", 1, SchoolsRec(2), "Columbia"],
|
|
[5, "Eureka", 1, SchoolsRec(1), "Eureka"],
|
|
])
|
|
|
|
# The first change is expected to work. The important check is that the relations don't get
|
|
# corrupted afterwards. So we do a second change to see if that still updates.
|
|
self.update_record("Schools", 1, name="Columbia")
|
|
self.assertTableData("Students", cols="subset", rows="subset", data=[
|
|
["id", "schoolName", "schoolsCount", "oneSchool", "oneSchoolName"],
|
|
[1, "Columbia", 2, SchoolsRec(1), "Columbia"],
|
|
[3, "Columbia", 2, SchoolsRec(1), "Columbia"],
|
|
[5, "Eureka", 0, SchoolsRec(0), ""],
|
|
])
|
|
|
|
# One more time, for good measure.
|
|
self.update_record("Schools", 1, name="Eureka")
|
|
self.assertTableData("Students", cols="subset", rows="subset", data=[
|
|
["id", "schoolName", "schoolsCount", "oneSchool", "oneSchoolName"],
|
|
[1, "Columbia", 1, SchoolsRec(2), "Columbia"],
|
|
[3, "Columbia", 1, SchoolsRec(2), "Columbia"],
|
|
[5, "Eureka", 1, SchoolsRec(1), "Eureka"],
|
|
])
|
|
|
|
def test_vlookup(self):
|
|
self.load_sample(testsamples.sample_students)
|
|
self.add_column("Students", "school", formula="VLOOKUP(Schools, name=$schoolName)")
|
|
self.add_column("Students", "schoolCity",
|
|
formula="VLOOKUP(Schools, name=$schoolName).address.city")
|
|
|
|
# A helper for comparing Record objects below.
|
|
schools_table = self.engine.tables['Schools']
|
|
def SchoolsRec(row_id):
|
|
return schools_table.Record(row_id, None)
|
|
|
|
# We'll play with schools "Columbia" and "Eureka", which are rows 1,3,5 in the Students table.
|
|
self.assertTableData("Students", cols="subset", rows="all", data=[
|
|
["id", "schoolName", "school", "schoolCity"],
|
|
[1, "Columbia", SchoolsRec(1), "New York" ],
|
|
[2, "Yale", SchoolsRec(3), "New Haven" ],
|
|
[3, "Columbia", SchoolsRec(1), "New York" ],
|
|
[4, "Yale", SchoolsRec(3), "New Haven" ],
|
|
[5, "Eureka", SchoolsRec(0), "" ],
|
|
[6, "Yale", SchoolsRec(3), "New Haven" ],
|
|
])
|
|
|
|
# Now change some values which should trigger recomputations.
|
|
self.update_record("Schools", 1, name="Eureka")
|
|
self.update_record("Students", 2, schoolName="Unknown")
|
|
|
|
self.assertTableData("Students", cols="subset", rows="all", data=[
|
|
["id", "schoolName", "school", "schoolCity"],
|
|
[1, "Columbia", SchoolsRec(2), "Colombia" ],
|
|
[2, "Unknown", SchoolsRec(0), "" ],
|
|
[3, "Columbia", SchoolsRec(2), "Colombia" ],
|
|
[4, "Yale", SchoolsRec(3), "New Haven" ],
|
|
[5, "Eureka", SchoolsRec(1), "New York" ],
|
|
[6, "Yale", SchoolsRec(3), "New Haven" ],
|
|
])
|
|
|
|
def test_contains(self):
|
|
sample = testutil.parse_test_sample({
|
|
"SCHEMA": [
|
|
[1, "Source", [
|
|
[11, "choicelist1", "ChoiceList", False, "", "choicelist1", ""],
|
|
[12, "choicelist2", "ChoiceList", False, "", "choicelist2", ""],
|
|
[13, "text1", "Text", False, "", "text1", ""],
|
|
[14, "text2", "Text", False, "", "text1", ""],
|
|
[15, "contains1", "RefList:Source", True,
|
|
"Source.lookupRecords(choicelist1=CONTAINS($text1))",
|
|
"contains1", ""],
|
|
[16, "contains2", "RefList:Source", True,
|
|
"Source.lookupRecords(choicelist2=CONTAINS($text2))",
|
|
"contains2", ""],
|
|
[17, "contains_both", "RefList:Source", True,
|
|
"Source.lookupRecords(choicelist1=CONTAINS($text1), choicelist2=CONTAINS($text2))",
|
|
"contains_both", ""],
|
|
[17, "combined", "RefList:Source", True,
|
|
"Source.lookupRecords(choicelist1=CONTAINS($text1), text2='x')",
|
|
"combined", ""],
|
|
]]
|
|
],
|
|
"DATA": {
|
|
"Source": [
|
|
["id", "choicelist1", "text1", "choicelist2", "text2"],
|
|
[101, ["a"], "a", ["x"], "y"],
|
|
[102, ["b"], "b", ["y"], "x"],
|
|
[103, ["a", "b"], "c", ["x", "y"], "c"],
|
|
]
|
|
}
|
|
})
|
|
self.load_sample(sample)
|
|
|
|
self.assertTableData("Source", cols="subset", data=[
|
|
["id", "contains1", "contains2", "contains_both", "combined"],
|
|
[101, [101, 103], [102, 103], [103], []],
|
|
[102, [102, 103], [101, 103], [103], [102]],
|
|
[103, [], [], [], []],
|
|
])
|
|
|
|
def test_sort_by(self):
|
|
self.load_sample(testutil.parse_test_sample({
|
|
"SCHEMA": [
|
|
[1, "Table1", [
|
|
[1, "num", "Numeric", False, "", "", ""],
|
|
[4, "is_num", "Any", True,
|
|
"isinstance($num, float)", "", ""],
|
|
[2, "lookup", "Any", True,
|
|
"Table1.lookupRecords(sort_by='num').num", "", ""],
|
|
[3, "lookup_reverse", "Any", True,
|
|
"Table1.lookupRecords(sort_by='-num').num", "", ""],
|
|
[5, "lookup_first", "Any", True,
|
|
"Table1.lookupOne().num", "", ""],
|
|
[6, "lookup_min", "Any", True,
|
|
"Table1.lookupOne(sort_by='num').num", "", ""],
|
|
[7, "lookup_min_num", "Any", True,
|
|
"Table1.lookupOne(is_num=True, sort_by='num').num", "", ""],
|
|
[8, "lookup_max", "Any", True,
|
|
"Table1.lookupOne(sort_by='-num').num", "", ""],
|
|
[9, "lookup_max_num",
|
|
"Any", True,
|
|
"Table1.lookupOne(is_num=True, sort_by='-num').num", "", ""],
|
|
]]
|
|
],
|
|
"DATA": {
|
|
"Table1": [
|
|
["id", "num"],
|
|
[1, 2],
|
|
[2, 1],
|
|
[3, 'foo'],
|
|
[4, 3],
|
|
[5, None],
|
|
[6, 0],
|
|
]
|
|
}
|
|
}))
|
|
|
|
self.assertTableData(
|
|
"Table1", cols="subset", rows="subset", data=[
|
|
["id",
|
|
"lookup",
|
|
"lookup_reverse",
|
|
"lookup_first",
|
|
"lookup_min", "lookup_min_num",
|
|
"lookup_max", "lookup_max_num"],
|
|
[1,
|
|
[None, 0, 1, 2, 3, 'foo'],
|
|
['foo', 3, 2, 1, 0, None],
|
|
2, # lookup_first: first record (by id)
|
|
None, 0, # lookup_min[_num]
|
|
'foo', 3], # lookup_max[_num]
|
|
])
|
|
|
|
def test_conversion(self):
|
|
# Test that values are converted to the type of the column when looking up
|
|
# i.e. '123' is converted to 123
|
|
# and 'foo' is converted to AltText('foo')
|
|
self.load_sample(testutil.parse_test_sample({
|
|
"SCHEMA": [
|
|
[1, "Table1", [
|
|
[1, "num", "Numeric", False, "", "", ""],
|
|
[2, "lookup1", "RefList:Table1", True, "Table1.lookupRecords(num='123')", "", ""],
|
|
[3, "lookup2", "RefList:Table1", True, "Table1.lookupRecords(num='foo')", "", ""],
|
|
]]
|
|
],
|
|
"DATA": {
|
|
"Table1": [
|
|
["id", "num"],
|
|
[1, 123],
|
|
[2, 'foo'],
|
|
]
|
|
}
|
|
}))
|
|
|
|
self.assertTableData(
|
|
"Table1", data=[
|
|
["id", "num", "lookup1", "lookup2"],
|
|
[1, 123, [1], [2]],
|
|
[2, 'foo', [1], [2]],
|
|
])
|