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 def _dummy_daemon_info():
  16     return {
  17         'addr': '172.20.0.2:0/256594694',
  18         'metadata': {
  19             'zonegroup_name': 'zonegroup2-realm1'
  20         }
  21     }
  22
  23
  24 @patch('dashboard.services.rgw_client._get_daemon_info', _dummy_daemon_info)
  25 class RgwClientTest(unittest.TestCase, KVStoreMockMixin):
  26     def setUp(self):
  27         RgwClient._user_instances.clear()  # pylint: disable=protected-access
  28         self.mock_kv_store()
  29         self.CONFIG_KEY_DICT.update({
  30             'RGW_API_ACCESS_KEY': 'klausmustermann',
  31             'RGW_API_SECRET_KEY': 'supergeheim',
  32             'RGW_API_HOST': 'localhost',
  33             'RGW_API_USER_ID': 'rgwadmin'
  34         })
  35
  36     def test_ssl_verify(self):
  37         Settings.RGW_API_SSL_VERIFY = True
  38         instance = RgwClient.admin_instance()
  39         self.assertTrue(instance.session.verify)
  40
  41     def test_no_ssl_verify(self):
  42         Settings.RGW_API_SSL_VERIFY = False
  43         instance = RgwClient.admin_instance()
  44         self.assertFalse(instance.session.verify)
  45
  46     @patch.object(RgwClient, '_get_daemon_zone_info')
  47     def test_get_placement_targets_from_zone(self, zone_info):
  48         zone_info.return_value = {
  49             'id': 'a0df30ea-4b5b-4830-b143-2bedf684663d',
  50             'placement_pools': [
  51                 {
  52                     'key': 'default-placement',
  53                     'val': {
  54                         'index_pool': 'default.rgw.buckets.index',
  55                         'storage_classes': {
  56                             'STANDARD': {
  57                                 'data_pool': 'default.rgw.buckets.data'
  58                             }
  59                         }
  60                     }
  61                 }
  62             ]
  63         }
  64
  65         instance = RgwClient.admin_instance()
  66         expected_result = {
  67             'zonegroup': 'zonegroup2-realm1',
  68             'placement_targets': [
  69                 {
  70                     'name': 'default-placement',
  71                     'data_pool': 'default.rgw.buckets.data'
  72                 }
  73             ]
  74         }
  75         self.assertEqual(expected_result, instance.get_placement_targets())
  76
  77     @patch.object(RgwClient, '_get_realms_info')
  78     def test_get_realms(self, realms_info):
  79         realms_info.side_effect = [
  80             {
  81                 'default_info': '51de8373-bc24-4f74-a9b7-8e9ef4cb71f7',
  82                 'realms': [
  83                     'realm1',
  84                     'realm2'
  85                 ]
  86             },
  87             {}
  88         ]
  89         instance = RgwClient.admin_instance()
  90
  91         self.assertEqual(['realm1', 'realm2'], instance.get_realms())
  92         self.assertEqual([], instance.get_realms())
  93
  94
  95 class RgwClientHelperTest(unittest.TestCase):
  96     def test_parse_frontend_config_1(self):
  97         self.assertEqual(_parse_frontend_config('beast port=8000'), (8000, False))
  98
  99     def test_parse_frontend_config_2(self):
 100         self.assertEqual(_parse_frontend_config('beast port=80 port=8000'), (80, False))
 101
 102     def test_parse_frontend_config_3(self):
 103         self.assertEqual(_parse_frontend_config('beast ssl_port=443 port=8000'), (443, True))
 104
 105     def test_parse_frontend_config_4(self):
 106         self.assertEqual(_parse_frontend_config('beast endpoint=192.168.0.100:8000'), (8000, False))
 107
 108     def test_parse_frontend_config_5(self):
 109         self.assertEqual(_parse_frontend_config('beast endpoint=[::1]'), (80, False))
 110
 111     def test_parse_frontend_config_6(self):
 112         self.assertEqual(_parse_frontend_config(
 113             'beast ssl_endpoint=192.168.0.100:8443'), (8443, True))
 114
 115     def test_parse_frontend_config_7(self):
 116         self.assertEqual(_parse_frontend_config('beast ssl_endpoint=192.168.0.100'), (443, True))
 117
 118     def test_parse_frontend_config_8(self):
 119         self.assertEqual(_parse_frontend_config(
 120             'beast ssl_endpoint=[::1]:8443 endpoint=192.0.2.3:80'), (8443, True))
 121
 122     def test_parse_frontend_config_9(self):
 123         self.assertEqual(_parse_frontend_config(
 124             'beast port=8080 endpoint=192.0.2.3:80'), (8080, False))
 125
 126     def test_parse_frontend_config_10(self):
 127         self.assertEqual(_parse_frontend_config(
 128             'beast ssl_endpoint=192.0.2.3:8443 port=8080'), (8443, True))
 129
 130     def test_parse_frontend_config_11(self):
 131         self.assertEqual(_parse_frontend_config('civetweb port=8000s'), (8000, True))
 132
 133     def test_parse_frontend_config_12(self):
 134         self.assertEqual(_parse_frontend_config('civetweb port=443s port=8000'), (443, True))
 135
 136     def test_parse_frontend_config_13(self):
 137         self.assertEqual(_parse_frontend_config('civetweb port=192.0.2.3:80'), (80, False))
 138
 139     def test_parse_frontend_config_14(self):
 140         self.assertEqual(_parse_frontend_config('civetweb port=172.5.2.51:8080s'), (8080, True))
 141
 142     def test_parse_frontend_config_15(self):
 143         self.assertEqual(_parse_frontend_config('civetweb port=[::]:8080'), (8080, False))
 144
 145     def test_parse_frontend_config_16(self):
 146         self.assertEqual(_parse_frontend_config('civetweb port=ip6-localhost:80s'), (80, True))
 147
 148     def test_parse_frontend_config_17(self):
 149         self.assertEqual(_parse_frontend_config('civetweb port=[2001:0db8::1234]:80'), (80, False))
 150
 151     def test_parse_frontend_config_18(self):
 152         self.assertEqual(_parse_frontend_config('civetweb port=[::1]:8443s'), (8443, True))
 153
 154     def test_parse_frontend_config_19(self):
 155         self.assertEqual(_parse_frontend_config('civetweb port=127.0.0.1:8443s+8000'), (8443, True))
 156
 157     def test_parse_frontend_config_20(self):
 158         self.assertEqual(_parse_frontend_config('civetweb port=127.0.0.1:8080+443s'), (8080, False))
 159
 160     def test_parse_frontend_config_21(self):
 161         with self.assertRaises(LookupError) as ctx:
 162             _parse_frontend_config('civetweb port=xyz')
 163         self.assertEqual(str(ctx.exception),
 164                          'Failed to determine RGW port from "civetweb port=xyz"')
 165
 166     def test_parse_frontend_config_22(self):
 167         with self.assertRaises(LookupError) as ctx:
 168             _parse_frontend_config('civetweb')
 169         self.assertEqual(str(ctx.exception), 'Failed to determine RGW port from "civetweb"')
 170
 171     def test_parse_frontend_config_23(self):
 172         with self.assertRaises(LookupError) as ctx:
 173             _parse_frontend_config('mongoose port=8080')
 174         self.assertEqual(str(ctx.exception),
 175                          'Failed to determine RGW port from "mongoose port=8080"')