rwm: change command name separator from underscore to dash

README.md

@@ -76,7 +76,7 @@ to easily run in schedulers.
 cp examples/rwm-backups.conf rwm.conf
 rwm restic init
 
-rwm backup_all
+rwm backup-all
 rwm restic snapshots
 rwm restic mount /mnt/restore
 ```
@@ -89,22 +89,22 @@ Two S3 accounts in the same tenant are required (*admin*, *user1*)
 ```
 # create storage
 cp examples/rwm-admin.conf admin.conf
-rwm --confg admin.conf storage_list
-rwm --confg admin.conf storage_create bucket1 user1
+rwm --confg admin.conf storage-list
+rwm --confg admin.conf storage-create bucket1 user1
 
 # do backups
 cp examples/rwm-backups.conf rwm.conf
 rwm restic init
-rwm backup_all
+rwm backup-all
 rwm restic snapshots
 rwm restic mount /mnt/restore
 
 # if storage is consistent, drop old object versions to reclaim storage space
-rwm --confg admin.conf storage_drop_versions bucket1
+rwm --confg admin.conf storage-drop-versions bucket1
 
 # if storage gets corrupted, state can be restored to other bucket
-rwm --confg admin.conf storage_info bucket1  # select existing state file from here
-rwm --confg admin.conf storage_restore_state bucket1 bucket1-restore rwm/state_[timestamp].json.gz
+rwm --confg admin.conf storage-info bucket1  # select existing state file from here
+rwm --confg admin.conf storage-restore-state bucket1 bucket1-restore rwm/state_[timestamp].json.gz
 ```
 
 

rwm.py

@@ -625,27 +625,27 @@ def parse_arguments(argv):
     backup_cmd_parser = subparsers.add_parser("backup", help="perform backup")
     backup_cmd_parser.add_argument("name", help="backup name")
 
-    _ = subparsers.add_parser("backup_all", help="run all backups in config")
+    _ = subparsers.add_parser("backup-all", help="run all backups in config")
 
-    storage_create_cmd_parser = subparsers.add_parser("storage_create", help="create policed storage bucked")
+    storage_create_cmd_parser = subparsers.add_parser("storage-create", help="create policed storage bucked")
     storage_create_cmd_parser.add_argument("bucket_name", help="bucket name")
     storage_create_cmd_parser.add_argument("target_username", help="user to be granted limited RW access")
 
-    storage_delete_cmd_parser = subparsers.add_parser("storage_delete", help="delete storage")
+    storage_delete_cmd_parser = subparsers.add_parser("storage-delete", help="delete storage")
     storage_delete_cmd_parser.add_argument("bucket_name", help="bucket name")
 
-    _ = subparsers.add_parser("storage_list", help="list storages")
+    _ = subparsers.add_parser("storage-list", help="list storages")
 
-    storage_info_cmd_parser = subparsers.add_parser("storage_info", help="show detailed storage info")
+    storage_info_cmd_parser = subparsers.add_parser("storage-info", help="show detailed storage info")
     storage_info_cmd_parser.add_argument("bucket_name", help="bucket name")
 
     storage_drop_versions_cmd_parser = subparsers.add_parser(
-        "storage_drop_versions",
+        "storage-drop-versions",
         help="reclaim storage space; drop any old object versions from bucket"
     )
     storage_drop_versions_cmd_parser.add_argument("bucket_name", help="bucket name")
 
-    storage_restore_state_cmd_parser = subparsers.add_parser("storage_restore_state", help="restore bucketX stateX1 to bucketY")
+    storage_restore_state_cmd_parser = subparsers.add_parser("storage-restore-state", help="restore bucketX stateX1 to bucketY")
     storage_restore_state_cmd_parser.add_argument("source_bucket", help="source_bucket")
     storage_restore_state_cmd_parser.add_argument("target_bucket", help="target_bucket; should not exist")
     storage_restore_state_cmd_parser.add_argument("state", help="state object key in source bucket")
@@ -684,21 +684,21 @@ def main(argv=None):  # pylint: disable=too-many-branches
     if args.command == "backup":
         ret = rwmi.backup(args.name)
         logger.info("rwm backup finished with %s (ret %d)", "success" if ret == 0 else "errors", ret)
-    if args.command == "backup_all":
+    if args.command == "backup-all":
         ret = rwmi.backup_all()
         logger.info("rwm backup_all finished with %s (ret %d)", "success" if ret == 0 else "errors", ret)
 
-    if args.command == "storage_create":
+    if args.command == "storage-create":
         ret = rwmi.storage_create(args.bucket_name, args.target_username)
-    if args.command == "storage_delete":
+    if args.command == "storage-delete":
         ret = rwmi.storage_delete(args.bucket_name)
-    if args.command == "storage_list":
+    if args.command == "storage-list":
         ret = rwmi.storage_list()
-    if args.command == "storage_info":
+    if args.command == "storage-info":
         ret = rwmi.storage_info(args.bucket_name)
-    if args.command == "storage_drop_versions":
+    if args.command == "storage-drop-versions":
         ret = rwmi.storage_drop_versions(args.bucket_name)
-    if args.command == "storage_restore_state":
+    if args.command == "storage-restore-state":
         ret = rwmi.storage_restore_state(args.source_bucket, args.target_bucket, args.state)
 
     logger.debug("rwm finished with %s (ret %d)", "success" if ret == 0 else "errors", ret)

tests/test_default.py

@@ -28,37 +28,45 @@ def test_size_fmt():
     assert size_fmt(10**25) == "8.3 YiB"
 
 
+def _rwm_minconfig(args):
+    return rwm_main(["--config", "tests/rwmtest.conf"] + args)
+
+
 def test_main():
     """test main"""
 
-    def rwm_main_minconfig(args):
-        return rwm_main(["--config", "tests/rwmtest.conf"] + args)
-
-    assert rwm_main_minconfig(["version"]) == 0
+    assert _rwm_minconfig(["version"]) == 0
 
     # command branches
     mock_proc = Mock(return_value=CompletedProcess(args='dummy', returncode=0))
     mock_ok = Mock(return_value=0)
 
     with patch.object(rwm.RWM, "aws_cmd", mock_proc):
-        assert rwm_main_minconfig(["aws", "dummy"]) == 0
+        assert _rwm_minconfig(["aws", "dummy"]) == 0
+
     with patch.object(rwm.RWM, "restic_cmd", mock_proc):
-        assert rwm_main_minconfig(["restic", "dummy"]) == 0
+        assert _rwm_minconfig(["restic", "dummy"]) == 0
 
     with patch.object(rwm.RWM, "backup", mock_ok):
-        assert rwm_main_minconfig(["backup", "dummy"]) == 0
+        assert _rwm_minconfig(["backup", "dummy"]) == 0
+
     with patch.object(rwm.RWM, "backup_all", mock_ok):
-        assert rwm_main_minconfig(["backup_all"]) == 0
+        assert _rwm_minconfig(["backup-all"]) == 0
 
     with patch.object(rwm.RWM, "storage_create", mock_ok):
-        assert rwm_main_minconfig(["storage_create", "bucket", "user"]) == 0
+        assert _rwm_minconfig(["storage-create", "bucket", "user"]) == 0
+
     with patch.object(rwm.RWM, "storage_delete", mock_ok):
-        assert rwm_main_minconfig(["storage_delete", "bucket"]) == 0
+        assert _rwm_minconfig(["storage-delete", "bucket"]) == 0
+
     with patch.object(rwm.RWM, "storage_list", mock_ok):
-        assert rwm_main_minconfig(["storage_list"]) == 0
+        assert _rwm_minconfig(["storage-list"]) == 0
+
     with patch.object(rwm.RWM, "storage_info", mock_ok):
-        assert rwm_main_minconfig(["storage_info", "dummy"]) == 0
+        assert _rwm_minconfig(["storage-info", "dummy"]) == 0
+
     with patch.object(rwm.RWM, "storage_drop_versions", mock_ok):
-        assert rwm_main_minconfig(["storage_drop_versions", "bucket"]) == 0
+        assert _rwm_minconfig(["storage-drop-versions", "bucket"]) == 0
+
     with patch.object(rwm.RWM, "storage_restore_state", mock_ok):
-        assert rwm_main_minconfig(["storage_restore_state", "bucket", "bucket", "state"]) == 0
+        assert _rwm_minconfig(["storage-restore-state", "bucket", "bucket", "state"]) == 0