def test_source_is_none(self, no_source, no_sink): """Test that if either the source or sink is none no connection is added to the model. """ class A(object): pass # Create the connection (as a mock) connection_source = A() connection_sink = A() connection = mock.Mock() connection.pre_obj = connection_source connection.post_obj = connection_sink # Create the Model which we'll build with m = Model() # Modify the Model so that we can interpret calls to the connection map m.connection_map = mock.Mock(name="ConnectionMap") obj = mock.Mock(name="Object") obj_port = mock.Mock(name="Port") # Add some build methods m._source_getters = ({ A: lambda m, c: None } if no_source else { A: lambda m, c: ObjectPort(obj, obj_port) }) m._sink_getters = ({ A: lambda m, c: None } if no_sink else { A: lambda m, c: ObjectPort(obj, obj_port) }) m._transmission_parameter_builders = {A: lambda m, c: None} m._reception_parameter_builders = {A: lambda m, c: None} # Make the connection # Set an RNG to build with m.rng = np.random # Build the connection directly m.make_connection(connection) # Assert no call was made to add_connection assert not m.connection_map.add_connection.called
def test_source_is_none(self, no_source, no_sink): """Test that if either the source or sink is none no connection is added to the model. """ class A(object): pass # Create the connection (as a mock) connection_source = A() connection_sink = A() connection = mock.Mock() connection.pre_obj = connection_source connection.post_obj = connection_sink # Create the Model which we'll build with m = Model() # Modify the Model so that we can interpret calls to the connection map m.connection_map = mock.Mock(name="ConnectionMap") obj = mock.Mock(name="Object") obj_port = mock.Mock(name="Port") # Add some build methods m._source_getters = ({A: lambda m, c: None} if no_source else {A: lambda m, c: ObjectPort(obj, obj_port)}) m._sink_getters = ({A: lambda m, c: None} if no_sink else {A: lambda m, c: ObjectPort(obj, obj_port)}) m._transmission_parameter_builders = {A: lambda m, c: None} m._reception_parameter_builders = {A: lambda m, c: None} # Make the connection # Set an RNG to build with m.rng = np.random # Build the connection directly m.make_connection(connection) # Assert no call was made to add_connection assert not m.connection_map.add_connection.called
def test_standard(self, use_make_connection): """Test building a single connection, ensure that all appropriate methods are called and that the signal is added to the connection map. """ class A(object): pass # Create the connection (as a mock) connection_source = A() connection_sink = A() connection = mock.Mock() connection.pre_obj = connection_source connection.post_obj = connection_sink # Create the Model which we'll build with m = Model() # Modify the Model so that we can interpret calls to the connection map m.connection_map = mock.Mock(name="ConnectionMap") m.connection_map.insert_and_stack_interposers = mock.Mock( return_value=([], m.connection_map) # NOP ) source = mock.Mock(name="Source Object") source_port = mock.Mock(name="Source Port") sink = mock.Mock(name="Sink Object") sink_port = mock.Mock(name="Sink Port") # Add some build methods def source_getter(model, conn): assert model is m assert conn is connection return spec(ObjectPort(source, source_port)) def sink_getter(model, conn): assert model is m assert conn is connection return spec(ObjectPort(sink, sink_port)) source_getters = {A: mock.Mock(side_effect=source_getter)} sink_getters = {A: mock.Mock(side_effect=sink_getter)} transmission_parameters = mock.Mock(name="Transmission Params") def transmission_builder(model, conn): assert model is m assert conn is connection return transmission_parameters reception_parameters = mock.Mock(name="Reception Params") def reception_builder(model, conn): assert model is m assert conn is connection return reception_parameters transmission_parameter_builders = { A: mock.Mock(side_effect=transmission_builder) } reception_parameter_builders = { A: mock.Mock(side_effect=reception_builder) } # Make the connection if use_make_connection: # Set an RNG to build with m.rng = np.random # Set the builders m._source_getters = source_getters m._sink_getters = sink_getters m._transmission_parameter_builders = \ transmission_parameter_builders m._reception_parameter_builders = reception_parameter_builders # Build the connection directly m.make_connection(connection) else: # Embed the connection in a mock Nengo network and build that # instead. network = mock.Mock() network.seed = None network.connections = [connection] network.ensembles = [] network.nodes = [] network.networks = [] network.probes = [] # Build this (having overridden the builders) with mock.patch.object(m, "source_getters", source_getters), \ mock.patch.object(m, "sink_getters", sink_getters), \ mock.patch.object(m, "transmission_parameter_builders", transmission_parameter_builders), \ mock.patch.object(m, "reception_parameter_builders", reception_parameter_builders): m.build(network) # Assert the connection map received an appropriate call m.connection_map.add_connection.assert_called_once_with( source, source_port, SignalParameters(), transmission_parameters, sink, sink_port, reception_parameters )
def test_standard(self, use_make_connection): """Test building a single connection, ensure that all appropriate methods are called and that the signal is added to the connection map. """ class A(object): pass # Create the connection (as a mock) connection_source = A() connection_sink = A() connection = mock.Mock() connection.pre_obj = connection_source connection.post_obj = connection_sink # Create the Model which we'll build with m = Model() # Modify the Model so that we can interpret calls to the connection map m.connection_map = mock.Mock(name="ConnectionMap") m.connection_map.insert_and_stack_interposers = mock.Mock( return_value=([], m.connection_map) # NOP ) source = mock.Mock(name="Source Object") source_port = mock.Mock(name="Source Port") sink = mock.Mock(name="Sink Object") sink_port = mock.Mock(name="Sink Port") # Add some build methods def source_getter(model, conn): assert model is m assert conn is connection return spec(ObjectPort(source, source_port)) def sink_getter(model, conn): assert model is m assert conn is connection return spec(ObjectPort(sink, sink_port)) source_getters = {A: mock.Mock(side_effect=source_getter)} sink_getters = {A: mock.Mock(side_effect=sink_getter)} transmission_parameters = mock.Mock(name="Transmission Params") def transmission_builder(model, conn): assert model is m assert conn is connection return transmission_parameters reception_parameters = mock.Mock(name="Reception Params") def reception_builder(model, conn): assert model is m assert conn is connection return reception_parameters transmission_parameter_builders = { A: mock.Mock(side_effect=transmission_builder) } reception_parameter_builders = { A: mock.Mock(side_effect=reception_builder) } # Make the connection if use_make_connection: # Set an RNG to build with m.rng = np.random # Set the builders m._source_getters = source_getters m._sink_getters = sink_getters m._transmission_parameter_builders = \ transmission_parameter_builders m._reception_parameter_builders = reception_parameter_builders # Build the connection directly m.make_connection(connection) else: # Embed the connection in a mock Nengo network and build that # instead. network = mock.Mock() network.seed = None network.connections = [connection] network.ensembles = [] network.nodes = [] network.networks = [] network.probes = [] # Build this (having overridden the builders) with mock.patch.object(m, "source_getters", source_getters), \ mock.patch.object(m, "sink_getters", sink_getters), \ mock.patch.object(m, "transmission_parameter_builders", transmission_parameter_builders), \ mock.patch.object(m, "reception_parameter_builders", reception_parameter_builders): m.build(network) # Assert the connection map received an appropriate call m.connection_map.add_connection.assert_called_once_with( source, source_port, SignalParameters(), transmission_parameters, sink, sink_port, reception_parameters)