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", {"name": "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                 "--endpoints",
 195                 "1.2.3.4:17070",
 196                 "--user",
 197                 "user",
 198                 "--secret",
 199                 "secret",
 200                 "--cacert",
 201                 "cacert",
 202                 "--lxd-cloud",
 203                 "lxd_cloud",
 204                 "--lxd-credentials",
 205                 "lxd_credentials",
 206                 "--k8s-cloud",
 207                 "k8s_cloud",
 208                 "--k8s-credentials",
 209                 "k8s_credentials",
 210                 "--description",
 211                 "description",
 212                 "--model-config",
 213                 json.dumps({"juju-https-proxy": "http://squid:3128"}),
 214             ],
 215         )
 216         mock_check_client_version.assert_called()
 217         self.ctx_obj.vca.update.assert_called_with(
 218             "name",
 219             {
 220                 "name": "name",
 221                 "endpoints": ["1.2.3.4:17070"],
 222                 "user": "user",
 223                 "secret": "secret",
 224                 "cacert": "cacert",
 225                 "lxd-cloud": "lxd_cloud",
 226                 "lxd-credentials": "lxd_credentials",
 227                 "k8s-cloud": "k8s_cloud",
 228                 "k8s-credentials": "k8s_credentials",
 229                 "description": "description",
 230                 "model-config": {"juju-https-proxy": "http://squid:3128"},
 231             },
 232         )
 233         mock_pretty_table.assert_not_called()
 234         self.table.add_row.assert_not_called()
 235         mock_print.assert_not_called()
 236
 237     def test_vca_add(
 238         self,
 239         mock_get_project,
 240         mock_check_client_version,
 241         mock_client,
 242         mock_pretty_table,
 243         mock_print,
 244     ):
 245         mock_client.return_value = self.ctx_obj
 246         self.runner.invoke(
 247             vca.vca_add,
 248             obj=self.ctx_obj,
 249             args=[
 250                 "name",
 251                 "--endpoints",
 252                 "1.2.3.4:17070",
 253                 "--user",
 254                 "user",
 255                 "--secret",
 256                 "secret",
 257                 "--cacert",
 258                 "cacert",
 259                 "--lxd-cloud",
 260                 "lxd_cloud",
 261                 "--lxd-credentials",
 262                 "lxd_credentials",
 263                 "--k8s-cloud",
 264                 "k8s_cloud",
 265                 "--k8s-credentials",
 266                 "k8s_credentials",
 267                 "--description",
 268                 "description",
 269                 "--model-config",
 270                 json.dumps({"juju-https-proxy": "http://squid:3128"}),
 271             ],
 272         )
 273         mock_check_client_version.assert_called()
 274         self.ctx_obj.vca.create.assert_called_with(
 275             "name",
 276             {
 277                 "name": "name",
 278                 "endpoints": ["1.2.3.4:17070"],
 279                 "user": "user",
 280                 "secret": "secret",
 281                 "cacert": "cacert",
 282                 "lxd-cloud": "lxd_cloud",
 283                 "lxd-credentials": "lxd_credentials",
 284                 "k8s-cloud": "k8s_cloud",
 285                 "k8s-credentials": "k8s_credentials",
 286                 "description": "description",
 287                 "model-config": {"juju-https-proxy": "http://squid:3128"},
 288             },
 289         )
 290         mock_pretty_table.assert_not_called()
 291         self.table.add_row.assert_not_called()
 292         mock_print.assert_not_called()
 293
 294     def test_vca_delete(
 295         self,
 296         mock_get_project,
 297         mock_check_client_version,
 298         mock_client,
 299         mock_pretty_table,
 300         mock_print,
 301     ):
 302         mock_client.return_value = self.ctx_obj
 303         self.runner.invoke(
 304             vca.vca_delete,
 305             obj=self.ctx_obj,
 306             args=["name"],
 307         )
 308         mock_check_client_version.assert_called()
 309         self.ctx_obj.vca.delete.assert_called_with("name", force=False)
 310         mock_pretty_table.assert_not_called()
 311         self.table.add_row.assert_not_called()
 312         mock_print.assert_not_called()
 313
 314     def test_load(
 315         self,
 316         mock_get_project,
 317         mock_check_client_version,
 318         mock_client,
 319         mock_pretty_table,
 320         mock_print,
 321     ):
 322         data = vca.load(json.dumps({"juju-https-proxy": "http://squid:3128"}))
 323         self.assertEqual(data, {"juju-https-proxy": "http://squid:3128"})