def test_only_column_count_returns_correct_number():
""" Checks that the column count is correct """
# Given
model = TreeModel()
# Then
assert model.columnCount(QModelIndex()) == len(list(TreeModelCols))
def test_header_data_none_for_invalid_orientation():
""" Check that the header data is correctly returned """
# Given
model = TreeModel()
# Then
assert model.headerData(0, Qt.Vertical, Qt.DisplayRole) != ""
def test_has_children_handles_no_project_set():
""" When no project is set, hasChildren should return False """
# Given
model = TreeModel()
# Then
assert model.hasChildren(QModelIndex()) is False
def test_pending_updates_are_cleared():
"""
If there are any previous pending changes, they are cleared before
updates are calculated
"""
# Given
tree_model = TreeModel()
tree_model.set_project(ResearchProject(""))
individuals_model = IndividualsModel([])
sources_model = SourcesModel([])
context = DataContext(
data_model=tree_model,
individuals_model=individuals_model,
sources_model=sources_model,
)
updater = LinkUpdater(context)
updater.source_updates = ["Foo", "Bar"]
updater.ancestor_fixes = ["Baz", "Fiz"]
# When
updater.calculate_updates()
# Then
assert updater.has_pending_updates() is False
def fixture_link_updater():
""" Fixture to create an updater with uncommitted updates """
tree_model = TreeModel()
individuals_model = IndividualsModel([])
sources_model = SourcesModel([])
old_value = "Altered Ancestor"
new_value = "Foo"
project = ResearchProject("")
plan_altered = ResearchPlan()
plan_altered.ancestor = old_value
plan_altered.ancestor_link = "I001"
project.plans.append(plan_altered)
tree_model.set_project(project)
context = DataContext(
data_model=tree_model,
individuals_model=individuals_model,
sources_model=sources_model,
)
updater = LinkUpdater(context)
plan_index = tree_model.index(0, TreeModelCols.TEXT, QModelIndex())
updater.ancestor_updates = [{"index": plan_index, "value": new_value}]
return (updater, old_value, new_value, tree_model, plan_index)
def test_task_links_are_checked():
"""
Check the following:
* Unchanged links are respected
* Broken links are identified
* Updated links are identified
"""
# Given
project = ResearchProject("")
individuals = []
sources = []
plan = ResearchPlan()
source_linked = Source("S123", "Linked", "Author", "Pub", "abbr")
sources.append(source_linked)
task_linked = ResearchTask()
task_linked.source = source_linked.autocomplete_name()
task_linked.source_link = source_linked.pointer
plan.tasks.append(task_linked)
task_broken = ResearchTask()
task_broken.source = "Broken Source"
task_broken.source_link = "FooBar"
plan.tasks.append(task_broken)
source_altered = Source("S987", "Altered", "Author", "Pub", "abbr")
sources.append(source_altered)
task_altered = ResearchTask()
task_altered.source = "Altered Source"
task_altered.source_link = source_altered.pointer
plan.tasks.append(task_altered)
project.plans.append(plan)
tree_model = TreeModel()
tree_model.set_project(project)
individuals_model = IndividualsModel(individuals)
sources_model = SourcesModel(sources)
context = DataContext(
data_model=tree_model,
individuals_model=individuals_model,
sources_model=sources_model,
)
updater = LinkUpdater(context)
# When
updater.calculate_updates()
# Then
assert updater.has_pending_updates() is True
assert len(updater.ancestor_updates) == 0
assert len(updater.source_updates) == 1
def test_has_children_handles_parent_index():
""" When no project is set, hasChildren should return False """
# Given
model = TreeModel()
project = ResearchProject("")
project.add_plan().add_task()
model.set_project(project)
# Then
assert model.hasChildren(QModelIndex()) is True
def test_set_project_calls_begin_end_reset(project, qtbot, qtmodeltester):
""" beginReset and endReset should be emitted """
# Given
model = TreeModel()
# When
with qtbot.waitSignals([model.modelAboutToBeReset, model.modelReset]):
model.set_project(project)
# Then
qtmodeltester.check(model)
def test_set_project_clears_existing_nodes():
""" Setting valid project should clear existing nodes """
# Given
model = TreeModel()
project = ResearchProject("")
# When
model.set_project(project)
model.set_project(project)
# Then
assert len(model.plans_node.children) == 0
def test_plan_links_are_checked():
"""
Check the following:
* Unchanged links are respected
* Broken links are identified
* Updated links are identified
"""
# Given
project = ResearchProject("")
individuals = []
sources = []
indi_linked = Individual("I1234", "Link", "Indi", 1000, 2000)
individuals.append(indi_linked)
plan_linked = ResearchPlan()
plan_linked.ancestor = indi_linked.autocomplete_name()
plan_linked.ancestor_link = indi_linked.pointer
project.plans.append(plan_linked)
plan_broken = ResearchPlan()
plan_broken.ancestor = "Broken Ancestor 1234/5678"
plan_broken.ancestor_link = "FooBar"
project.plans.append(plan_broken)
indi_altered = Individual("I9876", "Altered", "Indi", 1000, 2000)
individuals.append(indi_altered)
plan_altered = ResearchPlan()
plan_altered.ancestor = "Altered Ancestor 1000/2000"
plan_altered.ancestor_link = indi_altered.pointer
project.plans.append(plan_altered)
tree_model = TreeModel()
tree_model.set_project(project)
individuals_model = IndividualsModel(individuals)
sources_model = SourcesModel(sources)
context = DataContext(
data_model=tree_model,
individuals_model=individuals_model,
sources_model=sources_model,
)
updater = LinkUpdater(context)
# When
updater.calculate_updates()
# Then
assert updater.has_pending_updates() is True
assert len(updater.ancestor_updates) == 1
assert len(updater.source_updates) == 0
def test_setdata_returns_false_on_invalid_index():
""" When setting data, false is returned for invalid index """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
model.set_project(project)
# When
retval = model.setData(QModelIndex(), "Foo")
assert retval is False
def test_flags_no_flags_for_invalid_index():
""" Check that no flags are returned for invalid index """
# Given
model = TreeModel()
# project = ResearchProject("")
# project.add_plan().add_task()
# When
plan_index = model.index(0, 0, model.plans_index)
task_index = model.index(0, 0, plan_index)
# Then
assert model.flags(plan_index) == Qt.NoItemFlags
assert model.flags(task_index) == Qt.NoItemFlags
def test_index_returns_index_for_valid_row():
""" The start and end row removal signals should be emitted """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
model.set_project(project)
# When
plan_index = model.index(0, 0, model.plans_index)
# Then
assert plan_index.isValid() is True
def test_data_returns_none_for_invalid_index():
""" When getting data, nothing is returned for invalid index """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
model.set_project(project)
# When
retval = model.data(QModelIndex(), Qt.DisplayRole)
# Then
assert retval is None
def test_new_model_is_empty_by_default(qtmodeltester):
""" Empty model should not have a project set and no nodes """
# Given
model = TreeModel()
# Then
qtmodeltester.check(model)
assert model.project is None
assert model.plans_node is None
def __init__(self,
data_model=None,
individuals_model=None,
sources_model=None):
self.data_model = TreeModel() if data_model is None else data_model
self.individuals_model = (IndividualsModel(
[]) if individuals_model is None else individuals_model)
self.sources_model = (SourcesModel([])
if sources_model is None else sources_model)
def test_basic_checks(qtmodeltester):
""" Check the model for basic issues """
# Given
tree = TreeModel()
model = TableModel()
model.setSourceModel(tree)
# Then
qtmodeltester.check(model)
def test_delete_calls_signals(qtbot):
""" The start and end row removal signals should be emitted """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
model.set_project(project)
plan_index = model.index(0, 0, model.plans_index)
# When
with qtbot.waitSignals([model.rowsAboutToBeRemoved, model.rowsRemoved]):
model.delete_node(plan_index)
def test_setdata_updates_link():
""" setData() works on the link """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
project.plans[0].add_task()
model.set_project(project)
plan_index = model.index(0, 0, model.plans_index)
task_index = model.index(0, TreeModelCols.LINK, plan_index)
# When
retval = model.setData(task_index, 1234)
assert retval is True
assert model.data(task_index, Qt.DisplayRole) == 1234
def test_flags_not_editable_for_ancestor_column():
""" The ancestor column should not be editable """
model = TreeModel()
project = ResearchProject("")
project.add_plan().add_task()
model.set_project(project)
# When
plan_index = model.index(0, TreeModelCols.ANCESTOR, model.plans_index)
task_index = model.index(0, TreeModelCols.ANCESTOR, plan_index)
# Then
assert model.flags(plan_index) & Qt.ItemIsEditable != Qt.ItemIsEditable
assert model.flags(task_index) & Qt.ItemIsEditable != Qt.ItemIsEditable
def test_setdata_returns_false_on_invalid_column():
""" When setting data, false is returned for invalid column """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
model.set_project(project)
plan_index = model.index(0, model.columnCount(None) + 1, model.plans_index)
# When
retval = model.setData(plan_index, "Foo")
assert retval is False
def test_setdata_updates_description():
""" setData() works on the description """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
model.set_project(project)
plan_index = model.index(0, 1, model.plans_index)
# When
retval = model.setData(plan_index, "Foo")
assert retval is True
assert model.data(plan_index, Qt.DisplayRole) == "Foo"
def test_add_creates_plan():
""" Add should create a new plan in the underlying data structure """
# Given
model = TreeModel()
project = ResearchProject("")
model.set_project(project)
# When
model.add_node(model.plans_index)
# Then
assert len(project.plans) == 1
def test_delete_removes_task():
""" Delete removes task from underlying data structure """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
task = ResearchTask()
plan.tasks.append(task)
project.plans.append(plan)
model.set_project(project)
plan_index = model.index(0, 0, model.plans_index)
task_index = model.index(0, 0, plan_index)
# When
model.delete_node(task_index)
# Then
assert len(project.plans) == 1
assert len(plan.tasks) == 0
def test_add_creates_task():
""" Add should create a new task in the underlying data structure """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
model.set_project(project)
plan_index = model.index(0, 0, model.plans_index)
# When
model.add_node(plan_index)
# Then
assert len(project.plans) == 1
assert len(plan.tasks) == 1
def test_setdata_updates_result():
""" setData() works on the result """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
project.plans[0].add_task()
model.set_project(project)
plan_index = model.index(0, 0, model.plans_index)
task_index = model.index(0, 2, plan_index)
result = ResearchResult(True)
result.description = "Test"
# When
retval = model.setData(task_index, result)
assert retval is True
assert model.data(task_index, Qt.DisplayRole) == result
def test_setdata_fires_signal_on_change(qtbot):
""" When setting data, the dataChanged signal is emitted on changes """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
model.set_project(project)
plan_index = model.index(0, 0, model.plans_index)
# When
with qtbot.waitSignal(model.dataChanged):
retval = model.setData(plan_index, "Foo")
assert retval is True
def test_delete_does_nothing_on_invalid_index(qtbot):
""" Delete removes task from underlying data structure """
# Given
model = TreeModel()
project = ResearchProject("")
project.add_plan().add_task()
model.set_project(project)
# When
with qtbot.assertNotEmitted(model.rowsAboutToBeRemoved):
with qtbot.assertNotEmitted(model.rowsRemoved):
model.delete_node(QModelIndex())
# Then
assert len(project.plans) == 1
assert len(project.plans[0].tasks) == 1
def test_setdata_doesnot_fire_signal_if_no_change(qtbot):
""" When setting data, the dataChanged signal should only be emitted on actual changes """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
project.plans.append(plan)
model.set_project(project)
plan_index = model.index(0, 0, model.plans_index)
# When
with qtbot.assertNotEmitted(model.dataChanged):
retval = model.setData(plan_index, plan.ancestor)
assert retval is True
def test_data_returns_none_for_invalid_role():
""" When getting data, invalid role returns None """
# Given
model = TreeModel()
project = ResearchProject("")
plan = ResearchPlan()
plan.ancestor = "Foo"
project.plans.append(plan)
model.set_project(project)
plan_index = model.index(0, 0, model.plans_index)
# When
retval = model.data(plan_index, Qt.UserRole)
# Then
assert retval is None
