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 import json
  17 import unittest
  18 from unittest.mock import Mock, patch
  19 import yaml
  20
  21
  22 from click.testing import CliRunner
  23 from osmclient.scripts import osm
  24
  25
  26 @patch("builtins.print")
  27 @patch("osmclient.scripts.osm.PrettyTable")
  28 @patch("osmclient.scripts.osm.client.Client")
  29 @patch("osmclient.scripts.osm.check_client_version")
  30 @patch("osmclient.scripts.osm.get_project")
  31 class TestVca(unittest.TestCase):
  32     def setUp(self):
  33         self.runner = CliRunner()
  34         self.ctx_obj = Mock()
  35         self.table = Mock()
  36         self.vca_data = {
  37             "name": "name",
  38             "_id": "1234",
  39             "_admin": {
  40                 "detailed-status": "status",
  41                 "operationalState": "state",
  42             },
  43         }
  44
  45     def test_vca_list(
  46         self,
  47         mock_get_project,
  48         mock_check_client_version,
  49         mock_client,
  50         mock_pretty_table,
  51         mock_print,
  52     ):
  53         mock_client.return_value = self.ctx_obj
  54         mock_pretty_table.return_value = self.table
  55         mock_get_project.return_value = ("5678", "project")
  56         self.ctx_obj.vca.list.return_value = [self.vca_data]
  57         self.runner.invoke(
  58             osm.cli_osm,
  59             ["vca-list", "--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             osm.cli_osm,
  81             ["vca-list", "--filter", "somefilter", "--long"],
  82         )
  83         mock_check_client_version.assert_called()
  84         self.ctx_obj.vca.list.assert_called_with("somefilter")
  85         mock_pretty_table.assert_called_with(
  86             ["Name", "Id", "Project", "Operational State", "Detailed Status"]
  87         )
  88         self.table.add_row.assert_called_with(
  89             ["name", "1234", "project", "state", "status"]
  90         )
  91         mock_print.assert_called_with(self.table)
  92
  93     def test_vca_list_literal(
  94         self,
  95         mock_get_project,
  96         mock_check_client_version,
  97         mock_client,
  98         mock_pretty_table,
  99         mock_print,
 100     ):
 101         mock_client.return_value = self.ctx_obj
 102         self.ctx_obj.vca.list.return_value = [self.vca_data]
 103         self.runner.invoke(
 104             osm.cli_osm,
 105             ["vca-list", "--literal"],
 106         )
 107         mock_check_client_version.assert_called()
 108         self.ctx_obj.vca.list.assert_called()
 109         mock_pretty_table.assert_not_called()
 110         self.table.add_row.assert_not_called()
 111         mock_print.assert_called_with(
 112             yaml.safe_dump([self.vca_data], indent=4, default_flow_style=False)
 113         )
 114
 115     def test_vca_show(
 116         self,
 117         mock_get_project,
 118         mock_check_client_version,
 119         mock_client,
 120         mock_pretty_table,
 121         mock_print,
 122     ):
 123         mock_client.return_value = self.ctx_obj
 124         mock_pretty_table.return_value = self.table
 125         self.ctx_obj.vca.get.return_value = self.vca_data
 126         self.runner.invoke(
 127             osm.cli_osm,
 128             ["vca-show", "name"],
 129         )
 130         self.ctx_obj.vca.get.assert_called_with("name")
 131         mock_pretty_table.assert_called_with(["key", "attribute"])
 132         self.assertEqual(self.table.add_row.call_count, len(self.vca_data))
 133         mock_print.assert_called_with(self.table)
 134
 135     def test_vca_show_literal(
 136         self,
 137         mock_get_project,
 138         mock_check_client_version,
 139         mock_client,
 140         mock_pretty_table,
 141         mock_print,
 142     ):
 143         mock_client.return_value = self.ctx_obj
 144         self.ctx_obj.vca.get.return_value = self.vca_data
 145         self.runner.invoke(
 146             osm.cli_osm,
 147             ["vca-show", "name", "--literal"],
 148         )
 149         self.ctx_obj.vca.get.assert_called_with("name")
 150         mock_pretty_table.assert_not_called()
 151         self.table.add_row.assert_not_called()
 152         mock_print.assert_called_with(
 153             yaml.safe_dump(self.vca_data, indent=4, default_flow_style=False)
 154         )
 155
 156     def test_vca_update(
 157         self,
 158         mock_get_project,
 159         mock_check_client_version,
 160         mock_client,
 161         mock_pretty_table,
 162         mock_print,
 163     ):
 164         mock_client.return_value = self.ctx_obj
 165         self.runner.invoke(
 166             osm.cli_osm,
 167             ["vca-update", "name"],
 168         )
 169         mock_check_client_version.assert_called()
 170         self.ctx_obj.vca.update.assert_called_with("name", {"name": "name"})
 171         mock_pretty_table.assert_not_called()
 172         self.table.add_row.assert_not_called()
 173         mock_print.assert_not_called()
 174
 175     def test_vca_update_with_args(
 176         self,
 177         mock_get_project,
 178         mock_check_client_version,
 179         mock_client,
 180         mock_pretty_table,
 181         mock_print,
 182     ):
 183         mock_client.return_value = self.ctx_obj
 184         self.runner.invoke(
 185             osm.cli_osm,
 186             [
 187                 "vca-update",
 188                 "name",
 189                 "--endpoints",
 190                 "1.2.3.4:17070",
 191                 "--user",
 192                 "user",
 193                 "--secret",
 194                 "secret",
 195                 "--cacert",
 196                 "cacert",
 197                 "--lxd-cloud",
 198                 "lxd_cloud",
 199                 "--lxd-credentials",
 200                 "lxd_credentials",
 201                 "--k8s-cloud",
 202                 "k8s_cloud",
 203                 "--k8s-credentials",
 204                 "k8s_credentials",
 205                 "--description",
 206                 "description",
 207                 "--model-config",
 208                 json.dumps({"juju-https-proxy": "http://squid:3128"}),
 209             ],
 210         )
 211         mock_check_client_version.assert_called()
 212         self.ctx_obj.vca.update.assert_called_with(
 213             "name",
 214             {
 215                 "name": "name",
 216                 "endpoints": ["1.2.3.4:17070"],
 217                 "user": "user",
 218                 "secret": "secret",
 219                 "cacert": "cacert",
 220                 "lxd-cloud": "lxd_cloud",
 221                 "lxd-credentials": "lxd_credentials",
 222                 "k8s-cloud": "k8s_cloud",
 223                 "k8s-credentials": "k8s_credentials",
 224                 "description": "description",
 225                 "model-config": {"juju-https-proxy": "http://squid:3128"},
 226             },
 227         )
 228         mock_pretty_table.assert_not_called()
 229         self.table.add_row.assert_not_called()
 230         mock_print.assert_not_called()
 231
 232     def test_vca_add(
 233         self,
 234         mock_get_project,
 235         mock_check_client_version,
 236         mock_client,
 237         mock_pretty_table,
 238         mock_print,
 239     ):
 240         mock_client.return_value = self.ctx_obj
 241         self.runner.invoke(
 242             osm.cli_osm,
 243             [
 244                 "vca-add",
 245                 "name",
 246                 "--endpoints",
 247                 "1.2.3.4:17070",
 248                 "--user",
 249                 "user",
 250                 "--secret",
 251                 "secret",
 252                 "--cacert",
 253                 "cacert",
 254                 "--lxd-cloud",
 255                 "lxd_cloud",
 256                 "--lxd-credentials",
 257                 "lxd_credentials",
 258                 "--k8s-cloud",
 259                 "k8s_cloud",
 260                 "--k8s-credentials",
 261                 "k8s_credentials",
 262                 "--description",
 263                 "description",
 264                 "--model-config",
 265                 json.dumps({"juju-https-proxy": "http://squid:3128"}),
 266             ],
 267         )
 268         mock_check_client_version.assert_called()
 269         self.ctx_obj.vca.create.assert_called_with(
 270             "name",
 271             {
 272                 "name": "name",
 273                 "endpoints": ["1.2.3.4:17070"],
 274                 "user": "user",
 275                 "secret": "secret",
 276                 "cacert": "cacert",
 277                 "lxd-cloud": "lxd_cloud",
 278                 "lxd-credentials": "lxd_credentials",
 279                 "k8s-cloud": "k8s_cloud",
 280                 "k8s-credentials": "k8s_credentials",
 281                 "description": "description",
 282                 "model-config": {"juju-https-proxy": "http://squid:3128"},
 283             },
 284         )
 285         mock_pretty_table.assert_not_called()
 286         self.table.add_row.assert_not_called()
 287         mock_print.assert_not_called()
 288
 289     def test_vca_delete(
 290         self,
 291         mock_get_project,
 292         mock_check_client_version,
 293         mock_client,
 294         mock_pretty_table,
 295         mock_print,
 296     ):
 297         mock_client.return_value = self.ctx_obj
 298         self.runner.invoke(
 299             osm.cli_osm,
 300             ["vca-delete", "name"],
 301         )
 302         mock_check_client_version.assert_called()
 303         self.ctx_obj.vca.delete.assert_called_with("name", force=False)
 304         mock_pretty_table.assert_not_called()
 305         self.table.add_row.assert_not_called()
 306         mock_print.assert_not_called()
 307
 308     def test_load(
 309         self,
 310         mock_get_project,
 311         mock_check_client_version,
 312         mock_client,
 313         mock_pretty_table,
 314         mock_print,
 315     ):
 316         data = osm.load(json.dumps({"juju-https-proxy": "http://squid:3128"}))
 317         self.assertEqual(data, {"juju-https-proxy": "http://squid:3128"})