static void
test_read_concern_always_mutable (void)
{
mongoc_read_concern_t *read_concern;
read_concern = mongoc_read_concern_new ();
ASSERT (read_concern);
mongoc_read_concern_set_level (read_concern,
MONGOC_READ_CONCERN_LEVEL_LOCAL);
ASSERT_MATCH (_mongoc_read_concern_get_bson (read_concern),
"{'level': 'local'}");
mongoc_read_concern_set_level (read_concern,
MONGOC_READ_CONCERN_LEVEL_MAJORITY);
ASSERT_MATCH (_mongoc_read_concern_get_bson (read_concern),
"{'level': 'majority'}");
mongoc_read_concern_set_level (read_concern,
MONGOC_READ_CONCERN_LEVEL_LINEARIZABLE);
ASSERT_MATCH (_mongoc_read_concern_get_bson (read_concern),
"{'level': 'linearizable'}");
mongoc_read_concern_destroy (read_concern);
}
static void
test_read_concern_basic (void)
{
mongoc_read_concern_t *read_concern;
read_concern = mongoc_read_concern_new ();
BEGIN_IGNORE_DEPRECATIONS;
/*
* Test defaults.
*/
ASSERT (read_concern);
ASSERT (mongoc_read_concern_is_default (read_concern));
ASSERT (!mongoc_read_concern_get_level (read_concern));
/*
* Test changes to level.
*/
mongoc_read_concern_set_level (read_concern,
MONGOC_READ_CONCERN_LEVEL_LOCAL);
ASSERT (!mongoc_read_concern_is_default (read_concern));
ASSERT_CMPSTR (mongoc_read_concern_get_level (read_concern),
MONGOC_READ_CONCERN_LEVEL_LOCAL);
/*
* Check generated bson.
*/
ASSERT_MATCH (_mongoc_read_concern_get_bson (read_concern),
"{'level': 'local'}");
mongoc_read_concern_destroy (read_concern);
}
static void
_test_read_concern_wire_version (bool allow, bool explicit)
{
mongoc_read_concern_t *rc;
bson_t opts = BSON_INITIALIZER;
mock_server_t *server;
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
future_t *future;
request_t *request;
bson_error_t error;
rc = mongoc_read_concern_new ();
mongoc_read_concern_set_level (rc, "foo");
server = mock_server_with_autoismaster (
allow ? WIRE_VERSION_READ_CONCERN : WIRE_VERSION_READ_CONCERN - 1);
mock_server_run (server);
client = mongoc_client_new_from_uri (mock_server_get_uri (server));
collection = mongoc_client_get_collection (client, "db", "collection");
if (explicit) {
mongoc_read_concern_append (rc, &opts);
} else {
void HHVM_METHOD(MongoDBDriverReadConcern, __construct, const Variant &level)
{
MongoDBDriverReadConcernData* data = Native::data<MongoDBDriverReadConcernData>(this_);
data->m_read_concern = mongoc_read_concern_new();
if (!level.isNull()) {
mongoc_read_concern_set_level(data->m_read_concern, level.toString().c_str());
}
}
static bool hippo_mongo_driver_manager_apply_rc(mongoc_uri_t *uri, const Array options)
{
mongoc_read_concern_t *new_rc;
const mongoc_read_concern_t *old_rc;
const char *rc_str = NULL;
if (!(old_rc = mongoc_uri_get_read_concern(uri))) {
throw MongoDriver::Utils::throwRunTimeException("mongoc_uri_t does not have a read concern");
return false;
}
if (options.size() == 0) {
return true;
}
if (
!options.exists(s_MongoDBDriverManager_readConcernLevel) &&
!options.exists(s_MongoDBDriverManager_readconcernlevel)
) {
return true;
}
new_rc = mongoc_read_concern_copy(old_rc);
if (options.exists(s_MongoDBDriverManager_readconcernlevel) && options[s_MongoDBDriverManager_readconcernlevel].isString()) {
rc_str = options[s_MongoDBDriverManager_readconcernlevel].toString().c_str();
}
if (options.exists(s_MongoDBDriverManager_readConcernLevel) && options[s_MongoDBDriverManager_readConcernLevel].isString()) {
rc_str = options[s_MongoDBDriverManager_readConcernLevel].toString().c_str();
}
if (rc_str) {
mongoc_read_concern_set_level(new_rc, rc_str);
}
mongoc_uri_set_read_concern(uri, new_rc);
mongoc_read_concern_destroy(new_rc);
return true;
}
static void
test_read_concern_append (void)
{
mongoc_read_concern_t *rc;
bson_t *cmd;
cmd = tmp_bson ("{'foo': 1}");
/* append default readConcern */
rc = mongoc_read_concern_new ();
ASSERT (mongoc_read_concern_is_default (rc));
ASSERT_MATCH (cmd, "{'foo': 1, 'readConcern': {'$exists': false}}");
/* append readConcern with level */
mongoc_read_concern_set_level (rc, MONGOC_READ_CONCERN_LEVEL_LOCAL);
ASSERT (mongoc_read_concern_append (rc, cmd));
ASSERT_MATCH (cmd, "{'foo': 1, 'readConcern': {'level': 'local'}}");
mongoc_read_concern_destroy (rc);
}
static bool
mongoc_uri_parse_option (mongoc_uri_t *uri,
const char *str)
{
int32_t v_int;
const char *end_key;
char *key = NULL;
char *value = NULL;
bool ret = false;
if (!(key = scan_to_unichar(str, '=', "", &end_key))) {
goto CLEANUP;
}
value = bson_strdup(end_key + 1);
mongoc_uri_do_unescape(&value);
if (!value) {
/* do_unescape detected invalid UTF-8 and freed value */
goto CLEANUP;
}
if (mongoc_uri_option_is_int32(key)) {
v_int = (int) strtol (value, NULL, 10);
BSON_APPEND_INT32 (&uri->options, key, v_int);
} else if (!strcasecmp(key, "w")) {
if (*value == '-' || isdigit(*value)) {
v_int = (int) strtol (value, NULL, 10);
BSON_APPEND_INT32 (&uri->options, "w", v_int);
} else if (0 == strcasecmp (value, "majority")) {
BSON_APPEND_UTF8 (&uri->options, "w", "majority");
} else if (*value) {
BSON_APPEND_UTF8 (&uri->options, "w", value);
}
} else if (mongoc_uri_option_is_bool(key)) {
bson_append_bool (&uri->options, key, -1,
(0 == strcasecmp (value, "true")) ||
(0 == strcasecmp (value, "t")) ||
(0 == strcmp (value, "1")));
} else if (!strcasecmp(key, "readpreferencetags")) {
mongoc_uri_parse_tags(uri, value);
} else if (!strcasecmp(key, "authmechanism") ||
!strcasecmp(key, "authsource")) {
bson_append_utf8(&uri->credentials, key, -1, value, -1);
} else if (!strcasecmp(key, "readconcernlevel")) {
mongoc_read_concern_set_level (uri->read_concern, value);
} else if (!strcasecmp(key, "authmechanismproperties")) {
if (!mongoc_uri_parse_auth_mechanism_properties(uri, value)) {
goto CLEANUP;
}
#ifdef MONGOC_EXPERIMENTAL_FEATURES
} else if (!strcasecmp (key, "appname")) {
if (!mongoc_uri_set_appname (uri, value)) {
MONGOC_WARNING ("Cannot set appname: %s is invalid", value);
goto CLEANUP;
}
#endif
} else {
bson_append_utf8(&uri->options, key, -1, value, -1);
}
ret = true;
CLEANUP:
bson_free(key);
bson_free(value);
return ret;
}
