15 #include <aws/core/Aws.h> 16 #include <aws/core/utils/logging/LogMacros.h> 17 #include <gmock/gmock.h> 18 #include <gtest/gtest.h> 27 #include <ros_monitoring_msgs/MetricData.h> 36 using ::testing::Return;
37 using ::testing::StrEq;
45 MOCK_METHOD4(createMetricService,
46 std::shared_ptr<MetricService>(
47 const std::string & metrics_namespace,
48 const Aws::Client::ClientConfiguration & client_config,
49 const Aws::SDKOptions & sdk_options,
58 MOCK_METHOD0(publishBatchedData,
bool());
65 const Aws::Client::ClientConfiguration & client_config)
77 MOCK_METHOD1(batchData,
bool(
const MetricObject & data_to_batch));
78 MOCK_METHOD0(
start,
bool());
80 MOCK_METHOD0(publishBatchedData,
bool());
87 const std::string kMetricsTopic =
"metrics";
88 const std::string kMetricName1 =
"CWMetricsNodeTestMetric";
89 const std::string kMetricUnit1 =
"sec";
90 const std::string metric_namespace =
"test_namespace";
92 Aws::Client::ClientConfiguration
config;
106 metric_batcher = std::make_shared<MetricBatcherMock>();
107 metric_publisher = std::make_shared<MetricPublisherMock>(metric_namespace, config);
108 metric_service = std::make_shared<MetricServiceMock>(metric_publisher, metric_batcher);
111 void Initialize(std::map<std::string, std::string> metric_dimensions) {
114 metrics_collector = std::make_shared<MetricsCollector>();
116 node_handle = std::make_shared<ros::NodeHandle>();
117 metrics_pub = std::make_shared<ros::Publisher>(
118 node_handle->advertise<ros_monitoring_msgs::MetricList>(kMetricsTopic.c_str(), 1));
120 EXPECT_CALL(*metric_service,
start()).Times(1);
122 std::shared_ptr<MetricServiceFactoryMock> metric_factory_mock = std::make_shared<MetricServiceFactoryMock>();
124 EXPECT_CALL(*metric_factory_mock,
125 createMetricService(StrEq(metric_namespace), _, _, _))
126 .WillOnce(Return(metric_service));
128 node_handle = std::make_shared<ros::NodeHandle>();
130 metrics_collector->Initialize(metric_namespace,
137 metric_factory_mock);
139 metrics_collector->start();
143 if(metrics_collector) {
144 EXPECT_CALL(*metric_service,
shutdown()).Times(1);
145 metrics_collector->shutdown();
152 ros_monitoring_msgs::MetricList metric_list_msg = ros_monitoring_msgs::MetricList();
153 for (
int i = 0; i < num_msgs; i++) {
154 metric_data_proto.value = i;
156 metric_list_msg.metrics.clear();
157 metric_list_msg.metrics.push_back(metric_data_proto);
158 AWS_LOGSTREAM_DEBUG(__func__,
"Publishing " << metric_list_msg.metrics.size()
159 <<
" metrics to topic " << kMetricsTopic.c_str());
160 metrics_pub->publish(metric_list_msg);
162 std::this_thread::sleep_for(std::chrono::seconds(1));
168 ros_monitoring_msgs::MetricData metric_data = ros_monitoring_msgs::MetricData();
169 metric_data.metric_name = kMetricName1;
170 metric_data.unit = kMetricUnit1;
182 std::map<std::string, std::string> metric_dimensions;
183 Initialize(metric_dimensions);
195 ros_monitoring_msgs::MetricData metric_msg;
196 metric_msg.time_stamp = GetParam().input_time;
211 ::testing::ValuesIn(getMetricDataEpochMillisTestData));
215 std::map<std::string, std::string> metric_dimensions;
216 Initialize(metric_dimensions);
220 EXPECT_CALL(*metric_service, publishBatchedData())
221 .Times(::testing::AnyNumber())
222 .WillRepeatedly(::testing::Return(
true));
224 EXPECT_CALL(*metric_service,
225 batchData(::testing::_))
226 .Times(::testing::AtLeast(num_msgs))
227 .WillRepeatedly(::testing::Return(
true));
229 ros_monitoring_msgs::MetricData metric_data = BasicMetricData();
230 SendMetricMessages(num_msgs, metric_data);
231 for (
int i = 0; i < num_msgs; i++) {
233 std::this_thread::sleep_for(std::chrono::seconds(1));
242 return arg.metric_name == toTest.metric_name
243 && arg.value == toTest.value
244 && arg.unit == toTest.unit
245 && arg.dimensions == toTest.dimensions
246 && arg.storage_resolution == toTest.storage_resolution;
252 std::map<std::string, std::string> metric_dimensions;
253 Initialize(metric_dimensions);
261 EXPECT_CALL(*metric_service, publishBatchedData())
262 .Times(::testing::AnyNumber())
263 .WillRepeatedly(::testing::Return(
true));
265 ::testing::Sequence rm_seq;
266 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m01)))
267 .WillOnce(::testing::Return(
true));
268 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m02)))
269 .WillOnce(::testing::Return(
true));
270 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m03)))
271 .WillOnce(::testing::Return(
true));
274 ros_monitoring_msgs::MetricData metric_data = BasicMetricData();
275 SendMetricMessages(num_msgs, metric_data);
283 const std::string metric_dimension_name =
"CWMetricsNodeTestDim1";
284 const std::string metric_dimension_value =
"CWMetricsNodeTestDim1Value";
286 std::map<std::string, std::string> expected_dim;
287 expected_dim[metric_dimension_name] = metric_dimension_value;
293 EXPECT_CALL(*metric_service, publishBatchedData())
294 .Times(::testing::AnyNumber())
295 .WillRepeatedly(::testing::Return(
true));
298 ::testing::Sequence rm_seq;
299 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m01)))
300 .WillOnce(::testing::Return(
true));
301 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m02)))
302 .WillOnce(::testing::Return(
true));
303 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m03)))
304 .WillOnce(::testing::Return(
true));
307 Initialize(expected_dim);
309 ros_monitoring_msgs::MetricData metric_data = BasicMetricData();
310 ros_monitoring_msgs::MetricDimension metric_dimension = ros_monitoring_msgs::MetricDimension();
311 metric_dimension.name = metric_dimension_name;
312 metric_dimension.value = metric_dimension_value;
313 metric_data.dimensions.push_back(metric_dimension);
315 SendMetricMessages(num_msgs, metric_data);
323 const std::string metric_dimension_name =
"CWMetricsNodeTestDim1";
324 const std::string metric_dimension_value =
"CWMetricsNodeTestDim1Value";
326 std::map<std::string, std::string> expected_dim;
327 expected_dim[metric_dimension_name] = metric_dimension_value;
333 EXPECT_CALL(*metric_service, publishBatchedData())
334 .Times(::testing::AnyNumber())
335 .WillRepeatedly(::testing::Return(
true));
338 ::testing::Sequence rm_seq;
339 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m01)))
340 .WillOnce(::testing::Return(
true));
341 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m02)))
342 .WillOnce(::testing::Return(
true));
343 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m03)))
344 .WillOnce(::testing::Return(
true));
347 std::map<std::string, std::string> default_metric_dims;
348 default_metric_dims.emplace(metric_dimension_name, metric_dimension_value);
349 Initialize(default_metric_dims);
351 ros_monitoring_msgs::MetricData metric_data = BasicMetricData();
353 SendMetricMessages(num_msgs, metric_data);
359 std::vector<std::string> topics;
360 topics.emplace_back(
"metrics_topic0");
361 topics.emplace_back(
"metrics_topic1");
364 std::map<std::string, std::string> default_metric_dims;
369 EXPECT_CALL(*metric_service, publishBatchedData())
370 .Times(::testing::AnyNumber())
371 .WillRepeatedly(::testing::Return(
true));
372 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m01)))
374 .WillOnce(::testing::Return(
true));
375 EXPECT_CALL(*metric_service, batchData(metricsAreEqual(m02)))
377 .WillOnce(::testing::Return(
true));
379 Initialize(default_metric_dims);
381 ros_monitoring_msgs::MetricList metric_list_msg = ros_monitoring_msgs::MetricList();
382 ros_monitoring_msgs::MetricData metric_data = BasicMetricData();
384 node_handle->advertise<ros_monitoring_msgs::MetricList>(topics[0].c_str(), 1);
385 metric_data.value = 0;
387 metric_list_msg.metrics.clear();
388 metric_list_msg.metrics.push_back(metric_data);
389 metrics_pub0.
publish(metric_list_msg);
392 node_handle->advertise<ros_monitoring_msgs::MetricList>(topics[1].c_str(), 1);
393 metric_data.value = 1;
395 metric_list_msg.metrics.clear();
396 metric_list_msg.metrics.push_back(metric_data);
397 metrics_pub1.
publish(metric_list_msg);
399 std::this_thread::sleep_for(std::chrono::seconds(1));
403 int main(
int argc,
char ** argv)
405 testing::InitGoogleTest(&argc, argv);
408 return RUN_ALL_TESTS();
MATCHER_P(metricsAreEqual, toTest,"")
ros_monitoring_msgs::MetricData BasicMetricData()
void publish(const boost::shared_ptr< M > &message) const
std::shared_ptr< ros::NodeHandle > node_handle
ROSCPP_DECL void init(int &argc, char **argv, const std::string &name, uint32_t options=0)
const GetMetricDataEpochMillisTestDatum getMetricDataEpochMillisTestData[]
Aws::Client::ClientConfiguration config
std::shared_ptr< ros::Publisher > metrics_pub
std::shared_ptr< MetricBatcherMock > metric_batcher
MetricPublisherMock(const std::string &metrics_namespace, const Aws::Client::ClientConfiguration &client_config)
int64_t expected_timestamp
std::shared_ptr< MetricsCollector > metrics_collector
ROSCPP_DECL void set(const std::string &key, const XmlRpc::XmlRpcValue &v)
const std::string kNodeParamMonitorTopicsListKey("aws_monitored_metric_topics")
std::shared_ptr< MetricServiceMock > metric_service
void Initialize(std::map< std::string, std::string > metric_dimensions)
std::shared_ptr< MetricPublisherMock > metric_publisher
INSTANTIATE_TEST_CASE_P(getMetricDataEpochMillisTest, GetMetricDataEpochMillisFixture,::testing::ValuesIn(getMetricDataEpochMillisTestData))
Aws::SDKOptions sdk_options
int main(int argc, char **argv)
ROSCPP_DECL bool del(const std::string &key)
ROSCONSOLE_DECL void shutdown()
void SendMetricMessages(int num_msgs, ros_monitoring_msgs::MetricData &metric_data_proto)
Aws::CloudWatchMetrics::CloudWatchOptions cloudwatch_options
static int64_t GetMetricDataEpochMillis(const ros_monitoring_msgs::MetricData &metric_msg)
MetricServiceMock(std::shared_ptr< Publisher< MetricDatumCollection >> publisher, std::shared_ptr< DataBatcher< MetricDatum >> batcher, std::shared_ptr< FileUploadStreamer< MetricDatumCollection >> file_upload_streamer=nullptr)
ROSCPP_DECL void spinOnce()
TEST_F(MetricsCollectorFixture, Sanity)
TEST_P(GetMetricDataEpochMillisFixture, getMetricDataEpochMillisTestOk)