def test_probe_building_disabled(self, recwarn): """Test that build methods are not called and that a warning is raised if probe building is disabled. """ # Create test network with nengo.Network() as network: a = nengo.Ensemble(100, 2) p_a = nengo.Probe(a, label="Output") # Create a model model = Model() # Dummy neurons builder ens_build = mock.Mock(name="ensemble builder") # Define a probe build function build_ens_probe = mock.Mock() # Build the model probe_builders = {nengo.Ensemble: build_ens_probe} with patch.object(model, "builders", new={nengo.Ensemble: ens_build}),\ patch.object(model, "probe_builders", new=probe_builders): model.build(network, build_probes=False) # Assert the probes were NOT built assert p_a not in model.seeds assert build_ens_probe.call_count == 0 # And that a warning was raised w = recwarn.pop() assert "Probes" in str(w.message) assert "disabled" in str(w.message)
def test_make_connection_no_signal(self, source_getter, sink_getter): """Test that building connections adds a new signal to the model.""" model = Model() class A(object): pass # Create a connection from a to b connection = mock.Mock() connection.pre_obj = A() connection.post_obj = A() # Create a mock network network = mock.Mock() network.seed = None network.connections = [connection] network.ensembles = [] network.nodes = [] network.networks = [] network.probes = [] # Patch the getters, add a null builder with patch.object(model, "source_getters", {A: source_getter}), \ patch.object(model, "sink_getters", {A: sink_getter}), \ patch.object(model, "connection_parameter_builders", {A: mock.Mock()}): # Build the network model.build(network) # Assert that no signal exists assert connection not in model.connections_signals
def test_builds_hierarchy(self): """Test that networks are built hierarchically. """ class A(object): seed = 101 class B(object): pass builders = {A: mock.Mock()} extra_builders = {B: mock.Mock()} a = A() b = B() network_a = mock.Mock() network_a.seed = None network_a.connections = [] network_a.ensembles = [a] network_a.nodes = [] network_a.networks = [] network_a.probes = [] network_a.config = mock.Mock(name="config") network_b = mock.Mock() network_b.seed = None network_b.connections = [] network_b.ensembles = [] network_b.nodes = [b] network_b.networks = [] network_b.probes = [] network_b.config = mock.Mock(name="config") network = mock.Mock() network.seed = None network.connections = [] network.ensembles = [] network.nodes = [] network.networks = [network_a, network_b] network.probes = [] network.config = mock.Mock(name="config") # 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 # 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_standard(self, use_arguments, with_slice): # Create test network with nengo.Network() as network: a = nengo.Ensemble(100, 2) if not with_slice: p_a = nengo.Probe(a) else: p_a = nengo.Probe(a[0]) p_n = nengo.Probe(a.neurons) # Create a model model = Model() # Dummy neurons builder ens_build = mock.Mock(name="ensemble builder") # Define two different probe build functions def build_ens_probe_fn(model, probe): assert ens_build.called assert model is model assert probe is p_a build_ens_probe = mock.Mock(wraps=build_ens_probe_fn) def build_neurons_probe_fn(model, probe): assert ens_build.called assert model is model assert probe is p_n build_neurons_probe = mock.Mock(wraps=build_neurons_probe_fn) # Build the model probe_builders = { nengo.Ensemble: build_ens_probe, nengo.ensemble.Neurons: build_neurons_probe } with patch.object(model, "builders", new={nengo.Ensemble: ens_build}): if not use_arguments: with patch.object(model, "probe_builders", new=probe_builders): model.build(network) else: with patch.object(model, "probe_builders", new={}): model.build(network, extra_probe_builders=probe_builders) # Assert the probe functions were built assert p_a in model.seeds assert p_n in model.seeds assert build_ens_probe.call_count == 1 assert build_neurons_probe.call_count == 1
def test_standard(self, use_arguments, with_slice): # Create test network with nengo.Network() as network: a = nengo.Ensemble(100, 2) if not with_slice: p_a = nengo.Probe(a) else: p_a = nengo.Probe(a[0]) p_n = nengo.Probe(a.neurons) # Create a model model = Model() # Dummy neurons builder ens_build = mock.Mock(name="ensemble builder") # Define two different probe build functions def build_ens_probe_fn(model, probe): assert ens_build.called assert model is model assert probe is p_a build_ens_probe = mock.Mock(wraps=build_ens_probe_fn) def build_neurons_probe_fn(model, probe): assert ens_build.called assert model is model assert probe is p_n build_neurons_probe = mock.Mock(wraps=build_neurons_probe_fn) # Build the model probe_builders = {nengo.Ensemble: build_ens_probe, nengo.ensemble.Neurons: build_neurons_probe} with patch.object(model, "builders", new={nengo.Ensemble: ens_build}): if not use_arguments: with patch.object(model, "probe_builders", new=probe_builders): model.build(network) else: with patch.object(model, "probe_builders", new={}): model.build(network, extra_probe_builders=probe_builders) # Assert the probe functions were built assert p_a in model.seeds assert p_n in model.seeds assert build_ens_probe.call_count == 1 assert build_neurons_probe.call_count == 1
def test_make_connections(self, use_registered_dicts, seed): """Test that building connections adds a new signal to the model.""" # TODO Test that the connection is fully built model = Model() class A(object): pass class B(object): pass a = A() b = B() # Create a connection from a to b connection = mock.Mock() connection.seed = seed connection.pre_obj = a connection.post_obj = b # Create getter methods source = ObjectPort(mock.Mock(), None) sink = ObjectPort(mock.Mock(), None) def source_getter_fn(m, c): assert m is model assert c is connection return spec(source) source_getter = mock.Mock(wraps=source_getter_fn) def sink_getter_fn(m, c): assert m is model assert c is connection return spec(sink) sink_getter = mock.Mock(wraps=sink_getter_fn) # Create a method to build the connection built_connection = mock.Mock(name="built connection") def connection_builder_fn(m, c): assert m is model assert c is connection return built_connection connection_builder_a = mock.Mock(wraps=connection_builder_fn) connection_builder_b = mock.Mock(wraps=connection_builder_fn) # Create a mock network network = mock.Mock() network.seed = None network.connections = [connection] network.ensembles = [] network.nodes = [] network.networks = [] network.probes = [] if use_registered_dicts: # Patch the getters, add a null builder with patch.object(model, "source_getters", {A: source_getter}), \ patch.object(model, "sink_getters", {B: sink_getter}), \ patch.object(model, "connection_parameter_builders", {A: connection_builder_a, B: connection_builder_b}): # Build the network model.build(network) else: model.build(network, extra_source_getters={A: source_getter}, extra_sink_getters={B: sink_getter}, extra_connection_parameter_builders={ A: connection_builder_a, B: connection_builder_b, }) # Check that seeds were provided if seed is not None: assert model.seeds[connection] == seed else: assert model.seeds[connection] is not None # Assert the getters were called assert source_getter.call_count == 1 assert sink_getter.call_count == 1 # Assert that the connection parameter builder was called assert connection_builder_a.call_count == 1 assert connection_builder_b.call_count == 0 # Assert that the parameters were saved assert model.params[connection] is built_connection # Assert that the signal exists signal = model.connections_signals[connection] assert signal.source is source assert signal.sinks == [sink]
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)