WIP

tests/test_agents.py

@@ -20,13 +20,14 @@ class TestAgents(TestCase):
         assert ret == stime.INFINITY
 
     def test_die_raises_exception(self):
-        """A dead agent should raise an exception if it is stepped after death"""
+        """A dead agent should continue returning INFINITY after death"""
         d = Dead(unique_id=0, model=environment.Environment())
         assert d.alive
         d.step()
         assert not d.alive
-        with pytest.raises(stime.DeadAgent):
-            d.step()
+        when = d.step()
+        assert not d.alive
+        assert when == stime.INFINITY
 
     def test_agent_generator(self):
         """
@@ -79,30 +80,28 @@ class TestAgents(TestCase):
         """
 
         class BCast(agents.Evented):
-            pings_received = 0
+            pings_received = []
 
-            def step(self):
-                print(self.model.broadcast)
-                try:
-                    self.model.broadcast("PING")
-                except Exception as ex:
-                    print(ex)
+            async def step(self):
+                self.broadcast("PING")
+                print("PING sent")
                 while True:
-                    self.process_messages()
-                    yield
+                    msgs = await self.received()
+                    self.pings_received += msgs
 
-            def on_receive(self, msg, sender=None):
-                self.pings_received += 1
+        e = environment.Environment()
 
-        e = environment.EventedEnvironment()
-
-        for i in range(10):
+        num_agents = 10
+        for i in range(num_agents):
             e.add_agent(agent_class=BCast)
         e.step()
-        pings_received = lambda: [a.pings_received for a in e.agents]
-        assert sorted(pings_received()) == list(range(1, 11))
+        # Agents are executed in order, so the first agent should have not received any messages
+        pings_received = lambda: [len(a.pings_received) for a in e.agents]
+        assert sorted(pings_received()) == list(range(0, num_agents))
         e.step()
-        assert all(x == 10 for x in pings_received())
+        # After the second step, every agent should have received a broadcast from every other agent
+        received = pings_received()
+        assert all(x == (num_agents - 1) for x in received)
 
     def test_ask_messages(self):
         """
@@ -140,17 +139,16 @@ class TestAgents(TestCase):
                         print("NOT sending ping")
                     print("Checking msgs")
                     # Do not block if we have already received a PING
-                    if not self.process_messages():
-                        yield from self.received()
-                print("done")
+                    msgs = yield from self.received()
+                    for ping in msgs:
+                        if ping.payload == "PING":
+                            ping.reply = "PONG"
+                            pongs.append(self.now)
+                        else:
+                            raise Exception("This should never happen")
 
-            def on_receive(self, msg, sender=None):
-                if msg == "PING":
-                    pongs.append(self.now)
-                    return "PONG"
-                raise Exception("This should never happen")
 
-        e = environment.EventedEnvironment(schedule_class=stime.OrderedTimedActivation)
+        e = environment.Environment(schedule_class=stime.OrderedTimedActivation)
         for i in range(2):
             e.add_agent(agent_class=Ping)
         assert e.now == 0
@@ -372,4 +370,24 @@ class TestAgents(TestCase):
         assert a.my_state == 5
         model.step()
         assert a.now == 17
-        assert a.my_state == 5
+        assert a.my_state == 5
+    
+    def test_send_nonevent(self):
+        '''
+        Sending a non-event should raise an error.
+        '''
+        model = environment.Environment()
+        a = model.add_agent(agents.Noop)
+        class TestAgent(agents.Agent):
+            @agents.state(default=True)
+            def one(self):
+                try:
+                    a.tell(b, 1)
+                    raise AssertionError('Should have raised an error.')
+                except AttributeError:
+                    self.model.tell(1, sender=self, recipient=a)
+
+        model.add_agent(TestAgent)
+
+        with pytest.raises(ValueError):
+            model.step()

tests/test_exporters.py

@@ -81,7 +81,8 @@ class Exporters(TestCase):
             model=ConstantEnv,
             name="exporter_sim",
             exporters=[
-                exporters.default,
+                exporters.YAML,
+                exporters.SQLite,
                 exporters.csv,
             ],
             exporter_params={"copy_to": output},

tests/test_main.py

@@ -135,9 +135,9 @@ class TestMain(TestCase):
 
     def test_serialize_agent_class(self):
         """A class from soil.agents should be serialized without the module part"""
-        ser = agents._serialize_type(CustomAgent)
+        ser = serialization.serialize(CustomAgent, known_modules=["soil.agents"])[1]
         assert ser == "test_main.CustomAgent"
-        ser = agents._serialize_type(agents.BaseAgent)
+        ser = serialization.serialize(agents.BaseAgent, known_modules=["soil.agents"])[1]
         assert ser == "BaseAgent"
         pickle.dumps(ser)
 
@@ -227,3 +227,29 @@ class TestMain(TestCase):
         for i in a:
             for j in b:
                 assert {"a": i, "b": j} in configs
+    
+    def test_agent_reporters(self):
+        """An environment should be able to set its own reporters"""
+        class Noop2(agents.Noop):
+            pass
+
+        e = Environment()
+        e.add_agent(agents.Noop)
+        e.add_agent(Noop2)
+        e.add_agent_reporter("now")
+        e.add_agent_reporter("base", lambda a: "base", agent_class=agents.Noop)
+        e.add_agent_reporter("subclass", lambda a:"subclass", agent_class=Noop2)
+        e.step()
+
+        # Step 0 is not present because we added the reporters
+        # after initialization.
+        df = e.agent_df()
+        assert "now" in df.columns
+        assert "base" in df.columns
+        assert "subclass" in df.columns
+        assert df["now"][(0,0)] == 1
+        assert df["now"][(0,1)] == 1
+        assert df["base"][(0,0)] == "base"
+        assert df["base"][(0,1)] == "base"
+        assert df["subclass"][(0,0)] is None
+        assert df["subclass"][(0,1)] == "subclass"