/*
*-----------------------------------------------------------------------
*
* Run the JSON tests from the SDAM Monitoring spec.
*
*-----------------------------------------------------------------------
*/
static void
test_sdam_monitoring_cb (bson_t *test)
{
mongoc_client_t *client;
mongoc_topology_t *topology;
bson_t phase;
bson_t phases;
bson_t outcome;
bson_iter_t phase_iter;
bson_iter_t phase_field_iter;
bson_iter_t outcome_iter;
bson_iter_t iter;
bson_t events_expected;
context_t context;
/* parse out the uri and use it to create a client */
BSON_ASSERT (bson_iter_init_find (&iter, test, "uri"));
client = mongoc_client_new (bson_iter_utf8 (&iter, NULL));
topology = client->topology;
context_init (&context);
client_set_topology_event_callbacks (client, &context);
/* for each phase, parse and validate */
BSON_ASSERT (bson_iter_init_find (&iter, test, "phases"));
bson_iter_bson (&iter, &phases);
bson_iter_init (&phase_iter, &phases);
while (bson_iter_next (&phase_iter)) {
bson_iter_bson (&phase_iter, &phase);
/* this test doesn't exercise this code path naturally, see below in
* _test_topology_events for a non-hacky test of this event */
_mongoc_topology_description_monitor_opening (&topology->description);
process_sdam_test_ismaster_responses (&phase,
&client->topology->description);
/* parse out "outcome" and validate */
BSON_ASSERT (bson_iter_init_find (&phase_field_iter, &phase, "outcome"));
bson_iter_bson (&phase_field_iter, &outcome);
bson_iter_init (&outcome_iter, &outcome);
while (bson_iter_next (&outcome_iter)) {
if (strcmp ("events", bson_iter_key (&outcome_iter)) == 0) {
bson_iter_bson (&outcome_iter, &events_expected);
check_json_apm_events (&context.events, &events_expected);
} else {
fprintf (stderr,
"ERROR: unparsed test field %s\n",
bson_iter_key (&outcome_iter));
BSON_ASSERT (false);
}
}
}
mongoc_client_destroy (client);
context_destroy (&context);
}
static void
_test_topology_events (bool pooled)
{
mongoc_client_t *client;
mongoc_client_pool_t *pool = NULL;
context_t context;
bool r;
bson_error_t error;
bson_iter_t events_iter;
bson_iter_t event_iter;
uint32_t i;
context_init (&context);
if (pooled) {
pool = test_framework_client_pool_new ();
pool_set_topology_event_callbacks (pool, &context);
client = mongoc_client_pool_pop (pool);
} else {
client = test_framework_client_new ();
client_set_topology_event_callbacks (client, &context);
}
r = mongoc_client_command_simple (client, "admin", tmp_bson ("{'ping': 1}"),
NULL, NULL, &error);
ASSERT_OR_PRINT (r, error);
if (pooled) {
mongoc_client_pool_push (pool, client);
mongoc_client_pool_destroy (pool);
} else {
mongoc_client_destroy (client);
}
/* first event is topology opening */
bson_iter_init (&events_iter, &context.events);
bson_iter_next (&events_iter);
ASSERT (bson_iter_recurse (&events_iter, &event_iter));
ASSERT (bson_iter_find (&event_iter, "topology_opening_event"));
/* last event is topology closed */
for (i = 1; i < context.n_events; i++) {
ASSERT (bson_iter_next (&events_iter));
}
ASSERT (bson_iter_recurse (&events_iter, &event_iter));
ASSERT (bson_iter_find (&event_iter, "topology_closed_event"));
/* no more events */
ASSERT (!bson_iter_next (&events_iter));
context_destroy (&context);
}
static void
test_topology_events_disabled (void)
{
mongoc_client_t *client;
context_t context;
bool r;
bson_error_t error;
bson_iter_t events_iter;
bson_iter_t event_iter;
uint32_t i;
context_init (&context);
client = test_framework_client_new ();
client_set_topology_event_callbacks (client, &context);
r = mongoc_client_command_simple (
client, "admin", tmp_bson ("{'ping': 1}"), NULL, NULL, &error);
ASSERT_OR_PRINT (r, error);
/* disable callbacks before destroying so we don't see a topology closed
* event */
mongoc_client_set_apm_callbacks (client, NULL, NULL);
mongoc_client_destroy (client);
/* first event is topology opening */
bson_iter_init (&events_iter, &context.events);
bson_iter_next (&events_iter);
ASSERT (bson_iter_recurse (&events_iter, &event_iter));
ASSERT (bson_iter_find (&event_iter, "topology_opening_event"));
/* move forward to the last event */
for (i = 1; i < context.n_events; i++) {
ASSERT (bson_iter_next (&events_iter));
}
/* verify we didn't receive a topology closed event */
ASSERT (bson_iter_recurse (&events_iter, &event_iter));
ASSERT (!bson_iter_find (&event_iter, "topology_closed_event"));
/* no more events */
ASSERT (!bson_iter_next (&events_iter));
context_destroy (&context);
}
