[ffx][setui] Migrate Factory Reset

This CL adds a subcommand, factory reset of ffx_setui.

Bug: 76259
Test:
fx build ffx
fx ffx setui factory_reset -> watch
fx ffx setui factory_reset -l false -> set
fx test ffx_setui_factory_reset_test -o

Change-Id: I54b783590c7daa424bfd0e073963ee9c39bb6264
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/638129
Reviewed-by: Chip Fukuhara <cfukuhara@google.com>
Reviewed-by: William Xiao <wxyz@google.com>
Reviewed-by: Paul Faria <paulfaria@google.com>
Commit-Queue: Sijie Chen <sijiec@google.com>

Author: Sijie Chen

src/developer/ffx/plugins/setui/BUILD.gn

@@ -9,6 +9,7 @@ ffx_plugin("ffx_setui") {
   edition = "2018"
 
   plugin_deps = [
+    "factory_reset:ffx_setui_factory_reset",
     "night_mode:ffx_setui_night_mode",
     "privacy:ffx_setui_privacy",
   ]

src/developer/ffx/plugins/setui/factory_reset/BUILD.gn

@@ -0,0 +1,22 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//src/developer/ffx/build/ffx_plugin.gni")
+
+ffx_plugin("ffx_setui_factory_reset") {
+  version = "0.1.0"
+  edition = "2018"
+  with_unit_tests = true
+
+  deps = [
+    "//sdk/fidl/fuchsia.settings:fuchsia.settings-rustc",
+    "//src/developer/ffx/plugins/setui/utils:utils",
+  ]
+
+  test_deps = [ "//third_party/rust_crates:test-case" ]
+
+  args_sources = [ "src/args.rs" ]
+
+  sources = [ "src/lib.rs" ]
+}

src/developer/ffx/plugins/setui/factory_reset/src/args.rs

@@ -0,0 +1,16 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use argh::FromArgs;
+use ffx_core::ffx_command;
+
+#[ffx_command()]
+#[derive(FromArgs, Debug, PartialEq)]
+#[argh(subcommand, name = "factory_reset")]
+/// get or set factory reset settings
+pub struct FactoryReset {
+    /// when set to 'true', factory reset can be performed on the device
+    #[argh(option, short = 'l')]
+    pub is_local_reset_allowed: Option<bool>,
+}

src/developer/ffx/plugins/setui/factory_reset/src/lib.rs

@@ -0,0 +1,130 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use anyhow::Result;
+use ffx_core::ffx_plugin;
+use ffx_setui_factory_reset_args::FactoryReset;
+use fidl_fuchsia_settings::{FactoryResetProxy, FactoryResetSettings};
+use utils::handle_mixed_result;
+use utils::{self, Either, WatchOrSetResult};
+
+#[ffx_plugin(
+    "setui",
+    FactoryResetProxy = "core/setui_service:expose:fuchsia.settings.FactoryReset"
+)]
+pub async fn run_command(
+    factory_reset_proxy: FactoryResetProxy,
+    factory_reset: FactoryReset,
+) -> Result<()> {
+    handle_mixed_result(
+        "FactoryReset",
+        command(factory_reset_proxy, factory_reset.is_local_reset_allowed).await,
+    )
+    .await?;
+
+    Ok(())
+}
+
+async fn command(
+    proxy: FactoryResetProxy,
+    is_local_reset_allowed: Option<bool>,
+) -> WatchOrSetResult {
+    let mut settings = FactoryResetSettings::EMPTY;
+    settings.is_local_reset_allowed = is_local_reset_allowed;
+
+    Ok(if settings != FactoryResetSettings::EMPTY {
+        Either::Set(if let Err(err) = proxy.set(settings.clone()).await? {
+            format!("{:?}", err)
+        } else {
+            format!("Successfully set factory_reset to {:?}", settings)
+        })
+    } else {
+        Either::Watch(utils::watch_to_stream(proxy, |p| p.watch()))
+    })
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use fidl_fuchsia_settings::{FactoryResetRequest, FactoryResetSettings};
+    use futures::prelude::*;
+    use test_case::test_case;
+
+    #[test_case(
+        true;
+        "Test factory reset set() output with is_local_reset_allowed as true."
+    )]
+    #[test_case(
+        false;
+        "Test factory reset set() output with is_local_reset_allowed as false."
+    )]
+    #[fuchsia_async::run_singlethreaded(test)]
+    async fn validate_factory_reset_set_output(
+        expected_is_local_reset_allowed: bool,
+    ) -> Result<()> {
+        let proxy = setup_fake_factory_reset_proxy(move |req| match req {
+            FactoryResetRequest::Set { settings: _, responder } => {
+                let _ = responder.send(&mut Ok(()));
+            }
+            FactoryResetRequest::Watch { responder: _ } => {
+                panic!("Unexpected call to watch");
+            }
+        });
+
+        let output = utils::assert_set!(command(proxy, Some(expected_is_local_reset_allowed)));
+        assert_eq!(
+            output,
+            format!(
+                "Successfully set factory_reset to {:?}",
+                FactoryResetSettings {
+                    is_local_reset_allowed: Some(expected_is_local_reset_allowed),
+                    ..FactoryResetSettings::EMPTY
+                }
+            )
+        );
+        Ok(())
+    }
+
+    #[test_case(
+        None;
+        "Test factory reset watch() output with is_local_reset_allowed as None."
+    )]
+    #[test_case(
+        Some(false);
+        "Test factory reset watch() output with is_local_reset_allowed as false."
+    )]
+    #[test_case(
+        Some(true);
+        "Test factory reset watch() output with is_local_reset_allowed as true."
+    )]
+    #[fuchsia_async::run_singlethreaded(test)]
+    async fn validate_factory_reset_watch_output(
+        expected_is_local_reset_allowed: Option<bool>,
+    ) -> Result<()> {
+        let proxy = setup_fake_factory_reset_proxy(move |req| match req {
+            FactoryResetRequest::Set { settings: _, responder: _ } => {
+                panic!("Unexpected call to set");
+            }
+            FactoryResetRequest::Watch { responder } => {
+                let _ = responder.send(FactoryResetSettings {
+                    is_local_reset_allowed: expected_is_local_reset_allowed,
+                    ..FactoryResetSettings::EMPTY
+                });
+            }
+        });
+
+        let output = utils::assert_watch!(command(proxy, None));
+        assert_eq!(
+            output,
+            format!(
+                "{:#?}",
+                FactoryResetSettings {
+                    is_local_reset_allowed: expected_is_local_reset_allowed,
+                    ..FactoryResetSettings::EMPTY
+                }
+            )
+        );
+        Ok(())
+    }
+}