commit f6b387120252a1b89e7afd04af6a05475d99bd79
author Alex Vakulenko <avakulenko@chromium.org> Wed Sep 03 16:23:38 2014 -0700
committer chrome-internal-fetch <chrome-internal-fetch@google.com> Fri Sep 05 01:17:32 2014 +0000
tree 5f52d30c5cbc5284a2576e9be5ac5dc1ef23ffa3
parent f8f10fa8a436ee9c61138cc577cee8e0d3679088

buffet: Move command state into CommandInstance

The command state is now stored in CommandInstance and not in
DBusCommandProxy. CommandInstance can now notify the proxy of
command state changes via CommandProxyInterface.

Moved command status strings from dbus_constants.h into the
CommandInstance class, as members.

Added a property on DBusCommandProxy to expose the command
parameters to command handlers, so they can get the parameter
values over D-Bus.

BUG=chromium:374864
TEST=FEATURES=test emerge-link buffet

Change-Id: Ief3397ef09644772ffc3b1b01ed972a8b6779df4
Reviewed-on: https://chromium-review.googlesource.com/216296
Tested-by: Alex Vakulenko <avakulenko@chromium.org>
Reviewed-by: Christopher Wiley <wiley@chromium.org>
Commit-Queue: Alex Vakulenko <avakulenko@chromium.org>

buffet/commands/dbus_command_proxy_unittest.cc

diff --git a/buffet/commands/dbus_command_proxy_unittest.cc b/buffet/commands/dbus_command_proxy_unittest.cc
index 8dd11a6..45a872a 100644
--- a/buffet/commands/dbus_command_proxy_unittest.cc
+++ b/buffet/commands/dbus_command_proxy_unittest.cc
@@ -22,8 +22,10 @@
 using ::testing::Invoke;
 using ::testing::_;
 
-using chromeos::dbus_utils::ExportedObjectManager;
 using buffet::unittests::CreateDictionaryValue;
+using chromeos::dbus_utils::AsyncEventSequencer;
+using chromeos::dbus_utils::Dictionary;
+using chromeos::dbus_utils::ExportedObjectManager;
 
 namespace buffet {
 
@@ -32,8 +34,6 @@
 const char kTestCommandCategoty[] = "test_command_category";
 const char kTestCommandId[] = "cmd_1";
 
-void NoAction(bool all_succeeded) {}
-
 }  // namespace
 
 class DBusCommandProxyTest : public ::testing::Test {
@@ -92,11 +92,14 @@
 
     command_proxy_.reset(new DBusCommandProxy(nullptr, bus_,
                                               command_instance_.get()));
-    command_proxy_->RegisterAsync(base::Bind(NoAction));
+    command_instance_->SetProxy(command_proxy_.get());
+    command_proxy_->RegisterAsync(
+        AsyncEventSequencer::GetDefaultCompletionAction());
   }
 
   void TearDown() override {
     EXPECT_CALL(*mock_exported_object_command_, Unregister()).Times(1);
+    command_instance_->SetProxy(nullptr);
     command_proxy_.reset();
     command_instance_.reset();
     dict_.Clear();
@@ -115,6 +118,10 @@
     return command_proxy_->progress_.value();
   }
 
+  Dictionary GetParameters() const {
+    return command_proxy_->parameters_.value();
+  }
+
   std::unique_ptr<dbus::Response> CallMethod(
       const std::string& method_name,
       const std::function<void(dbus::MessageWriter*)>& param_callback) {
@@ -168,17 +175,24 @@
 };
 
 TEST_F(DBusCommandProxyTest, Init) {
-  EXPECT_EQ(dbus_constants::kCommandStatusQueued, GetStatus());
+  Dictionary params = {
+    {"height", int32_t{53}},
+    {"_jumpType", std::string{"_withKick"}},
+  };
+  EXPECT_EQ(CommandInstance::kStatusQueued, GetStatus());
   EXPECT_EQ(0, GetProgress());
+  EXPECT_EQ(params, GetParameters());
   EXPECT_EQ("robot.jump",
             GetPropertyValue<std::string>(dbus_constants::kCommandName));
   EXPECT_EQ(kTestCommandCategoty,
             GetPropertyValue<std::string>(dbus_constants::kCommandCategory));
   EXPECT_EQ(kTestCommandId,
             GetPropertyValue<std::string>(dbus_constants::kCommandId));
-  EXPECT_EQ(dbus_constants::kCommandStatusQueued,
+  EXPECT_EQ(CommandInstance::kStatusQueued,
             GetPropertyValue<std::string>(dbus_constants::kCommandStatus));
   EXPECT_EQ(0, GetPropertyValue<int32_t>(dbus_constants::kCommandProgress));
+  EXPECT_EQ(params,
+            GetPropertyValue<Dictionary>(dbus_constants::kCommandParameters));
 }
 
 TEST_F(DBusCommandProxyTest, SetProgress) {
@@ -188,9 +202,9 @@
     writer->AppendInt32(10);
   });
   VerifyResponse(response, {});
-  EXPECT_EQ(dbus_constants::kCommandStatusInProgress, GetStatus());
+  EXPECT_EQ(CommandInstance::kStatusInProgress, GetStatus());
   EXPECT_EQ(10, GetProgress());
-  EXPECT_EQ(dbus_constants::kCommandStatusInProgress,
+  EXPECT_EQ(CommandInstance::kStatusInProgress,
             GetPropertyValue<std::string>(dbus_constants::kCommandStatus));
   EXPECT_EQ(10, GetPropertyValue<int32_t>(dbus_constants::kCommandProgress));
 }
@@ -201,7 +215,7 @@
     writer->AppendInt32(110);
   });
   EXPECT_TRUE(IsResponseError(response));
-  EXPECT_EQ(dbus_constants::kCommandStatusQueued, GetStatus());
+  EXPECT_EQ(CommandInstance::kStatusQueued, GetStatus());
   EXPECT_EQ(0, GetProgress());
 }
 
@@ -209,21 +223,25 @@
   EXPECT_CALL(*mock_exported_object_command_, SendSignal(_)).Times(1);
   auto response = CallMethod(dbus_constants::kCommandAbort, {});
   VerifyResponse(response, {});
-  EXPECT_EQ(dbus_constants::kCommandStatusAborted, GetStatus());
+  EXPECT_EQ(CommandInstance::kStatusAborted, GetStatus());
 }
 
 TEST_F(DBusCommandProxyTest, Cancel) {
   EXPECT_CALL(*mock_exported_object_command_, SendSignal(_)).Times(1);
   auto response = CallMethod(dbus_constants::kCommandCancel, {});
   VerifyResponse(response, {});
-  EXPECT_EQ(dbus_constants::kCommandStatusCanceled, GetStatus());
+  EXPECT_EQ(CommandInstance::kStatusCanceled, GetStatus());
 }
 
 TEST_F(DBusCommandProxyTest, Done) {
-  EXPECT_CALL(*mock_exported_object_command_, SendSignal(_)).Times(2);
+  // 3 property updates:
+  // status: queued -> inProgress
+  // progress: 0 -> 100
+  // status: inProgress -> done
+  EXPECT_CALL(*mock_exported_object_command_, SendSignal(_)).Times(3);
   auto response = CallMethod(dbus_constants::kCommandDone, {});
   VerifyResponse(response, {});
-  EXPECT_EQ(dbus_constants::kCommandStatusDone, GetStatus());
+  EXPECT_EQ(CommandInstance::kStatusDone, GetStatus());
   EXPECT_EQ(100, GetProgress());
 }