def setUp(self):
self.model = AnalysisModel()
self.header = ("a", "b", "c")
self.data = ((1, 2, 3), (4, 5, 6))
self.metadata = ({}, {'d': 10})
self.state_dict = {
"header": self.header,
"1": {
'data': self.data[0],
'metadata': self.metadata[0]
},
"2": {
'data': self.data[1],
'metadata': self.metadata[1]
}
}
def setUp(self):
self.analysis_model = AnalysisModel(
header=['parameter_1', 'parameter_2',
'kpi_1'],
_evaluation_steps=[('A', 1.45, 10),
('A', 5.11, 12),
('B', 4.999, 17),
('B', 4.998, 22)],
_step_metadata=[
{
'height_profile': [
[0, 1, 2, 3, 4, 5],
[0.1, 0.2, 0.4, 0.7, 0.8, 0.9]
]
},
{
'height_profile': [
[0, 1, 2, 3, 4, 5],
[0.1, 0.2, 0.4, 0.7, 0.8, 0.9]
],
'ref_height_profile': [
[0, 1.1, 2.2, 3.3, 4.4, 5.5],
[0.11, 0.22, 0.5, 0.7, 0.8, 0.9]
]
},
{
'height_profile': [
[0, 1, 2, 3, 4, 5],
[0.1, 0.2, 0.4, 0.7, 0.8, 0.9]
],
'ref_height_profile': [
[0, 0.9, 2, 3, 3.8, 5.2],
[0.14, 0.24, 0.6, 0.71, 0.84, 0.97]
],
'temp_profile': [
[0, 1, 2, 3, 4, 5],
[0.1, 0.2, 0.4, 0.7, 0.8, 0.9]
],
'ref_temp_profile': [
[0, 0.9, 2, 3, 3.8, 5.2],
[0.14, 0.24, 0.6, 0.71, 0.84, 0.97]
]
}, {}]
)
self.data_view = PUFoamDataView(
analysis_model=self.analysis_model
)
def get_probe_wfmanager_tasks(wf_manager=None, contributed_uis=None):
# Returns the Setup and Review Tasks, with a mock TaskWindow and dummy
# Application which does not have an event loop.
if wf_manager is None:
wf_manager = DummyWfManager()
analysis_model = AnalysisModel()
workflow_model = Workflow()
factory_registry_plugin = ProbeFactoryRegistry()
if contributed_uis is None:
contributed_uis = [DummyContributedUI()]
wf_manager.factory_registry = factory_registry_plugin
setup_test = WfManagerSetupTask(
analysis_model=analysis_model,
workflow_model=workflow_model,
factory_registry=factory_registry_plugin,
contributed_uis=contributed_uis,
)
review_task = WfManagerReviewTask(
analysis_model=analysis_model,
workflow_model=workflow_model,
factory_registry=factory_registry_plugin,
)
tasks = [setup_test, review_task]
mock_window = mock.Mock(spec=TaskWindow)
mock_window.tasks = tasks
mock_window.application = wf_manager
for task in tasks:
task.window = mock_window
task.create_central_pane()
# A Task's central pane is generally aware of its task in normal
# operations, but it doesn't seem to be so in this mock situation;
# so we "make" it aware.
if hasattr(task, "central_pane") and task.central_pane is not None:
task.central_pane.task = task
task.create_dock_panes()
return tasks[0], tasks[1]
def test___getstate__(self):
self.model.notify(self.header)
for entry, meta in zip(self.data, self.metadata):
self.model.notify(meta, metadata=True)
self.model.notify(entry)
state = self.model.__getstate__()
self.assertDictEqual(
{
"header": self.header,
1: {
'data': self.data[0],
'metadata': self.metadata[0]
},
2: {
'data': self.data[1],
'metadata': self.metadata[1]
}
}, state)
with mock.patch.object(AnalysisModel, "__getstate__") as mock_getstate:
AnalysisModel().to_json()
mock_getstate.assert_called_once()
def setUp(self):
self.analysis_model = AnalysisModel()
self.plot = ExampleCustomPlot(analysis_model=self.analysis_model)
def setUp(self):
self.model = AnalysisModel()
self.pane = DataViewPane(analysis_model=self.model)
def setUp(self):
self.model = AnalysisModel()
self.pane = ResultsPane(analysis_model=self.model)
def setUp(self):
super().setUp()
self.analysis_model = AnalysisModel()
self.plot = self.plot_cls(analysis_model=self.analysis_model)
self.mock_path = '.'.join(
[self.plot.__class__.__module__, self.plot.__class__.__name__])
def setUp(self):
self.analysis_model = AnalysisModel(
header=['parameter_1', 'parameter_2', 'salt', 'kpi_1'],
_evaluation_steps=[('A', 1.45, 0.5, 10), ('A', 5.11, 1.0, 12),
('B', 4.999, 1.1, 17), ('B', 4.998, 2.0, 22)])
self.plot = SubsetPlot(analysis_model=self.analysis_model)
def test_json(self):
error = ("AnalysisModel can't be instantiated from a data dictionary"
" that does not contain a header.")
with LogCapture() as capture:
with self.assertRaisesRegex(KeyError, error):
AnalysisModel().from_json({
"1": {
'data': self.data[0],
'metadata': self.metadata[0]
},
"2": {
'data': self.data[1],
'metadata': self.metadata[1]
}
})
capture.check((
"force_wfmanager.model.analysis_model",
"ERROR",
"AnalysisModel can't be instantiated from a data dictionary "
"that does not contain a header.",
))
with mock.patch.object(AnalysisModel, "clear") as mock_clear:
model = AnalysisModel()
model.from_json(self.state_dict)
mock_clear.assert_called_once()
self.model.from_json(self.state_dict)
self.assertTupleEqual(self.model.header, self.header)
self.assertEqual(2, len(self.model.evaluation_steps))
self.assertEqual(2, len(self.model.step_metadata))
self.assertTupleEqual(self.data[0], self.model.evaluation_steps[0])
self.assertDictEqual(self.metadata[0], self.model.step_metadata[0])
self.assertTupleEqual(self.data[1], self.model.evaluation_steps[1])
self.assertDictEqual(self.metadata[1], self.model.step_metadata[1])
tmp_file = tempfile.NamedTemporaryFile()
filename = tmp_file.name
self.model.dump_json(filename)
with open(filename) as f:
json_data = json.load(f)
self.assertDictEqual(
{
"header": list(self.header),
"1": {
'data': list(self.data[0]),
'metadata': self.metadata[0]
},
"2": {
'data': list(self.data[1]),
'metadata': self.metadata[1]
}
}, json_data)
self.model._export_enabled = False
self.assertFalse(self.model.dump_json(None))
state_dict = {
"header": self.header,
"1": {
'data': self.data[0],
'metadata': self.metadata[0]
},
"3": {
'data': self.data[1],
'metadata': self.metadata[1]
}
}
with LogCapture() as capture:
AnalysisModel().from_json(state_dict)
capture.check((
"force_wfmanager.model.analysis_model",
"WARNING",
"Can't find a row with index 2. This index will "
"be skipped in the AnalysisModel.",
))
with self.subTest("Check deprecated formats"):
# TODO: This test can be removed when issue #414
# is resolved
state_dict = {"header": self.header, "1": list(self.data[0])}
with LogCapture() as capture:
model = AnalysisModel()
model.from_json(state_dict)
capture.check((
"force_wfmanager.model.analysis_model",
"WARNING",
"Project file format is deprecated and will"
" be removed in version 0.7.0",
))
self.assertDictEqual(
{
"header": self.header,
1: {
"data": self.data[0],
"metadata": {}
}
}, model.__getstate__())
def _analysis_model_default(self):
return AnalysisModel()
def setUp(self):
self.analysis_model = AnalysisModel()
self.data_view = SamplingDataView(analysis_model=self.analysis_model)
self.plot = self.data_view.sampling_plot
self.analysis_model.notify(("x", "y", "E"))
def setUp(self):
self.analysis_model = AnalysisModel()
self.data_view = SamplingDataView(analysis_model=self.analysis_model)