oks-cli 1.16__tar.gz → 1.18__tar.gz

{oks_cli-1.16 → oks_cli-1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oks-cli
-Version: 1.16
+Version: 1.18
 Author: Outscale SAS
 Author-email: opensource@outscale.com
 License: BSD

{oks_cli-1.16 → oks_cli-1.18}/oks_cli/cache.py

@@ -2,7 +2,7 @@ import click
 from .utils import clear_cache, find_project_id_by_name, find_cluster_id_by_name, get_all_cache, get_expiration_date, \
                    ctx_update, login_profile, profile_completer, cluster_completer, project_completer, print_table
 
-import prettytable
+from prettytable import TableStyle
 
 # DEFINE THE CACHE COMMAND GROUP
 @click.group(help="Cache related commands.")
@@ -57,8 +57,8 @@ def list_kubeconfigs(ctx, project_name, cluster_name, plain, msword, profile):
 
     style = None
     if plain:
-        style = prettytable.PLAIN_COLUMNS
+        style = TableStyle.PLAIN_COLUMNS
     if msword:
-        style = prettytable.MSWORD_FRIENDLY
+        style = TableStyle.MSWORD_FRIENDLY
 
     print_table(data, fields, style=style)

{oks_cli-1.16 → oks_cli-1.18}/oks_cli/cluster.py

@@ -14,6 +14,7 @@ import prettytable
 import logging
 import yaml
 
+from prettytable import TableStyle
 from .utils import cluster_completer, do_request, print_output,                 \
                    find_project_id_by_name, find_cluster_id_by_name,            \
                    get_cache, save_cache, detect_and_parse_input,               \
@@ -22,7 +23,7 @@ from .utils import cluster_completer, do_request, print_output,
                    ctx_update, set_cluster_id, get_cluster_id, get_project_id,  \
                    get_template, get_cluster_name, format_changed_row,          \
                    is_interesting_status, profile_completer, project_completer, \
-                   kubeconfig_parse_fields, print_table, get_expiration_date
+                   kubeconfig_parse_fields, print_table, format_row
 
 from .profile import add_profile
 from .project import project_create, project_login
@@ -86,19 +87,22 @@ def cluster_logout(ctx, profile):
 @click.option('--watch', '-w', is_flag=True, help="Watch the changes")
 @click.option('--output', '-o', type=click.Choice(["json", "yaml", "wide"]), help="Specify output format")
 @click.option('--profile', help="Configuration profile to use")
+@click.option('--all', '-A', is_flag=True, help="List clusters from all projects")
 @click.pass_context
-def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch, output, profile):
+def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch, output, profile, all):
     """Display clusters with optional filtering and real-time monitoring."""
     project_name, cluster_name, profile = ctx_update(ctx, project_name, cluster_name, profile)
     login_profile(profile)
 
     profile_name = os.getenv('OKS_PROFILE')
     region_name = os.getenv('OKS_REGION')
-    project_id = find_project_id_by_name(project_name)
-    cluster_id = get_cluster_id()
-
     params = {}
-    params['project_id'] = project_id
+
+    if not all:
+        project_id = find_project_id_by_name(project_name)
+        params['project_id'] = project_id
+
+    cluster_id = get_cluster_id()
 
     if cluster_name:
         params['name'] = cluster_name
@@ -107,7 +111,17 @@ def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch,
 
     field_names = ["CLUSTER", "PROFILE", "REGION", "CREATED", "UPDATED", "STATUS", "DEFAULT"]
 
-    data = do_request("GET", 'clusters', params=params)
+    if all:
+        field_names.insert(0, "PROJECT")
+
+        projects = {project["id"]: project for project in do_request("GET", "projects")}
+        data = do_request("GET", "clusters/all", params=params)
+
+        for cluster in data:
+            project = projects.get(cluster.get("project_id"))
+            cluster["project_name"] = project.get("name")
+    else:
+        data = do_request("GET", "clusters", params=params)
 
     if output == "wide":
         field_names.insert(0, "ID")
@@ -123,49 +137,27 @@ def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch,
     table._min_width = {"CREATED": 13, "UPDATED": 13, "STATUS": 10}
 
     if plain or watch:
-        table.set_style(prettytable.PLAIN_COLUMNS)
+        table.set_style(TableStyle.PLAIN_COLUMNS)
 
     if msword:
         table.set_style(prettytable.MSWORD_FRIENDLY)
 
-    def format_row(cluster):
-        status = cluster['statuses']['status']
-
-        is_default = True if cluster.get('id') == cluster_id else False
-
-        if status == 'ready':
-            msg = click.style(status, fg='green')
-        elif status == 'failed' or status == 'deleted':
-            msg = click.style(status, fg='red')
-        elif status == 'deploying':
-            msg = click.style(status, fg='yellow')
-        else:
-            msg = status
-
-        name = click.style(cluster['name'], bold=True)
-        if is_default:
-            default = "*"
-        else:
-            default = ""
-
-        created_at = dateutil.parser.parse(cluster['statuses']['created_at'])
-        updated_at = dateutil.parser.parse(cluster['statuses']['updated_at'])
-        now = datetime.now(tz = created_at.tzinfo)
-
-        row = [name, profile_name, region_name, human_readable.date_time(now - created_at), human_readable.date_time(now - updated_at), msg, default]
+    initial_clusters = {}
 
+    for cluster in data:
+        row, _, name = format_row(cluster.get('statuses'), cluster.get('name'), cluster_id == cluster.get('id'))
+        row.insert(1, profile_name)
+        row.insert(2, region_name)
+        if all:
+            project_name = click.style(cluster.get("project_name"), bold=True)
+            row.insert(0, project_name)
         if output == "wide":
-            row.insert(0, cluster['id'])
-            row.append(cluster['version'])
-            row.append(cluster['control_planes'])
-
-        return row, status, cluster['name']
+            row.insert(0, cluster.get('id'))
+            row.append(cluster.get('version'))
+            row.append(cluster.get('control_planes'))
 
-    initial_clusters = {}
-    for cluster in data:
-        row, _, name = format_row(cluster)
         table.add_row(row)
-        initial_clusters[name] = cluster
+        initial_clusters[cluster.get("id")] = cluster
 
     click.echo(table)
 
@@ -177,46 +169,66 @@ def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch,
                 total_sleep += 2
 
                 try:
-                    data = do_request("GET", 'clusters', params=params)
+                    if all:
+                        projects = {project["id"]: project for project in do_request("GET", "projects")}
+                        data = do_request("GET", "clusters/all", params=params)
+
+                        for cluster in data:
+                            project = projects.get(cluster.get("project_id"))
+                            cluster["project_name"] = project.get("name")
+                    else:
+                        data = do_request("GET", 'clusters', params=params)
                 except click.ClickException as err:
                     click.echo(f"Error during watch: {err}")
                     continue
 
-                current_cluster_names = {cluster['name'] for cluster in data}
+                current_cluster_ids = {cluster.get('id') for cluster in data}
 
-                for name, cluster in list(initial_clusters.items()):
-                    if name not in current_cluster_names:
+                for id, cluster in list(initial_clusters.items()):
+                    if id not in current_cluster_ids:
                         deleted_cluster = cluster.copy()
                         deleted_cluster['statuses']['status'] = 'deleted'
 
-                        row, current_status, _ = format_row(deleted_cluster)
+                        row, current_status, _ = format_row(deleted_cluster.get('statuses'), deleted_cluster.get('name'), cluster_id == deleted_cluster.get('id'))
+                        row.insert(1, profile_name)
+                        row.insert(2, region_name)
+                        if all:
+                            project_name = click.style(cluster.get("project_name"), bold=True)
+                            row.insert(0, project_name)
 
                         new_table = format_changed_row(table, row)
                         click.echo(new_table)
                         
-                        del initial_clusters[name]
+                        del initial_clusters[id]
 
                 for cluster in data:
-                    row, current_status, name = format_row(cluster)
+                    row, current_status, name = format_row(cluster.get('statuses'), cluster.get('name'), cluster_id == cluster.get('id'))
+                    row.insert(1, profile_name)
+                    row.insert(2, region_name)
+                    if all:
+                        project_name = click.style(cluster.get("project_name"), bold=True)
+                        row.insert(0, project_name)
+
+                    cl_id = cluster.get('id')
 
-                    if name not in initial_clusters:
+                    if cl_id not in initial_clusters:
                         new_table = format_changed_row(table, row)
                         click.echo(new_table)
-                        initial_clusters[name] = cluster
+                        initial_clusters[cl_id] = cluster
                         continue
 
-                    stored_cluster = initial_clusters[name]
+                    stored_cluster = initial_clusters[cl_id]
                     cluster_status = stored_cluster.get('statuses').get('status')
                     if cluster_status != current_status:
                         new_table = format_changed_row(table, row)
                         click.echo(new_table)
-                        initial_clusters[name] = cluster
+                        initial_clusters[cl_id] = cluster
                         continue
 
                     if total_sleep % 10 == 0 and is_interesting_status(current_status):
                         new_table = format_changed_row(table, row)
                         click.echo(new_table)
-                        initial_clusters[name] = cluster
+                        initial_clusters[cl_id] = cluster
 
         except KeyboardInterrupt:
             click.echo("\nWatch stopped.")
@@ -245,6 +257,9 @@ def cluster_get_command(ctx, project_name, cluster_name, output, profile):
 def prepare_cluster_template(cluster_config):
     cluster_template = get_template("cluster")
 
+    if cluster_template.get("project_id") == "":
+        cluster_template.pop("project_id", None)
+
     admin_whitelist = cluster_config.get("admin_whitelist") or []
     if isinstance(admin_whitelist, str):
         admin_whitelist = [admin_whitelist]
@@ -473,7 +488,23 @@ def cluster_update_command(ctx, project_name, cluster_name, description, admin,
         if len(admin) == 0:
             cluster_config['admin_whitelist'] = []
         else:
-            cluster_config['admin_whitelist'] = admin.split(',')
+            admin_list = admin.split(',')
+            resolved_ips = []
+            for ip in admin_list:
+                ip = ip.strip()
+                if ip == "my-ip":
+                    try:
+                        data = do_request("GET", "myip")
+                        if isinstance(data, dict) and "x_real_ip" in data:
+                            resolved_ip = data["x_real_ip"]
+                            resolved_ips.append(f"{resolved_ip}/32")
+                        else:
+                            raise click.ClickException(f"Unexpected response format from 'myip': {data}")
+                    except Exception as e:
+                        raise click.ClickException(f"Unable to resolve 'my-ip': {e}")
+                else:
+                    resolved_ips.append(ip)
+            cluster_config['admin_whitelist'] = resolved_ips
 
     if version is not None:
         cluster_config['version'] = version

{oks_cli-1.16 → oks_cli-1.18}/oks_cli/profile.py

@@ -18,7 +18,7 @@ def profile():
 @click.option('--password', required=False, help="Password", type=click.STRING)
 @click.option('--region', required=True, help="Region name", type=click.Choice(['eu-west-2', 'cloudgouv-eu-west-1']))
 @click.option('--endpoint', required=False, help="API endpoint", type=click.STRING)
-@click.option('--jwt', help="Enable JWT, by default is false")
+@click.option('--jwt', help="Enable JWT, by default is false", type=click.BOOL)
 def add_profile(profile_name, access_key, secret_key, username, password, region, endpoint, jwt):
     """Add a new profile with AK/SK or username/password authentication."""
     if not profile_name:

{oks_cli-1.16 → oks_cli-1.18}/oks_cli/project.py

@@ -5,8 +5,12 @@ import dateutil.parser
 import human_readable
 import prettytable
 import os
+from prettytable import TableStyle
 
-from .utils import do_request, print_output, print_table, find_project_id_by_name, get_project_id, set_project_id, detect_and_parse_input, transform_tuple, ctx_update, set_cluster_id, get_template, get_project_name, format_changed_row, is_interesting_status, login_profile, profile_completer, project_completer
+from .utils import do_request, print_output, print_table, find_project_id_by_name, get_project_id, set_project_id, \
+                   detect_and_parse_input, transform_tuple, ctx_update, set_cluster_id, get_template, get_project_name, \
+                   format_changed_row, is_interesting_status, login_profile, profile_completer, project_completer, \
+                   format_row
 
 # DEIFNE THE PROJECT COMMAND GROUP
 @click.group(help="Project related commands.")
@@ -73,6 +77,7 @@ def project_list(ctx, project_name, deleted, plain, msword, uuid, watch, output,
     login_profile(profile)
 
     profile_name = os.getenv('OKS_PROFILE')
+    region_name = os.getenv('OKS_REGION')
     project_id = get_project_id()
 
     params = {}
@@ -98,51 +103,24 @@ def project_list(ctx, project_name, deleted, plain, msword, uuid, watch, output,
     table._min_width = {"CREATED": 13, "UPDATED": 13, "STATUS": 10}
 
     if plain or watch:
-        table.set_style(prettytable.PLAIN_COLUMNS)
+        table.set_style(TableStyle.PLAIN_COLUMNS)
 
     if msword:
         table.set_style(prettytable.MSWORD_FRIENDLY)
 
-    def format_row(project):
-        status = project.get('status')
-        is_default = True if project.get('id') == project_id else False
-
-        if status == 'ready':
-            msg = click.style(status, fg='green')
-        elif status == 'failed' or status == 'deleted':
-            msg = click.style(status, fg='red')
-        elif status == 'deploying':
-            msg = click.style(status, fg='yellow')
-        else:
-            msg = status
-
-        name = click.style(project['name'], bold=True)
-        if is_default:
-            default = "*"
-        else:
-            default = ""
-
-        region_name = project.get('region')
-        created_at = dateutil.parser.parse(project['created_at'])
-        updated_at = dateutil.parser.parse(project['updated_at'])
-        now = datetime.datetime.now(tz=created_at.tzinfo)
-
-        row = [name, profile_name, region_name, human_readable.date_time(now - created_at), human_readable.date_time(now - updated_at), msg, default]
-        if uuid:
-            row.append(project['id'])
-
-        return row, status, project['name']
-
     initial_projects = {}
 
     for project in data:
-        row, _, name = format_row(project)
+        row, _, name = format_row(project, project.get('name'), project_id == project.get('id'))
+        row.insert(1, profile_name)
+        row.insert(2, region_name)
+        if uuid:
+            row.append(project.get('id'))
         table.add_row(row)
         initial_projects[name] = project
 
     click.echo(table)
 
-
     if watch:
         total_sleep = 0
         try:
@@ -162,15 +140,19 @@ def project_list(ctx, project_name, deleted, plain, msword, uuid, watch, output,
                         deleted_project = project.copy()
                         deleted_project['status'] = 'deleted'
 
-                        row, current_status, _ = format_row(deleted_project)
-
+                        row, current_status, _ = format_row(deleted_project, deleted_project.get('name'), project_id == deleted_project.get('id'))
+                        row.insert(1, profile_name)
+                        row.insert(2, region_name)
                         new_table = format_changed_row(table, row)
+
                         click.echo(new_table)
 
                         del initial_projects[name]
 
                 for project in data:
-                    row, current_status, name = format_row(project)
+                    row, current_status, name = format_row(project, project.get('name'), project_id == project.get('id'))
+                    row.insert(1, profile_name)
+                    row.insert(2, region_name)
 
                     if name not in initial_projects:
                         new_table = format_changed_row(table, row)
@@ -409,4 +391,22 @@ def project_get_public_ips(ctx, project_name, output, profile):
     project_id = find_project_id_by_name(project_name)
 
     data = do_request("GET", f'projects/{project_id}/public_ips')
+    print_output(data, output)
+
+
+
+# GET NETS BY PROJECT NAME
+@project.command('nets', help="Get project nets")
+@click.option('--project-name', '-p', help="Name of the project", shell_complete=project_completer)
+@click.option('--output', '-o', type=click.Choice(["json", "yaml"]), help="Specify output format, by default is json")
+@click.option('--profile',help="Configuration profile to use")
+@click.pass_context
+def project_get_public_ips(ctx, project_name, output, profile):
+    """Retrieve the list of Nets associated with the specified project."""
+    project_name, _, profile = ctx_update(ctx, project_name, None, profile)
+    login_profile(profile)
+
+    project_id = find_project_id_by_name(project_name)
+
+    data = do_request("GET", f'projects/{project_id}/nets')
     print_output(data, output)

{oks_cli-1.16 → oks_cli-1.18}/oks_cli/utils.py

@@ -14,7 +14,8 @@ from datetime import datetime
 import OpenSSL
 import shutil
 import prettytable
-
+import dateutil.parser
+import human_readable
 import base64
 import sys
 
@@ -35,6 +36,9 @@ class JSONClickException(click.ClickException):
     def show(self, file=None):
         click.echo(self.message, file=file)
 
+class _LiteralStr(str): pass
+
+yaml.add_representer(_LiteralStr, lambda dumper, data: dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|'))
 
 def find_response_object(data):
     """Extract the main object from the API response payload."""
@@ -71,6 +75,10 @@ def find_response_object(data):
             return response["Snapshots"]
         elif key == "PublicIps":
             return response["PublicIps"]
+        elif key == "IP":
+            return response["IP"]
+        elif key == "Nets":
+            return response["Nets"]
 
     raise click.ClickException("The API response format is incorrect.")
 
@@ -102,10 +110,13 @@ def do_request(method, path, *args, **kwargs):
             obj = find_response_object(data)
             return obj
         except requests.exceptions.HTTPError as err:
-            otp_response = handle_otp_error(err, lambda: do_request(method, path, *args, **kwargs))
+            otp_response = handle_otp_error(err, method, path, args, kwargs)
             if otp_response is not None:
                 return otp_response
 
+            if os.environ.get("OKS_OTP_CODE") is not None:
+                raise JSONClickException(err.response.text)
+
             jwt_response = handle_jwt_error(err, method, path, args, kwargs)
             if jwt_response is not None:
                 return jwt_response
@@ -158,12 +169,22 @@ def build_headers():
 
     return headers
 
+def _convert_multiline(obj):
+    """Recursively convert multiline strings"""
+    if isinstance(obj, dict):
+        return {k: _convert_multiline(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_convert_multiline(i) for i in obj]
+    if isinstance(obj, str) and '\n' in obj:
+        return _LiteralStr(obj)
+    return obj
+
 def print_output(data, output_fromat):
     """Print data in the specified format: JSON, YAML, or silent."""
     output_data = json.dumps(data, indent=4)
 
     if output_fromat == "yaml":
-        output_data = yaml.dump(data, sort_keys=False)
+        output_data = yaml.dump(_convert_multiline(data), sort_keys=False)
 
     elif output_fromat == "silent":
         return
@@ -194,7 +215,7 @@ def print_table(data, table_fields, align="l", style=None):
         table.add_row([d[v] if v in d else "" for v in values])
     click.echo(table)
 
-def handle_otp_error(err, callback):
+def handle_otp_error(err, method, path, args, kwargs):
     """Handle OTP authentication error by prompting the user and retrying the request."""
     try:
         response_body = json.loads(err.response.text)
@@ -202,7 +223,11 @@ def handle_otp_error(err, callback):
             otp_code = click.prompt('Enter your OTP code', type=int)
             os.environ["OKS_OTP_CODE"] = str(otp_code)
 
-            return callback()
+            logging.info("Retrying request with user-provided OTP...")
+            return do_request(method, path, *args, **kwargs)
+
+    except JSONClickException:
+        raise
     except Exception:
         return None
 
@@ -241,8 +266,14 @@ def find_cluster_id_by_name(project_id, cluster_name):
     """Retrieve the cluster ID by name within a given project, or use the default cluster if none is provided."""
     if not cluster_name:
         cluster_id = get_cluster_id()
+        errors = {"Error": "--cluster-name must be specified, or a default cluster must be set"}
+
         if not cluster_id:
-            raise click.BadParameter("--cluster-name must be specified, or a default cluster must be set")
+            raise JSONClickException(json.dumps(errors))
+
+        cluster = do_request("GET", f'clusters/{cluster_id}')
+        if cluster['project_id'] != project_id:
+            raise JSONClickException(json.dumps(errors))
     else:
         data = do_request("GET", 'clusters', params={"project_id": project_id, "name": cluster_name})
         if len(data) != 1:
@@ -365,6 +396,34 @@ def login_profile(name):
 
     return {}
 
+def format_row(data: dict, name: str, is_default: bool):
+    """Parse status and dates from a cluster of project object and returns elements"""
+
+    if not data.get('status'):
+        raise click.ClickException(f"Can't find 'status' in project/cluster data")
+
+    status = data.get('status')
+    if status == 'ready':
+        msg = click.style(status, fg='green')
+    elif status in ['failed', 'deleted']:
+        msg = click.style(status, fg='red')
+    elif status in ['deploying', 'deleting', 'pending']:
+        msg = click.style(status, fg='yellow')
+    else:
+        msg = status
+
+    if is_default:
+        default = "*"
+    else:
+        default = ""
+
+    created_at = dateutil.parser.parse(data['created_at'])
+    updated_at = dateutil.parser.parse(data['updated_at'])
+    now = datetime.now(tz=created_at.tzinfo)
+
+    row = [click.style(name, bold=True), human_readable.date_time(now - created_at), human_readable.date_time(now - updated_at), msg, default]
+    return row, status, name
+
 def profile_list():
     """Return all profiles as a dict, or empty if none."""
     _, PROFILE_FILE = get_config_path()

{oks_cli-1.16 → oks_cli-1.18}/oks_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oks-cli
-Version: 1.16
+Version: 1.18
 Author: Outscale SAS
 Author-email: opensource@outscale.com
 License: BSD

{oks_cli-1.16 → oks_cli-1.18}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="oks-cli",
-    version="1.16",
+    version="1.18",
     packages=['oks_cli'],
     author="Outscale SAS",
     author_email="opensource@outscale.com",

{oks_cli-1.16 → oks_cli-1.18}/tests/test_cluster.py

@@ -66,6 +66,37 @@ def test_cluster_list_all_args(mock_request, add_default_profile):
     assert result.exit_code == 0
     assert "test-cluster" in result.output
 
+# Test the "cluster list" command with --all(-A) flag
+@patch("oks_cli.utils.requests.request")
+def test_cluster_list_all(mock_request, add_default_profile):
+    mock_request.side_effect = [
+        MagicMock(status_code=200, headers={}, json=lambda: {"ResponseContext": {}, "Projects": [{"id": "12345", "name": "test-project"}]}),
+        MagicMock(status_code=200, headers={}, json=lambda: {
+            "ResponseContext": {},
+            "Clusters": [{
+                "id": "67890",
+                "project_id": "12345",
+                "name": "test-cluster",
+                "statuses": {
+                    "status": "ready",
+                    "created_at": "2019-08-24T14:15:22Z",
+                    "updated_at": "2019-08-24T14:15:22Z"
+                }
+            }]
+        }),
+    ]
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [
+        "cluster", "list",
+        "-A",
+        "--profile", "default"
+    ])
+
+    assert result.exit_code == 0
+    assert "test-project" in result.output
+    assert "test-cluster" in result.output
+
 # Test the "cluster get" command: verifies fetching details of a specific cluster
 @patch("oks_cli.utils.requests.request")
 def test_cluster_get_command(mock_request, add_default_profile):
@@ -438,3 +469,92 @@ def test_cluster_create_by_one_click_command(mock_request,  mock_sleep, mock_for
     result = runner.invoke(cli, ["cluster", "create",  "-p", "default", "-c", "test"], input=input_data)
     assert result.exit_code == 0
 
+@patch("oks_cli.utils.requests.request")
+@patch("time.sleep")
+def test_cluster_list_watch_command(mock_sleep, mock_request, add_default_profile):
+    """Test the cluster list command with --watch option"""
+    
+    # Simulate successive API responses
+    initial_response = MagicMock(
+        status_code=200, 
+        headers={}, 
+        json=lambda: {
+            "ResponseContext": {}, 
+            "Projects": [{"id": "12345"}]
+        }
+    )
+    
+    # First query for clusters (initial state)
+    first_cluster_response = MagicMock(
+        status_code=200,
+        headers={},
+        json=lambda: {
+            "ResponseContext": {},
+            "Clusters": [{
+                "id": "12345",
+                "name": "test-cluster",
+                "statuses": {
+                    "status": "deploying",
+                    "created_at": "2023-01-01T00:00:00Z",
+                    "updated_at": "2023-01-01T00:00:00Z"
+                },
+                "version": "1.0",
+                "control_planes": 3
+            }]
+        }
+    )
+    
+    # Second query for clusters (status change)
+    second_cluster_response = MagicMock(
+        status_code=200,
+        headers={},
+        json=lambda: {
+            "ResponseContext": {},
+            "Clusters": [{
+                "id": "12345",
+                "name": "test-cluster",
+                "statuses": {
+                    "status": "ready",
+                    "created_at": "2023-01-01T00:00:00Z",
+                    "updated_at": "2023-01-01T00:01:00Z"
+                },
+                "version": "1.0",
+                "control_planes": 3
+            }]
+        }
+    )
+    
+    # Mock call configuration
+    mock_request.side_effect = [
+        initial_response,
+        first_cluster_response,
+        second_cluster_response,
+        second_cluster_response,
+    ]
+    
+    # Simulate KeyboardInterrupt after a few iterations
+    def side_effect_sleep(duration):
+        if mock_sleep.call_count >= 3:
+            raise KeyboardInterrupt()
+        return None
+    
+    mock_sleep.side_effect = side_effect_sleep
+    
+    runner = CliRunner()
+    
+    result = runner.invoke(cli, [
+        "cluster", "list", 
+        "-p", "test", 
+        "-c", "test-cluster", 
+        "--watch"
+    ])
+    
+    # Checks
+    assert result.exit_code == 0
+    assert "test-cluster" in result.output
+    assert "Watch stopped." in result.output
+    
+    assert mock_sleep.called
+    
+    assert mock_request.call_count >= 3
+

{oks_cli-1.16 → oks_cli-1.18}/tests/test_profile.py

@@ -1,6 +1,6 @@
 from click.testing import CliRunner
 from oks_cli.main import cli
-
+from unittest.mock import patch
 
 def test_profile_list_command():
     runner = CliRunner()
@@ -38,6 +38,32 @@ def test_profile_add_command():
     assert result.exit_code == 0
     assert "Profile default has been successfully added" in result.output
 
+def test_profile_add_jwt_boolean():
+    runner = CliRunner()
+
+    with patch("oks_cli.profile.set_profile") as mock_set_profile:
+        result = runner.invoke(
+            cli,
+            [
+                "profile", "add",
+                "--region", "eu-west-2",
+                "--access-key", "AK",
+                "--secret-key", "SK",
+                "--jwt", "true"
+            ],
+            input="y\n"
+        )
+
+        assert result.exit_code == 0
+
+        mock_set_profile.assert_called_once()
+        profile_name, obj = mock_set_profile.call_args[0]
+
+        assert profile_name == "default"
+
+        assert isinstance(obj["jwt"], bool)
+        assert obj["jwt"] is True
+
 def test_profile_update_command(add_default_profile):
     runner = CliRunner()
     result = runner.invoke(cli, ["profile", "update", "--profile-name", "default", "--region", "cloudgouv-eu-west-1"])

{oks_cli-1.16 → oks_cli-1.18}/tests/test_project.py

@@ -473,4 +473,186 @@ def test_project_publicips_yaml(mock_request, add_default_profile):
     data = yaml.safe_load(result.output)
     assert isinstance(data, list)
     assert data == []
-# END PROJECT PUBLICIPS COMMAND
+# END PROJECT PUBLICIPS COMMAND
+
+
+# START PROJECT NETS COMMAND
+# Test the "project nets" command: verifies fetching project nets
+nets = [{
+    "DhcpOptionsSetId": "dopt-12345678",
+    "IpRange": "10.50.0.0/16",
+    "NetId": "vpc-12345678",
+    "State": "available",
+    "Tags": [
+        {
+            "Key": "Name",
+            "Value": "default"
+        }
+    ]
+}]
+
+@patch("oks_cli.utils.requests.request")
+def test_project_nets_command(mock_request, add_default_profile):
+    mock_request.side_effect = [
+        MagicMock(status_code=200, headers = {}, json=lambda: {"ResponseContext": {}, "Projects": [{"id": "12345"}]}),
+        MagicMock(status_code=200, headers = {}, json=lambda: {"ResponseContext": {}, "Nets": nets })
+    ]
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["project", "nets", "-p", "test"])
+    assert result.exit_code == 0
+
+    data = json.loads(result.output)
+    assert isinstance(data, list)
+    assert data == nets
+
+@patch("oks_cli.utils.requests.request")
+def test_project_nets_json(mock_request, add_default_profile):
+    mock_request.side_effect = [
+        MagicMock(status_code=200, headers={}, json=lambda: {"ResponseContext": {}, "Projects": [{"id": "12345"}]}),
+        MagicMock(status_code=200, headers = {}, json=lambda: {"ResponseContext": {}, "Nets": nets })
+    ]
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [
+        "project", "nets",
+        "-p", "test-project",
+        "-o", "json",
+        "--profile", "default"
+    ])
+
+    assert result.exit_code == 0
+
+    data = json.loads(result.output)
+    assert isinstance(data, list)
+    assert data == nets
+
+@patch("oks_cli.utils.requests.request")
+def test_project_nets_yaml(mock_request, add_default_profile):
+    mock_request.side_effect = [
+        MagicMock(status_code=200, headers={}, json=lambda: {"ResponseContext": {}, "Projects": [{"id": "12345"}]}),
+        MagicMock(status_code=200, headers = {}, json=lambda: {"ResponseContext": {}, "Nets": nets })
+    ]
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [
+        "project", "nets",
+        "-p", "test-project",
+        "-o", "yaml",
+        "--profile", "default"
+    ])
+
+    assert result.exit_code == 0
+
+    data = yaml.safe_load(result.output)
+    assert isinstance(data, list)
+    assert data == nets
+# END PROJECT NETS COMMAND
+
+
+# Test the "project list" command with --watch option
+@patch("oks_cli.utils.requests.request")
+@patch("time.sleep")
+def test_project_list_watch_command(mock_sleep, mock_request, add_default_profile):
+    """Test the project list command with --watch option"""
+    
+    # First query for projects (initial state)
+    first_project_response = MagicMock(
+        status_code=200,
+        headers={},
+        json=lambda: {
+            "ResponseContext": {},
+            "Projects": [{
+                "id": "12345",
+                "name": "test-project",
+                "created_at": "2023-01-01T00:00:00Z",
+                "updated_at": "2023-01-01T00:00:00Z",
+                "status": "active"
+            }]
+        }
+    )
+    
+    # Second query for projects (new project appears)
+    second_project_response = MagicMock(
+        status_code=200,
+        headers={},
+        json=lambda: {
+            "ResponseContext": {},
+            "Projects": [
+                {
+                    "id": "12345",
+                    "name": "test-project",
+                    "created_at": "2023-01-01T00:00:00Z",
+                    "updated_at": "2023-01-01T00:00:00Z",
+                    "status": "active"
+                },
+                {
+                    "id": "67890",
+                    "name": "new-project",
+                    "created_at": "2023-01-01T00:01:00Z",
+                    "updated_at": "2023-01-01T00:01:00Z",
+                    "status": "creating"
+                }
+            ]
+        }
+    )
+    
+    # Third query for projects (status change)
+    third_project_response = MagicMock(
+        status_code=200,
+        headers={},
+        json=lambda: {
+            "ResponseContext": {},
+            "Projects": [
+                {
+                    "id": "12345",
+                    "name": "test-project",
+                    "created_at": "2023-01-01T00:00:00Z",
+                    "updated_at": "2023-01-01T00:00:00Z",
+                    "status": "active"
+                },
+                {
+                    "id": "67890",
+                    "name": "new-project",
+                    "created_at": "2023-01-01T00:01:00Z",
+                    "updated_at": "2023-01-01T00:02:00Z",
+                    "status": "active"
+                }
+            ]
+        }
+    )
+    
+    # Mock call configuration
+    mock_request.side_effect = [
+        first_project_response,
+        second_project_response,
+        third_project_response,
+        third_project_response,
+    ]
+    
+    # Simulate KeyboardInterrupt after a few iterations
+    def side_effect_sleep(duration):
+        if mock_sleep.call_count >= 3:
+            raise KeyboardInterrupt()
+        return None
+    
+    mock_sleep.side_effect = side_effect_sleep
+    
+    runner = CliRunner()
+    
+    # Launch command with --watch
+    result = runner.invoke(cli, [
+        "project", "list", 
+        "--watch"
+    ])
+    
+    # Checks
+    assert result.exit_code == 0
+    assert "test-project" in result.output
+    assert "Watch stopped." in result.output
+    
+    # Verify that sleep was called (indicates watch is working)
+    assert mock_sleep.called
+    
+    # Verify multiple API calls were made (at least 3 for watching)
+    assert mock_request.call_count >= 3