def test_create_invalid(self):
values = [
(None, {}, None), # author is None
("a", ADummyClass(), None), # non primitive payload
("a", {}, "m"), # metadata is not a dict
("a", {}, [1, 2, 3]), # metadata is not a dict
]
for (author, payload, meta) in values:
with self.assertRaises(TypeError):
B.create(author, payload, meta)
def test_create(self):
block = B.create("author", "payload", {"x": 1})
for key in B.KEYS:
self.assertIn(key, block)
self.assertEqual(block[B.AUTHOR], "author")
self.assertEqual(block[B.DATA], "payload")
self.assertEqual(block[B.METADATA], {"x": 1})
def test_processBlock_put(self):
store = Store()
block = B.create("test", 1, metadata={
"method": PUT_METHOD,
"path": "t1"
})
store.processBlock(B.serialize(block))
self.assertEqual(store.get("t1"), [1])
def _onUpdate(self, method, path, data):
if path == JOURNAL_PATH:
return
metadata = {
"method": method,
"path": path
}
block = B.create("store", data, metadata)
self.add(JOURNAL_PATH, block)
def test_client_inbound(self):
block1 = B.serialize(
B.create("t1", "A", {
"method": ADD_METHOD,
"path": "p1"
}))
block2 = B.serialize(
B.create("t1", "B", {
"method": ADD_METHOD,
"path": "p1"
}))
signal1 = Signal(data=block1, channel="Ch1")
signal2 = Signal(data=block2, channel="Ch1")
socket1 = MockSocket()
socket1.listOnRecv(
[HUB_VERSION + SEPARATOR,
signal1.bytes(),
signal2.bytes()])
hub = MockHub(store=MockStore(), subscriptions=["Ch1"])
hub.mockSockets([socket1, socket1])
def callback(ami):
s1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s1.connect((hub.host, hub.port))
s1.close()
time.sleep(0.2)
self.assertEqual(Util.getStates(Util.run(hub, callback)),
STATE_SEQUENCE)
inbounds = [i[DATA] for i in hub.store.getLogs(INBOUND_PATH)]
self.assertEqual(
inbounds,
[str(signal1.bytes()), str(signal2.bytes())])
p1_path = [i[DATA] for i in hub.store.getLogs("p1")]
self.assertEqual(p1_path, ["A", "B"])
def test_HubClient_inboundQueue(self):
signal = Signal(data=B.serialize(B.create('a', 'p')), channel="ABCDEF")
socket = MockSocket()
socket.listOnRecv([HUB_VERSION + SEPARATOR, signal.bytes()])
def callback(ami):
time.sleep(0.2)
hubClient = HubClient(socket, "127.0.0.1", store=MockStore())
self.assertEqual(Util.getStates(Util.run(hubClient, callback)),
STATE_SEQUENCE)
inbounds = hubClient.store.get(INBOUND_PATH)
self.assertEqual(inbounds, [signal.bytes()])
def test_emit_offline(self):
hub = Hub(store=MockStore())
assert (hub.store.get(OUBOUND_PATH) is None)
signal = Signal(channel="CH1", data=B.serialize(B.create('a', 'p')))
hub.emit(signal)
assert (hub.store.get(OUBOUND_PATH) == [signal.bytes()])
def test_serialize_deserialize(self):
block = B.create("author", {"data": 123})
serialized = B.serialize(block)
self.assertIsInstance(serialized, bytes)
self.assertEqual(block, B.deserialize(serialized))
def test_isValid(self):
block = B.create("author", "payload")
self.assertTrue(B.is_valid(block))
def test_isValid_corrupted(self):
for key in B.KEYS:
block = B.create("author", "payload")
block[key] = "xxx"
self.assertFalse(B.is_valid(block))
def test_isBlock_missingKey(self):
for key in B.KEYS:
block = B.create("author", "payload")
del block[key]
self.assertFalse(B.is_block(block))
def test_isBlock_notFull(self):
block = B.create("author", "payload")
del block[B.HASH]
self.assertFalse(B.is_block(block))
self.assertTrue(B.is_block(block, full=False))
def test_isBlock(self):
block = B.create("author", "payload")
self.assertTrue(B.is_block(block))
