Merge pull request #112 from AutoModality/AM-628/fix-sending-commands

fix: manifested nodes now being checked properly.

Author: Dillon-Roller

src/am_super/super_node_mediator.cpp

@@ -222,12 +222,12 @@ pair<bool, map<string, string>> SuperNodeMediator::allManifestedNodesCheck(
     Supervisor& supervisor, std::function<bool(SuperNodeMediator::SuperNodeInfo&, SuperNodeMediator&)> check)
 {
   map<string, string> failed_nodes;
-
   bool success = true;
-  std::string error_message;
+  
   for (pair<string, SuperNodeInfo> nodePair : supervisor.nodes)
   {
     SuperNodeInfo node = nodePair.second;
+    std::string error_message;
     // only check manifested nodes, ignore others
     if (node.manifested)
     {

test/super_node_mediator_unit_tests.cpp

@@ -1,6 +1,10 @@
 #include <gtest/gtest.h>  // googletest header file
 #include <am_super/super_node_mediator.h>
 #include <boost/algorithm/string/join.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/join.hpp>
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/range/adaptor/map.hpp>
 
 using namespace std;
 using namespace am;
@@ -11,8 +15,20 @@ class SuperNodeMediatorTest : public ::testing::Test
   const string SUPER_NODE_NAME = "my_super_node";
   SuperNodeMediator superNodeMediator;
 
+
+
   SuperNodeMediatorTest() : superNodeMediator(SUPER_NODE_NAME) {}
 
+  SuperNodeMediator::SuperNodeInfo manifested_lifecycle_node(string node_name, LifeCycleState state)
+  {
+    SuperNodeMediator::SuperNodeInfo node;
+    node.name = node_name;
+    node.online = true;
+    node.manifested = true;
+    node.state = state;
+    return node;
+  }
+
   void ASSERT_CHECK(std::function<bool(SuperNodeMediator::SuperNodeInfo&, SuperNodeMediator&)> check, LifeCycleState state, bool expected,
     OperatorCommand last_op_command_received = OperatorCommand::ARM, ControllerState last_controller_state_received = ControllerState::COMPLETED)
   {
@@ -48,6 +64,20 @@ class SuperNodeMediatorTest : public ::testing::Test
     }
   }
 
+  void assertAllManifestedNodesCheck(SuperNodeMediator::Supervisor supervisor,
+                                    std::function<bool(SuperNodeMediator::SuperNodeInfo&, SuperNodeMediator&)> check, 
+                                    vector<string> expected_failed_nodes, bool expected_success)
+  {
+    pair<bool, map<string, string>> result = superNodeMediator.allManifestedNodesCheck(supervisor, check);
+    vector<string> failed_nodes;
+    boost::copy(result.second | boost::adaptors::map_keys, std::back_inserter(failed_nodes));
+
+    std::sort(failed_nodes.begin(), failed_nodes.end());
+    std::sort(expected_failed_nodes.begin(), expected_failed_nodes.end());
+
+    ASSERT_EQ((failed_nodes == expected_failed_nodes), expected_success);
+  }
+
   void ASSERT_getStateTransition(const SuperState &current_state, const SuperState &expected_state, const OperatorCommand &operator_command = (OperatorCommand)-1, 
     const ControllerState& controller_state = (ControllerState)-1)
   {
@@ -204,6 +234,74 @@ TEST_F(SuperNodeMediatorTest, allManifestedNodesCheck_FlightControllerLifeCycleN
   assertAllManifestedNodesCheck(expected_success = true, node, check_result = false, "[WCK2]");
 }
 
+TEST_F(SuperNodeMediatorTest, allManifestedNodesCheck_MultipleNodes_FirstNodeFails)
+{
+  SuperNodeMediator::Supervisor supervisor;
+  supervisor.system_state = SuperState::BOOTING;
+
+  //supervisor stores a map<string, SuperNodeInfo>
+  supervisor.nodes.insert({"a", manifested_lifecycle_node("a", LifeCycleState::CONFIGURING)});
+  supervisor.nodes.insert({"b", manifested_lifecycle_node("b", LifeCycleState::INACTIVE)});
+  supervisor.nodes.insert({"c", manifested_lifecycle_node("c", LifeCycleState::INACTIVE)});
+  supervisor.nodes.insert({"d", manifested_lifecycle_node("d", LifeCycleState::INACTIVE)});
+
+  //a and c should fail
+  vector<string> expected_failed_nodes({"a"});
+
+  assertAllManifestedNodesCheck(supervisor, SuperNodeMediator::checkReadyToArm, expected_failed_nodes, true);
+}
+
+TEST_F(SuperNodeMediatorTest, allManifestedNodesCheck_MultipleNodes_TwoNodesFail)
+{
+  SuperNodeMediator::Supervisor supervisor;
+  supervisor.system_state = SuperState::BOOTING;
+
+  //supervisor stores a map<string, SuperNodeInfo>
+  supervisor.nodes.insert({"a", manifested_lifecycle_node("a", LifeCycleState::CONFIGURING)});
+  supervisor.nodes.insert({"b", manifested_lifecycle_node("b", LifeCycleState::CONFIGURING)});
+  supervisor.nodes.insert({"c", manifested_lifecycle_node("c", LifeCycleState::INACTIVE)});
+  supervisor.nodes.insert({"d", manifested_lifecycle_node("d", LifeCycleState::INACTIVE)});
+
+  //a and b should fail
+  vector<string> expected_failed_nodes({"a", "b"});
+
+  assertAllManifestedNodesCheck(supervisor, SuperNodeMediator::checkReadyToArm, expected_failed_nodes, true);
+}
+
+TEST_F(SuperNodeMediatorTest, allManifestedNodesCheck_MultipleNodes_AllNodesFail)
+{
+  SuperNodeMediator::Supervisor supervisor;
+  supervisor.system_state = SuperState::BOOTING;
+
+  //supervisor stores a map<string, SuperNodeInfo>
+  supervisor.nodes.insert({"a", manifested_lifecycle_node("a", LifeCycleState::CONFIGURING)});
+  supervisor.nodes.insert({"b", manifested_lifecycle_node("b", LifeCycleState::CONFIGURING)});
+  supervisor.nodes.insert({"c", manifested_lifecycle_node("c", LifeCycleState::CONFIGURING)});
+  supervisor.nodes.insert({"d", manifested_lifecycle_node("d", LifeCycleState::CONFIGURING)});
+
+  //all should fail
+  vector<string> expected_failed_nodes({"a", "b", "c", "d"});
+
+  assertAllManifestedNodesCheck(supervisor, SuperNodeMediator::checkReadyToArm, expected_failed_nodes, true);
+}
+
+TEST_F(SuperNodeMediatorTest, allManifestedNodesCheck_MultipleNodes_AllNodesPass)
+{
+  SuperNodeMediator::Supervisor supervisor;
+  supervisor.system_state = SuperState::BOOTING;
+
+  //supervisor stores a map<string, SuperNodeInfo>
+  supervisor.nodes.insert({"a", manifested_lifecycle_node("a", LifeCycleState::INACTIVE)});
+  supervisor.nodes.insert({"b", manifested_lifecycle_node("b", LifeCycleState::INACTIVE)});
+  supervisor.nodes.insert({"c", manifested_lifecycle_node("c", LifeCycleState::INACTIVE)});
+  supervisor.nodes.insert({"d", manifested_lifecycle_node("d", LifeCycleState::INACTIVE)});
+
+  //none should fail
+  vector<string> expected_failed_nodes({});
+
+  assertAllManifestedNodesCheck(supervisor, SuperNodeMediator::checkReadyToArm, expected_failed_nodes, true);
+}
+
 TEST_F(SuperNodeMediatorTest, parseManifest_EmptyManifest)
 {
   SuperNodeMediator::Supervisor supervisor;