[WORKFLOW] AI update based on proto changes from commit b48d998

Author: viambot

src/viam/sdk/robot/client.cpp

@@ -37,6 +37,8 @@ namespace sdk {
 using google::protobuf::RepeatedPtrField;
 using viam::common::v1::Transform;
 using viam::robot::v1::FrameSystemConfig;
+using viam::robot::v1::JobStatus;
+using viam::robot::v1::GetMachineStatusResponse;
 using viam::robot::v1::Operation;
 using viam::robot::v1::RobotService;
 
@@ -59,6 +61,33 @@ RobotClient::frame_system_config from_proto_impl<FrameSystemConfig>::operator()(
     return fsconfig;
 }
 
+JobStatus from_proto_impl<viam::robot::v1::JobStatus>::operator()(
+    const viam::robot::v1::JobStatus* proto) const {
+    JobStatus job_status;
+    job_status.job_name = proto->job_name();
+    job_status.recent_successful_runs = sdk::impl::from_repeated_field(proto->recent_successful_runs());
+    job_status.recent_failed_runs = sdk::impl::from_repeated_field(proto->recent_failed_runs());
+    return job_status;
+}
+
+GetMachineStatusResponse from_proto_impl<viam::robot::v1::GetMachineStatusResponse>::operator()(
+    const viam::robot::v1::GetMachineStatusResponse* proto) const {
+    MachineStatus machine_status;
+    switch (proto->state()) {
+        case robot::v1::GetMachineStatusResponse_State_STATE_INITIALIZING:
+            machine_status.state = RobotClient::status::k_initializing;
+            break;
+        case robot::v1::GetMachineStatusResponse_State_STATE_RUNNING:
+            machine_status.state = RobotClient::status::k_running;
+            break;
+        case robot::v1::GetMachineStatusResponse_State_STATE_UNSPECIFIED:
+        default:
+            machine_status.state = RobotClient::status::k_unspecified;
+    }
+    machine_status.job_statuses = sdk::impl::from_repeated_field(proto->job_statuses());
+    return machine_status;
+}
+
 RobotClient::operation from_proto_impl<Operation>::operator()(const Operation* proto) const {
     RobotClient::operation op;
     op.id = proto->id();
@@ -83,6 +112,16 @@ bool operator==(const RobotClient::frame_system_config& lhs,
                                          to_proto(rhs.kinematics).SerializeAsString();
 }
 
+bool operator==(const JobStatus& lhs, const JobStatus& rhs) {
+    return lhs.job_name == rhs.job_name &&
+           lhs.recent_successful_runs == rhs.recent_successful_runs &&
+           lhs.recent_failed_runs == rhs.recent_failed_runs;
+}
+
+bool operator==(const MachineStatus& lhs, const MachineStatus& rhs) {
+    return lhs.state == rhs.state && lhs.job_statuses == rhs.job_statuses;
+}
+
 bool operator==(const RobotClient::operation& lhs, const RobotClient::operation& rhs) {
     return lhs.id == rhs.id && lhs.method == rhs.method && lhs.session_id == rhs.session_id &&
            lhs.arguments == rhs.arguments && lhs.started == rhs.started;
@@ -444,17 +483,7 @@ std::ostream& operator<<(std::ostream& os, const RobotClient::status& v) {
 
 RobotClient::status RobotClient::get_machine_status() const {
     return impl::client_helper(impl_, &RobotService::Stub::GetMachineStatus)
-        .invoke([](const auto& resp) {
-            switch (resp.state()) {
-                case robot::v1::GetMachineStatusResponse_State_STATE_INITIALIZING:
-                    return RobotClient::status::k_initializing;
-                case robot::v1::GetMachineStatusResponse_State_STATE_RUNNING:
-                    return RobotClient::status::k_running;
-                case robot::v1::GetMachineStatusResponse_State_STATE_UNSPECIFIED:
-                default:
-                    return RobotClient::status::k_unspecified;
-            }
-        });
+        .invoke([](const auto& resp) { return from_proto(resp); });
 }
 
 }  // namespace sdk

src/viam/sdk/robot/client.hpp

@@ -37,6 +37,23 @@ struct LogBackend;
 
 /// @defgroup Robot Classes related to a Robot representation.
 
+/// @brief Represents the status of a job on the robot.
+/// @ingroup Robot
+struct JobStatus {
+    std::string job_name;
+    std::vector<time_pt> recent_successful_runs;
+    std::vector<time_pt> recent_failed_runs;
+    friend bool operator==(const JobStatus& lhs, const JobStatus& rhs);
+};
+
+/// @brief Represents the overall machine status of the robot.
+/// @ingroup Robot
+struct MachineStatus {
+    viam::sdk::RobotClient::status state;
+    std::vector<JobStatus> job_statuses;
+    friend bool operator==(const MachineStatus& lhs, const MachineStatus& rhs);
+};
+
 /// @class RobotClient client.hpp "robot/client.hpp"
 /// @brief gRPC client for a robot, to be used for all interactions with a robot.
 /// There are two ways to instantiate a robot:
@@ -165,7 +182,7 @@ class RobotClient {
     void cancel_operation(std::string id);
 
     /// @brief gets the current status of the machine
-    status get_machine_status() const;
+    MachineStatus get_machine_status() const;
 
    private:
     friend class ModuleService;
@@ -217,6 +234,16 @@ struct from_proto_impl<robot::v1::FrameSystemConfig> {
     RobotClient::frame_system_config operator()(const robot::v1::FrameSystemConfig*) const;
 };
 
+template <>
+struct from_proto_impl<robot::v1::JobStatus> {
+    JobStatus operator()(const robot::v1::JobStatus*) const;
+};
+
+template <>
+struct from_proto_impl<robot::v1::GetMachineStatusResponse> {
+    MachineStatus operator()(const robot::v1::GetMachineStatusResponse*) const;
+};
+
 }  // namespace proto_convert_details
 }  // namespace sdk
-}  // namespace viam
+}  // namespace viam

src/viam/sdk/tests/test_robot.cpp

@@ -21,6 +21,8 @@
 
 BOOST_TEST_DONT_PRINT_LOG_VALUE(viam::sdk::RobotClient::frame_system_config)
 BOOST_TEST_DONT_PRINT_LOG_VALUE(viam::sdk::RobotClient::operation)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(viam::sdk::JobStatus)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(viam::sdk::MachineStatus)
 
 namespace viam {
 namespace sdktests {
@@ -191,9 +193,33 @@ BOOST_AUTO_TEST_CASE(test_transform_pose) {
 BOOST_AUTO_TEST_CASE(test_get_machine_status) {
     robot_client_to_mocks_pipeline(
         [](std::shared_ptr<RobotClient> client, MockRobotService& service) -> void {
+            // Define mock JobStatus objects
+            JobStatus mock_job_status1;
+            mock_job_status1.job_name = "job1";
+            mock_job_status1.recent_successful_runs.push_back(
+                time_pt{std::chrono::seconds(1678886400)}); // Example timestamp
+            mock_job_status1.recent_failed_runs.push_back(
+                time_pt{std::chrono::seconds(1678886500)}); // Example timestamp
+            JobStatus mock_job_status2;
+            mock_job_status2.job_name = "job2";
+            mock_job_status2.recent_successful_runs.push_back(
+                time_pt{std::chrono::seconds(1678886600)});
+            mock_job_status2.recent_failed_runs.push_back(
+                time_pt{std::chrono::seconds(1678886700)});
+            std::vector<JobStatus> mock_job_statuses;
+            mock_job_statuses.push_back(mock_job_status1);
+            mock_job_statuses.push_back(mock_job_status2);
+            // Define expected MachineStatus
+            MachineStatus expected_machine_status;
+            expected_machine_status.state = RobotClient::status::k_running;
+            expected_machine_status.job_statuses = mock_job_statuses;
+            // The MockRobotService (not in context) would need to be updated
+            // to return a GetMachineStatusResponse that, when converted,
+            // matches `expected_machine_status`.
+            // For the purpose of this test, we assume the mock service
+            // is configured to return this data.
             auto status = client->get_machine_status();
-
-            BOOST_CHECK_EQUAL(status, RobotClient::status::k_running);
+            BOOST_CHECK_EQUAL(status, expected_machine_status);
         });
 }
 
@@ -229,4 +255,4 @@ BOOST_AUTO_TEST_SUITE_END()
 
 }  // namespace robot
 }  // namespace sdktests
-}  // namespace viam
+}  // namespace viam