ceph/src/pybind/mgr/dashboard/tests/test_rgw_client.py

   1 # -*- coding: utf-8 -*-
   2 # pylint: disable=too-many-public-methods
   3 import unittest
   4
   5 try:
   6     from unittest.mock import patch
   7 except ImportError:
   8     from mock import patch  # type: ignore
   9
  10 from ..services.rgw_client import RgwClient, _parse_frontend_config
  11 from ..settings import Settings
  12 from . import KVStoreMockMixin
  13
  14
  15 class RgwClientTest(unittest.TestCase, KVStoreMockMixin):
  16     def setUp(self):
  17         RgwClient._user_instances.clear()  # pylint: disable=protected-access
  18         self.mock_kv_store()
  19         self.CONFIG_KEY_DICT.update({
  20             'RGW_API_ACCESS_KEY': 'klausmustermann',
  21             'RGW_API_SECRET_KEY': 'supergeheim',
  22             'RGW_API_HOST': 'localhost',
  23             'RGW_API_USER_ID': 'rgwadmin'
  24         })
  25
  26     def test_ssl_verify(self):
  27         Settings.RGW_API_SSL_VERIFY = True
  28         instance = RgwClient.admin_instance()
  29         self.assertTrue(instance.session.verify)
  30
  31     def test_no_ssl_verify(self):
  32         Settings.RGW_API_SSL_VERIFY = False
  33         instance = RgwClient.admin_instance()
  34         self.assertFalse(instance.session.verify)
  35
  36     @patch.object(RgwClient, '_get_daemon_zone_info')
  37     def test_get_placement_targets_from_default_zone(self, zone_info):
  38         zone_info.return_value = {
  39             'placement_pools': [
  40                 {
  41                     'key': 'default-placement',
  42                     'val': {
  43                         'index_pool': 'default.rgw.buckets.index',
  44                         'storage_classes': {
  45                             'STANDARD': {
  46                                 'data_pool': 'default.rgw.buckets.data'
  47                             }
  48                         },
  49                         'data_extra_pool': 'default.rgw.buckets.non-ec',
  50                         'index_type': 0
  51                     }
  52                 }
  53             ],
  54             'realm_id': ''
  55         }
  56
  57         instance = RgwClient.admin_instance()
  58         expected_result = {
  59             'zonegroup': 'default',
  60             'placement_targets': [
  61                 {
  62                     'name': 'default-placement',
  63                     'data_pool': 'default.rgw.buckets.data'
  64                 }
  65             ]
  66         }
  67         self.assertEqual(expected_result, instance.get_placement_targets())
  68
  69     @patch.object(RgwClient, '_get_daemon_zone_info')
  70     @patch.object(RgwClient, '_get_daemon_zonegroup_map')
  71     def test_get_placement_targets_from_realm_zone(self, zonegroup_map, zone_info):
  72         zone_info.return_value = {
  73             'id': 'a0df30ea-4b5b-4830-b143-2bedf684663d',
  74             'placement_pools': [
  75                 {
  76                     'key': 'default-placement',
  77                     'val': {
  78                         'index_pool': 'default.rgw.buckets.index',
  79                         'storage_classes': {
  80                             'STANDARD': {
  81                                 'data_pool': 'default.rgw.buckets.data'
  82                             }
  83                         }
  84                     }
  85                 }
  86             ],
  87             'realm_id': 'b5a25d1b-e7ed-4fe5-b461-74f24b8e759b'
  88         }
  89
  90         zonegroup_map.return_value = [
  91             {
  92                 'api_name': 'zonegroup1-realm1',
  93                 'zones': [
  94                     {
  95                         'id': '2ef7d0ef-7616-4e9c-8553-b732ebf0592b'
  96                     },
  97                     {
  98                         'id': 'b1d15925-6c8e-408e-8485-5a62cbccfe1f'
  99                     }
 100                 ]
 101             },
 102             {
 103                 'api_name': 'zonegroup2-realm1',
 104                 'zones': [
 105                     {
 106                         'id': '645f0f59-8fcc-4e11-95d5-24f289ee8e25'
 107                     },
 108                     {
 109                         'id': 'a0df30ea-4b5b-4830-b143-2bedf684663d'
 110                     }
 111                 ]
 112             }
 113         ]
 114
 115         instance = RgwClient.admin_instance()
 116         expected_result = {
 117             'zonegroup': 'zonegroup2-realm1',
 118             'placement_targets': [
 119                 {
 120                     'name': 'default-placement',
 121                     'data_pool': 'default.rgw.buckets.data'
 122                 }
 123             ]
 124         }
 125         self.assertEqual(expected_result, instance.get_placement_targets())
 126
 127     @patch.object(RgwClient, '_get_realms_info')
 128     def test_get_realms(self, realms_info):
 129         realms_info.side_effect = [
 130             {
 131                 'default_info': '51de8373-bc24-4f74-a9b7-8e9ef4cb71f7',
 132                 'realms': [
 133                     'realm1',
 134                     'realm2'
 135                 ]
 136             },
 137             {}
 138         ]
 139         instance = RgwClient.admin_instance()
 140
 141         self.assertEqual(['realm1', 'realm2'], instance.get_realms())
 142         self.assertEqual([], instance.get_realms())
 143
 144
 145 class RgwClientHelperTest(unittest.TestCase):
 146     def test_parse_frontend_config_1(self):
 147         self.assertEqual(_parse_frontend_config('beast port=8000'), (8000, False))
 148
 149     def test_parse_frontend_config_2(self):
 150         self.assertEqual(_parse_frontend_config('beast port=80 port=8000'), (80, False))
 151
 152     def test_parse_frontend_config_3(self):
 153         self.assertEqual(_parse_frontend_config('beast ssl_port=443 port=8000'), (443, True))
 154
 155     def test_parse_frontend_config_4(self):
 156         self.assertEqual(_parse_frontend_config('beast endpoint=192.168.0.100:8000'), (8000, False))
 157
 158     def test_parse_frontend_config_5(self):
 159         self.assertEqual(_parse_frontend_config('beast endpoint=[::1]'), (80, False))
 160
 161     def test_parse_frontend_config_6(self):
 162         self.assertEqual(_parse_frontend_config(
 163             'beast ssl_endpoint=192.168.0.100:8443'), (8443, True))
 164
 165     def test_parse_frontend_config_7(self):
 166         self.assertEqual(_parse_frontend_config('beast ssl_endpoint=192.168.0.100'), (443, True))
 167
 168     def test_parse_frontend_config_8(self):
 169         self.assertEqual(_parse_frontend_config(
 170             'beast ssl_endpoint=[::1]:8443 endpoint=192.0.2.3:80'), (8443, True))
 171
 172     def test_parse_frontend_config_9(self):
 173         self.assertEqual(_parse_frontend_config(
 174             'beast port=8080 endpoint=192.0.2.3:80'), (8080, False))
 175
 176     def test_parse_frontend_config_10(self):
 177         self.assertEqual(_parse_frontend_config(
 178             'beast ssl_endpoint=192.0.2.3:8443 port=8080'), (8443, True))
 179
 180     def test_parse_frontend_config_11(self):
 181         self.assertEqual(_parse_frontend_config('civetweb port=8000s'), (8000, True))
 182
 183     def test_parse_frontend_config_12(self):
 184         self.assertEqual(_parse_frontend_config('civetweb port=443s port=8000'), (443, True))
 185
 186     def test_parse_frontend_config_13(self):
 187         self.assertEqual(_parse_frontend_config('civetweb port=192.0.2.3:80'), (80, False))
 188
 189     def test_parse_frontend_config_14(self):
 190         self.assertEqual(_parse_frontend_config('civetweb port=172.5.2.51:8080s'), (8080, True))
 191
 192     def test_parse_frontend_config_15(self):
 193         self.assertEqual(_parse_frontend_config('civetweb port=[::]:8080'), (8080, False))
 194
 195     def test_parse_frontend_config_16(self):
 196         self.assertEqual(_parse_frontend_config('civetweb port=ip6-localhost:80s'), (80, True))
 197
 198     def test_parse_frontend_config_17(self):
 199         self.assertEqual(_parse_frontend_config('civetweb port=[2001:0db8::1234]:80'), (80, False))
 200
 201     def test_parse_frontend_config_18(self):
 202         self.assertEqual(_parse_frontend_config('civetweb port=[::1]:8443s'), (8443, True))
 203
 204     def test_parse_frontend_config_19(self):
 205         self.assertEqual(_parse_frontend_config('civetweb port=127.0.0.1:8443s+8000'), (8443, True))
 206
 207     def test_parse_frontend_config_20(self):
 208         self.assertEqual(_parse_frontend_config('civetweb port=127.0.0.1:8080+443s'), (8080, False))
 209
 210     def test_parse_frontend_config_21(self):
 211         with self.assertRaises(LookupError) as ctx:
 212             _parse_frontend_config('civetweb port=xyz')
 213         self.assertEqual(str(ctx.exception),
 214                          'Failed to determine RGW port from "civetweb port=xyz"')
 215
 216     def test_parse_frontend_config_22(self):
 217         with self.assertRaises(LookupError) as ctx:
 218             _parse_frontend_config('civetweb')
 219         self.assertEqual(str(ctx.exception), 'Failed to determine RGW port from "civetweb"')
 220
 221     def test_parse_frontend_config_23(self):
 222         with self.assertRaises(LookupError) as ctx:
 223             _parse_frontend_config('mongoose port=8080')
 224         self.assertEqual(str(ctx.exception),
 225                          'Failed to determine RGW port from "mongoose port=8080"')