def test_add_incoming_return(self): """Nodes can have an infinite amount of incoming RETURN links, as long as the link triple is unique.""" source_one = WorkflowNode() source_two = WorkflowNode() target = Data().store() # Needs to be stored: see `test_validate_outgoing_workflow` target.add_incoming(source_one, LinkType.RETURN, 'link_label') # Can only have a single incoming RETURN link from each source node if the label is not unique with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.RETURN, 'link_label') # From another source node or using another label is fine target.validate_incoming(source_one, LinkType.RETURN, 'other_label') target.validate_incoming(source_two, LinkType.RETURN, 'link_label')
def test_add_incoming_create(self): """Nodes can only have a single incoming CREATE link, independent of the source node.""" source_one = CalculationNode() source_two = CalculationNode() target = Data() target.add_incoming(source_one, LinkType.CREATE, 'link_label') # Can only have a single incoming CREATE link with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.CREATE, 'link_label') # Even when the source node is different with self.assertRaises(ValueError): target.validate_incoming(source_two, LinkType.CREATE, 'link_label') # Or when the link label is different with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.CREATE, 'other_label')
class TestNodeLinks(AiidaTestCase): """Test for linking from and to Node.""" def setUp(self): super(TestNodeLinks, self).setUp() self.node_source = CalculationNode() self.node_target = Data() def test_get_stored_link_triples(self): """Validate the `get_stored_link_triples` method.""" data = Data().store() calculation = CalculationNode() calculation.add_incoming(data, LinkType.INPUT_CALC, 'input') calculation.store() stored_triples = calculation.get_stored_link_triples() self.assertEqual(len(stored_triples), 1) link_triple = stored_triples[0] # Verify the type and value of the tuple elements self.assertTrue(isinstance(link_triple, LinkTriple)) self.assertTrue(isinstance(link_triple.node, Node)) self.assertTrue(isinstance(link_triple.link_type, LinkType)) self.assertEqual(link_triple.node.uuid, data.uuid) self.assertEqual(link_triple.link_type, LinkType.INPUT_CALC) self.assertEqual(link_triple.link_label, 'input') def test_validate_incoming_ipsum(self): """Test the `validate_incoming` method with respect to linking ourselves.""" with self.assertRaises(ValueError): self.node_target.validate_incoming(self.node_target, LinkType.CREATE, 'link_label') def test_validate_incoming(self): """Test the `validate_incoming` method For a generic Node all incoming link types are valid as long as the source is also of type Node and the link type is a valid LinkType enum value. """ with self.assertRaises(TypeError): self.node_target.validate_incoming(self.node_source, None, 'link_label') with self.assertRaises(TypeError): self.node_target.validate_incoming(None, LinkType.CREATE, 'link_label') with self.assertRaises(TypeError): self.node_target.validate_incoming(self.node_source, LinkType.CREATE.value, 'link_label') def test_add_incoming_create(self): """Nodes can only have a single incoming CREATE link, independent of the source node.""" source_one = CalculationNode() source_two = CalculationNode() target = Data() target.add_incoming(source_one, LinkType.CREATE, 'link_label') # Can only have a single incoming CREATE link with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.CREATE, 'link_label') # Even when the source node is different with self.assertRaises(ValueError): target.validate_incoming(source_two, LinkType.CREATE, 'link_label') # Or when the link label is different with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.CREATE, 'other_label') def test_add_incoming_call_calc(self): """Nodes can only have a single incoming CALL_CALC link, independent of the source node.""" source_one = WorkflowNode() source_two = WorkflowNode() target = CalculationNode() target.add_incoming(source_one, LinkType.CALL_CALC, 'link_label') # Can only have a single incoming CALL_CALC link with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.CALL_CALC, 'link_label') # Even when the source node is different with self.assertRaises(ValueError): target.validate_incoming(source_two, LinkType.CALL_CALC, 'link_label') # Or when the link label is different with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.CALL_CALC, 'other_label') def test_add_incoming_call_work(self): """Nodes can only have a single incoming CALL_WORK link, independent of the source node.""" source_one = WorkflowNode() source_two = WorkflowNode() target = WorkflowNode() target.add_incoming(source_one, LinkType.CALL_WORK, 'link_label') # Can only have a single incoming CALL_WORK link with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.CALL_WORK, 'link_label') # Even when the source node is different with self.assertRaises(ValueError): target.validate_incoming(source_two, LinkType.CALL_WORK, 'link_label') # Or when the link label is different with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.CALL_WORK, 'other_label') def test_add_incoming_input_calc(self): """Nodes can have an infinite amount of incoming INPUT_CALC links, as long as the link pair is unique.""" source_one = Data() source_two = Data() target = CalculationNode() target.add_incoming(source_one, LinkType.INPUT_CALC, 'link_label') # Can only have a single incoming INPUT_CALC link from each source node if the label is not unique with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.INPUT_CALC, 'link_label') # Using another link label is fine target.validate_incoming(source_one, LinkType.INPUT_CALC, 'other_label') # However, using the same link, even from another node is illegal with self.assertRaises(ValueError): target.validate_incoming(source_two, LinkType.INPUT_CALC, 'link_label') def test_add_incoming_input_work(self): """Nodes can have an infinite amount of incoming INPUT_WORK links, as long as the link pair is unique.""" source_one = Data() source_two = Data() target = WorkflowNode() target.add_incoming(source_one, LinkType.INPUT_WORK, 'link_label') # Can only have a single incoming INPUT_WORK link from each source node if the label is not unique with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.INPUT_WORK, 'link_label') # Using another link label is fine target.validate_incoming(source_one, LinkType.INPUT_WORK, 'other_label') # However, using the same link, even from another node is illegal with self.assertRaises(ValueError): target.validate_incoming(source_two, LinkType.INPUT_WORK, 'link_label') def test_add_incoming_return(self): """Nodes can have an infinite amount of incoming RETURN links, as long as the link triple is unique.""" source_one = WorkflowNode() source_two = WorkflowNode() target = Data().store() # Needs to be stored: see `test_validate_outgoing_workflow` target.add_incoming(source_one, LinkType.RETURN, 'link_label') # Can only have a single incoming RETURN link from each source node if the label is not unique with self.assertRaises(ValueError): target.validate_incoming(source_one, LinkType.RETURN, 'link_label') # From another source node or using another label is fine target.validate_incoming(source_one, LinkType.RETURN, 'other_label') target.validate_incoming(source_two, LinkType.RETURN, 'link_label') def test_validate_outgoing_workflow(self): """Verify that attaching an unstored `Data` node with `RETURN` link from a `WorkflowNode` raises. This would for example be the case if a user inside a workfunction or work chain creates a new node based on its inputs or the outputs returned by another process and tries to attach it as an output. This would the provenance of that data node to be lost and should be explicitly forbidden by raising. """ source = WorkflowNode() target = Data() with self.assertRaises(ValueError): target.add_incoming(source, LinkType.RETURN, 'link_label') def test_get_incoming(self): """Test that `Node.get_incoming` will return stored and cached input links.""" source_one = Data().store() source_two = Data().store() target = CalculationNode() target.add_incoming(source_one, LinkType.INPUT_CALC, 'link_one') target.add_incoming(source_two, LinkType.INPUT_CALC, 'link_two') # Without link type incoming_nodes = target.get_incoming().all() incoming_uuids = sorted([neighbor.node.uuid for neighbor in incoming_nodes]) self.assertEqual(incoming_uuids, sorted([source_one.uuid, source_two.uuid])) # Using a single link type incoming_nodes = target.get_incoming(link_type=LinkType.INPUT_CALC).all() incoming_uuids = sorted([neighbor.node.uuid for neighbor in incoming_nodes]) self.assertEqual(incoming_uuids, sorted([source_one.uuid, source_two.uuid])) # Using a link type tuple incoming_nodes = target.get_incoming(link_type=(LinkType.INPUT_CALC, LinkType.INPUT_WORK)).all() incoming_uuids = sorted([neighbor.node.uuid for neighbor in incoming_nodes]) self.assertEqual(incoming_uuids, sorted([source_one.uuid, source_two.uuid])) def test_node_indegree_unique_pair(self): """Test that the validation of links with indegree `unique_pair` works correctly The example here is a `DataNode` that has two incoming links with the same label, but with different types. This is legal and should pass validation. """ caller = WorkflowNode().store() data = Data().store() called = CalculationNode() # Verify that adding two incoming links with the same link label but different type is allowed called.add_incoming(caller, link_type=LinkType.CALL_CALC, link_label='call') called.add_incoming(data, link_type=LinkType.INPUT_CALC, link_label='call') called.store() uuids_incoming = set(node.uuid for node in called.get_incoming().all_nodes()) uuids_expected = set([caller.uuid, data.uuid]) self.assertEqual(uuids_incoming, uuids_expected) def test_node_indegree_unique_triple(self): """Test that the validation of links with indegree `unique_triple` works correctly The example here is a `DataNode` that has two incoming RETURN links with the same label, but from different source nodes. This is legal and should pass validation. """ return_one = WorkflowNode() return_two = WorkflowNode() data = Data().store() # Needs to be stored: see `test_validate_outgoing_workflow` # Verify that adding two return links with the same link label but from different source is allowed data.add_incoming(return_one, link_type=LinkType.RETURN, link_label='returned') data.add_incoming(return_two, link_type=LinkType.RETURN, link_label='returned') uuids_incoming = set(node.uuid for node in data.get_incoming().all_nodes()) uuids_expected = set([return_one.uuid, return_two.uuid]) self.assertEqual(uuids_incoming, uuids_expected) def test_node_outdegree_unique_triple(self): """Test that the validation of links with outdegree `unique_triple` works correctly The example here is a `CalculationNode` that has two outgoing CREATE links with the same label, but to different target nodes. This is legal and should pass validation. """ creator = CalculationNode().store() data_one = Data() data_two = Data() # Verify that adding two create links with the same link label but to different target is allowed from the # perspective of the source node (the CalculationNode in this case) data_one.add_incoming(creator, link_type=LinkType.CREATE, link_label='create') data_two.add_incoming(creator, link_type=LinkType.CREATE, link_label='create') data_one.store() data_two.store() uuids_outgoing = set(node.uuid for node in creator.get_outgoing().all_nodes()) uuids_expected = set([data_one.uuid, data_two.uuid]) self.assertEqual(uuids_outgoing, uuids_expected) def test_get_node_by_label(self): """Test the get_node_by_label() method of the `LinkManager` In particular, check both the it returns the correct values, but also that it raises the expected exceptions where appropriate (missing link with a given label, or more than one link) """ data = Data().store() calc_one_a = CalculationNode() calc_one_b = CalculationNode() calc_two = CalculationNode() # Two calcs using the data with the same label calc_one_a.add_incoming(data, link_type=LinkType.INPUT_CALC, link_label='input') calc_one_b.add_incoming(data, link_type=LinkType.INPUT_CALC, link_label='input') # A different label calc_two.add_incoming(data, link_type=LinkType.INPUT_CALC, link_label='the_input') calc_one_a.store() calc_one_b.store() calc_two.store() # Retrieve a link when the label is unique output_the_input = data.get_outgoing(link_type=LinkType.INPUT_CALC).get_node_by_label('the_input') self.assertEqual(output_the_input.pk, calc_two.pk) with self.assertRaises(exceptions.MultipleObjectsError): data.get_outgoing(link_type=LinkType.INPUT_CALC).get_node_by_label('input') with self.assertRaises(exceptions.NotExistent): data.get_outgoing(link_type=LinkType.INPUT_CALC).get_node_by_label('some_weird_label') def test_tab_completable_properties(self): """Test properties to go from one node to a neighboring one""" # pylint: disable=too-many-statements input1 = Data().store() input2 = Data().store() top_workflow = WorkflowNode() workflow = WorkflowNode() calc1 = CalculationNode() calc2 = CalculationNode() output1 = Data().store() output2 = Data().store() # The `top_workflow` has two inputs, proxies them to `workflow`, that in turn calls two calculations, passing # one data node to each as input, and return the two data nodes returned one by each called calculation top_workflow.add_incoming(input1, link_type=LinkType.INPUT_WORK, link_label='a') top_workflow.add_incoming(input2, link_type=LinkType.INPUT_WORK, link_label='b') top_workflow.store() workflow.add_incoming(input1, link_type=LinkType.INPUT_WORK, link_label='a') workflow.add_incoming(input2, link_type=LinkType.INPUT_WORK, link_label='b') workflow.add_incoming(top_workflow, link_type=LinkType.CALL_WORK, link_label='CALL') workflow.store() calc1.add_incoming(input1, link_type=LinkType.INPUT_CALC, link_label='input_value') calc1.add_incoming(workflow, link_type=LinkType.CALL_CALC, link_label='CALL') calc1.store() output1.add_incoming(calc1, link_type=LinkType.CREATE, link_label='result') calc2.add_incoming(input2, link_type=LinkType.INPUT_CALC, link_label='input_value') calc2.add_incoming(workflow, link_type=LinkType.CALL_CALC, link_label='CALL') calc2.store() output2.add_incoming(calc2, link_type=LinkType.CREATE, link_label='result') output1.add_incoming(workflow, link_type=LinkType.RETURN, link_label='result_a') output2.add_incoming(workflow, link_type=LinkType.RETURN, link_label='result_b') output1.add_incoming(top_workflow, link_type=LinkType.RETURN, link_label='result_a') output2.add_incoming(top_workflow, link_type=LinkType.RETURN, link_label='result_b') # creator self.assertEqual(output1.creator.pk, calc1.pk) self.assertEqual(output2.creator.pk, calc2.pk) # caller (for calculations) self.assertEqual(calc1.caller.pk, workflow.pk) self.assertEqual(calc2.caller.pk, workflow.pk) # caller (for workflows) self.assertEqual(workflow.caller.pk, top_workflow.pk) # .inputs for calculations self.assertEqual(calc1.inputs.input_value.pk, input1.pk) self.assertEqual(calc2.inputs.input_value.pk, input2.pk) with self.assertRaises(exceptions.NotExistent): _ = calc1.inputs.some_label # .inputs for workflows self.assertEqual(top_workflow.inputs.a.pk, input1.pk) self.assertEqual(top_workflow.inputs.b.pk, input2.pk) self.assertEqual(workflow.inputs.a.pk, input1.pk) self.assertEqual(workflow.inputs.b.pk, input2.pk) with self.assertRaises(exceptions.NotExistent): _ = workflow.inputs.some_label # .outputs for calculations self.assertEqual(calc1.outputs.result.pk, output1.pk) self.assertEqual(calc2.outputs.result.pk, output2.pk) with self.assertRaises(exceptions.NotExistent): _ = calc1.outputs.some_label # .outputs for workflows self.assertEqual(top_workflow.outputs.result_a.pk, output1.pk) self.assertEqual(top_workflow.outputs.result_b.pk, output2.pk) self.assertEqual(workflow.outputs.result_a.pk, output1.pk) self.assertEqual(workflow.outputs.result_b.pk, output2.pk) with self.assertRaises(exceptions.NotExistent): _ = workflow.outputs.some_label