[ceph.git] / ceph / src / pybind / mgr / dashboard / tests / test_rgw.py

from unittest.mock import Mock, call, patch

from .. import mgr
from ..controllers.rgw import Rgw, RgwDaemon, RgwUser
from ..rest_client import RequestException
from ..services.rgw_client import RgwClient
from ..tests import ControllerTestCase, RgwStub


class RgwControllerTestCase(ControllerTestCase):
    @classmethod
    def setup_server(cls):
        cls.setup_controllers([Rgw], '/test')

    def setUp(self) -> None:
        RgwStub.get_daemons()
        RgwStub.get_settings()

    @patch.object(RgwClient, '_get_user_id', Mock(return_value='fake-user'))
    @patch.object(RgwClient, 'is_service_online', Mock(return_value=True))
    @patch.object(RgwClient, '_is_system_user', Mock(return_value=True))
    def test_status_available(self):
        self._get('/test/ui-api/rgw/status')
        self.assertStatus(200)
        self.assertJsonBody({'available': True, 'message': None})

    @patch.object(RgwClient, '_get_user_id', Mock(return_value='fake-user'))
    @patch.object(RgwClient, 'is_service_online', Mock(
        side_effect=RequestException('My test error')))
    def test_status_online_check_error(self):
        self._get('/test/ui-api/rgw/status')
        self.assertStatus(200)
        self.assertJsonBody({'available': False,
                             'message': 'My test error'})

    @patch.object(RgwClient, '_get_user_id', Mock(return_value='fake-user'))
    @patch.object(RgwClient, 'is_service_online', Mock(return_value=False))
    def test_status_not_online(self):
        self._get('/test/ui-api/rgw/status')
        self.assertStatus(200)
        self.assertJsonBody({'available': False,
                             'message': "Failed to connect to the Object Gateway's Admin Ops API."})

    @patch.object(RgwClient, '_get_user_id', Mock(return_value='fake-user'))
    @patch.object(RgwClient, 'is_service_online', Mock(return_value=True))
    @patch.object(RgwClient, '_is_system_user', Mock(return_value=False))
    def test_status_not_system_user(self):
        self._get('/test/ui-api/rgw/status')
        self.assertStatus(200)
        self.assertJsonBody({'available': False,
                             'message': 'The system flag is not set for user "fake-user".'})

    def test_status_no_service(self):
        RgwStub.get_mgr_no_services()
        self._get('/test/ui-api/rgw/status')
        self.assertStatus(200)
        self.assertJsonBody({'available': False, 'message': 'No RGW service is running.'})


class RgwDaemonControllerTestCase(ControllerTestCase):
    @classmethod
    def setup_server(cls):
        cls.setup_controllers([RgwDaemon], '/test')

    @patch('dashboard.services.rgw_client.RgwClient._get_user_id', Mock(
        return_value='dummy_admin'))
    def test_list(self):
        RgwStub.get_daemons()
        RgwStub.get_settings()
        mgr.list_servers.return_value = [{
            'hostname': 'host1',
            'services': [{'id': '4832', 'type': 'rgw'}, {'id': '5356', 'type': 'rgw'}]
        }]
        mgr.get_metadata.side_effect = [
            {
                'ceph_version': 'ceph version master (dev)',
                'id': 'daemon1',
                'realm_name': 'realm1',
                'zonegroup_name': 'zg1',
                'zone_name': 'zone1'
            },
            {
                'ceph_version': 'ceph version master (dev)',
                'id': 'daemon2',
                'realm_name': 'realm2',
                'zonegroup_name': 'zg2',
                'zone_name': 'zone2'
            }]
        self._get('/test/api/rgw/daemon')
        self.assertStatus(200)
        self.assertJsonBody([{
            'id': 'daemon1',
            'service_map_id': '4832',
            'version': 'ceph version master (dev)',
            'server_hostname': 'host1',
            'realm_name': 'realm1',
            'zonegroup_name': 'zg1',
            'zone_name': 'zone1', 'default': True
        },
            {
            'id': 'daemon2',
            'service_map_id': '5356',
            'version': 'ceph version master (dev)',
            'server_hostname': 'host1',
            'realm_name': 'realm2',
            'zonegroup_name': 'zg2',
            'zone_name': 'zone2',
            'default': False
        }])

    def test_list_empty(self):
        RgwStub.get_mgr_no_services()
        self._get('/test/api/rgw/daemon')
        self.assertStatus(200)
        self.assertJsonBody([])


class RgwUserControllerTestCase(ControllerTestCase):
    @classmethod
    def setup_server(cls):
        cls.setup_controllers([RgwUser], '/test')

    @patch('dashboard.controllers.rgw.RgwRESTController.proxy')
    def test_user_list(self, mock_proxy):
        mock_proxy.side_effect = [{
            'count': 3,
            'keys': ['test1', 'test2', 'test3'],
            'truncated': False
        }]
        self._get('/test/api/rgw/user?daemon_name=dummy-daemon')
        self.assertStatus(200)
        mock_proxy.assert_has_calls([
            call('dummy-daemon', 'GET', 'user?list', {})
        ])
        self.assertJsonBody(['test1', 'test2', 'test3'])

    @patch('dashboard.controllers.rgw.RgwRESTController.proxy')
    def test_user_list_marker(self, mock_proxy):
        mock_proxy.side_effect = [{
            'count': 3,
            'keys': ['test1', 'test2', 'test3'],
            'marker': 'foo:bar',
            'truncated': True
        }, {
            'count': 1,
            'keys': ['admin'],
            'truncated': False
        }]
        self._get('/test/api/rgw/user')
        self.assertStatus(200)
        mock_proxy.assert_has_calls([
            call(None, 'GET', 'user?list', {}),
            call(None, 'GET', 'user?list', {'marker': 'foo:bar'})
        ])
        self.assertJsonBody(['test1', 'test2', 'test3', 'admin'])

    @patch('dashboard.controllers.rgw.RgwRESTController.proxy')
    def test_user_list_duplicate_marker(self, mock_proxy):
        mock_proxy.side_effect = [{
            'count': 3,
            'keys': ['test1', 'test2', 'test3'],
            'marker': 'foo:bar',
            'truncated': True
        }, {
            'count': 3,
            'keys': ['test4', 'test5', 'test6'],
            'marker': 'foo:bar',
            'truncated': True
        }, {
            'count': 1,
            'keys': ['admin'],
            'truncated': False
        }]
        self._get('/test/api/rgw/user')
        self.assertStatus(500)

    @patch('dashboard.controllers.rgw.RgwRESTController.proxy')
    def test_user_list_invalid_marker(self, mock_proxy):
        mock_proxy.side_effect = [{
            'count': 3,
            'keys': ['test1', 'test2', 'test3'],
            'marker': 'foo:bar',
            'truncated': True
        }, {
            'count': 3,
            'keys': ['test4', 'test5', 'test6'],
            'marker': '',
            'truncated': True
        }, {
            'count': 1,
            'keys': ['admin'],
            'truncated': False
        }]
        self._get('/test/api/rgw/user')
        self.assertStatus(500)

    @patch('dashboard.controllers.rgw.RgwRESTController.proxy')
    @patch.object(RgwUser, '_keys_allowed')
    def test_user_get_with_keys(self, keys_allowed, mock_proxy):
        keys_allowed.return_value = True
        mock_proxy.return_value = {
            'tenant': '',
            'user_id': 'my_user_id',
            'keys': [],
            'swift_keys': []
        }
        self._get('/test/api/rgw/user/testuser')
        self.assertStatus(200)
        self.assertInJsonBody('keys')
        self.assertInJsonBody('swift_keys')

    @patch('dashboard.controllers.rgw.RgwRESTController.proxy')
    @patch.object(RgwUser, '_keys_allowed')
    def test_user_get_without_keys(self, keys_allowed, mock_proxy):
        keys_allowed.return_value = False
        mock_proxy.return_value = {
            'tenant': '',
            'user_id': 'my_user_id',
            'keys': [],
            'swift_keys': []
        }
        self._get('/test/api/rgw/user/testuser')
        self.assertStatus(200)
        self.assertNotIn('keys', self.json_body())
        self.assertNotIn('swift_keys', self.json_body())
Commit	Line	Data
f67539c2	1	from unittest.mock import Mock, call, patch
11fdf7f2	2
adb31ebb	3	from .. import mgr
f67539c2 TL	4	from ..controllers.rgw import Rgw, RgwDaemon, RgwUser
	5	from ..rest_client import RequestException
	6	from ..services.rgw_client import RgwClient
a4b75251	7	from ..tests import ControllerTestCase, RgwStub
adb31ebb TL	8
	9
	10	class RgwControllerTestCase(ControllerTestCase):
	11	@classmethod
	12	def setup_server(cls):
adb31ebb TL	13	cls.setup_controllers([Rgw], '/test')
adb31ebb TL	14
f67539c2 TL	15	def setUp(self) -> None:
	16	RgwStub.get_daemons()
	17	RgwStub.get_settings()
	18
	19	@patch.object(RgwClient, '_get_user_id', Mock(return_value='fake-user'))
	20	@patch.object(RgwClient, 'is_service_online', Mock(return_value=True))
	21	@patch.object(RgwClient, '_is_system_user', Mock(return_value=True))
	22	def test_status_available(self):
2a845540	23	self._get('/test/ui-api/rgw/status')
f67539c2 TL	24	self.assertStatus(200)
	25	self.assertJsonBody({'available': True, 'message': None})
	26
	27	@patch.object(RgwClient, '_get_user_id', Mock(return_value='fake-user'))
	28	@patch.object(RgwClient, 'is_service_online', Mock(
	29	side_effect=RequestException('My test error')))
	30	def test_status_online_check_error(self):
2a845540	31	self._get('/test/ui-api/rgw/status')
f67539c2 TL	32	self.assertStatus(200)
	33	self.assertJsonBody({'available': False,
	34	'message': 'My test error'})
	35
	36	@patch.object(RgwClient, '_get_user_id', Mock(return_value='fake-user'))
	37	@patch.object(RgwClient, 'is_service_online', Mock(return_value=False))
	38	def test_status_not_online(self):
2a845540	39	self._get('/test/ui-api/rgw/status')
f67539c2 TL	40	self.assertStatus(200)
	41	self.assertJsonBody({'available': False,
	42	'message': "Failed to connect to the Object Gateway's Admin Ops API."})
	43
	44	@patch.object(RgwClient, '_get_user_id', Mock(return_value='fake-user'))
	45	@patch.object(RgwClient, 'is_service_online', Mock(return_value=True))
	46	@patch.object(RgwClient, '_is_system_user', Mock(return_value=False))
	47	def test_status_not_system_user(self):
2a845540	48	self._get('/test/ui-api/rgw/status')
f67539c2 TL	49	self.assertStatus(200)
	50	self.assertJsonBody({'available': False,
	51	'message': 'The system flag is not set for user "fake-user".'})
	52
adb31ebb	53	def test_status_no_service(self):
f67539c2	54	RgwStub.get_mgr_no_services()
2a845540	55	self._get('/test/ui-api/rgw/status')
adb31ebb TL	56	self.assertStatus(200)
adb31ebb TL	57	self.assertJsonBody({'available': False, 'message': 'No RGW service is running.'})
11fdf7f2 TL	58
11fdf7f2 TL	59
f67539c2 TL	60	class RgwDaemonControllerTestCase(ControllerTestCase):
	61	@classmethod
	62	def setup_server(cls):
f67539c2 TL	63	cls.setup_controllers([RgwDaemon], '/test')
	64
	65	@patch('dashboard.services.rgw_client.RgwClient._get_user_id', Mock(
	66	return_value='dummy_admin'))
	67	def test_list(self):
	68	RgwStub.get_daemons()
	69	RgwStub.get_settings()
	70	mgr.list_servers.return_value = [{
	71	'hostname': 'host1',
522d829b	72	'services': [{'id': '4832', 'type': 'rgw'}, {'id': '5356', 'type': 'rgw'}]
f67539c2 TL	73	}]
	74	mgr.get_metadata.side_effect = [
	75	{
	76	'ceph_version': 'ceph version master (dev)',
	77	'id': 'daemon1',
a4b75251	78	'realm_name': 'realm1',
f67539c2 TL	79	'zonegroup_name': 'zg1',
	80	'zone_name': 'zone1'
	81	},
	82	{
	83	'ceph_version': 'ceph version master (dev)',
	84	'id': 'daemon2',
a4b75251	85	'realm_name': 'realm2',
f67539c2 TL	86	'zonegroup_name': 'zg2',
	87	'zone_name': 'zone2'
	88	}]
	89	self._get('/test/api/rgw/daemon')
	90	self.assertStatus(200)
	91	self.assertJsonBody([{
	92	'id': 'daemon1',
522d829b	93	'service_map_id': '4832',
f67539c2 TL	94	'version': 'ceph version master (dev)',
f67539c2 TL	95	'server_hostname': 'host1',
a4b75251	96	'realm_name': 'realm1',
f67539c2 TL	97	'zonegroup_name': 'zg1',
	98	'zone_name': 'zone1', 'default': True
	99	},
	100	{
	101	'id': 'daemon2',
522d829b	102	'service_map_id': '5356',
f67539c2 TL	103	'version': 'ceph version master (dev)',
f67539c2 TL	104	'server_hostname': 'host1',
a4b75251	105	'realm_name': 'realm2',
f67539c2 TL	106	'zonegroup_name': 'zg2',
	107	'zone_name': 'zone2',
	108	'default': False
	109	}])
	110
	111	def test_list_empty(self):
	112	RgwStub.get_mgr_no_services()
	113	self._get('/test/api/rgw/daemon')
	114	self.assertStatus(200)
	115	self.assertJsonBody([])
	116
	117
11fdf7f2 TL	118	class RgwUserControllerTestCase(ControllerTestCase):
	119	@classmethod
	120	def setup_server(cls):
11fdf7f2 TL	121	cls.setup_controllers([RgwUser], '/test')
11fdf7f2 TL	122
f67539c2	123	@patch('dashboard.controllers.rgw.RgwRESTController.proxy')
11fdf7f2 TL	124	def test_user_list(self, mock_proxy):
	125	mock_proxy.side_effect = [{
	126	'count': 3,
	127	'keys': ['test1', 'test2', 'test3'],
	128	'truncated': False
	129	}]
f67539c2	130	self._get('/test/api/rgw/user?daemon_name=dummy-daemon')
11fdf7f2 TL	131	self.assertStatus(200)
11fdf7f2 TL	132	mock_proxy.assert_has_calls([
f67539c2	133	call('dummy-daemon', 'GET', 'user?list', {})
11fdf7f2 TL	134	])
	135	self.assertJsonBody(['test1', 'test2', 'test3'])
	136
f67539c2	137	@patch('dashboard.controllers.rgw.RgwRESTController.proxy')
11fdf7f2 TL	138	def test_user_list_marker(self, mock_proxy):
	139	mock_proxy.side_effect = [{
	140	'count': 3,
	141	'keys': ['test1', 'test2', 'test3'],
	142	'marker': 'foo:bar',
	143	'truncated': True
	144	}, {
	145	'count': 1,
	146	'keys': ['admin'],
	147	'truncated': False
	148	}]
	149	self._get('/test/api/rgw/user')
	150	self.assertStatus(200)
	151	mock_proxy.assert_has_calls([
f67539c2 TL	152	call(None, 'GET', 'user?list', {}),
f67539c2 TL	153	call(None, 'GET', 'user?list', {'marker': 'foo:bar'})
11fdf7f2 TL	154	])
	155	self.assertJsonBody(['test1', 'test2', 'test3', 'admin'])
	156
f67539c2	157	@patch('dashboard.controllers.rgw.RgwRESTController.proxy')
11fdf7f2 TL	158	def test_user_list_duplicate_marker(self, mock_proxy):
	159	mock_proxy.side_effect = [{
	160	'count': 3,
	161	'keys': ['test1', 'test2', 'test3'],
	162	'marker': 'foo:bar',
	163	'truncated': True
	164	}, {
	165	'count': 3,
	166	'keys': ['test4', 'test5', 'test6'],
	167	'marker': 'foo:bar',
	168	'truncated': True
	169	}, {
	170	'count': 1,
	171	'keys': ['admin'],
	172	'truncated': False
	173	}]
	174	self._get('/test/api/rgw/user')
	175	self.assertStatus(500)
	176
f67539c2	177	@patch('dashboard.controllers.rgw.RgwRESTController.proxy')
11fdf7f2 TL	178	def test_user_list_invalid_marker(self, mock_proxy):
	179	mock_proxy.side_effect = [{
	180	'count': 3,
	181	'keys': ['test1', 'test2', 'test3'],
	182	'marker': 'foo:bar',
	183	'truncated': True
	184	}, {
	185	'count': 3,
	186	'keys': ['test4', 'test5', 'test6'],
	187	'marker': '',
	188	'truncated': True
	189	}, {
	190	'count': 1,
	191	'keys': ['admin'],
	192	'truncated': False
	193	}]
	194	self._get('/test/api/rgw/user')
	195	self.assertStatus(500)
9f95a23c	196
f67539c2 TL	197	@patch('dashboard.controllers.rgw.RgwRESTController.proxy')
f67539c2 TL	198	@patch.object(RgwUser, '_keys_allowed')
9f95a23c TL	199	def test_user_get_with_keys(self, keys_allowed, mock_proxy):
	200	keys_allowed.return_value = True
	201	mock_proxy.return_value = {
	202	'tenant': '',
	203	'user_id': 'my_user_id',
	204	'keys': [],
	205	'swift_keys': []
	206	}
	207	self._get('/test/api/rgw/user/testuser')
	208	self.assertStatus(200)
	209	self.assertInJsonBody('keys')
	210	self.assertInJsonBody('swift_keys')
	211
f67539c2 TL	212	@patch('dashboard.controllers.rgw.RgwRESTController.proxy')
f67539c2 TL	213	@patch.object(RgwUser, '_keys_allowed')
9f95a23c TL	214	def test_user_get_without_keys(self, keys_allowed, mock_proxy):
	215	keys_allowed.return_value = False
	216	mock_proxy.return_value = {
	217	'tenant': '',
	218	'user_id': 'my_user_id',
	219	'keys': [],
	220	'swift_keys': []
	221	}
	222	self._get('/test/api/rgw/user/testuser')
	223	self.assertStatus(200)
	224	self.assertNotIn('keys', self.json_body())
	225	self.assertNotIn('swift_keys', self.json_body())