Use pytest's monkeypatch to set env variables

Author: Peque

osbrain/tests/test_agent.py

@@ -276,15 +276,15 @@ def test_bind_tcp_addr_specific_port(nsproxy):
     (0, 1, False),
     (-1, 1, True),
 ])
-def test_linger(nsproxy, linger, sleep_time, should_receive):
+def test_linger(monkeypatch, nsproxy, linger, sleep_time, should_receive):
     '''
     Test linger works when closing the sockets of an agent.
     '''
     class AgentTest(Agent):
         def on_init(self):
             self.received = []
 
-    osbrain.config['LINGER'] = linger
+    monkeypatch.setitem(osbrain.config, 'LINGER', linger)
 
     puller = run_agent('puller', base=AgentTest)
     pusher = run_agent('pusher', base=AgentTest)
@@ -684,14 +684,14 @@ def spawn_process(self):
     assert agent.spawn_process()
 
 
-def test_agent_execute_as_function(nsproxy):
+def test_agent_execute_as_function(monkeypatch, nsproxy):
     """
     Test `execute_as_function` method, which should execute a given function
     in the remote agent.
     """
     class EnvironmentAgent(Agent):
         def set_environment(self, value):
-            os.environ['__OSBRAIN_TEST'] = value
+            monkeypatch.setitem(os.environ, '__OSBRAIN_TEST', value)
 
     def name(prefix, suffix='suffix'):
         return prefix + os.environ.get('__OSBRAIN_TEST', '') + suffix

osbrain/tests/test_agent_transport.py

@@ -32,7 +32,7 @@ def test_agent_bind_transport_platform_default(nsproxy):
 
 
 @skip_windows_spawn
-def test_agent_bind_transport_global(nsproxy):
+def test_agent_bind_transport_global(monkeypatch, nsproxy):
     """
     Test global default transport change.
     """
@@ -42,7 +42,7 @@ def test_agent_bind_transport_global(nsproxy):
     assert address.transport != 'inproc'
 
     # Changing default global transport to `inproc`
-    osbrain.config['TRANSPORT'] = 'inproc'
+    monkeypatch.setitem(osbrain.config, 'TRANSPORT', 'inproc')
     agent = run_agent('a1')
     address = agent.bind('PUSH')
     assert address.transport == 'inproc'

osbrain/tests/test_proxy.py

@@ -7,7 +7,6 @@
 import pytest
 from threading import Timer
 
-
 import osbrain
 from osbrain import run_agent
 from osbrain import Agent
@@ -179,20 +178,20 @@ def test_agent_proxy_nameserver_address(nsproxy):
     assert agent.nsaddr() == nsproxy.addr()
 
 
-def test_agent_proxy_safe_and_unsafe_property(nsproxy):
+def test_agent_proxy_safe_and_unsafe_property(monkeypatch, nsproxy):
     """
     Using the safe/unsafe property from a proxy should allow us to
     override the environment global configuration.
     """
     run_agent('foo')
     # Safe environment
-    osbrain.config['SAFE'] = True
+    monkeypatch.setitem(osbrain.config, 'SAFE', True)
     proxy = Proxy('foo')
     assert proxy._safe
     assert proxy.safe._safe
     assert not proxy.unsafe._safe
     # Unsafe environment
-    osbrain.config['SAFE'] = False
+    monkeypatch.setitem(osbrain.config, 'SAFE', False)
     proxy = Proxy('foo')
     assert not proxy._safe
     assert proxy.safe._safe
@@ -210,33 +209,33 @@ def test_agent_run_agent_safe_and_unsafe(nsproxy):
     assert not unsafe._safe
 
 
-def test_agent_proxy_safe_and_unsafe_parameter(nsproxy):
+def test_agent_proxy_safe_and_unsafe_parameter(monkeypatch, nsproxy):
     """
     Using the safe/unsafe parameter when initializating a proxy should allow
     us to override the environment global configuration.
     """
     run_agent('foo')
     # Safe environment
-    osbrain.config['SAFE'] = True
+    monkeypatch.setitem(osbrain.config, 'SAFE', True)
     proxy = Proxy('foo')
     assert proxy._safe
     proxy = Proxy('foo', safe=False)
     assert not proxy._safe
     # Unsafe environment
-    osbrain.config['SAFE'] = False
+    monkeypatch.setitem(osbrain.config, 'SAFE', False)
     proxy = Proxy('foo')
     assert not proxy._safe
     proxy = Proxy('foo', safe=True)
     assert proxy._safe
 
 
-def test_agent_proxy_safe_and_unsafe_calls_property_safe(nsproxy):
+def test_agent_proxy_safe_and_unsafe_calls_property_safe(monkeypatch, nsproxy):
     """
     An agent can be accessed through a proxy in both safe and unsafe ways.
     When using the `safe` property, calls are expected to wait until the main
     thread is able to process them to avoid concurrency.
     """
-    osbrain.config['SAFE'] = False
+    monkeypatch.setitem(osbrain.config, 'SAFE', False)
     worker = setup_bussy_worker(nsproxy)
     assert not worker._safe
     t0 = time.time()
@@ -247,13 +246,14 @@ def test_agent_proxy_safe_and_unsafe_calls_property_safe(nsproxy):
     assert not worker._safe
 
 
-def test_agent_proxy_safe_and_unsafe_calls_property_unsafe(nsproxy):
+def test_agent_proxy_safe_and_unsafe_calls_property_unsafe(
+        monkeypatch, nsproxy):
     """
     An agent can be accessed through a proxy in both safe and unsafe ways.
     When using the `unsafe` property, calls are not expected to wait until
     the main thread is able to process them (concurrency is allowed).
     """
-    osbrain.config['SAFE'] = True
+    monkeypatch.setitem(osbrain.config, 'SAFE', True)
     worker = setup_bussy_worker(nsproxy)
     assert worker._safe
     t0 = time.time()
@@ -266,27 +266,28 @@ def test_agent_proxy_safe_and_unsafe_calls_property_unsafe(nsproxy):
     assert worker._safe
 
 
-def test_agent_proxy_safe_and_unsafe_calls_environ_safe(nsproxy):
+def test_agent_proxy_safe_and_unsafe_calls_environ_safe(monkeypatch, nsproxy):
     """
     An agent can be accessed through a proxy in both safe and unsafe ways.
     When using the `safe` property, calls are expected to wait until the main
     thread is able to process them to avoid concurrency.
     """
-    osbrain.config['SAFE'] = True
+    monkeypatch.setitem(osbrain.config, 'SAFE', True)
     worker = setup_bussy_worker(nsproxy)
     t0 = time.time()
     assert worker.listen() == 'OK'
     assert since(t0, passed=2., tolerance=0.1)
     assert not worker.get_attr('bussy')
 
 
-def test_agent_proxy_safe_and_unsafe_calls_environ_unsafe(nsproxy):
+def test_agent_proxy_safe_and_unsafe_calls_environ_unsafe(
+        monkeypatch, nsproxy):
     """
     An agent can be accessed through a proxy in both safe and unsafe ways.
     When using the `unsafe` property, calls are not expected to wait until
     the main thread is able to process them (concurrency is allowed).
     """
-    osbrain.config['SAFE'] = False
+    monkeypatch.setitem(osbrain.config, 'SAFE', False)
     worker = setup_bussy_worker(nsproxy)
     t0 = time.time()
     assert worker.listen() == 'OK'