/* * Copyright 2013 MongoDB, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include "mongoc/mongoc-server-description.h" #include "mongoc/mongoc-server-description-private.h" #include "mongoc/mongoc-topology-private.h" #include "mongoc/mongoc-client-private.h" #include "mongoc/mongoc-uri-private.h" #include "mongoc/mongoc-util-private.h" #include "mongoc/mongoc-linux-distro-scanner-private.h" #include "TestSuite.h" #include "test-conveniences.h" #include "test-libmongoc.h" #ifdef BSON_HAVE_STRINGS_H #include #endif #if defined(_MSC_VER) && defined(_WIN64) #include #include #endif #ifdef MONGOC_ENABLE_SSL_OPENSSL #include "mongoc/mongoc-openssl-private.h" #endif /* libbson */ extern void test_atomic_install (TestSuite *suite); extern void test_bcon_basic_install (TestSuite *suite); extern void test_bcon_extract_install (TestSuite *suite); extern void test_bson_corpus_install (TestSuite *suite); extern void test_bson_install (TestSuite *suite); extern void test_bson_version_install (TestSuite *suite); extern void test_clock_install (TestSuite *suite); extern void test_decimal128_install (TestSuite *suite); extern void test_endian_install (TestSuite *suite); extern void test_bson_error_install (TestSuite *suite); extern void test_iso8601_install (TestSuite *suite); extern void test_iter_install (TestSuite *suite); extern void test_json_install (TestSuite *suite); extern void test_oid_install (TestSuite *suite); extern void test_reader_install (TestSuite *suite); extern void test_string_install (TestSuite *suite); extern void test_utf8_install (TestSuite *suite); extern void test_value_install (TestSuite *suite); extern void test_writer_install (TestSuite *suite); extern void test_b64_install (TestSuite *suite); extern void test_bson_cmp_install (TestSuite *suite); /* libmongoc */ extern void test_aggregate_install (TestSuite *suite); extern void test_array_install (TestSuite *suite); extern void test_async_install (TestSuite *suite); extern void test_buffer_install (TestSuite *suite); extern void test_bulk_install (TestSuite *suite); extern void test_change_stream_install (TestSuite *suite); extern void test_client_install (TestSuite *suite); extern void test_client_max_staleness_install (TestSuite *suite); extern void test_client_hedged_reads_install (TestSuite *suite); extern void test_client_pool_install (TestSuite *suite); extern void test_client_cmd_install (TestSuite *suite); extern void test_client_versioned_api_install (TestSuite *suite); extern void test_cluster_install (TestSuite *suite); extern void test_collection_install (TestSuite *suite); extern void test_collection_find_install (TestSuite *suite); extern void test_collection_find_with_opts_install (TestSuite *suite); extern void test_connection_uri_install (TestSuite *suite); extern void test_command_monitoring_install (TestSuite *suite); extern void test_cursor_install (TestSuite *suite); extern void test_database_install (TestSuite *suite); extern void test_dns_install (TestSuite *suite); extern void test_error_install (TestSuite *suite); extern void test_exhaust_install (TestSuite *suite); extern void test_find_and_modify_install (TestSuite *suite); extern void test_gridfs_bucket_install (TestSuite *suite); extern void test_gridfs_file_page_install (TestSuite *suite); extern void test_gridfs_install (TestSuite *suite); extern void test_linux_distro_scanner_install (TestSuite *suite); extern void test_list_install (TestSuite *suite); extern void test_log_install (TestSuite *suite); extern void test_matcher_install (TestSuite *suite); extern void test_mongos_pinning_install (TestSuite *suite); extern void test_handshake_install (TestSuite *suite); extern void test_queue_install (TestSuite *suite); extern void test_primary_stepdown_install (TestSuite *suite); extern void test_read_concern_install (TestSuite *suite); extern void test_read_write_concern_install (TestSuite *suite); extern void test_read_prefs_install (TestSuite *suite); extern void test_retryable_writes_install (TestSuite *suite); extern void test_retryable_reads_install (TestSuite *suite); extern void test_rpc_install (TestSuite *suite); extern void test_samples_install (TestSuite *suite); extern void test_scram_install (TestSuite *suite); extern void test_sdam_install (TestSuite *suite); extern void test_sdam_monitoring_install (TestSuite *suite); extern void test_server_selection_install (TestSuite *suite); extern void test_session_install (TestSuite *suite); extern void test_server_selection_errors_install (TestSuite *suite); extern void test_set_install (TestSuite *suite); extern void test_opts_install (TestSuite *suite); extern void test_socket_install (TestSuite *suite); extern void test_speculative_auth_install (TestSuite *suite); extern void test_stream_install (TestSuite *suite); extern void test_thread_install (TestSuite *suite); extern void test_topology_install (TestSuite *suite); extern void test_topology_description_install (TestSuite *suite); extern void test_topology_reconcile_install (TestSuite *suite); extern void test_transactions_install (TestSuite *suite); extern void test_topology_scanner_install (TestSuite *suite); extern void test_ts_pool_install (TestSuite *suite); extern void test_uri_install (TestSuite *suite); extern void test_usleep_install (TestSuite *suite); extern void test_util_install (TestSuite *suite); extern void test_version_install (TestSuite *suite); extern void test_with_transaction_install (TestSuite *suite); extern void test_write_command_install (TestSuite *suite); extern void test_write_concern_install (TestSuite *suite); #ifdef MONGOC_ENABLE_SSL extern void test_stream_tls_install (TestSuite *suite); extern void test_x509_install (TestSuite *suite); extern void test_stream_tls_error_install (TestSuite *suite); #endif #ifdef MONGOC_ENABLE_SASL_CYRUS extern void test_cyrus_install (TestSuite *suite); #endif extern void test_happy_eyeballs_install (TestSuite *suite); extern void test_counters_install (TestSuite *suite); extern void test_crud_install (TestSuite *suite); extern void test_mongohouse_install (TestSuite *suite); extern void test_apm_install (TestSuite *suite); extern void test_client_side_encryption_install (TestSuite *suite); extern void test_long_namespace_install (TestSuite *suite); extern void test_server_description_install (TestSuite *suite); extern void test_aws_install (TestSuite *suite); extern void test_streamable_hello_install (TestSuite *suite); #if defined(MONGOC_ENABLE_OCSP_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10101000L extern void test_ocsp_cache_install (TestSuite *suite); #endif extern void test_interrupt_install (TestSuite *suite); extern void test_monitoring_install (TestSuite *suite); extern void test_http_install (TestSuite *suite); extern void test_install_unified (TestSuite *suite); extern void test_timeout_install (TestSuite *suite); extern void test_bson_match_install (TestSuite *suite); extern void test_bson_util_install (TestSuite *suite); extern void test_result_install (TestSuite *suite); extern void test_loadbalanced_install (TestSuite *suite); extern void test_server_stream_install (TestSuite *suite); extern void test_generation_map_install (TestSuite *suite); extern void test_shared_install (TestSuite *suite); extern void test_ssl_install (TestSuite *suite); typedef struct { mongoc_log_level_t level; char *msg; } log_entry_t; static bson_mutex_t captured_logs_mutex; static mongoc_array_t captured_logs; static bool capturing_logs; #ifdef MONGOC_ENABLE_SSL static mongoc_ssl_opt_t gSSLOptions; #endif static log_entry_t * log_entry_create (mongoc_log_level_t level, const char *msg) { log_entry_t *log_entry; log_entry = bson_malloc (sizeof (log_entry_t)); log_entry->level = level; log_entry->msg = bson_strdup (msg); return log_entry; } static void log_entry_destroy (log_entry_t *log_entry) { bson_free (log_entry->msg); bson_free (log_entry); } void capture_logs (bool capture) { capturing_logs = capture; clear_captured_logs (); } void clear_captured_logs (void) { size_t i; log_entry_t *log_entry; bson_mutex_lock (&captured_logs_mutex); for (i = 0; i < captured_logs.len; i++) { log_entry = _mongoc_array_index (&captured_logs, log_entry_t *, i); log_entry_destroy (log_entry); } captured_logs.len = 0; bson_mutex_unlock (&captured_logs_mutex); } bool has_captured_log (mongoc_log_level_t level, const char *msg) { size_t i; log_entry_t *log_entry; bson_mutex_lock (&captured_logs_mutex); for (i = 0; i < captured_logs.len; i++) { log_entry = _mongoc_array_index (&captured_logs, log_entry_t *, i); if (level == log_entry->level && strstr (log_entry->msg, msg)) { bson_mutex_unlock (&captured_logs_mutex); return true; } } bson_mutex_unlock (&captured_logs_mutex); return false; } bool has_captured_logs (void) { bool ret; bson_mutex_lock (&captured_logs_mutex); ret = 0 != captured_logs.len; bson_mutex_unlock (&captured_logs_mutex); return ret; } void assert_all_captured_logs_have_prefix (const char *prefix) { size_t i; log_entry_t *log_entry; bson_mutex_lock (&captured_logs_mutex); for (i = 0; i < captured_logs.len; i++) { log_entry = _mongoc_array_index (&captured_logs, log_entry_t *, i); ASSERT_STARTSWITH (log_entry->msg, prefix); } bson_mutex_unlock (&captured_logs_mutex); } void print_captured_logs (const char *prefix) { size_t i; log_entry_t *log_entry; bson_mutex_lock (&captured_logs_mutex); for (i = 0; i < captured_logs.len; i++) { log_entry = _mongoc_array_index (&captured_logs, log_entry_t *, i); if (prefix) { fprintf (stderr, "%s%s %s\n", prefix, mongoc_log_level_str (log_entry->level), log_entry->msg); } else { fprintf (stderr, "%s %s\n", mongoc_log_level_str (log_entry->level), log_entry->msg); } } bson_mutex_unlock (&captured_logs_mutex); } #define DEFAULT_FUTURE_TIMEOUT_MS 10 * 1000 int64_t get_future_timeout_ms () { return test_framework_getenv_int64 ("MONGOC_TEST_FUTURE_TIMEOUT_MS", DEFAULT_FUTURE_TIMEOUT_MS); } static void log_handler (mongoc_log_level_t log_level, const char *log_domain, const char *message, void *user_data) { TestSuite *suite; log_entry_t *log_entry; suite = (TestSuite *) user_data; if (log_level < MONGOC_LOG_LEVEL_INFO) { bson_mutex_lock (&captured_logs_mutex); if (capturing_logs) { log_entry = log_entry_create (log_level, message); _mongoc_array_append_val (&captured_logs, log_entry); bson_mutex_unlock (&captured_logs_mutex); return; } bson_mutex_unlock (&captured_logs_mutex); if (!suite->silent) { mongoc_log_default_handler (log_level, log_domain, message, NULL); } } else if (log_level == MONGOC_LOG_LEVEL_DEBUG && test_suite_debug_output ()) { mongoc_log_default_handler (log_level, log_domain, message, NULL); } } mongoc_database_t * get_test_database (mongoc_client_t *client) { return mongoc_client_get_database (client, "test"); } char * gen_collection_name (const char *str) { return bson_strdup_printf ("%s_%u_%u", str, (uint32_t) bson_get_monotonic_time (), (uint32_t) gettestpid ()); } mongoc_collection_t * get_test_collection (mongoc_client_t *client, const char *prefix) { mongoc_collection_t *ret; char *str; str = gen_collection_name (prefix); ret = mongoc_client_get_collection (client, "test", str); bson_free (str); return ret; } char * test_framework_getenv (const char *name) { return _mongoc_getenv (name); } char * test_framework_getenv_required (const char *name) { char *ret = _mongoc_getenv (name); if (!ret) { test_error ("Expected environment variable %s to be set", name); } return ret; } /* Returns false if unable to set environment variable. Which may occur if * test-libmongoc lacks permissions to do so. */ bool test_framework_setenv (const char *name, const char *value) { #ifdef _WIN32 char *envstring; envstring = bson_strdup_printf ("%s=%s", name, value); if (0 != _putenv (envstring)) { return false; } return true; #else if (0 != setenv (name, value, 1)) { return false; } return true; #endif } /* *-------------------------------------------------------------------------- * * test_framework_getenv_bool -- * * Check if an environment variable is set. * * Returns: * True if the variable is set, or set to "on", false if it is not set * or set to "off". * * Side effects: * Logs and aborts if there is another value like "yes" or "true". * *-------------------------------------------------------------------------- */ bool test_framework_getenv_bool (const char *name) { char *value = test_framework_getenv (name); bool ret = false; if (value) { if (!strcasecmp (value, "off")) { ret = false; } else if (!strcasecmp (value, "") || !strcasecmp (value, "on")) { ret = true; } else { fprintf (stderr, "Unrecognized value for %s: \"%s\". Use \"on\" or \"off\".\n", name, value); abort (); } } bson_free (value); return ret; } /* *-------------------------------------------------------------------------- * * test_framework_getenv_int64 -- * * Get a number from an environment variable. * * Returns: * The number, or default. * * Side effects: * Logs and aborts if there is a non-numeric value. * *-------------------------------------------------------------------------- */ int64_t test_framework_getenv_int64 (const char *name, int64_t default_value) { char *value = test_framework_getenv (name); char *endptr; int64_t ret; if (value) { errno = 0; ret = bson_ascii_strtoll (value, &endptr, 10); if (errno) { perror (bson_strdup_printf ("Parsing %s from environment", name)); abort (); } bson_free (value); return ret; } return default_value; } static char * test_framework_get_unix_domain_socket_path (void) { char *path = test_framework_getenv ("MONGOC_TEST_UNIX_DOMAIN_SOCKET"); if (path) { return path; } return bson_strdup_printf ("/tmp/mongodb-%d.sock", test_framework_get_port ()); } /* *-------------------------------------------------------------------------- * * test_framework_get_unix_domain_socket_path_escaped -- * * Get the path to Unix Domain Socket .sock of the test MongoDB server, * URI-escaped ("/" is replaced with "%2F"). * * Returns: * A string you must bson_free. * * Side effects: * None. * *-------------------------------------------------------------------------- */ char * test_framework_get_unix_domain_socket_path_escaped (void) { char *path = test_framework_get_unix_domain_socket_path (), *c = path; bson_string_t *escaped = bson_string_new (NULL); /* Connection String Spec: "The host information cannot contain an unescaped * slash ("/"), if it does then an exception MUST be thrown informing users * that paths must be URL encoded." * * Even though the C Driver does not currently enforce the spec, let's pass * a correctly escaped URI. */ do { if (*c == '/') { bson_string_append (escaped, "%2F"); } else { bson_string_append_c (escaped, *c); } } while (*(++c)); bson_string_append_c (escaped, '\0'); bson_free (path); return bson_string_free (escaped, false /* free_segment */); } static char * _uri_str_from_env (void) { if (test_framework_getenv_bool ("MONGOC_TEST_LOADBALANCED")) { char *loadbalanced_uri_str = test_framework_getenv ("SINGLE_MONGOS_LB_URI"); if (!loadbalanced_uri_str) { test_error ("SINGLE_MONGOS_LB_URI and MULTI_MONGOS_LB_URI must be set " "when MONGOC_TEST_LOADBALANCED is enabled"); } return loadbalanced_uri_str; } return test_framework_getenv ("MONGOC_TEST_URI"); } static mongoc_uri_t * _uri_from_env (void) { char *env_uri_str; mongoc_uri_t *uri; env_uri_str = _uri_str_from_env (); if (env_uri_str) { uri = mongoc_uri_new (env_uri_str); bson_free (env_uri_str); return uri; } return NULL; } /* *-------------------------------------------------------------------------- * * test_framework_get_host -- * * Get the hostname of the test MongoDB server. * * Returns: * A string you must bson_free. * * Side effects: * None. * *-------------------------------------------------------------------------- */ char * test_framework_get_host (void) { mongoc_uri_t *env_uri; const mongoc_host_list_t *hosts; char *host; /* MONGOC_TEST_URI takes precedence */ env_uri = _uri_from_env (); if (env_uri) { /* choose first host */ hosts = mongoc_uri_get_hosts (env_uri); host = bson_strdup (hosts->host); mongoc_uri_destroy (env_uri); return host; } host = test_framework_getenv ("MONGOC_TEST_HOST"); return host ? host : bson_strdup ("localhost"); } /* *-------------------------------------------------------------------------- * * test_framework_get_port -- * * Get the port number of the test MongoDB server. * * Returns: * The port number, 27017 by default. * * Side effects: * None. * *-------------------------------------------------------------------------- */ uint16_t test_framework_get_port (void) { mongoc_uri_t *env_uri; const mongoc_host_list_t *hosts; char *port_str; unsigned long port = MONGOC_DEFAULT_PORT; /* MONGOC_TEST_URI takes precedence */ env_uri = _uri_from_env (); if (env_uri) { /* choose first port */ hosts = mongoc_uri_get_hosts (env_uri); port = hosts->port; mongoc_uri_destroy (env_uri); } else { port_str = test_framework_getenv ("MONGOC_TEST_PORT"); if (port_str && strlen (port_str)) { port = strtoul (port_str, NULL, 10); if (port == 0 || port > UINT16_MAX) { /* parse err or port out of range -- mongod prohibits port 0 */ port = MONGOC_DEFAULT_PORT; } } bson_free (port_str); } return (uint16_t) port; } char * test_framework_get_host_and_port (void) { char *host = test_framework_get_host (); uint16_t port = test_framework_get_port (); char *host_and_port; if (strchr (host, ':')) { /* wrap IPv6 address in square brackets. */ host_and_port = bson_strdup_printf ("[%s]:%hu", host, port); } else { host_and_port = bson_strdup_printf ("%s:%hu", host, port); } bson_free (host); return host_and_port; } /* *-------------------------------------------------------------------------- * * test_framework_get_admin_user -- * * Get the username of an admin user on the test MongoDB server. * * Returns: * A string you must bson_free, or NULL. * * Side effects: * None. * *-------------------------------------------------------------------------- */ char * test_framework_get_admin_user (void) { char *retval = NULL; mongoc_uri_t *env_uri = _uri_from_env (); /* MONGOC_TEST_URI takes precedence */ if (env_uri) { const char *tmp = mongoc_uri_get_username (env_uri); if (tmp) { retval = bson_strdup (tmp); } mongoc_uri_destroy (env_uri); } if (!retval) { retval = test_framework_getenv ("MONGOC_TEST_USER"); } return retval; } /* *-------------------------------------------------------------------------- * * test_framework_get_admin_password -- * * Get the password of an admin user on the test MongoDB server. * * Returns: * A string you must bson_free, or NULL. * * Side effects: * None. * *-------------------------------------------------------------------------- */ char * test_framework_get_admin_password (void) { char *retval = NULL; mongoc_uri_t *env_uri = _uri_from_env (); /* MONGOC_TEST_URI takes precedence */ if (env_uri) { const char *tmp = mongoc_uri_get_password (env_uri); if (tmp) { retval = bson_strdup (tmp); } mongoc_uri_destroy (env_uri); } if (!retval) { retval = test_framework_getenv ("MONGOC_TEST_PASSWORD"); } return retval; } /* *-------------------------------------------------------------------------- * * test_framework_get_user_password -- * * Get the username and password of an admin user on the test MongoDB * server. * * Returns: * True if username and password environment variables are set. * * Side effects: * Sets passed-in string pointers to strings you must free, or NULL. * Logs and aborts if user or password is set in the environment * but not both, or if user and password are set but SSL is not * compiled in (SSL is required for SCRAM-SHA-1, see CDRIVER-520). * *-------------------------------------------------------------------------- */ static bool test_framework_get_user_password (char **user, char **password) { /* TODO: uri-escape username and password */ *user = test_framework_get_admin_user (); *password = test_framework_get_admin_password (); if ((*user && !*password) || (!*user && *password)) { fprintf (stderr, "Specify both MONGOC_TEST_USER and" " MONGOC_TEST_PASSWORD, or neither\n"); abort (); } #ifndef MONGOC_ENABLE_CRYPTO if (*user && *password) { fprintf (stderr, "You need to configure with ENABLE_SSL" " when providing user+password (for SCRAM-SHA-1)\n"); abort (); } #endif return *user != NULL; } /* *-------------------------------------------------------------------------- * * test_framework_add_user_password -- * * Copy a connection string, with user and password added. * * Returns: * A string you must bson_free. * * Side effects: * None. * *-------------------------------------------------------------------------- */ char * test_framework_add_user_password (const char *uri_str, const char *user, const char *password) { return bson_strdup_printf ( "mongodb://%s:%s@%s", user, password, uri_str + strlen ("mongodb://")); } /* *-------------------------------------------------------------------------- * * test_framework_add_user_password_from_env -- * * Add password of an admin user on the test MongoDB server. * * Returns: * A string you must bson_free. * * Side effects: * Same as test_framework_get_user_password. * *-------------------------------------------------------------------------- */ char * test_framework_add_user_password_from_env (const char *uri_str) { char *user; char *password; char *uri_str_auth; if (test_framework_get_user_password (&user, &password)) { uri_str_auth = test_framework_add_user_password (uri_str, user, password); bson_free (user); bson_free (password); } else { uri_str_auth = bson_strdup (uri_str); } return uri_str_auth; } /* *-------------------------------------------------------------------------- * * test_framework_get_compressors -- * * Get the list of compressors to enable * * Returns: * A string you must bson_free, or NULL if the variable is not set. * * Side effects: * None. * *-------------------------------------------------------------------------- */ char * test_framework_get_compressors () { return test_framework_getenv ("MONGOC_TEST_COMPRESSORS"); } /* *-------------------------------------------------------------------------- * * test_framework_has_compressors -- * * Check if the test suite has been configured to use compression * * Returns: * true if compressors should be used. * * Side effects: * None. * *-------------------------------------------------------------------------- */ bool test_framework_has_compressors () { bool retval; char *compressors = test_framework_get_compressors (); retval = !!compressors; bson_free (compressors); return retval; } /* *-------------------------------------------------------------------------- * * test_framework_get_ssl -- * * Should we connect to the test MongoDB server over SSL? * * Returns: * True if any MONGOC_TEST_SSL_* environment variables are set. * * Side effects: * None. * *-------------------------------------------------------------------------- */ bool test_framework_get_ssl (void) { char *ssl_option_names[] = {"MONGOC_TEST_SSL_PEM_FILE", "MONGOC_TEST_SSL_PEM_PWD", "MONGOC_TEST_SSL_CA_FILE", "MONGOC_TEST_SSL_CA_DIR", "MONGOC_TEST_SSL_CRL_FILE", "MONGOC_TEST_SSL_WEAK_CERT_VALIDATION"}; char *ssl_option_value; size_t i; for (i = 0; i < sizeof ssl_option_names / sizeof (char *); i++) { ssl_option_value = test_framework_getenv (ssl_option_names[i]); if (ssl_option_value) { bson_free (ssl_option_value); return true; } } return test_framework_getenv_bool ("MONGOC_TEST_SSL"); } /* *-------------------------------------------------------------------------- * * test_framework_get_unix_domain_socket_uri_str -- * * Get the connection string (unix domain socket style) of the test * MongoDB server based on the variables set in the environment. * Does *not* call hello to discover your actual topology. * * Returns: * A string you must bson_free. * * Side effects: * Same as test_framework_get_user_password. * *-------------------------------------------------------------------------- */ char * test_framework_get_unix_domain_socket_uri_str () { char *path; char *test_uri_str; char *test_uri_str_auth; path = test_framework_get_unix_domain_socket_path_escaped (); test_uri_str = bson_strdup_printf ( "mongodb://%s/%s", path, test_framework_get_ssl () ? "?ssl=true" : ""); test_uri_str_auth = test_framework_add_user_password_from_env (test_uri_str); bson_free (path); bson_free (test_uri_str); return test_uri_str_auth; } /* *-------------------------------------------------------------------------- * * call_hello_with_host_and_port -- * * Call hello or legacy hello on a server, possibly over SSL. * * Side effects: * Fills reply with hello response. Logs and aborts on error. * *-------------------------------------------------------------------------- */ static void call_hello_with_host_and_port (const char *host_and_port, bson_t *reply) { char *user; char *password; char *uri_str; mongoc_uri_t *uri; mongoc_client_t *client; bson_error_t error; if (test_framework_get_user_password (&user, &password)) { uri_str = bson_strdup_printf ("mongodb://%s:%s@%s%s", user, password, host_and_port, test_framework_get_ssl () ? "/?ssl=true" : ""); bson_free (user); bson_free (password); } else { uri_str = bson_strdup_printf ("mongodb://%s%s", host_and_port, test_framework_get_ssl () ? "/?ssl=true" : ""); } uri = mongoc_uri_new (uri_str); BSON_ASSERT (uri); mongoc_uri_set_option_as_int32 (uri, MONGOC_URI_CONNECTTIMEOUTMS, 10000); mongoc_uri_set_option_as_int32 ( uri, MONGOC_URI_SERVERSELECTIONTIMEOUTMS, 10000); mongoc_uri_set_option_as_bool ( uri, MONGOC_URI_SERVERSELECTIONTRYONCE, false); if (test_framework_has_compressors ()) { char *compressors = test_framework_get_compressors (); mongoc_uri_set_compressors (uri, compressors); bson_free (compressors); } client = test_framework_client_new_from_uri (uri, NULL); #ifdef MONGOC_ENABLE_SSL test_framework_set_ssl_opts (client); #endif if (!mongoc_client_command_simple ( client, "admin", tmp_bson ("{'hello': 1}"), NULL, reply, &error)) { bson_destroy (reply); if (!mongoc_client_command_simple ( client, "admin", tmp_bson ("{'" HANDSHAKE_CMD_LEGACY_HELLO "': 1}"), NULL, reply, &error)) { fprintf (stderr, "error calling legacy hello: '%s'\n", error.message); fprintf (stderr, "URI = %s\n", uri_str); abort (); } } mongoc_client_destroy (client); mongoc_uri_destroy (uri); bson_free (uri_str); } /* *-------------------------------------------------------------------------- * * call_hello -- * * Call hello or legacy hello on the test server, possibly over SSL, using * host and port from the environment. * * Side effects: * Fills reply with hello response. Logs and aborts on error. * *-------------------------------------------------------------------------- */ static void call_hello (bson_t *reply) { char *host_and_port = test_framework_get_host_and_port (); call_hello_with_host_and_port (host_and_port, reply); bson_free (host_and_port); } static char * set_name (bson_t *hello_response) { bson_iter_t iter; if (bson_iter_init_find (&iter, hello_response, "setName")) { return bson_strdup (bson_iter_utf8 (&iter, NULL)); } else { return NULL; } } static bool uri_str_has_db (bson_string_t *uri_string) { const char *after_scheme; ASSERT_STARTSWITH (uri_string->str, "mongodb://"); after_scheme = uri_string->str + strlen ("mongodb://"); return strchr (after_scheme, '/') != NULL; } static void add_option_to_uri_str (bson_string_t *uri_string, const char *option, const char *value) { if (strchr (uri_string->str, '?')) { /* already has some options */ bson_string_append_c (uri_string, '&'); } else if (uri_str_has_db (uri_string)) { /* like "mongodb://host/db" */ bson_string_append_c (uri_string, '?'); } else { /* like "mongodb://host" */ bson_string_append_printf (uri_string, "/?"); } bson_string_append_printf (uri_string, "%s=%s", option, value); } /* *-------------------------------------------------------------------------- * * test_framework_get_uri_str_no_auth -- * * Get the connection string of the test MongoDB topology -- * standalone, replica set, mongos, or mongoses -- along with * SSL options, but not username and password. Calls calls hello with * that connection string to discover your topology, and * returns an appropriate connection string for the topology * type. * * database_name is optional. * * Returns: * A string you must bson_free. * * Side effects: * Same as test_framework_get_user_password. * *-------------------------------------------------------------------------- */ char * test_framework_get_uri_str_no_auth (const char *database_name) { char *env_uri_str; bson_t hello_response; bson_string_t *uri_string; char *name; bson_iter_t iter; bson_iter_t hosts_iter; bool first; char *host; uint16_t port; env_uri_str = _uri_str_from_env (); if (env_uri_str) { uri_string = bson_string_new (env_uri_str); if (database_name) { if (uri_string->str[uri_string->len - 1] != '/') { bson_string_append (uri_string, "/"); } bson_string_append (uri_string, database_name); } bson_free (env_uri_str); } else { /* construct a direct connection or replica set connection URI */ call_hello (&hello_response); uri_string = bson_string_new ("mongodb://"); if ((name = set_name (&hello_response))) { /* make a replica set URI */ bson_iter_init_find (&iter, &hello_response, "hosts"); bson_iter_recurse (&iter, &hosts_iter); first = true; /* append "host1,host2,host3" */ while (bson_iter_next (&hosts_iter)) { BSON_ASSERT (BSON_ITER_HOLDS_UTF8 (&hosts_iter)); if (!first) { bson_string_append (uri_string, ","); } bson_string_append (uri_string, bson_iter_utf8 (&hosts_iter, NULL)); first = false; } bson_string_append (uri_string, "/"); if (database_name) { bson_string_append (uri_string, database_name); } add_option_to_uri_str (uri_string, MONGOC_URI_REPLICASET, name); bson_free (name); } else { host = test_framework_get_host (); port = test_framework_get_port (); bson_string_append_printf (uri_string, "%s:%hu", host, port); bson_string_append (uri_string, "/"); if (database_name) { bson_string_append (uri_string, database_name); } bson_free (host); } if (test_framework_get_ssl ()) { add_option_to_uri_str (uri_string, MONGOC_URI_SSL, "true"); } bson_destroy (&hello_response); } if (test_framework_has_compressors ()) { char *compressors = test_framework_get_compressors (); add_option_to_uri_str (uri_string, MONGOC_URI_COMPRESSORS, compressors); bson_free (compressors); } /* make tests a little more resilient to transient errors */ add_option_to_uri_str ( uri_string, MONGOC_URI_SERVERSELECTIONTRYONCE, "false"); return bson_string_free (uri_string, false); } /* *-------------------------------------------------------------------------- * * test_framework_get_uri_str -- * * Get the connection string of the test MongoDB topology -- * standalone, replica set, mongos, or mongoses -- along with * SSL options, username and password. * * Returns: * A string you must bson_free. * * Side effects: * Same as test_framework_get_user_password. * *-------------------------------------------------------------------------- */ char * test_framework_get_uri_str () { char *uri_str_no_auth; char *uri_str; /* no_auth also contains compressors. */ uri_str_no_auth = test_framework_get_uri_str_no_auth (NULL); uri_str = test_framework_add_user_password_from_env (uri_str_no_auth); bson_free (uri_str_no_auth); return uri_str; } /* *-------------------------------------------------------------------------- * * test_framework_get_uri -- * * Like test_framework_get_uri_str (). Get the URI of the test * MongoDB server. * * Returns: * A mongoc_uri_t* you must destroy. * * Side effects: * Same as test_framework_get_user_password. * *-------------------------------------------------------------------------- */ mongoc_uri_t * test_framework_get_uri () { char *test_uri_str = test_framework_get_uri_str (); mongoc_uri_t *uri = mongoc_uri_new (test_uri_str); BSON_ASSERT (uri); bson_free (test_uri_str); return uri; } mongoc_uri_t * test_framework_get_uri_multi_mongos_loadbalanced () { char *uri_str_no_auth; char *uri_str; mongoc_uri_t *uri; bson_error_t error; uri_str_no_auth = _mongoc_getenv ("MULTI_MONGOS_LB_URI"); if (!uri_str_no_auth) { test_error ("expected MULTI_MONGOS_LB_URI to be set"); } uri_str = test_framework_add_user_password_from_env (uri_str_no_auth); uri = mongoc_uri_new_with_error (uri_str, &error); ASSERT_OR_PRINT (uri, error); bson_free (uri_str_no_auth); bson_free (uri_str); return uri; } bool test_framework_uri_apply_multi_mongos (mongoc_uri_t *uri, bool use_multi, bson_error_t *error) { bool ret = false; if (!test_framework_is_mongos ()) { ret = true; goto done; } /* TODO Once CDRIVER-3285 is resolved, update this to no longer hardcode the * hosts. */ if (use_multi) { if (!mongoc_uri_upsert_host_and_port (uri, "localhost:27017", error)) { goto done; } if (!mongoc_uri_upsert_host_and_port (uri, "localhost:27018", error)) { goto done; } } else { const mongoc_host_list_t *hosts; hosts = mongoc_uri_get_hosts (uri); if (hosts->next) { test_set_error (error, "useMultiMongoses is false, so expected single " "host listed, but got: %s", mongoc_uri_get_string (uri)); goto done; } } ret = true; done: return ret; } /* *-------------------------------------------------------------------------- * * test_framework_mongos_count -- * * Returns the number of servers in the test framework's MongoDB URI. * *-------------------------------------------------------------------------- */ size_t test_framework_mongos_count (void) { mongoc_uri_t *uri = test_framework_get_uri (); const mongoc_host_list_t *h; size_t count = 0; BSON_ASSERT (uri); h = mongoc_uri_get_hosts (uri); while (h) { ++count; h = h->next; } mongoc_uri_destroy (uri); return count; } /* *-------------------------------------------------------------------------- * * test_framework_replset_name -- * * Returns the replica set name or NULL. You must free the string. * *-------------------------------------------------------------------------- */ char * test_framework_replset_name (void) { bson_t reply; bson_iter_t iter; char *replset_name; call_hello (&reply); if (!bson_iter_init_find (&iter, &reply, "setName")) { return NULL; } replset_name = bson_strdup (bson_iter_utf8 (&iter, NULL)); bson_destroy (&reply); return replset_name; } /* *-------------------------------------------------------------------------- * * test_framework_replset_member_count -- * * Returns the number of replica set members (including arbiters). * *-------------------------------------------------------------------------- */ size_t test_framework_replset_member_count (void) { mongoc_client_t *client; bson_t reply; bson_error_t error; bool r; bson_iter_t iter, array; size_t count = 0; client = test_framework_new_default_client (); r = mongoc_client_command_simple (client, "admin", tmp_bson ("{'replSetGetStatus': 1}"), NULL, &reply, &error); if (r) { if (bson_iter_init_find (&iter, &reply, "members") && BSON_ITER_HOLDS_ARRAY (&iter)) { bson_iter_recurse (&iter, &array); while (bson_iter_next (&array)) { ++count; } } } else if (!strstr (error.message, "not running with --replSet") && !strstr (error.message, "replSetGetStatus is not supported through mongos")) { /* failed for some other reason */ ASSERT_OR_PRINT (false, error); } bson_destroy (&reply); mongoc_client_destroy (client); return count; } /* *-------------------------------------------------------------------------- * * test_framework_data_nodes_count -- * * Returns the number of replica set members (excluding arbiters), * or number of mongos servers or 1 for a standalone. * *-------------------------------------------------------------------------- */ size_t test_framework_data_nodes_count (void) { bson_t reply; bson_iter_t iter, array; size_t count = 0; call_hello (&reply); if (!bson_iter_init_find (&iter, &reply, "hosts")) { bson_destroy (&reply); return test_framework_mongos_count (); } BSON_ASSERT (bson_iter_recurse (&iter, &array)); while (bson_iter_next (&array)) { ++count; } bson_destroy (&reply); return count; } /* *-------------------------------------------------------------------------- * * test_framework_server_count -- * * Returns the number of mongos servers or replica set members, * or 1 if the server is standalone. * *-------------------------------------------------------------------------- */ size_t test_framework_server_count (void) { size_t count = 0; count = test_framework_replset_member_count (); if (count > 0) { return count; } return test_framework_mongos_count (); } /* *-------------------------------------------------------------------------- * * test_framework_set_ssl_opts -- * * Configure a client to connect to the test MongoDB server. * * Returns: * None. * * Side effects: * Logs and aborts if any MONGOC_TEST_SSL_* environment variables are * set but the driver is not built with SSL enabled. * *-------------------------------------------------------------------------- */ void test_framework_set_ssl_opts (mongoc_client_t *client) { BSON_ASSERT (client); if (test_framework_get_ssl ()) { #ifndef MONGOC_ENABLE_SSL fprintf (stderr, "SSL test config variables are specified in the environment, but" " SSL isn't enabled\n"); abort (); #else mongoc_client_set_ssl_opts (client, &gSSLOptions); #endif } } /* *-------------------------------------------------------------------------- * * test_framework_new_default_client -- * * Get a client connected to the test MongoDB topology. * * Returns: * A client you must mongoc_client_destroy. * * Side effects: * None. * *-------------------------------------------------------------------------- */ mongoc_client_t * test_framework_new_default_client () { char *test_uri_str = test_framework_get_uri_str (); mongoc_client_t *client = test_framework_client_new (test_uri_str, NULL); BSON_ASSERT (client); test_framework_set_ssl_opts (client); bson_free (test_uri_str); return client; } /* *-------------------------------------------------------------------------- * * test_framework_client_new_no_server_api -- * * Get a client connected to the test MongoDB topology, with no server * API version set. * * Returns: * A client you must mongoc_client_destroy. * * Side effects: * None. * *-------------------------------------------------------------------------- */ mongoc_client_t * test_framework_client_new_no_server_api () { mongoc_uri_t *uri = test_framework_get_uri (); mongoc_client_t *client = mongoc_client_new_from_uri (uri); BSON_ASSERT (client); test_framework_set_ssl_opts (client); mongoc_uri_destroy (uri); return client; } mongoc_server_api_t * test_framework_get_default_server_api (void) { char *api_version = test_framework_getenv ("MONGODB_API_VERSION"); mongoc_server_api_version_t version; if (!api_version) { return NULL; } ASSERT (mongoc_server_api_version_from_string (api_version, &version)); bson_free (api_version); return mongoc_server_api_new (version); } /* *-------------------------------------------------------------------------- * * test_framework_client_new -- * * Get a client connected to the indicated connection string * * Parameters: * @uri_str: A connection string to the test deployment * @api: A mongoc_server_api_t that declares an API version. If omitted, * the API version indicated in the MONGODB_API_VERSION env variable * is used. * * Returns: * A client you must mongoc_client_destroy. * * Side effects: * None. * *-------------------------------------------------------------------------- */ mongoc_client_t * test_framework_client_new (const char *uri_str, const mongoc_server_api_t *api) { mongoc_client_t *client = mongoc_client_new (uri_str); bson_error_t error; mongoc_server_api_t *default_api = NULL; if (!client) { return client; } if (api) { ASSERT_OR_PRINT (mongoc_client_set_server_api (client, api, &error), error); } else { default_api = test_framework_get_default_server_api (); if (default_api) { ASSERT_OR_PRINT ( mongoc_client_set_server_api (client, default_api, &error), error); } } mongoc_server_api_destroy (default_api); return client; } /* *-------------------------------------------------------------------------- * * test_framework_client_new_from_uri -- * * Get a client connected to the indicated URI * * Parameters: * @uri_str: A mongoc_uri_t to connect with * @api: A mongoc_server_api_t that declares an API version. If omitted, * the API version indicated in the MONGODB_API_VERSION env variable * is used. * * Returns: * A client you must mongoc_client_destroy. * * Side effects: * None. * *-------------------------------------------------------------------------- */ mongoc_client_t * test_framework_client_new_from_uri (const mongoc_uri_t *uri, const mongoc_server_api_t *api) { mongoc_client_t *client = mongoc_client_new_from_uri (uri); bson_error_t error; mongoc_server_api_t *default_api = NULL; if (!client) { return client; } if (api) { ASSERT_OR_PRINT (mongoc_client_set_server_api (client, api, &error), error); } else { default_api = test_framework_get_default_server_api (); if (default_api) { ASSERT_OR_PRINT ( mongoc_client_set_server_api (client, default_api, &error), error); } } mongoc_server_api_destroy (default_api); return client; } #ifdef MONGOC_ENABLE_SSL /* *-------------------------------------------------------------------------- * * test_framework_get_ssl_opts -- * * Get options for connecting to mongod over SSL (even if mongod * isn't actually SSL-enabled). * * Returns: * A pointer to constant global SSL-test options. * * Side effects: * None. * *-------------------------------------------------------------------------- */ const mongoc_ssl_opt_t * test_framework_get_ssl_opts (void) { return &gSSLOptions; } #endif /* *-------------------------------------------------------------------------- * * test_framework_set_pool_ssl_opts -- * * Configure a client pool to connect to the test MongoDB server. * * Returns: * None. * * Side effects: * Logs and aborts if any MONGOC_TEST_SSL_* environment variables are * set but the driver is not built with SSL enabled. * *-------------------------------------------------------------------------- */ void test_framework_set_pool_ssl_opts (mongoc_client_pool_t *pool) { BSON_ASSERT (pool); if (test_framework_get_ssl ()) { #ifndef MONGOC_ENABLE_SSL fprintf (stderr, "SSL test config variables are specified in the environment, but" " SSL isn't enabled\n"); abort (); #else mongoc_client_pool_set_ssl_opts (pool, &gSSLOptions); #endif } } /* *-------------------------------------------------------------------------- * * test_framework_new_default_client_pool -- * * Get a client pool connected to the test MongoDB topology. * * Returns: * A pool you must destroy. * * Side effects: * None. * *-------------------------------------------------------------------------- */ mongoc_client_pool_t * test_framework_new_default_client_pool () { mongoc_uri_t *test_uri = test_framework_get_uri (); mongoc_client_pool_t *pool = test_framework_client_pool_new_from_uri (test_uri, NULL); BSON_ASSERT (pool); test_framework_set_pool_ssl_opts (pool); mongoc_uri_destroy (test_uri); BSON_ASSERT (pool); return pool; } /* *-------------------------------------------------------------------------- * * test_framework_client_pool_new_from_uri -- * * Get a client pool connected to the indicated connection string * * Parameters: * @uri_str: A mongoc_uri_t to connect to * @api: A mongoc_server_api_t that declares an API version. If omitted, * the API version indicated in the MONGODB_API_VERSION env variable * is used. * * Returns: * A pool you must mongoc_client_pool_destroy. * * Side effects: * None. * *-------------------------------------------------------------------------- */ mongoc_client_pool_t * test_framework_client_pool_new_from_uri (const mongoc_uri_t *uri, const mongoc_server_api_t *api) { mongoc_client_pool_t *pool = mongoc_client_pool_new (uri); bson_error_t error; mongoc_server_api_t *default_api = NULL; if (!pool) { return pool; } if (api) { ASSERT_OR_PRINT (mongoc_client_pool_set_server_api (pool, api, &error), error); } else { default_api = test_framework_get_default_server_api (); if (default_api) { ASSERT_OR_PRINT ( mongoc_client_pool_set_server_api (pool, default_api, &error), error); } } mongoc_server_api_destroy (default_api); return pool; } #ifdef MONGOC_ENABLE_SSL static void test_framework_global_ssl_opts_init (void) { memcpy (&gSSLOptions, mongoc_ssl_opt_get_default (), sizeof gSSLOptions); gSSLOptions.pem_file = test_framework_getenv ("MONGOC_TEST_SSL_PEM_FILE"); gSSLOptions.pem_pwd = test_framework_getenv ("MONGOC_TEST_SSL_PEM_PWD"); gSSLOptions.ca_file = test_framework_getenv ("MONGOC_TEST_SSL_CA_FILE"); gSSLOptions.ca_dir = test_framework_getenv ("MONGOC_TEST_SSL_CA_DIR"); gSSLOptions.crl_file = test_framework_getenv ("MONGOC_TEST_SSL_CRL_FILE"); gSSLOptions.weak_cert_validation = test_framework_getenv_bool ("MONGOC_TEST_SSL_WEAK_CERT_VALIDATION"); } static void test_framework_global_ssl_opts_cleanup (void) { bson_free ((void *) gSSLOptions.pem_file); bson_free ((void *) gSSLOptions.pem_pwd); bson_free ((void *) gSSLOptions.ca_file); bson_free ((void *) gSSLOptions.ca_dir); bson_free ((void *) gSSLOptions.crl_file); } #endif bool test_framework_is_mongos (void) { bson_t reply; bson_iter_t iter; bool is_mongos; call_hello (&reply); is_mongos = (bson_iter_init_find (&iter, &reply, "msg") && BSON_ITER_HOLDS_UTF8 (&iter) && !strcasecmp (bson_iter_utf8 (&iter, NULL), "isdbgrid")); bson_destroy (&reply); return is_mongos; } bool test_framework_is_replset (void) { return test_framework_replset_member_count () > 0; } bool test_framework_server_is_secondary (mongoc_client_t *client, uint32_t server_id) { bson_t reply; bson_iter_t iter; mongoc_server_description_t const *sd; bson_error_t error; bool ret; sd = mongoc_topology_description_server_by_id_const ( client->topology->_shared_descr_.ptr, server_id, &error); ASSERT_OR_PRINT (sd, error); call_hello_with_host_and_port (sd->host.host_and_port, &reply); ret = bson_iter_init_find (&iter, &reply, "secondary") && bson_iter_as_bool (&iter); bson_destroy (&reply); return ret; } bool test_framework_clustertime_supported (void) { bson_t reply; bool has_cluster_time; call_hello (&reply); has_cluster_time = bson_has_field (&reply, "$clusterTime"); bson_destroy (&reply); return has_cluster_time && test_framework_max_wire_version_at_least (WIRE_VERSION_OP_MSG); } int64_t test_framework_session_timeout_minutes (void) { bson_t reply; bson_iter_t iter; int64_t timeout = -1; if (!TestSuite_CheckLive ()) { return -1; } call_hello (&reply); if (bson_iter_init_find (&iter, &reply, "logicalSessionTimeoutMinutes")) { timeout = bson_iter_as_int64 (&iter); } bson_destroy (&reply); return timeout; } void test_framework_get_max_wire_version (int64_t *max_version) { bson_t reply; bson_iter_t iter; call_hello (&reply); BSON_ASSERT (bson_iter_init_find (&iter, &reply, "maxWireVersion")); *max_version = bson_iter_as_int64 (&iter); bson_destroy (&reply); } bool test_framework_has_auth (void) { char *user; #ifndef MONGOC_ENABLE_SSL /* requires SSL for SCRAM implementation, can't test auth */ return false; #endif /* checks if the MONGOC_TEST_USER env var is set */ user = test_framework_get_admin_user (); bson_free (user); if (user) { return true; } else { return false; } } int test_framework_skip_if_auth (void) { if (!TestSuite_CheckLive ()) { return 0; } if (test_framework_has_auth ()) { return 0; } return 1; } int test_framework_skip_if_no_auth (void) { if (!TestSuite_CheckLive ()) { return 0; } if (!test_framework_has_auth ()) { return 0; } return 1; } static bool _test_framework_has_crypto (void) { #ifdef MONGOC_ENABLE_CRYPTO return true; #else return false; #endif } int test_framework_skip_if_no_sessions (void) { if (!TestSuite_CheckLive ()) { return 0; } if (!_test_framework_has_crypto ()) { return 0; } return -1 != test_framework_session_timeout_minutes (); } int test_framework_skip_if_no_cluster_time (void) { if (!TestSuite_CheckLive ()) { return 0; } return test_framework_clustertime_supported () ? 1 : 0; } int test_framework_skip_if_crypto (void) { return _test_framework_has_crypto () ? 0 : 1; } int test_framework_skip_if_no_crypto (void) { return test_framework_skip_if_crypto () ? 0 : 1; } int test_framework_skip_if_offline (void) { return test_framework_getenv_bool ("MONGOC_TEST_OFFLINE") ? 0 : 1; } int test_framework_skip_if_rhel8_zseries (void) { /* CDRIVER-3923: It appears that when running on RHEL8 on zSeries the * /server_discovery_and_monitoring/monitoring/heartbeat/pooled/dns test * fails. The best guess is that calling getaddrinfo() on that platform * blocks for 5 seconds, while the test expects a server selection error * after 3000 ms, or 3 seconds. Skip the test when executing on RHEL8 on * zSeries. */ #ifdef __s390x__ char *name; char *version; _mongoc_linux_distro_scanner_get_distro (&name, &version); bool rhel = strcmp (name, "Red Hat Enterprise Linux") == 0; bool vers8 = version[0] == '8'; int skip = (rhel && vers8) ? 0 : 1; bson_free (name); bson_free (version); return skip; #else return 1; #endif } int test_framework_skip_if_slow (void) { return test_framework_getenv_bool ("MONGOC_TEST_SKIP_SLOW") ? 0 : 1; } int test_framework_skip_if_slow_or_live (void) { return test_framework_skip_if_slow () && TestSuite_CheckLive (); } int test_framework_skip_if_valgrind (void) { return test_suite_valgrind () ? 0 : 1; } int test_framework_skip_if_windows (void) { #ifdef _WIN32 return 0; #else return 1; #endif } /* skip if no Unix domain socket */ int test_framework_skip_if_no_uds (void) { #ifdef _WIN32 return 0; #else char *path; int ret; if (!TestSuite_CheckLive ()) { return 0; } path = test_framework_get_unix_domain_socket_path (); ret = access (path, R_OK | W_OK) == 0 ? 1 : 0; bson_free (path); return ret; #endif } int test_framework_skip_if_no_txns (void) { if (test_framework_skip_if_no_crypto () && test_framework_skip_if_no_sessions () && test_framework_skip_if_not_replset () && test_framework_skip_if_max_wire_version_less_than_7 ()) { return 1; } if (test_framework_skip_if_no_crypto () && test_framework_skip_if_no_sessions () && test_framework_skip_if_not_mongos () && test_framework_skip_if_max_wire_version_less_than_8 ()) { return 1; } /* transactions not supported, skip the test */ return 0; } bool test_framework_max_wire_version_at_least (int version) { int64_t max_version; BSON_ASSERT (version > 0); test_framework_get_max_wire_version (&max_version); return max_version >= version; } int64_t test_framework_max_write_batch_size (void) { bson_t reply; bson_iter_t iter; int64_t size; call_hello (&reply); if (bson_iter_init_find (&iter, &reply, "maxWriteBatchSize")) { size = bson_iter_as_int64 (&iter); } else { size = 1000; } bson_destroy (&reply); return size; } #define N_SERVER_VERSION_PARTS 3 static server_version_t _parse_server_version (const bson_t *buildinfo) { bson_iter_t iter; bson_iter_t array_iter; int i; server_version_t ret = 0; ASSERT (bson_iter_init_find (&iter, buildinfo, "versionArray")); ASSERT (bson_iter_recurse (&iter, &array_iter)); /* Server returns a 4-part version like [3, 2, 0, 0], or like [3, 2, 0, -49] * for an RC. Ignore the 4th part since RCs are equivalent to non-RCs for * testing purposes. */ for (i = 0; i < N_SERVER_VERSION_PARTS && bson_iter_next (&array_iter); i++) { ret *= 1000; ret += 100 + bson_iter_as_int64 (&array_iter); } ASSERT_CMPINT (i, ==, N_SERVER_VERSION_PARTS); return ret; } server_version_t test_framework_get_server_version_with_client (mongoc_client_t *client) { bson_t reply; bson_error_t error; server_version_t ret = 0; ASSERT_OR_PRINT ( mongoc_client_command_simple ( client, "admin", tmp_bson ("{'buildinfo': 1}"), NULL, &reply, &error), error); ret = _parse_server_version (&reply); bson_destroy (&reply); return ret; } server_version_t test_framework_get_server_version (void) { mongoc_client_t *client; server_version_t ret = 0; client = test_framework_new_default_client (); ret = test_framework_get_server_version_with_client (client); mongoc_client_destroy (client); return ret; } server_version_t test_framework_str_to_version (const char *version_str) { char *str_copy; char *part; char *end; int i; server_version_t ret = 0; str_copy = bson_strdup (version_str); part = strtok (str_copy, "."); /* Versions can have 4 parts like "3.2.0.0", or like "3.2.0.-49" for an RC. * Ignore the 4th part since RCs are equivalent to non-RCs for testing * purposes. */ for (i = 0; i < N_SERVER_VERSION_PARTS && part; i++) { ret *= 1000; ret += 100 + bson_ascii_strtoll (part, &end, 10); part = strtok (NULL, "."); } /* pad out a short version like "3.0" to three parts */ for (; i < N_SERVER_VERSION_PARTS; i++) { ret *= 1000; ret += 100; } bson_free (str_copy); return ret; } /* self-tests for a test framework feature */ static void test_version_cmp (void) { server_version_t v2_6_12 = 102106112; server_version_t v3_0_0 = 103100100; server_version_t v3_0_1 = 103100101; server_version_t v3_0_10 = 103100110; server_version_t v3_2_0 = 103102100; ASSERT (v2_6_12 == test_framework_str_to_version ("2.6.12")); ASSERT (v2_6_12 == _parse_server_version ( tmp_bson ("{'versionArray': [2, 6, 12, 0]}"))); ASSERT (v3_0_0 == test_framework_str_to_version ("3")); ASSERT (v3_0_0 == _parse_server_version (tmp_bson ("{'versionArray': [3, 0, 0, 0]}"))); ASSERT (v3_0_1 == test_framework_str_to_version ("3.0.1")); ASSERT (v3_0_1 == _parse_server_version (tmp_bson ("{'versionArray': [3, 0, 1, 0]}"))); ASSERT (v3_0_10 == test_framework_str_to_version ("3.0.10")); ASSERT (v3_0_10 == _parse_server_version ( tmp_bson ("{'versionArray': [3, 0, 10, 0]}"))); /* release candidates should be equivalent to non-rcs. */ ASSERT (v3_2_0 == test_framework_str_to_version ("3.2.0.-49")); ASSERT (v3_2_0 == _parse_server_version ( tmp_bson ("{'versionArray': [3, 2, 0, -49]}"))); ASSERT (v3_2_0 > test_framework_str_to_version ("3.1.9")); ASSERT (v3_2_0 == test_framework_str_to_version ("3.2")); ASSERT (v3_2_0 < test_framework_str_to_version ("3.2.1")); } int test_framework_skip_if_single (void) { if (!TestSuite_CheckLive ()) { return 0; } return (test_framework_is_mongos () || test_framework_is_replset ()); } int test_framework_skip_if_no_mongohouse (void) { if (!getenv ("RUN_MONGOHOUSE_TESTS")) { return 0; } return 1; } int test_framework_skip_if_mongos (void) { if (!TestSuite_CheckLive ()) { return 0; } return test_framework_is_mongos () ? 0 : 1; } int test_framework_skip_if_replset (void) { if (!TestSuite_CheckLive ()) { return 0; } return test_framework_is_replset () ? 0 : 1; } int test_framework_skip_if_not_single (void) { if (!TestSuite_CheckLive ()) { return 0; } return !test_framework_skip_if_single (); } int test_framework_skip_if_not_mongos (void) { if (!TestSuite_CheckLive ()) { return 0; } return !test_framework_skip_if_mongos (); } int test_framework_skip_if_not_replset (void) { if (!TestSuite_CheckLive ()) { return 0; } return !test_framework_skip_if_replset (); } /* convenience skip functions based on the wire version. */ #define WIRE_VERSION_CHECKS(wv) \ int test_framework_skip_if_max_wire_version_more_than_##wv () \ { \ if (!TestSuite_CheckLive ()) { \ return 0; \ } \ return test_framework_max_wire_version_at_least (wv + 1) ? 0 : 1; \ } \ int test_framework_skip_if_max_wire_version_less_than_##wv () \ { \ if (!TestSuite_CheckLive ()) { \ return 0; \ } \ return test_framework_max_wire_version_at_least (wv); \ } \ int test_framework_skip_if_not_rs_version_##wv (void) \ { \ if (!TestSuite_CheckLive ()) { \ return 0; \ } \ return (test_framework_max_wire_version_at_least (wv) && \ test_framework_is_replset ()) \ ? 1 \ : 0; \ } \ int test_framework_skip_if_rs_version_##wv (void) \ { \ if (!TestSuite_CheckLive ()) { \ return 0; \ } \ return (test_framework_max_wire_version_at_least (wv) && \ test_framework_is_replset ()) \ ? 0 \ : 1; \ } WIRE_VERSION_CHECKS (6) WIRE_VERSION_CHECKS (7) WIRE_VERSION_CHECKS (8) WIRE_VERSION_CHECKS (9) /* wire versions 10, 11, 12 were internal to the 5.0 release cycle */ WIRE_VERSION_CHECKS (13) /* wire version 14 begins with the 5.1 prerelease. */ WIRE_VERSION_CHECKS (14) /* wire version 17 begins with the 6.0 release. */ WIRE_VERSION_CHECKS (17) int test_framework_skip_if_no_dual_ip_hostname (void) { struct addrinfo hints = {0}, *res = NULL, *iter; int res_count = 0; char *host = test_framework_getenv ("MONGOC_TEST_IPV4_AND_IPV6_HOST"); bool needs_free = false; if (host) { needs_free = true; } else { host = "localhost"; } hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = 0; hints.ai_protocol = 0; BSON_ASSERT (getaddrinfo (host, "27017", &hints, &res) != -1); iter = res; while (iter) { res_count++; iter = iter->ai_next; } freeaddrinfo (res); if (needs_free) { bson_free (host); } ASSERT_CMPINT (res_count, >, 0); return res_count > 1; } int test_framework_skip_if_no_compressors (void) { char *compressors = test_framework_get_compressors (); bool ret = compressors != NULL; bson_free (compressors); return ret; } int test_framework_skip_if_compressors (void) { return !test_framework_skip_if_no_compressors (); } int test_framework_skip_if_no_failpoint (void) { mongoc_client_t *client; bool ret; bson_error_t error; if (!TestSuite_CheckLive ()) { return 0; } client = test_framework_new_default_client (); mongoc_client_set_error_api (client, MONGOC_ERROR_API_VERSION_2); ret = mongoc_client_command_simple ( client, "admin", tmp_bson ("{'configureFailPoint': 'failCommand', 'mode': 'off', 'data': " "{'errorCode': 10107, 'failCommands': ['count']}}"), NULL, NULL, &error); mongoc_client_destroy (client); if (!ret) { return 0; /* do not proceed */ } /* proceed. */ return 1; } int test_framework_skip_if_no_client_side_encryption (void) { const char *required_env_vars[] = { "MONGOC_TEST_AWS_SECRET_ACCESS_KEY", "MONGOC_TEST_AWS_ACCESS_KEY_ID", "MONGOC_TEST_AZURE_TENANT_ID", "MONGOC_TEST_AZURE_CLIENT_ID", "MONGOC_TEST_AZURE_CLIENT_SECRET", "MONGOC_TEST_GCP_EMAIL", "MONGOC_TEST_GCP_PRIVATEKEY", "MONGOC_TEST_CSFLE_TLS_CA_FILE", "MONGOC_TEST_CSFLE_TLS_CERTIFICATE_KEY_FILE", NULL}; const char **iter; bool has_creds = true; for (iter = required_env_vars; *iter != NULL; iter++) { char *val; val = test_framework_getenv (*iter); if (!val) { MONGOC_DEBUG ("%s not defined", *iter); has_creds = false; break; } bson_free (val); } if (has_creds) { #ifdef MONGOC_ENABLE_CLIENT_SIDE_ENCRYPTION return 1; /* 1 == proceed. */ #else return 0; /* 0 == do not proceed. */ #endif } return 0; /* 0 == do not proceed. */ } int test_framework_skip_if_no_aws (void) { #ifdef MONGOC_ENABLE_MONGODB_AWS_AUTH return 1; /* proceed. */ #else return 0; /* do not proceed. */ #endif } /* test-libmongoc may not have permissions to set environment variables. */ int test_framework_skip_if_no_setenv (void) { char *value; if (!test_framework_setenv ("MONGOC_TEST_CANARY", "VALUE")) { return 0; /* do not proceed. */ } value = test_framework_getenv ("MONGOC_TEST_CANARY"); if (!value || 0 != strcmp (value, "VALUE")) { return 0; /* do not proceed. */ } bson_free (value); return 1; } bool test_framework_is_serverless (void) { return test_framework_getenv_bool ("MONGOC_TEST_IS_SERVERLESS"); } int test_framework_skip_if_time_sensitive (void) { if (test_suite_valgrind ()) { return 0; } /* Skip time sensitive tests on macOS per CDRIVER-3549. */ #ifdef __APPLE__ return 0; #else return 1; #endif } int test_framework_skip_due_to_cdriver3708 (void) { if (0 == test_framework_skip_if_auth () && 0 == test_framework_skip_if_replset () && test_framework_get_server_version () > test_framework_str_to_version ("4.4.0")) { /* If auth is enabled, we're using a replica set, and using a > 4.4 * server, skip test. */ return 0; } return 1; } static char MONGOC_TEST_UNIQUE[32]; #if defined(_MSC_VER) && defined(_WIN64) LONG WINAPI windows_exception_handler (EXCEPTION_POINTERS *pExceptionInfo) { HANDLE process = GetCurrentProcess (); fprintf (stderr, "entering windows exception handler\n"); SymInitialize (process, NULL, TRUE); /* Shamelessly stolen from https://stackoverflow.com/a/28115589 */ /* StackWalk64() may modify context record passed to it, so we will use a copy. */ CONTEXT context_record = *pExceptionInfo->ContextRecord; DWORD exception_code = pExceptionInfo->ExceptionRecord->ExceptionCode; /* Initialize stack walking. */ char exception_string[128]; bson_snprintf (exception_string, sizeof (exception_string), (exception_code == EXCEPTION_ACCESS_VIOLATION) ? "(access violation)" : "0x%08X", exception_code); char address_string[32]; bson_snprintf (address_string, sizeof (address_string), "0x%p", pExceptionInfo->ExceptionRecord->ExceptionAddress); fprintf (stderr, "exception '%s' at '%s', terminating\n", exception_string, address_string); STACKFRAME64 stack_frame; memset (&stack_frame, 0, sizeof (stack_frame)); #if defined(_WIN64) int machine_type = IMAGE_FILE_MACHINE_AMD64; stack_frame.AddrPC.Offset = context_record.Rip; stack_frame.AddrFrame.Offset = context_record.Rbp; stack_frame.AddrStack.Offset = context_record.Rsp; #else int machine_type = IMAGE_FILE_MACHINE_I386; stack_frame.AddrPC.Offset = context_record.Eip; stack_frame.AddrFrame.Offset = context_record.Ebp; stack_frame.AddrStack.Offset = context_record.Esp; #endif stack_frame.AddrPC.Mode = AddrModeFlat; stack_frame.AddrFrame.Mode = AddrModeFlat; stack_frame.AddrStack.Mode = AddrModeFlat; SYMBOL_INFO *symbol; symbol = calloc (sizeof (SYMBOL_INFO) + 256, 1); symbol->MaxNameLen = 255; symbol->SizeOfStruct = sizeof (SYMBOL_INFO); fprintf (stderr, "begin stack trace\n"); while (StackWalk64 (machine_type, GetCurrentProcess (), GetCurrentThread (), &stack_frame, &context_record, NULL, &SymFunctionTableAccess64, &SymGetModuleBase64, NULL)) { DWORD64 displacement = 0; if (SymFromAddr (process, (DWORD64) stack_frame.AddrPC.Offset, &displacement, symbol)) { IMAGEHLP_MODULE64 moduleInfo; memset (&moduleInfo, 0, sizeof (moduleInfo)); moduleInfo.SizeOfStruct = sizeof (moduleInfo); if (SymGetModuleInfo64 (process, symbol->ModBase, &moduleInfo)) fprintf (stderr, "%s : ", moduleInfo.ModuleName); fprintf (stderr, "%s", symbol->Name); } IMAGEHLP_LINE line; line.SizeOfStruct = sizeof (IMAGEHLP_LINE); DWORD offset_ln = 0; if (SymGetLineFromAddr ( process, (DWORD64) stack_frame.AddrPC.Offset, &offset_ln, &line)) { fprintf (stderr, " %s:%d ", line.FileName, line.LineNumber); } fprintf (stderr, "\n"); } fprintf (stderr, "end stack trace\n"); fflush (stderr); return EXCEPTION_EXECUTE_HANDLER; } #endif int main (int argc, char *argv[]) { TestSuite suite; int ret; #if defined(_MSC_VER) && defined(_WIN64) SetUnhandledExceptionFilter (windows_exception_handler); #endif mongoc_init (); bson_snprintf (MONGOC_TEST_UNIQUE, sizeof MONGOC_TEST_UNIQUE, "test_%u_%u", (unsigned) time (NULL), (unsigned) gettestpid ()); bson_mutex_init (&captured_logs_mutex); _mongoc_array_init (&captured_logs, sizeof (log_entry_t *)); mongoc_log_set_handler (log_handler, (void *) &suite); #ifdef MONGOC_ENABLE_SSL test_framework_global_ssl_opts_init (); atexit (test_framework_global_ssl_opts_cleanup); #endif TestSuite_Init (&suite, "", argc, argv); TestSuite_Add (&suite, "/TestSuite/version_cmp", test_version_cmp); /* libbson */ test_atomic_install (&suite); test_bcon_basic_install (&suite); test_bcon_extract_install (&suite); test_bson_corpus_install (&suite); test_bson_error_install (&suite); test_bson_install (&suite); test_bson_version_install (&suite); test_clock_install (&suite); test_decimal128_install (&suite); test_endian_install (&suite); test_iso8601_install (&suite); test_iter_install (&suite); test_json_install (&suite); test_oid_install (&suite); test_reader_install (&suite); test_string_install (&suite); test_utf8_install (&suite); test_value_install (&suite); test_writer_install (&suite); test_b64_install (&suite); test_bson_cmp_install (&suite); /* libmongoc */ test_aggregate_install (&suite); test_array_install (&suite); test_async_install (&suite); test_buffer_install (&suite); test_change_stream_install (&suite); test_client_install (&suite); test_client_max_staleness_install (&suite); test_client_hedged_reads_install (&suite); test_client_pool_install (&suite); test_client_cmd_install (&suite); test_client_versioned_api_install (&suite); test_write_command_install (&suite); test_bulk_install (&suite); test_cluster_install (&suite); test_collection_install (&suite); test_collection_find_install (&suite); test_collection_find_with_opts_install (&suite); test_connection_uri_install (&suite); test_command_monitoring_install (&suite); test_cursor_install (&suite); test_database_install (&suite); test_error_install (&suite); test_exhaust_install (&suite); test_find_and_modify_install (&suite); test_gridfs_install (&suite); test_gridfs_bucket_install (&suite); test_gridfs_file_page_install (&suite); test_handshake_install (&suite); test_linux_distro_scanner_install (&suite); test_list_install (&suite); test_log_install (&suite); test_long_namespace_install (&suite); test_matcher_install (&suite); test_mongos_pinning_install (&suite); test_queue_install (&suite); test_primary_stepdown_install (&suite); test_read_concern_install (&suite); test_read_write_concern_install (&suite); test_read_prefs_install (&suite); test_retryable_writes_install (&suite); test_retryable_reads_install (&suite); test_rpc_install (&suite); test_socket_install (&suite); test_opts_install (&suite); test_topology_scanner_install (&suite); test_topology_reconcile_install (&suite); test_transactions_install (&suite); test_samples_install (&suite); test_scram_install (&suite); test_sdam_install (&suite); test_sdam_monitoring_install (&suite); test_server_selection_install (&suite); test_dns_install (&suite); test_server_selection_errors_install (&suite); test_session_install (&suite); test_set_install (&suite); test_speculative_auth_install (&suite); test_stream_install (&suite); test_thread_install (&suite); test_topology_install (&suite); test_topology_description_install (&suite); test_ts_pool_install (&suite); test_uri_install (&suite); test_usleep_install (&suite); test_util_install (&suite); test_version_install (&suite); test_with_transaction_install (&suite); test_write_concern_install (&suite); #ifdef MONGOC_ENABLE_SSL test_stream_tls_install (&suite); test_x509_install (&suite); test_stream_tls_error_install (&suite); test_client_side_encryption_install (&suite); #endif #ifdef MONGOC_ENABLE_SASL_CYRUS test_cyrus_install (&suite); #endif test_happy_eyeballs_install (&suite); test_counters_install (&suite); test_crud_install (&suite); test_mongohouse_install (&suite); test_apm_install (&suite); test_server_description_install (&suite); test_aws_install (&suite); test_streamable_hello_install (&suite); #if defined(MONGOC_ENABLE_OCSP_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10101000L test_ocsp_cache_install (&suite); #endif test_interrupt_install (&suite); test_monitoring_install (&suite); test_http_install (&suite); test_install_unified (&suite); test_timeout_install (&suite); test_bson_match_install (&suite); test_bson_util_install (&suite); test_result_install (&suite); test_loadbalanced_install (&suite); test_server_stream_install (&suite); test_generation_map_install (&suite); test_shared_install (&suite); test_ssl_install (&suite); if (test_framework_is_loadbalanced ()) { mongoc_global_mock_service_id = true; } ret = TestSuite_Run (&suite); TestSuite_Destroy (&suite); capture_logs (false); /* clear entries */ _mongoc_array_destroy (&captured_logs); mongoc_cleanup (); return ret; } /* * test_framework_skip_if_no_legacy_opcodes returns 0 if the connected server * does not support legacy wire protocol op codes. * * As of SERVER-57457 and SERVER-57391, the following legacy wire protocol * op codes have been removed in the server 5.1: * - OP_KILL_CURSORS * - OP_INSERT * - OP_UPDATE * - OP_DELETE * - OP_GET_MORE * - OP_QUERY (for any command other than isMaster, which drivers use to * initially discover the min/max wire version of a server) */ bool test_framework_supports_legacy_opcodes (void) { /* Wire v14+ removed legacy opcodes */ return test_framework_skip_if_max_wire_version_less_than_14 () == 0; } int test_framework_skip_if_no_legacy_opcodes (void) { if (!TestSuite_CheckLive ()) { return 0; } if (test_framework_supports_legacy_opcodes ()) { return 1; } return 0; } /* SERVER-57390 removed the getLastError command on 5.1 servers. */ int test_framework_skip_if_no_getlasterror (void) { if (!TestSuite_CheckLive ()) { return 0; } if (test_framework_supports_legacy_opcodes ()) { return 1; } return 0; } bool test_framework_is_loadbalanced (void) { return test_framework_getenv_bool ("MONGOC_TEST_LOADBALANCED") || test_framework_getenv_bool ("MONGOC_TEST_DNS_LOADBALANCED"); }