def test_search(self, _find):
_impl = Mock()
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
received = [(Mock(), Document(sn='1')), (Mock(), Document(sn='2')),
(Mock(), Document(sn='3'))]
# test
url = TEST_URL
node = Node('')
sn = received[1][1].sn
reader = Reader(node, url)
reader.next = Mock(side_effect=received)
document = reader.search(sn, timeout=10)
# validation
next_calls = reader.next.call_args_list
self.assertEqual(len(next_calls), 2)
self.assertEqual(document, received[1][1])
for call in next_calls:
self.assertEqual(call[0][0], 10)
self.assertTrue(received[0][0].ack.called)
self.assertTrue(received[1][0].ack.called)
self.assertFalse(received[2][0].ack.called)
def test_init(self):
node = Node('')
url = TEST_URL
reader = BaseReader(node, url)
self.assertEqual(reader.node, node)
self.assertEqual(reader.url, url)
self.assertTrue(isinstance(reader, Messenger))
def test_abstract(self):
url = TEST_URL
node = Node('test')
reader = BaseReader(node, url)
self.assertRaises(NotImplementedError, reader.get, 10)
self.assertRaises(NotImplementedError, reader.ack, '')
self.assertRaises(NotImplementedError, reader.reject, '')
def test_repair(self, _find):
_impl = Mock()
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
url = TEST_URL
node = Node('test')
reader = Reader(node, url)
reader.repair()
_impl.repair.assert_called_with()
def test_open(self, _find):
_impl = Mock()
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
url = TEST_URL
node = Node('')
reader = Reader(node, url)
reader.open()
_impl.open.assert_called_once_with()
def test_close(self, _find):
_impl = Mock()
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
url = TEST_URL
node = Node('')
reader = Reader(node, url)
# soft
reader.close()
_impl.close.assert_called_with()
def test_ack(self, _find):
_impl = Mock()
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
message = Mock()
url = TEST_URL
node = Node('')
reader = Reader(node, url)
reader.ack(message)
message.ack.assert_called_once_with()
def test_reject(self, _find):
_impl = Mock()
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
message = Mock()
url = TEST_URL
node = Node('')
reader = Reader(node, url)
reader.reject(message, 29)
message.reject.assert_called_with(29)
def test_all(self):
cat = Node('cat')
dog = Queue('dog')
domain = _Domain()
domain.add(cat)
# add
domain.add(dog)
self.assertEqual(domain.content, {'Node::cat': cat, 'Queue::dog': dog})
# contains
self.assertTrue(domain.contains(dog))
self.assertFalse(domain.contains(Node('dog')))
self.assertTrue(dog in domain)
# find
self.assertEqual(domain.find(dog.domain_id), dog)
# not found
self.assertRaises(NotFound, domain.find, '123')
# len
self.assertEqual(len(domain), 2)
# delete
domain.delete(dog)
self.assertEqual(domain.content, {'Node::cat': cat})
def test_init(self, _find):
_impl = Mock()
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
node = Node('test')
url = TEST_URL
# test
reader = Reader(node, url)
# validation
_find.assert_called_with(url)
plugin.Reader.assert_called_with(node, url)
self.assertEqual(reader.authenticator, None)
self.assertTrue(isinstance(reader, BaseReader))
def test_next_not_found(self, _find):
_impl = Mock()
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
# test
reader = Reader(Node(''))
reader.get = Mock(return_value=None)
reader.authenticator = Mock()
_message, _document = reader.next(10)
# validation
reader.get.assert_called_once_with(10)
self.assertEqual(_message, None)
self.assertEqual(_document, None)
def test_get(self, _find):
message = Mock()
_impl = Mock()
_impl.get.return_value = message
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
node = Node('')
url = TEST_URL
# test
reader = Reader(node, url)
# validation
m = reader.get(10)
_impl.get.assert_called_with(10)
self.assertEqual(m, message)
def test_next_auth_rejected(self, _find, auth, validate):
_impl = Mock()
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
message = Mock(body='test-content')
auth.validate.side_effect = ModelError
# test
reader = Reader(Node(''))
reader.get = Mock(return_value=message)
reader.authenticator = Mock()
self.assertRaises(ModelError, reader.next, 10)
# validation
reader.get.assert_called_once_with(10)
auth.validate.assert_called_once_with(reader.authenticator, message.body)
message.ack.assert_called_once_with()
self.assertFalse(validate.called)
def test_next(self, _find, auth, validate):
_impl = Mock()
plugin = Mock()
plugin.Reader.return_value = _impl
_find.return_value = plugin
message = Mock(body='test-content')
document = Mock()
auth.validate.return_value = document
# test
reader = Reader(Node(''))
reader.get = Mock(return_value=message)
reader.authenticator = Mock()
_message, _document = reader.next(10)
# validation
reader.get.assert_called_once_with(10)
auth.validate.assert_called_once_with(reader.authenticator, message.body)
validate.assert_called_once_with(document)
self.assertEqual(_message, reader.get.return_value)
self.assertEqual(_document, document)
def test_unicode(self):
n = Node('test')
self.assertEqual(unicode(n), n.name)
def test_init(self):
name = 'test'
n = Node(name)
self.assertEqual(n.name, name)
def test_abstract(self):
n = Node('test')
self.assertRaises(NotImplementedError, n.declare, '')
self.assertRaises(NotImplementedError, n.delete, '')
def test_domain_id(self):
n = Node('test')
self.assertEqual(n.domain_id, 'Node::test')
def test_address(self):
n = Node('test')
self.assertEqual(n.address, n.name)
def test_str(self):
n = Node('test')
self.assertEqual(str(n), n.name)
