Reactivate (#209)

Author: Juliya Smith

CHANGELOG.md

@@ -13,11 +13,13 @@ how a consumer would use the library (e.g. adding unit tests, updating documenta
 # Added
 
 - The `devices` command is added. Included are:
-    - `devices deactivate` to deactivate a single computer.
-    - `devices show` to retrieve detailed information about a computer.
+    - `devices deactivate` to deactivate a single device.
+    - `devices reactivate` to reactivate a single device.
+    - `devices show` to retrieve detailed information about a device.
     - `devices list` to retrieve info about many devices, including device settings.
     - `devices list-backup-sets` to retrieve detailed info about device backup sets.
     - `devices bulk deactivate` to deactivate a list of devices.
+    - `devices bulk reactivate` to reactivate a list of devices.
 
 - `code42 departing-employee list` command.
 

src/code42cli/bulk.py

@@ -74,6 +74,7 @@ def run_bulk_process(row_handler, rows, progress_label=None):
         row_handler (callable): A callable that you define to process values from the row as
             either *args or **kwargs.
         rows (iterable): the rows to process.
+        progress_label: a label that prints with the progress bar.
     """
     processor = _create_bulk_processor(row_handler, rows, progress_label)
     return processor.run()
@@ -93,7 +94,6 @@ class BulkProcessor:
             and first row `1,test`, then `row_handler` should receive kwargs
             `prop_a: '1', prop_b: 'test'` when processing the first row. If it's a flat file, then
             `row_handler` only needs to take an extra arg.
-        reader (CSVReader or FlatFileReader): A generator that reads rows and yields data into `row_handler`.
     """
 
     def __init__(self, row_handler, rows, worker=None, progress_label=None):

src/code42cli/cmds/devices.py

@@ -28,7 +28,9 @@ def devices(state):
     pass
 
 
-device_guid_argument = click.argument("device-guid", type=str)
+device_guid_argument = click.argument(
+    "device-guid", type=str, callback=lambda ctx, param, arg: _verify_guid_type(arg),
+)
 
 change_device_name_option = click.option(
     "--change-device-name",
@@ -59,20 +61,19 @@ def deactivate(state, device_guid, change_device_name, purge_date):
     _deactivate_device(state.sdk, device_guid, change_device_name, purge_date)
 
 
+@devices.command()
+@device_guid_argument
+@sdk_options()
+def reactivate(state, device_guid):
+    """Reactivate a device within Code42. Requires the device GUID to reactivate."""
+    _reactivate_device(state.sdk, device_guid)
+
+
 def _deactivate_device(sdk, device_guid, change_device_name, purge_date):
     try:
-        int(device_guid)
-    except ValueError:
-        raise Code42CLIError("Not a valid guid.")
-    try:
-        device = sdk.devices.get_by_guid(device_guid)
-        sdk.devices.deactivate(device.data["computerId"])
+        device = _change_device_activation(sdk, device_guid, "deactivate")
     except exceptions.Py42BadRequestError:
         raise Code42CLIError("The device {} is in legal hold.".format(device_guid))
-    except exceptions.Py42NotFoundError:
-        raise Code42CLIError("The device {} was not found.".format(device_guid))
-    except exceptions.Py42ForbiddenError:
-        raise Code42CLIError("Unable to deactivate {}.".format(device_guid))
     if purge_date:
         _update_cold_storage_purge_date(sdk, device_guid, purge_date)
     if change_device_name and not device.data["name"].startswith("deactivated_"):
@@ -86,6 +87,35 @@ def _deactivate_device(sdk, device_guid, change_device_name, purge_date):
         )
 
 
+def _reactivate_device(sdk, device_guid):
+    _change_device_activation(sdk, device_guid, "reactivate")
+
+
+def _change_device_activation(sdk, device_guid, cmd_str):
+    try:
+        device = sdk.devices.get_by_guid(device_guid)
+        device_id = device.data["computerId"]
+        if cmd_str == "reactivate":
+            sdk.devices.reactivate(device_id)
+        elif cmd_str == "deactivate":
+            sdk.devices.deactivate(device_id)
+        return device
+    except exceptions.Py42NotFoundError:
+        raise Code42CLIError("The device {} was not found.".format(device_guid))
+    except exceptions.Py42ForbiddenError:
+        raise Code42CLIError("Unable to {} {}.".format(cmd_str, device_guid))
+
+
+def _verify_guid_type(device_guid):
+    if device_guid is None:
+        return
+    try:
+        int(device_guid)
+        return device_guid
+    except ValueError:
+        raise Code42CLIError("Not a valid guid.")
+
+
 def _update_cold_storage_purge_date(sdk, guid, purge_date):
     archives_response = sdk.archive.get_all_by_device_guid(guid)
     archive_guid_list = [
@@ -455,3 +485,27 @@ def handle_row(**row):
         handle_row, csv_rows, progress_label="Deactivating devices:"
     )
     formatter.echo_formatted_list(result_rows)
+
+
+@bulk.command(name="reactivate")
+@read_csv_arg(headers=["guid"])
+@format_option
+@sdk_options()
+def bulk_reactivate(state, csv_rows, format):
+    """Reactivate all devices from the provided CSV containing a 'guid' column."""
+    sdk = state.sdk
+    csv_rows[0]["reactivated"] = False
+    formatter = OutputFormatter(format, {key: key for key in csv_rows[0].keys()})
+
+    def handle_row(**row):
+        try:
+            _reactivate_device(sdk, row["guid"])
+            row["reactivated"] = "True"
+        except Exception as e:
+            row["reactivated"] = "False: {}".format(e)
+        return row
+
+    result_rows = run_bulk_process(
+        handle_row, csv_rows, progress_label="Reactivating devices:"
+    )
+    formatter.echo_formatted_list(result_rows)

tests/cmds/test_devices.py

@@ -254,7 +254,7 @@ def mock_backup_set(mocker):
 
 
 @pytest.fixture
-def deactivate_response(mocker):
+def empty_successful_response(mocker):
     return _create_py42_response(mocker, "")
 
 
@@ -303,15 +303,25 @@ def archives_list_success(cli_state):
 
 
 @pytest.fixture
-def deactivate_device_success(cli_state, deactivate_response):
-    cli_state.sdk.devices.deactivate.return_value = deactivate_response
+def deactivate_device_success(cli_state, empty_successful_response):
+    cli_state.sdk.devices.deactivate.return_value = empty_successful_response
+
+
+@pytest.fixture
+def reactivate_device_success(cli_state, empty_successful_response):
+    cli_state.sdk.devices.reactivate.return_value = empty_successful_response
 
 
 @pytest.fixture
 def deactivate_device_not_found_failure(cli_state):
     cli_state.sdk.devices.deactivate.side_effect = Py42NotFoundError(HTTPError())
 
 
+@pytest.fixture
+def reactivate_device_not_found_failure(cli_state):
+    cli_state.sdk.devices.reactivate.side_effect = Py42NotFoundError(HTTPError())
+
+
 @pytest.fixture
 def deactivate_device_in_legal_hold_failure(cli_state):
     cli_state.sdk.devices.deactivate.side_effect = Py42BadRequestError(HTTPError())
@@ -322,6 +332,11 @@ def deactivate_device_not_allowed_failure(cli_state):
     cli_state.sdk.devices.deactivate.side_effect = Py42ForbiddenError(HTTPError())
 
 
+@pytest.fixture
+def reactivate_device_not_allowed_failure(cli_state):
+    cli_state.sdk.devices.reactivate.side_effect = Py42ForbiddenError(HTTPError())
+
+
 @pytest.fixture
 def backupusage_success(cli_state, backupusage_response):
     cli_state.sdk.devices.get_by_guid.return_value = backupusage_response
@@ -440,6 +455,33 @@ def test_deactivate_fails_if_device_deactivation_forbidden(
     assert "Unable to deactivate {}.".format(TEST_DEVICE_GUID) in result.output
 
 
+def test_reactivate_reactivates_device(
+    runner, cli_state, deactivate_device_success, get_device_by_guid_success
+):
+    runner.invoke(cli, ["devices", "reactivate", TEST_DEVICE_GUID], obj=cli_state)
+    cli_state.sdk.devices.reactivate.assert_called_once_with(TEST_DEVICE_ID)
+
+
+def test_reactivate_fails_if_device_does_not_exist(
+    runner, cli_state, reactivate_device_not_found_failure
+):
+    result = runner.invoke(
+        cli, ["devices", "reactivate", TEST_DEVICE_GUID], obj=cli_state
+    )
+    assert result.exit_code == 1
+    assert f"The device {TEST_DEVICE_GUID} was not found." in result.output
+
+
+def test_reactivate_fails_if_device_reactivation_forbidden(
+    runner, cli_state, reactivate_device_not_allowed_failure
+):
+    result = runner.invoke(
+        cli, ["devices", "reactivate", TEST_DEVICE_GUID], obj=cli_state
+    )
+    assert result.exit_code == 1
+    assert f"Unable to reactivate {TEST_DEVICE_GUID}." in result.output
+
+
 def test_show_prints_device_info(runner, cli_state, backupusage_success):
     result = runner.invoke(cli, ["devices", "show", TEST_DEVICE_GUID], obj=cli_state)
     assert "SNWINTEST1" in result.output
@@ -581,7 +623,7 @@ def test_add_backup_set_settings_to_dataframe_returns_one_line_per_backup_set(
 
 
 def test_bulk_deactivate_uses_expected_arguments(runner, mocker, cli_state):
-    bulk_processor = mocker.patch("{}.run_bulk_process".format(_NAMESPACE))
+    bulk_processor = mocker.patch(f"{_NAMESPACE}.run_bulk_process")
     with runner.isolated_filesystem():
         with open("test_bulk_deactivate.csv", "w") as csv:
             csv.writelines(["guid,username\n", "test,value\n"])
@@ -598,3 +640,16 @@ def test_bulk_deactivate_uses_expected_arguments(runner, mocker, cli_state):
             "purge_date": None,
         }
     ]
+
+
+def test_bulk_reactivate_uses_expected_arguments(runner, mocker, cli_state):
+    bulk_processor = mocker.patch(f"{_NAMESPACE}.run_bulk_process")
+    with runner.isolated_filesystem():
+        with open("test_bulk_reactivate.csv", "w") as csv:
+            csv.writelines(["guid,username\n", "test,value\n"])
+        runner.invoke(
+            cli,
+            ["devices", "bulk", "reactivate", "test_bulk_reactivate.csv"],
+            obj=cli_state,
+        )
+    assert bulk_processor.call_args[0][1] == [{"guid": "test", "reactivated": False}]