Rednet

Author: neumond

computercraft/subapis/rednet.py

@@ -1,34 +1,55 @@
-from typing import Any, List
+from typing import Any, List, Optional, Tuple, Union
 
 from .base import BaseSubAPI
 from ..lua import LuaNum
-from ..rproc import nil, integer, boolean, array_integer
+from ..rproc import nil, integer, option_string, boolean, array_integer, option_integer, fact_option, fact_tuple
+
+
+recv_result = fact_option(fact_tuple(
+    integer,
+    lambda v: v,
+    option_string,
+    tail_nils=1,
+))
 
 
 class RednetAPI(BaseSubAPI):
+    CHANNEL_REPEAT = 65533
+    CHANNEL_BROADCAST = 65535
+
     async def open(self, side: str):
         return nil(await self._send('open', side))
 
-    async def close(self, side: str):
+    async def close(self, side: str = None):
         return nil(await self._send('close', side))
 
-    async def send(self, receiverID: int, message: Any, protocol: str = None):
-        return nil(await self._send('send', receiverID, message, protocol))
+    async def send(self, receiverID: int, message: Any, protocol: str = None) -> bool:
+        return boolean(await self._send('send', receiverID, message, protocol))
 
     async def broadcast(self, message: Any, protocol: str = None):
         return nil(await self._send('broadcast', message, protocol))
 
-    async def receive(self, protocolFilter: str = None, timeout: LuaNum = None) -> int:
-        return integer(await self._send('receive', protocolFilter, timeout))
+    async def receive(
+        self, protocolFilter: str = None, timeout: LuaNum = None,
+    ) -> Optional[Tuple[int, Any, Optional[str]]]:
+        return recv_result(await self._send('receive', protocolFilter, timeout))
 
-    async def isOpen(self, side: str) -> bool:
+    async def isOpen(self, side: str = None) -> bool:
         return boolean(await self._send('isOpen', side))
 
     async def host(self, protocol: str, hostname: str):
         return nil(await self._send('host', protocol, hostname))
 
-    async def unhost(self, protocol: str, hostname: str):
-        return nil(await self._send('unhost', protocol, hostname))
-
-    async def lookup(self, protocol: str, hostname: str) -> List[int]:
-        return array_integer(await self._send('lookup', protocol, hostname))
+    async def unhost(self, protocol: str):
+        return nil(await self._send('unhost', protocol))
+
+    async def lookup(self, protocol: str, hostname: str = None) -> Union[Optional[int], List[int]]:
+        result = await self._send('lookup', protocol, hostname)
+        if hostname is None:
+            if result is None:
+                return []
+            if isinstance(result, list):
+                return array_integer(result)
+            return [integer(result)]
+        else:
+            return option_integer(result)

testmod.py

@@ -1807,4 +1807,57 @@ async def test_paintutils(api):
     await api.print('Test finished successfully')
 
 
+async def test_rednet(api):
+    from computercraft.subapis.rednet import RednetAPI
+    tbl = await get_object_table(api, 'rednet')
+    del tbl['function']['run']
+    assert get_class_table(RednetAPI) == tbl
+
+    side = 'back'
+
+    await step(api, f'Attach modem to {side} side of computer')
+
+    assert await api.rednet.isOpen(side) is False
+    assert await api.rednet.isOpen() is False
+
+    with assert_raises(LuaException):
+        await api.rednet.close('doesnotexist')
+
+    assert await api.rednet.close(side) is None
+
+    with assert_raises(LuaException):
+        await api.rednet.open('doesnotexist')
+
+    assert await api.rednet.open(side) is None
+    assert await api.rednet.isOpen(side) is True
+
+    with assert_raises(LuaException):
+        # disallowed hostname
+        await api.rednet.host('helloproto', 'localhost')
+    assert await api.rednet.host('helloproto', 'alpha') is None
+
+    cid = await api.os.getComputerID()
+
+    assert await api.rednet.lookup('helloproto', 'localhost') == cid
+    assert await api.rednet.lookup('helloproto') == [cid]
+    assert await api.rednet.lookup('nonexistent', 'localhost') is None
+    assert await api.rednet.lookup('nonexistent') == []
+
+    assert await api.rednet.unhost('helloproto') is None
+
+    assert await api.rednet.send(cid + 100, 'message', 'anyproto') is True
+    assert await api.rednet.broadcast('message', 'anyproto') is None
+
+    assert await api.rednet.receive(timeout=1) is None
+    assert await asyncio.gather(
+        api.rednet.receive(timeout=1),
+        api.rednet.send(cid, 'message'),
+    ) == [(cid, 'message', None), True]
+
+    assert await api.rednet.close() is None
+    assert await api.rednet.isOpen(side) is False
+
+    await api.print('Test finished successfully')
+
+
 # vector won't be implemented, use python equivalent