def test_main_list(self, mock_list, mock_parser):
args = mock.Mock()
args.parse_args.return_value = mock.Mock(command='list')
mock_parser.return_value = args
mock_list.return_value = [{
'domain_name': 'node-1',
'status': 'running',
'address': '::',
'port': 321
}, {
'domain_name': 'node-0',
'status': 'running',
'address': '::',
'port': 123
}]
with mock.patch.object(sys, 'stdout', six.StringIO()) as output:
vbmc.main()
out = output.getvalue()
expected_output = """\
+-------------+---------+---------+------+
| Domain name | Status | Address | Port |
+-------------+---------+---------+------+
| node-0 | running | :: | 123 |
| node-1 | running | :: | 321 |
+-------------+---------+---------+------+
"""
self.assertEqual(expected_output, out)
args.parse_args.assert_called_once_with()
mock_list.assert_called_once_with()
def test_main_show(self, mock_show, mock_parser):
args = mock.Mock()
args.parse_args.return_value = mock.Mock(command='show',
domain_name='SpongeBob')
mock_parser.return_value = args
self.domain['status'] = 'running'
mock_show.return_value = self.domain
with mock.patch.object(sys, 'stdout', six.StringIO()) as output:
vbmc.main()
out = output.getvalue()
expected_output = """\
+-----------------------+-----------+
| Property | Value |
+-----------------------+-----------+
| address | :: |
| domain_name | SpongeBob |
| libvirt_sasl_password | None |
| libvirt_sasl_username | None |
| libvirt_uri | foo://bar |
| password | pass |
| port | 123 |
| status | running |
| username | admin |
+-----------------------+-----------+
"""
self.assertEqual(expected_output, out)
args.parse_args.assert_called_once_with()
mock_show.assert_called_once_with('SpongeBob')
def test_main_start(self, mock_start, mock_parser):
args = mock.Mock()
args.parse_args.return_value = mock.Mock(command='start',
domain_name='SpongeBob')
mock_parser.return_value = args
vbmc.main()
args.parse_args.assert_called_once_with()
mock_start.assert_called_once_with('SpongeBob')
def test_main_add(self, mock_add, mock_parser):
args = mock.Mock()
args.parse_args.return_value = mock.Mock(command='add', **self.domain)
mock_parser.return_value = args
vbmc.main()
args.parse_args.assert_called_once_with()
mock_add.assert_called_once_with(**self.domain)
def test_main_stop(self, mock_stop, mock_parser):
args = mock.Mock()
args.parse_args.return_value = mock.Mock(command='stop',
domain_names=['foo', 'bar'])
mock_parser.return_value = args
vbmc.main()
args.parse_args.assert_called_once_with()
expected_calls = [mock.call('foo'), mock.call('bar')]
self.assertEqual(expected_calls, mock_stop.call_args_list)
def test_main_delete(self, mock_zmq_poller, mock_zmq_context):
expected_rc = 0
expected_output = ''
srv_rsp = {'rc': expected_rc, 'msg': ['OK']}
mock_zmq_context = mock_zmq_context.return_value
mock_zmq_socket = mock_zmq_context.socket.return_value
mock_zmq_socket.recv.return_value = json.dumps(srv_rsp).encode()
mock_zmq_poller = mock_zmq_poller.return_value
mock_zmq_poller.poll.return_value = {mock_zmq_socket: zmq.POLLIN}
with mock.patch.object(sys, 'stdout', six.StringIO()) as output:
rc = vbmc.main(['delete', 'foo', 'bar'])
query = json.loads(mock_zmq_socket.send.call_args[0][0].decode())
expected_query = {
"domain_names": ["foo", "bar"],
"command": "delete",
}
self.assertEqual(expected_query, query)
self.assertEqual(expected_rc, rc)
self.assertEqual(expected_output, output.getvalue())
def test_main_add(self, mock_zmq_poller, mock_zmq_context):
expected_rc = 0
expected_output = ''
srv_rsp = {'rc': expected_rc, 'msg': ['OK']}
mock_zmq_context = mock_zmq_context.return_value
mock_zmq_socket = mock_zmq_context.socket.return_value
mock_zmq_socket.recv.return_value = json.dumps(srv_rsp).encode()
mock_zmq_poller = mock_zmq_poller.return_value
mock_zmq_poller.poll.return_value = {mock_zmq_socket: zmq.POLLIN}
with mock.patch.object(sys, 'stdout', six.StringIO()) as output:
rc = vbmc.main(['add', '--username', 'ironic', 'bar'])
query = json.loads(mock_zmq_socket.send.call_args[0][0].decode())
expected_query = {
'command': 'add',
'address': '::',
'port': 623,
'libvirt_uri': 'qemu:///system',
'libvirt_sasl_username': None,
'libvirt_sasl_password': None,
'username': '******',
'password': '******',
'domain_name': 'bar',
}
self.assertEqual(expected_query, query)
self.assertEqual(expected_rc, rc)
self.assertEqual(expected_output, output.getvalue())
def test_main_delete(self, mock_zmq_poller, mock_zmq_context):
expected_rc = 0
expected_output = ''
srv_rsp = {
'rc': expected_rc,
'msg': ['OK']
}
mock_zmq_context = mock_zmq_context.return_value
mock_zmq_socket = mock_zmq_context.socket.return_value
mock_zmq_socket.recv.return_value = json.dumps(srv_rsp).encode()
mock_zmq_poller = mock_zmq_poller.return_value
mock_zmq_poller.poll.return_value = {
mock_zmq_socket: zmq.POLLIN
}
with mock.patch.object(sys, 'stdout', six.StringIO()) as output:
rc = vbmc.main(['delete', 'foo', 'bar'])
query = json.loads(mock_zmq_socket.send.call_args[0][0].decode())
expected_query = {
"domain_names": ["foo", "bar"],
"command": "delete",
}
self.assertEqual(expected_query, query)
self.assertEqual(expected_rc, rc)
self.assertEqual(expected_output, output.getvalue())
def test_server_timeout(self, mock_zmq_poller, mock_zmq_context):
expected_rc = 1
expected_output = ('Server at 50891 may be dead, '
'will not try to revive it\n')
mock_zmq_poller = mock_zmq_poller.return_value
mock_zmq_poller.poll.return_value = {}
with mock.patch.object(sys, 'stderr', six.StringIO()) as output:
rc = vbmc.main(
['--no-daemon', 'add', '--username', 'ironic', 'bar'])
self.assertEqual(expected_rc, rc)
self.assertEqual(expected_output, output.getvalue())
def test_server_timeout(self, mock_zmq_poller, mock_zmq_context):
expected_rc = 1
expected_output = ('Server at 50891 may be dead, '
'will not try to revive it\n')
mock_zmq_poller = mock_zmq_poller.return_value
mock_zmq_poller.poll.return_value = {}
with mock.patch.object(sys, 'stderr', six.StringIO()) as output:
rc = vbmc.main(['--no-daemon',
'add', '--username', 'ironic', 'bar'])
self.assertEqual(expected_rc, rc)
self.assertEqual(expected_output, output.getvalue())
def test_server_timeout(self, mock_zmq_poller, mock_zmq_context):
expected_rc = 1
expected_output = (
'Failed to connect to the vbmcd server on port 50891, error: '
'Server response timed out\n')
mock_zmq_poller = mock_zmq_poller.return_value
mock_zmq_poller.poll.return_value = {}
with mock.patch.object(sys, 'stderr', io.StringIO()) as output:
rc = vbmc.main(
['--no-daemon', 'add', '--username', 'ironic', 'bar'])
self.assertEqual(expected_rc, rc)
self.assertEqual(expected_output, output.getvalue())
def test_main_show(self, mock_zmq_poller, mock_zmq_context):
expected_rc = 0
expected_output = """+-------+-------+
| col1 | col2 |
+-------+-------+
| cell1 | cell2 |
| cell3 | cell4 |
+-------+-------+
"""
srv_rsp = {
'rc': expected_rc,
'header': ['col1', 'col2'],
'rows': [['cell1', 'cell2'],
['cell3', 'cell4']]
}
mock_zmq_context = mock_zmq_context.return_value
mock_zmq_socket = mock_zmq_context.socket.return_value
mock_zmq_socket.recv.return_value = json.dumps(srv_rsp).encode()
mock_zmq_poller = mock_zmq_poller.return_value
mock_zmq_poller.poll.return_value = {
mock_zmq_socket: zmq.POLLIN
}
with mock.patch.object(sys, 'stdout', six.StringIO()) as output:
rc = vbmc.main(['show', 'domain0'])
query = json.loads(mock_zmq_socket.send.call_args[0][0].decode())
expected_query = {
"domain_name": "domain0",
"command": "show",
}
# Cliff adds some extra args to the query
query = {key: query[key] for key in query
if key in expected_query}
self.assertEqual(expected_query, query)
self.assertEqual(expected_rc, rc)
self.assertEqual(expected_output, output.getvalue())
def test_main_show(self, mock_zmq_poller, mock_zmq_context):
expected_rc = 0
expected_output = """+-------+-------+
| col1 | col2 |
+-------+-------+
| cell1 | cell2 |
| cell3 | cell4 |
+-------+-------+
"""
srv_rsp = {
'rc': expected_rc,
'header': ['col1', 'col2'],
'rows': [['cell1', 'cell2'], ['cell3', 'cell4']]
}
mock_zmq_context = mock_zmq_context.return_value
mock_zmq_socket = mock_zmq_context.socket.return_value
mock_zmq_socket.recv.return_value = json.dumps(srv_rsp).encode()
mock_zmq_poller = mock_zmq_poller.return_value
mock_zmq_poller.poll.return_value = {mock_zmq_socket: zmq.POLLIN}
with mock.patch.object(sys, 'stdout', six.StringIO()) as output:
rc = vbmc.main(['show', 'domain0'])
query = json.loads(mock_zmq_socket.send.call_args[0][0].decode())
expected_query = {
"domain_name": "domain0",
"command": "show",
}
# Cliff adds some extra args to the query
query = {key: query[key] for key in query if key in expected_query}
self.assertEqual(expected_query, query)
self.assertEqual(expected_rc, rc)
self.assertEqual(expected_output, output.getvalue())
def test_main_add(self, mock_zmq_poller, mock_zmq_context):
expected_rc = 0
expected_output = ''
srv_rsp = {
'rc': expected_rc,
'msg': ['OK']
}
mock_zmq_context = mock_zmq_context.return_value
mock_zmq_socket = mock_zmq_context.socket.return_value
mock_zmq_socket.recv.return_value = json.dumps(srv_rsp).encode()
mock_zmq_poller = mock_zmq_poller.return_value
mock_zmq_poller.poll.return_value = {
mock_zmq_socket: zmq.POLLIN
}
with mock.patch.object(sys, 'stdout', six.StringIO()) as output:
rc = vbmc.main(['add', '--username', 'ironic', 'bar'])
query = json.loads(mock_zmq_socket.send.call_args[0][0].decode())
expected_query = {
'command': 'add',
'address': '::',
'port': 623,
'libvirt_uri': 'qemu:///system',
'libvirt_sasl_username': None,
'libvirt_sasl_password': None,
'username': '******',
'password': '******',
'domain_name': 'bar',
}
self.assertEqual(expected_query, query)
self.assertEqual(expected_rc, rc)
self.assertEqual(expected_output, output.getvalue())
