def test_DuplicateEntry_exception_raised_when_connecting_already_connected_port_to_a_resource(self):
# GIVEN the following mesh
#
# _____________ _____________
# | A | | B |
# |-------------| |-------------|
# | | n1 |-------->| p1 | |
# |______|______| |______|______|
#
#
# [ Resource X ]
#
m = Mesh()
m.add_component('A', needs_ports=['n1'])
m.add_component('B', provides_ports=['p1'])
m.add_resource('Resource X')
m.add_connection('A', 'n1', 'B', 'p1')
# WHEN attempting to create the following invalid connections
# _____________ _____________
# | A | | B |
# |-------------| |-------------|
# | | n1 |----+----->| p1 | |
# |______|______| | |______|______|
# |
# INVALID
# |
# |
# +----->[ Resource X ]
#
#
# THEN an InvalidConnection exception is raised
self.assertRaises(InvalidConnection, m.add_connection_to_resource, 'A', 'n1', 'Resource X')
def test_DuplicateEntry_exception_raised_when_adding_resources_with_same_name(self):
# GIVEN a Mesh with existing resource
m = Mesh()
m.add_resource('Resource X')
# WHEN we attempt to add a resource with the same name
# THEN a DuplicateEntry exception is raised
self.assertRaises(DuplicateEntry, m.add_resource, 'Resource X')
def test_added_resource_can_be_retrieved_from_mesh(self):
# GIVEN a new Mesh instance
m = Mesh()
# WHEN I add a resource
m.add_resource('Resource X')
# THEN that resource is represented in the output
self.assertEqual({
'components': [],
'resources': ['Resource X'],
'connections': [],
}, m.as_dict())
def test_resources_are_returned_in_the_order_they_were_added(self):
# GIVEN a new Mesh instance
m = Mesh()
# WHEN I add several resources
m.add_resource('Resource X')
m.add_resource('Resource Z')
m.add_resource('Resource Y')
# THEN that resources are presented in the order they were added
self.assertEqual({
'components': [],
'resources': ['Resource X', 'Resource Z', 'Resource Y'],
'connections': [],
}, m.as_dict())
def test_InvalidComponent_exception_raised_when_highlighting_unknown_component(self):
# GIVEN a mesh with the following component and resource
#
# _____________
# | A |
# |-------------|
# | | n1 | [ Resource X ]
# |______|______|
#
m = Mesh()
m.add_component('A', needs_ports=['n1'])
m.add_resource('Resource X')
# WHEN unknown component Y
# THEN an InvalidComponent exception is raised
self.assertRaises(InvalidComponent, m.highlight_component, 'Y')
def test_InvalidResource_exception_raised_when_creating_connections_to_resource_that_does_not_exist(self):
# GIVEN a mesh with the following component and resource
#
# _____________
# | A |
# |-------------|
# | | n1 | [ Resource X ]
# |______|______|
#
m = Mesh()
m.add_component('A', needs_ports=['n1'])
m.add_resource('Resource X')
# WHEN creating a component between A:n1 and Resource P
# THEN an InvalidResource exception is raised
self.assertRaises(InvalidResource, m.add_connection_to_resource, 'A', 'n1', 'Resource P')
def test_InvalidPort_exception_raised_when_creating_connections_to_resource_with_invalid_consumer_port(self):
# GIVEN a mesh with the following component and resource
#
# _____________
# | A |
# |-------------|
# | | n1 | [ Resource X ]
# |______|______|
#
m = Mesh()
m.add_component('A', needs_ports=['n1'])
m.add_resource('Resource X')
# WHEN creating a component between A:nX and Resource X
# THEN an InvalidPort exception is raised
self.assertRaises(InvalidPort, m.add_connection_to_resource, 'A', 'nX', 'Resource X')
def test_resource_can_be_highlighted(self):
# GIVEN the following mesh
#
# _____________ _____________
# | A | | B |
# |-------------| |-------------|
# | | n1 |-------->| p1 | n2 |--------->[ Resource X ]
# |______|______| |______|______|
#
#
m = Mesh()
m.add_component('A', needs_ports=['n1'])
m.add_component('B', needs_ports=['n2'], provides_ports=['p1'])
m.add_resource('Resource X')
m.add_connection('A', 'n1', 'B', 'p1')
m.add_connection_to_resource('B', 'n2', 'Resource X')
# WHEN Resource X is highlighted
m.highlight_resource('Resource X')
# THEN this is reflected in the dict representation
self.assertEqual({
'components': [
{'name': 'A', 'needs_ports': ['n1'], 'provides_ports': []},
{'name': 'B', 'needs_ports': ['n2'], 'provides_ports': ['p1']}
],
'resources': ['Resource X'],
'highlighted_resources': ['Resource X'],
'connections': [
{
'consumer_component': 'A',
'consumer_port': 'n1',
'producer_component': 'B',
'producer_port': 'p1',
},
{
'consumer_component': 'B',
'consumer_port': 'n2',
'resource': 'Resource X',
},
],
}, m.as_dict())
def test_InvalidResource_exception_raised_when_highlighting_unknown_resource(self):
# GIVEN a mesh with the following component and resource
#
# _____________ _____________
# | A | | B |
# |-------------| |-------------|
# | | n1 |-------->| p1 | n2 |--------->[ Resource X ]
# |______|______| |______|______|
#
#
m = Mesh()
m.add_component('A', needs_ports=['n1'])
m.add_component('B', needs_ports=['n2'], provides_ports=['p1'])
m.add_resource('Resource X')
m.add_connection('A', 'n1', 'B', 'p1')
m.add_connection_to_resource('B', 'n2', 'Resource X')
# WHEN unknown resource is highlighted
# THEN an InvalidResource exception is raised
self.assertRaises(InvalidResource, m.highlight_resource, 'Resource K')
def test_adding_connection_from_port_to_edge_resource(self):
# GIVEN a mesh with the following component and resource
#
# _____________
# | A |
# |-------------|
# | | n1 | [ Resource X ]
# |______|______|
#
m = Mesh()
m.add_component('A', needs_ports=['n1'])
m.add_resource('Resource X')
# WHEN we connect A:n1 to Resource X
m.add_connection_to_resource('A', 'n1', 'Resource X')
# THEN we get the following mesh representation
#
# _____________
# | A |
# |-------------|
# | | n1 |--------->[ Resource X ]
# |______|______|
#
self.assertEqual({
'components': [
{'name': 'A', 'needs_ports': ['n1'], 'provides_ports': []},
],
'resources': ['Resource X'],
'connections': [
{
'consumer_component': 'A',
'consumer_port': 'n1',
'resource': 'Resource X',
},
],
}, m.as_dict())
def test_textual_representation_can_be_rendered_for_a_populated_mesh(self):
# GIVEN the following mesh
#
# _____________ _____________
# | A | | B |
# |-------------| |-------------|
# | | n1 |----------->| p1 | |
# | |______| |______| nY |----->[ Resource Y ]
# | | n2 |-----+ +-->| p2 | |
# |______|______| | | |______|______|
# +- | -+
# | |
# _____________ | | _____________
# | C | | | | D |
# |-------------| | | |-------------|
# | | nX |--+ +---->| pX | nX |------>[ Resource X ]
# |______|______| |______|______|
#
m = Mesh()
m.add_component('A', needs_ports=['n1', 'n2'])
m.add_component('B', provides_ports=['p1', 'p2'], needs_ports=['nY'])
m.add_component('C', needs_ports=['nX'])
m.add_component('D', provides_ports=['pX'], needs_ports=['nX'])
m.add_resource('Resource X')
m.add_resource('Resource Y')
m.add_connection('A', 'n1', 'B', 'p1')
m.add_connection('A', 'n2', 'D', 'pX')
m.add_connection('C', 'nX', 'B', 'p2')
m.add_connection_to_resource('D', 'nX', 'Resource X')
m.add_connection_to_resource('B', 'nY', 'Resource Y')
# WHEN the textual representation is rendered
out = render(m, self.JSON_TEMPLATE)
# THEN the rendered output reflects that of the mesh
out_data = json.loads(out)
self.assertEqual({
'components': [
{'name': 'A', 'needs_ports': ['n1', 'n2'], 'provides_ports': []},
{'name': 'B', 'needs_ports': ['nY'], 'provides_ports': ['p1', 'p2']},
{'name': 'C', 'needs_ports': ['nX'], 'provides_ports': []},
{'name': 'D', 'needs_ports': ['nX'], 'provides_ports': ['pX']},
],
'resources': ['Resource X', 'Resource Y'],
'connections': [
{
'consumer_component': 'A',
'consumer_port': 'n1',
'producer_component': 'B',
'producer_port': 'p1',
},
{
'consumer_component': 'A',
'consumer_port': 'n2',
'producer_component': 'D',
'producer_port': 'pX',
},
{
'consumer_component': 'C',
'consumer_port': 'nX',
'producer_component': 'B',
'producer_port': 'p2',
},
{
'consumer_component': 'D',
'consumer_port': 'nX',
'resource': 'Resource X',
},
{
'consumer_component': 'B',
'consumer_port': 'nY',
'resource': 'Resource Y',
},
],
}, out_data)
