osmclient/scripts/tests/tests_vca.py

   1 # Copyright 2021 Canonical Ltd.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 #     Unless required by applicable law or agreed to in writing, software
  10 #     distributed under the License is distributed on an "AS IS" BASIS,
  11 #     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 #     See the License for the specific language governing permissions and
  13 #     limitations under the License.
  14
  15
  16 from click.testing import CliRunner
  17 import json
  18 import unittest
  19 from unittest.mock import Mock, patch
  20 import yaml
  21
  22 from osmclient.cli_commands import vca
  23
  24
  25 @patch("builtins.print")
  26 @patch("osmclient.cli_commands.vca.PrettyTable")
  27 @patch("osmclient.scripts.osm.client.Client")
  28 @patch("osmclient.cli_commands.utils.check_client_version")
  29 @patch("osmclient.cli_commands.vca.utils.get_project")
  30 class TestVca(unittest.TestCase):
  31     def setUp(self):
  32         self.runner = CliRunner()
  33         self.ctx_obj = Mock()
  34         self.table = Mock()
  35         self.vca_data = {
  36             "name": "name",
  37             "_id": "1234",
  38             "_admin": {
  39                 "detailed-status": "status",
  40                 "operationalState": "state",
  41             },
  42         }
  43
  44     def test_vca_list(
  45         self,
  46         mock_get_project,
  47         mock_check_client_version,
  48         mock_client,
  49         mock_pretty_table,
  50         mock_print,
  51     ):
  52         mock_client.return_value = self.ctx_obj
  53         mock_pretty_table.return_value = self.table
  54         mock_get_project.return_value = ("5678", "project")
  55         self.ctx_obj.vca.list.return_value = [self.vca_data]
  56         self.runner.invoke(
  57             vca.vca_list,
  58             obj=self.ctx_obj,
  59             args=["--filter", "somefilter"],
  60         )
  61         mock_check_client_version.assert_called()
  62         self.ctx_obj.vca.list.assert_called_with("somefilter")
  63         mock_pretty_table.assert_called_with(["Name", "Id", "Operational State"])
  64         self.table.add_row.assert_called_with(["name", "1234", "state"])
  65         mock_print.assert_called_with(self.table)
  66
  67     def test_vca_list_long(
  68         self,
  69         mock_get_project,
  70         mock_check_client_version,
  71         mock_client,
  72         mock_pretty_table,
  73         mock_print,
  74     ):
  75         mock_client.return_value = self.ctx_obj
  76         mock_pretty_table.return_value = self.table
  77         mock_get_project.return_value = ("5678", "project")
  78         self.ctx_obj.vca.list.return_value = [self.vca_data]
  79         self.runner.invoke(
  80             vca.vca_list,
  81             obj=self.ctx_obj,
  82             args=["--filter", "somefilter", "--long"],
  83         )
  84         mock_check_client_version.assert_called()
  85         self.ctx_obj.vca.list.assert_called_with("somefilter")
  86         mock_pretty_table.assert_called_with(
  87             ["Name", "Id", "Project", "Operational State", "Detailed Status"]
  88         )
  89         self.table.add_row.assert_called_with(
  90             ["name", "1234", "project", "state", "status"]
  91         )
  92         mock_print.assert_called_with(self.table)
  93
  94     def test_vca_list_literal(
  95         self,
  96         mock_get_project,
  97         mock_check_client_version,
  98         mock_client,
  99         mock_pretty_table,
 100         mock_print,
 101     ):
 102         mock_client.return_value = self.ctx_obj
 103         self.ctx_obj.vca.list.return_value = [self.vca_data]
 104         self.runner.invoke(
 105             vca.vca_list,
 106             obj=self.ctx_obj,
 107             args=["--literal"],
 108         )
 109         mock_check_client_version.assert_called()
 110         self.ctx_obj.vca.list.assert_called()
 111         mock_pretty_table.assert_not_called()
 112         self.table.add_row.assert_not_called()
 113         mock_print.assert_called_with(
 114             yaml.safe_dump([self.vca_data], indent=4, default_flow_style=False)
 115         )
 116
 117     def test_vca_show(
 118         self,
 119         mock_get_project,
 120         mock_check_client_version,
 121         mock_client,
 122         mock_pretty_table,
 123         mock_print,
 124     ):
 125         mock_client.return_value = self.ctx_obj
 126         mock_pretty_table.return_value = self.table
 127         self.ctx_obj.vca.get.return_value = self.vca_data
 128         self.runner.invoke(
 129             vca.vca_show,
 130             obj=self.ctx_obj,
 131             args=["name"],
 132         )
 133         self.ctx_obj.vca.get.assert_called_with("name")
 134         mock_pretty_table.assert_called_with(["key", "attribute"])
 135         self.assertEqual(self.table.add_row.call_count, len(self.vca_data))
 136         mock_print.assert_called_with(self.table)
 137
 138     def test_vca_show_literal(
 139         self,
 140         mock_get_project,
 141         mock_check_client_version,
 142         mock_client,
 143         mock_pretty_table,
 144         mock_print,
 145     ):
 146         mock_client.return_value = self.ctx_obj
 147         self.ctx_obj.vca.get.return_value = self.vca_data
 148         self.runner.invoke(
 149             vca.vca_show,
 150             obj=self.ctx_obj,
 151             args=["name", "--literal"],
 152         )
 153         self.ctx_obj.vca.get.assert_called_with("name")
 154         mock_pretty_table.assert_not_called()
 155         self.table.add_row.assert_not_called()
 156         mock_print.assert_called_with(
 157             yaml.safe_dump(self.vca_data, indent=4, default_flow_style=False)
 158         )
 159
 160     def test_vca_update(
 161         self,
 162         mock_get_project,
 163         mock_check_client_version,
 164         mock_client,
 165         mock_pretty_table,
 166         mock_print,
 167     ):
 168         mock_client.return_value = self.ctx_obj
 169         self.runner.invoke(
 170             vca.vca_update,
 171             obj=self.ctx_obj,
 172             args=["name"],
 173         )
 174         mock_check_client_version.assert_called()
 175         self.ctx_obj.vca.update.assert_called_with("name", {})
 176         mock_pretty_table.assert_not_called()
 177         self.table.add_row.assert_not_called()
 178         mock_print.assert_not_called()
 179
 180     def test_vca_update_with_args(
 181         self,
 182         mock_get_project,
 183         mock_check_client_version,
 184         mock_client,
 185         mock_pretty_table,
 186         mock_print,
 187     ):
 188         mock_client.return_value = self.ctx_obj
 189         self.runner.invoke(
 190             vca.vca_update,
 191             obj=self.ctx_obj,
 192             args=[
 193                 "name",
 194                 "--newname",
 195                 "newname",
 196                 "--endpoints",
 197                 "1.2.3.4:17070",
 198                 "--user",
 199                 "user",
 200                 "--secret",
 201                 "secret",
 202                 "--cacert",
 203                 "cacert",
 204                 "--lxd-cloud",
 205                 "lxd_cloud",
 206                 "--lxd-credentials",
 207                 "lxd_credentials",
 208                 "--k8s-cloud",
 209                 "k8s_cloud",
 210                 "--k8s-credentials",
 211                 "k8s_credentials",
 212                 "--description",
 213                 "description",
 214                 "--model-config",
 215                 json.dumps({"juju-https-proxy": "http://squid:3128"}),
 216             ],
 217         )
 218         mock_check_client_version.assert_called()
 219         self.ctx_obj.vca.update.assert_called_with(
 220             "name",
 221             {
 222                 "name": "newname",
 223                 "endpoints": ["1.2.3.4:17070"],
 224                 "user": "user",
 225                 "secret": "secret",
 226                 "cacert": "cacert",
 227                 "lxd-cloud": "lxd_cloud",
 228                 "lxd-credentials": "lxd_credentials",
 229                 "k8s-cloud": "k8s_cloud",
 230                 "k8s-credentials": "k8s_credentials",
 231                 "description": "description",
 232                 "model-config": {"juju-https-proxy": "http://squid:3128"},
 233             },
 234         )
 235         mock_pretty_table.assert_not_called()
 236         self.table.add_row.assert_not_called()
 237         mock_print.assert_not_called()
 238
 239     def test_vca_add(
 240         self,
 241         mock_get_project,
 242         mock_check_client_version,
 243         mock_client,
 244         mock_pretty_table,
 245         mock_print,
 246     ):
 247         mock_client.return_value = self.ctx_obj
 248         self.runner.invoke(
 249             vca.vca_add,
 250             obj=self.ctx_obj,
 251             args=[
 252                 "name",
 253                 "--endpoints",
 254                 "1.2.3.4:17070",
 255                 "--user",
 256                 "user",
 257                 "--secret",
 258                 "secret",
 259                 "--cacert",
 260                 "cacert",
 261                 "--lxd-cloud",
 262                 "lxd_cloud",
 263                 "--lxd-credentials",
 264                 "lxd_credentials",
 265                 "--k8s-cloud",
 266                 "k8s_cloud",
 267                 "--k8s-credentials",
 268                 "k8s_credentials",
 269                 "--description",
 270                 "description",
 271                 "--model-config",
 272                 json.dumps({"juju-https-proxy": "http://squid:3128"}),
 273             ],
 274         )
 275         mock_check_client_version.assert_called()
 276         self.ctx_obj.vca.create.assert_called_with(
 277             "name",
 278             {
 279                 "name": "name",
 280                 "endpoints": ["1.2.3.4:17070"],
 281                 "user": "user",
 282                 "secret": "secret",
 283                 "cacert": "cacert",
 284                 "lxd-cloud": "lxd_cloud",
 285                 "lxd-credentials": "lxd_credentials",
 286                 "k8s-cloud": "k8s_cloud",
 287                 "k8s-credentials": "k8s_credentials",
 288                 "description": "description",
 289                 "model-config": {"juju-https-proxy": "http://squid:3128"},
 290             },
 291         )
 292         mock_pretty_table.assert_not_called()
 293         self.table.add_row.assert_not_called()
 294         mock_print.assert_not_called()
 295
 296     def test_vca_delete(
 297         self,
 298         mock_get_project,
 299         mock_check_client_version,
 300         mock_client,
 301         mock_pretty_table,
 302         mock_print,
 303     ):
 304         mock_client.return_value = self.ctx_obj
 305         self.runner.invoke(
 306             vca.vca_delete,
 307             obj=self.ctx_obj,
 308             args=["name"],
 309         )
 310         mock_check_client_version.assert_called()
 311         self.ctx_obj.vca.delete.assert_called_with("name", force=False)
 312         mock_pretty_table.assert_not_called()
 313         self.table.add_row.assert_not_called()
 314         mock_print.assert_not_called()
 315
 316     def test_load(
 317         self,
 318         mock_get_project,
 319         mock_check_client_version,
 320         mock_client,
 321         mock_pretty_table,
 322         mock_print,
 323     ):
 324         data = vca.load(json.dumps({"juju-https-proxy": "http://squid:3128"}))
 325         self.assertEqual(data, {"juju-https-proxy": "http://squid:3128"})