def test_builder_dictionaries_are_combined(self, use_make_object):
"""Test that the builder and extra_builders dictionaries are combined
and that a mrolookupdict is used.
"""
class A(object):
seed = 101
class B(object):
pass
builders = {A: mock.Mock()}
extra_builders = {B: mock.Mock()}
a = A()
b = B()
network = mock.Mock()
network.seed = None
network.connections = []
network.ensembles = [a]
network.nodes = [b]
network.networks = []
network.probes = []
network.config = mock.Mock(name="config")
if not use_make_object:
# Patch the default builders
with patch.object(Model, "builders", new=builders):
# Create a model and build the mock network
model = Model()
model.build(network, extra_builders=extra_builders)
# Assert that the config was stored in the model
assert model.config is network.config
else:
# Create the model
model = Model()
model.rng = np.random
# When using `make_object` directly `_builders` should be defined
# and used.
model._builders.update(builders)
model._builders.update(extra_builders)
# Build the objects
model.make_object(a)
model.make_object(b)
# Assert that seeds were supplied
assert model.seeds[a] == a.seed
assert model.seeds[b] is not None
# Assert the builders got called
builders[A].assert_called_once_with(model, a)
extra_builders[B].assert_called_once_with(model, b)
def test_builder_dictionaries_are_combined(self, use_make_object):
"""Test that the builder and extra_builders dictionaries are combined
and that a mrolookupdict is used.
"""
class A(object):
seed = 101
class B(object):
pass
builders = {A: mock.Mock()}
extra_builders = {B: mock.Mock()}
a = A()
b = B()
network = mock.Mock()
network.seed = None
network.connections = []
network.ensembles = [a]
network.nodes = [b]
network.networks = []
network.probes = []
network.config = mock.Mock(name="config")
if not use_make_object:
# Patch the default builders
with patch.object(Model, "builders", new=builders):
# Create a model and build the mock network
model = Model()
model.build(network, extra_builders=extra_builders)
# Assert that the config was stored in the model
assert model.config is network.config
else:
# Create the model
model = Model()
model.rng = np.random
# When using `make_object` directly `_builders` should be defined
# and used.
model._builders.update(builders)
model._builders.update(extra_builders)
# Build the objects
model.make_object(a)
model.make_object(b)
# Assert that seeds were supplied
assert model.seeds[a] == a.seed
assert model.seeds[b] is not None
# Assert the builders got called
builders[A].assert_called_once_with(model, a)
extra_builders[B].assert_called_once_with(model, b)
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)
