oks-cli 1.20__tar.gz → 1.22__tar.gz

{oks_cli-1.20 → oks_cli-1.22}/PKG-INFO

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

{oks_cli-1.20 → oks_cli-1.22}/oks_cli/cache.py

@@ -38,7 +38,7 @@ def list_kubeconfigs(ctx, project_name, cluster_name, plain, msword, profile):
 
     result = get_all_cache(project_id, cluster_id, "kubeconfig")
 
-    data = list()
+    data = []
     fields = [["user", "user"],["group", "group"], ["expiration date", "expires_at"]]
 
     for element in result:

{oks_cli-1.20 → oks_cli-1.22}/oks_cli/cluster.py

@@ -121,20 +121,20 @@ def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch,
     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")
         field_names.append("VERSION")
         field_names.append("CONTROL PLANE")
     elif output:
+        if all:
+            projects = {p["id"]: p for p 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)
+
         print_output(data, output)
         return
 
@@ -149,10 +149,14 @@ def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch,
     if msword:
         table.set_style(TableStyle.MSWORD_FRIENDLY)
 
-    initial_clusters = {}
 
-    for cluster in data:
-        row, _, name = format_row(cluster.get('statuses'), cluster.get('name'), cluster_id == cluster.get('id'))
+    def build_row(cluster):
+        row, current_status, _ = 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:
@@ -163,6 +167,21 @@ def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch,
             row.append(cluster.get('version'))
             row.append(cluster.get('control_planes'))
 
+        return row, current_status
+
+    if all:
+        projects = {p["id"]: p for p 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)
+
+    initial_clusters = {}
+
+    for cluster in data:
+        row, _ = build_row(cluster)
         table.add_row(row)
         initial_clusters[cluster.get("id")] = cluster
 
@@ -177,46 +196,32 @@ def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch,
 
                 try:
                     if all:
-                        projects = {project["id"]: project for project in do_request("GET", "projects")}
+                        projects = {p["id"]: p for p 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)
+                        data = do_request("GET", "clusters", params=params)
                 except click.ClickException as err:
                     click.echo(f"Error during watch: {err}")
                     continue
 
-                current_cluster_ids = {cluster.get('id') for cluster in data}
+                current_ids = {c.get('id') for c in data}
 
-                for id, cluster in list(initial_clusters.items()):
-                    if id not in current_cluster_ids:
-                        deleted_cluster = cluster.copy()
+                for cl_id, stored_cluster in list(initial_clusters.items()):
+                    if cl_id not in current_ids:
+                        deleted_cluster = stored_cluster.copy()
                         deleted_cluster['statuses']['status'] = 'deleted'
 
-                        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)
-
+                        row, _ = build_row(deleted_cluster)
                         new_table = format_changed_row(table, row)
                         click.echo(new_table)
-                        
-                        del initial_clusters[id]
+                        del initial_clusters[cl_id]
 
                 for cluster in data:
-                    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')
+                    row, current_status = build_row(cluster)
 
                     if cl_id not in initial_clusters:
                         new_table = format_changed_row(table, row)
@@ -225,8 +230,8 @@ def cluster_list(ctx, project_name, cluster_name, deleted, plain, msword, watch,
                         continue
 
                     stored_cluster = initial_clusters[cl_id]
-                    cluster_status = stored_cluster.get('statuses').get('status')
-                    if cluster_status != current_status:
+                    stored_status = stored_cluster.get('statuses').get('status')
+                    if stored_status != current_status:
                         new_table = format_changed_row(table, row)
                         click.echo(new_table)
                         initial_clusters[cl_id] = cluster
@@ -368,8 +373,8 @@ def _create_cluster(project_name, cluster_config, output):
 @click.option('--cidr-service', help='CIDR of services')
 @click.option('--control-plane', shell_complete=shell_completions, help="Controlplane plan")
 @click.option('--zone', '-z', multiple=True, shell_complete=shell_completions, help="List of Control Plane availability zones")
-@click.option('--enable-admission-plugins', help="List of admission plugins, separated by commas")
-@click.option('--disable-admission-plugins', help="List of admission plugins, separated by commas")
+@click.option('--enable-admission-plugins', shell_complete=shell_completions, help="List of admission plugins, separated by commas")
+@click.option('--disable-admission-plugins', shell_complete=shell_completions, help="List of admission plugins, separated by commas")
 @click.option('--quirk', '-q', multiple=True, help="Quirk")
 @click.option('--tags', '-t', help="Comma-separated list of tags, example: 'key1=value1,key2=value2'")
 @click.option('--disable-api-termination', type=click.BOOL, help="Disable delete action by API")
@@ -467,8 +472,8 @@ def cluster_create_command(ctx, project_name, cluster_name, description, admin,
 @click.option('--admin', '-a', help="Admin Whitelist ips. you can use 'my-ip' to automatically use your current IP.")
 @click.option('--version', '-v', shell_complete=shell_completions, help="Kubernetes version")
 @click.option('--tags', '-t', help="Comma-separated list of tags, example: 'key1=value1,key2=value2'")
-@click.option('--enable-admission-plugins', help="List of admission plugins, separated by commas")
-@click.option('--disable-admission-plugins', help="List of admission plugins, separated by commas")
+@click.option('--enable-admission-plugins', shell_complete=shell_completions, help="List of admission plugins, separated by commas")
+@click.option('--disable-admission-plugins', shell_complete=shell_completions, help="List of admission plugins, separated by commas")
 @click.option('--quirk', '-q', multiple=True, help="Quirk")
 @click.option('--disable-api-termination', type=click.BOOL, help="Disable delete action by API")
 @click.option('--control-plane', shell_complete=shell_completions, help="Controlplane plan")
@@ -523,7 +528,7 @@ def cluster_update_command(ctx, project_name, cluster_name, description, admin,
     if tags is not None:
         parsed_tags = {}
 
-        if not len(tags) == 0:
+        if len(tags) != 0:
             pairs = tags.split(',')
             for pair in pairs:
                 if '=' not in pair:
@@ -736,19 +741,29 @@ def _run_kubectl(project_id, cluster_id, user, group, args, input=None, capture=
 
         if not kubeconfig_raw:
             click.echo("Cannot get kubeconfig")
-            raise SystemExit()
+            raise SystemExit(1)
 
         kubeconfig_path = save_cache(project_id, cluster_id, 'kubeconfig', kubeconfig_raw, user, group)
 
     env = dict(os.environ)
     env['KUBECONFIG'] = str(kubeconfig_path)
-    cmd = ['kubectl']
-    cmd += list(args)
+
+    cmd = ['kubectl'] + list(args)
     logging.info("running %s", cmd)
-    if not input:
-        return subprocess.run(cmd, env=env, capture_output=capture)
-    else:
-        return subprocess.run(cmd, input=input, text=True, env=env, capture_output=capture)
+
+    try:
+        if not input:
+            return subprocess.run(cmd, env=env, capture_output=capture, check=True)
+        else:
+            return subprocess.run(cmd, input=input, text=True, env=env, capture_output=capture, check=True)
+
+    except subprocess.CalledProcessError as e:
+        if e.stderr:
+            click.echo(e.stderr, err=True)
+        elif e.stdout:
+            click.echo(e.stdout, err=True)
+
+        raise SystemExit(e.returncode)
 
 
 @cluster.command('kubectl', help='Fetch the kubeconfig for a cluster and run kubectl against it', context_settings={"ignore_unknown_options": True})

{oks_cli-1.20 → oks_cli-1.22}/oks_cli/main.py

@@ -9,6 +9,7 @@ from .profile import profile
 from .cache import cache
 from .quotas import quotas
 from .netpeering import netpeering
+from .user import user
 
 from .utils import ctx_update, install_completions, profile_completer, cluster_completer, project_completer
 
@@ -47,7 +48,7 @@ def cli(ctx, project_name, cluster_name, profile, verbose):
         click.echo(ctx.get_help())
 
     if not hasattr(ctx, 'obj') or not ctx.obj:
-        ctx.obj = dict()
+        ctx.obj = {}
 
     if project_name != None:
         ctx.obj['project_name'] = project_name
@@ -62,6 +63,7 @@ cli.add_command(profile)
 cli.add_command(cache)
 cli.add_command(quotas)
 cli.add_command(netpeering)
+cli.add_command(user)
 
 def recursive_help(cmd, parent=None):
     """Recursively prints help for all commands and subcommands."""

{oks_cli-1.20 → oks_cli-1.22}/oks_cli/profile.py

@@ -122,7 +122,7 @@ def list_profiles(output):
         return click.echo("There are no profiles")
 
     profiles_keys = list(profiles.keys())
-    lines = list()
+    lines = []
 
     for key in profiles_keys:
         if 'endpoint' not in profiles[key]:

{oks_cli-1.20 → oks_cli-1.22}/oks_cli/project.py

@@ -328,7 +328,7 @@ def project_update_command(ctx, project_name, description, quirk, tags, disable_
     if tags is not None:
         parsed_tags = {}
 
-        if not len(tags) == 0:
+        if len(tags) != 0:
             pairs = tags.split(',')
             for pair in pairs:
                 if '=' not in pair:
@@ -365,7 +365,8 @@ def project_get_quotas(ctx, project_name, output, profile):
                                      ["Collection", "QuotaCollection"],
                                      ["Description", "ShortDescription"],
                                      ["Max Value", "MaxValue"],
-                                     ["Used Value", "UsedValue"]])
+                                     ["Used Value", "UsedValue"],
+                                     ["AccountId", "AccountId"]])
         print_table(data["subregions"], [["Region", "RegionName"],
                                          ["Availability Zone", "SubregionName"],
                                          ["State", "State"]])

oks_cli-1.22/oks_cli/user.py

@@ -0,0 +1,204 @@
+import click
+from datetime import datetime
+import dateutil.parser
+import human_readable
+import prettytable
+import json
+
+from nacl.public import PrivateKey, SealedBox
+from nacl.encoding import Base64Encoder
+from prettytable import TableStyle
+
+from .utils import do_request, print_output, find_project_id_by_name, ctx_update, login_profile, profile_completer, project_completer, JSONClickException
+
+# DEIFNE THE USER COMMAND GROUP
+@click.group(help="EIM users related commands.")
+@click.option('--project-name', '-p', required=False, help="Project Name", shell_complete=project_completer)
+@click.option('--profile', help="Configuration profile to use", shell_complete=profile_completer)
+@click.pass_context
+def user(ctx, project_name, profile):
+    """Group of commands related to project management."""
+    ctx_update(ctx, project_name, None, profile)
+
+# LIST USERS
+@user.command('list', help="List EIM users")
+@click.option('--output', '-o', type=click.Choice(["json", "yaml"]), help="Specify output format, by default is json")
+@click.option('--project-name', '-p', required=False, help="Project Name", shell_complete=project_completer)
+@click.option('--profile', help="Configuration profile to use")
+@click.pass_context
+def user_list(ctx, output, project_name, profile):
+    """List users"""
+    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}/eim_users')
+
+    if output:
+        print_output(data, output)
+        return
+
+    field_names = ["USER", "ACCESS KEY", "STATE", "CREATED", "EXPIRATION DATE"]
+    table = prettytable.PrettyTable()
+    table.field_names = field_names
+
+    for user in data:
+        access_keys = user.get("AccessKeys", [])
+        access_key = access_keys[0] if access_keys else {}
+
+
+        state =  access_key.get("State", "N/A")
+        if state == 'ACTIVE':
+            state = click.style(state, fg='green')
+        elif state == "INACTIVE":
+            state = click.style(state, fg='red')
+
+
+        row = [
+            user.get("UserName"),
+            access_key.get("AccessKeyId", "N/A"),
+            state
+        ]
+
+        if "CreationDate" in access_key:
+            created_at = dateutil.parser.parse(access_key.get("CreationDate"))
+            now = datetime.now(tz=created_at.tzinfo)
+            row.append(human_readable.date_time(now - created_at))
+        else:
+            row.append("N/A")
+
+        if "ExpirationDate" in access_key:
+            exp_at = dateutil.parser.parse(access_key.get("ExpirationDate"))
+            now = datetime.now(tz=exp_at.tzinfo)
+            row.append(human_readable.date_time(now - exp_at))
+        else:
+            row.append("N/A")
+
+        table.add_row(row)
+
+    click.echo(table)
+    
+
+@user.command('create', help="Create a new EIM user")
+@click.option('--project-name', '-p', help="Name of project", type=click.STRING, 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.option('--user', '-u', required=True, help="OKS User type")
+@click.option('--ttl', type=click.STRING, help="TTL in human readable format (5h, 1d, 1w), by default is 1w")
+@click.option('--nacl', is_flag=True, help="Use public key encryption on wire")
+@click.pass_context
+def user_create(ctx, project_name, output, profile, user, ttl, nacl):
+    """Create a new EIM user."""
+    project_name, _, profile = ctx_update(ctx, project_name, None, profile)
+    login_profile(profile)
+
+    project_id = find_project_id_by_name(project_name)
+
+    params = {
+        "user": user
+    }
+    if ttl:
+        params["ttl"] = ttl
+
+    if nacl:
+        ephemeral = PrivateKey.generate()
+        unsealbox = SealedBox(ephemeral)
+
+        headers = {
+            'x-encrypt-nacl': ephemeral.public_key.encode(Base64Encoder).decode('ascii')
+        }
+
+        raw_data = do_request(
+            "POST",
+            f'projects/{project_id}/eim_users',
+            params=params,
+            headers=headers
+        )
+
+        decrypted = unsealbox.decrypt(
+            raw_data.get("Data").encode('ascii'),
+            encoder=Base64Encoder
+        ).decode('ascii')
+
+        data = json.loads(decrypted)
+
+        # format decrypted errors the same way as the api errors.
+        if "Errors" in data:
+            response_context = raw_data.get("ResponseContext")
+            errors = []
+            for error in data.get("Errors", []):
+                error["Code"] = str(data.get("Code"))
+                errors.append(error)
+
+            raise JSONClickException(json.dumps({"Errors": errors,"ResponseContext": response_context}, separators=(",", ":")))
+
+    else:
+        data = do_request(
+            "POST",
+            f'projects/{project_id}/eim_users',
+            params=params
+        )
+
+    print_output(data, output)
+
+# DELETE USER
+@user.command('delete', help="Delete an EIM user")
+@click.option('--project-name', '-p', required=False, help="Project name", shell_complete=project_completer)
+@click.option('--user', '-u', required=True, help="User name")
+@click.option('--output', '-o', type=click.Choice(["json", "yaml"]), help="Specify output format")
+@click.option('--dry-run', is_flag=True, help="Run without any action")
+@click.option('--force', is_flag=True, help="Force deletion without confirmation")
+@click.option('--profile', help="Configuration profile to use", shell_complete=profile_completer)
+@click.pass_context
+def user_delete(ctx, project_name, user, output, dry_run, force, profile):
+    """CLI command to delete an EIM user."""
+    
+    project_name, _, profile = ctx_update(ctx, project_name, None, profile)
+    login_profile(profile)
+
+    project_id = find_project_id_by_name(project_name)
+
+    if dry_run:
+        message = {"message": f"Dry run: The user '{user}' would be deleted."}
+        print_output(message, output)
+        return
+
+    if force or click.confirm(f"Are you sure you want to delete the user '{user}'?", abort=True):
+        data = do_request("DELETE", f"projects/{project_id}/eim_users/{user}")
+        print_output(data, output)
+
+
+@user.command('types', help="List available user types")
+@click.option('--project-name', '-p', required=False, help="Project Name", shell_complete=project_completer)
+@click.option('--output', '-o', type=click.Choice(["json", "yaml"]), help="Specify output format")
+@click.option('--plain', is_flag=True, help="Plain table format")
+@click.option('--profile', help="Configuration profile to use", shell_complete=profile_completer)
+@click.pass_context
+def user_types(ctx, project_name, output, plain, profile):
+    """Display available user types."""
+    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}/eim_users/types')
+
+    if output:
+        print_output(data, output)
+        return
+
+    table = prettytable.PrettyTable()
+    table.field_names = ["USER TYPE", "DESCRIPTION"]
+
+    if plain:
+        table.set_style(TableStyle.PLAIN_COLUMNS)
+
+    for entry in data:
+        table.add_row([
+            entry.get("UserType", ""),
+            entry.get("Description") or "-"
+        ])
+
+    click.echo(table)
+    

{oks_cli-1.20 → oks_cli-1.22}/oks_cli/utils.py

@@ -79,6 +79,16 @@ def find_response_object(data):
             return response["IP"]
         elif key == "Nets":
             return response["Nets"]
+        elif key == "EimUsers":
+            return response["EimUsers"]
+        elif key == "EimUser":
+            return response["EimUser"]
+        elif key == "AdmissionPlugins":
+            return response["AdmissionPlugins"]
+        elif key == "Data":
+            return response
+        elif key == "EimUserTypes":
+            return response["EimUserTypes"]
 
     raise click.ClickException("The API response format is incorrect.")
 
@@ -202,8 +212,8 @@ def print_table(data, table_fields, align="l", style=None):
     table.align = align
     if style and isinstance(style, prettytable.TableStyle):
         table.set_style(style)
-    fields = list()
-    values = list()
+    fields = []
+    values = []
 
     for d in table_fields:
         fields.append(d[0])
@@ -417,7 +427,7 @@ 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")
+        raise click.ClickException("Can't find 'status' in project/cluster data")
 
     status = data.get('status')
     if status == 'ready':
@@ -805,14 +815,14 @@ def kubeconfig_parse_fields(kubeconfig, cluster_name, user, group):
     group: user group name of this kubeconfig (if set)
     """
     kubeconfig_str = yaml.safe_load(kubeconfig)
-    kubedata = list()
+    kubedata = []
 
     # Ensure loaded YAML returnes a valid dict object
     if not isinstance(kubeconfig_str, dict):
         return kubedata
 
     for context in kubeconfig_str.get('contexts', []):
-        data = dict()
+        data = {}
         ctx_cluster = context.get('context').get('cluster', None)
         ctx_user = context.get('context').get('user', None)
         ctx_name = context.get('name')
@@ -841,9 +851,11 @@ def kubeconfig_parse_fields(kubeconfig, cluster_name, user, group):
 
     return kubedata
 
-def retrieve_cp_sized(filepath, endpoint):
+def retrieve_cp_sized(filepath, endpoint, key = None):
     """Fetch control plane sizes from API and save to file."""
     cp_list = do_request("GET", endpoint)
+    if key:
+        cp_list = cp_list.get(key)
 
     with open(filepath, "w") as file:
         json.dump(cp_list, file)
@@ -865,6 +877,8 @@ def shell_completions(ctx, param: click.core.Option, incomplete):
     if profile not in profiles:
         return []
 
+    key = None
+
     login_profile(profile)
 
     if param.name == "version":
@@ -873,6 +887,16 @@ def shell_completions(ctx, param: click.core.Option, incomplete):
         endpoint = "clusters/limits/control_plane_plans"
     elif param.name == "zone":
         endpoint = "clusters/limits/cp_subregions"
+    elif param.name == "disable_admission_plugins" and ctx.params["version"]:
+        key = "DisableAdmissionPlugins"
+        version = ctx.params["version"]
+        endpoint = f"clusters/limits/admission_plugins?version={version}"
+        param.name += f".{version}"
+    elif param.name == "enable_admission_plugins" and ctx.params["version"]:
+        key = "EnableAdmissionPlugins"
+        version = ctx.params["version"]
+        endpoint = f"clusters/limits/admission_plugins?version={version}"
+        param.name += f".{version}"
     else:
         return []
     
@@ -882,9 +906,9 @@ def shell_completions(ctx, param: click.core.Option, incomplete):
     if os.path.exists(CP_SIZES_PATH):
         file_ctime = os.path.getctime(CP_SIZES_PATH)
         if datetime.timestamp(datetime.now()) - file_ctime > 300:
-            retrieve_cp_sized(CP_SIZES_PATH, endpoint)
+            retrieve_cp_sized(CP_SIZES_PATH, endpoint, key)
     else:
-        retrieve_cp_sized(CP_SIZES_PATH, endpoint)
+        retrieve_cp_sized(CP_SIZES_PATH, endpoint, key)
 
     if os.path.exists(CP_SIZES_PATH):
         with open(CP_SIZES_PATH, "r") as file:
@@ -892,6 +916,19 @@ def shell_completions(ctx, param: click.core.Option, incomplete):
     else:
         cp_list = []
 
+    # Handle comma-separated values
+    if "," in incomplete:
+        parts = incomplete.split(",")
+        selected = set(parts[:-1])
+        current = parts[-1]
+        prefix = ",".join(parts[:-1])
+
+        return [
+            f"{prefix},{item}"
+            for item in cp_list
+            if item.startswith(current) and item not in selected
+        ]
+
     return [k for k in cp_list if k.startswith(incomplete)]
 
 def update_shell_profile(shell_profile, filepath):
@@ -950,8 +987,8 @@ def install_completions(shell_type):
             shell_name = result.stdout.strip()
 
             shell_type = os.path.basename(shell_name).lstrip('-')
-        except subprocess.SubProcessError:
-            click.echo("Failed to determine shell type, please specify it by --type")
+        except (subprocess.SubprocessError, FileNotFoundError):
+            raise click.ClickException("Failed to determine shell type, please specify it by --type")
 
     completion_dir = os.path.join(home, ".oks_cli", "completions")
     os.makedirs(completion_dir, exist_ok=True)
@@ -1037,7 +1074,7 @@ def get_template(type):
 def ctx_update(ctx, project_name=None, cluster_name=None, profile=None, overwrite=True):
     """Update context with project, cluster, and profile; optionally prevent overwrites."""
     if not hasattr(ctx, 'obj') or not ctx.obj:
-        ctx.obj = dict()
+        ctx.obj = {}
 
     if project_name is not None:
         if ctx.obj.get('project_name') and not overwrite:

{oks_cli-1.20 → oks_cli-1.22}/oks_cli.egg-info/PKG-INFO

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

{oks_cli-1.20 → oks_cli-1.22}/oks_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ oks_cli/netpeering.py
 oks_cli/profile.py
 oks_cli/project.py
 oks_cli/quotas.py
+oks_cli/user.py
 oks_cli/utils.py
 oks_cli.egg-info/PKG-INFO
 oks_cli.egg-info/SOURCES.txt
@@ -23,4 +24,5 @@ tests/test_nodepool.py
 tests/test_profile.py
 tests/test_project.py
 tests/test_quota.py
-tests/test_shell_completion.py
+tests/test_shell_completion.py
+tests/test_user.py

{oks_cli-1.20 → oks_cli-1.22}/setup.py

@@ -2,11 +2,11 @@ from setuptools import setup, find_packages
 
 setup(
     name="oks-cli",
-    version="1.20",
+    version="1.22",
     packages=['oks_cli'],
     author="Outscale SAS",
     author_email="opensource@outscale.com",
-    long_description=open("README.md").read(),
+    long_description=open("README.md", encoding="utf-8").read(), 
     long_description_content_type="text/markdown",
     include_package_data=True,
     license="BSD",

oks_cli-1.22/tests/test_user.py

@@ -0,0 +1,88 @@
+from click.testing import CliRunner
+from oks_cli.main import cli
+from unittest.mock import patch, MagicMock
+
+@patch("oks_cli.utils.requests.request")
+def test_user_list_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": {}, "EimUsers":  []})
+    ]
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["user", "list", "-p", "test"])
+    assert result.exit_code == 0
+    assert 'USER | ACCESS KEY' in result.output
+
+@patch("oks_cli.utils.requests.request")
+def test_user_create_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": {}, "EimUser":  {
+            "UserName": "OKSAuditor",
+            "CreationDate": "2026-03-04T12:31:58.000+0000",
+            "UserId": "BlaBla",
+            "UserEmail": "bla@email.local",
+            "LastModificationDate": "2026-03-04T12:31:58.000+0000",
+            "Path": "/",
+            "AccessKeys": [
+            {
+                "State": "ACTIVE",
+                "AccessKeyId": "AK",
+                "CreationDate": "2026-03-04T12:31:59.841+0000",
+                "ExpirationDate": "2026-03-11T12:31:59.297+0000",
+                "SecretKey": "SK",
+                "LastModificationDate": "2026-03-04T12:31:59.841+0000"
+            }
+            ]
+        }})
+    ]
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["user", "create", "-p", "test", "-u", "OKSAuditor", "--ttl", "1w"])
+    assert result.exit_code == 0
+    assert 'bla@email.local' in result.output
+
+@patch("oks_cli.utils.requests.request")
+def test_user_delete_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": {}, "Details": "User has been deleted." })
+    ]
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["user", "delete", "-p", "test", "-u", "OKSAuditor", "--force"])
+    assert result.exit_code == 0
+    assert 'User has been deleted.' in result.output
+
+@patch("oks_cli.utils.requests.request")
+def test_user_types_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": {}, "EimUserTypes": [
+            {"UserType": "OKSSnapshotsManager", "Description": "OKS user with full access to snapshots"},
+            {"UserType": "OKSVolumesManager", "Description": "OKS user with management access to volumes BSU"},
+        ]})
+    ]
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["user", "types", "-p", "test"])
+    assert result.exit_code == 0
+    assert 'OKSSnapshotsManager' in result.output
+    assert 'OKSVolumesManager' in result.output
+
+@patch("oks_cli.utils.requests.request")
+def test_user_types_command_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": {}, "EimUserTypes": [
+            {"UserType": "OKSSnapshotsManager", "Description": "OKS user with full access to snapshots"},
+            {"UserType": "OKSVolumesManager", "Description": "OKS user with management access to volumes BSU"},
+        ]})
+    ]
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["user", "types", "-p", "test", "-o", "json"])
+    assert result.exit_code == 0
+    assert 'OKSSnapshotsManager' in result.output
+    assert 'OKS user with full access to snapshots' in result.output