static void
test_write_concern_bson_includes_false_fsync_and_journal (void)
{
mongoc_write_concern_t *write_concern;
const bson_t *gle;
const bson_t *bson;
bson_iter_t iter;
write_concern = mongoc_write_concern_new();
/*
* Check generated bson.
*/
ASSERT(write_concern);
mongoc_write_concern_set_fsync(write_concern, false);
mongoc_write_concern_set_journal(write_concern, false);
gle = _mongoc_write_concern_get_gle(write_concern);
ASSERT(bson_iter_init_find(&iter, gle, "getlasterror") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 1);
ASSERT(bson_iter_init_find(&iter, gle, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, gle, "j") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));
ASSERT(!bson_iter_init_find(&iter, gle, "w"));
ASSERT(gle);
bson = _mongoc_write_concern_get_bson(write_concern);
ASSERT(!bson_iter_init_find(&iter, bson, "getlasterror"));
ASSERT(bson_iter_init_find(&iter, bson, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, bson, "j") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));
ASSERT(!bson_iter_init_find(&iter, bson, "w"));
ASSERT(bson);
mongoc_write_concern_destroy(write_concern);
}
void
mongoc_uri_destroy (mongoc_uri_t *uri)
{
mongoc_host_list_t *tmp;
if (uri) {
while (uri->hosts) {
tmp = uri->hosts;
uri->hosts = tmp->next;
bson_free(tmp);
}
bson_free(uri->str);
bson_free(uri->database);
bson_free(uri->username);
bson_destroy(&uri->options);
bson_destroy(&uri->read_prefs);
mongoc_write_concern_destroy(uri->write_concern);
if (uri->password) {
bson_zero_free(uri->password, strlen(uri->password));
}
bson_free(uri);
}
}
static void
test_write_concern_bson_omits_defaults (void)
{
mongoc_write_concern_t *write_concern;
const bson_t *gle;
const bson_t *bson;
bson_iter_t iter;
write_concern = mongoc_write_concern_new();
/*
* Check generated bson.
*/
ASSERT(write_concern);
gle = _mongoc_write_concern_get_gle(write_concern);
ASSERT(bson_iter_init_find(&iter, gle, "getlasterror") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 1);
ASSERT(!bson_iter_init_find(&iter, gle, "fsync"));
ASSERT(!bson_iter_init_find(&iter, gle, "j"));
ASSERT(!bson_iter_init_find(&iter, gle, "w"));
ASSERT(gle);
bson = _mongoc_write_concern_get_bson(write_concern);
ASSERT(!bson_iter_init_find(&iter, bson, "getlasterror"));
ASSERT(!bson_iter_init_find(&iter, bson, "fsync"));
ASSERT(!bson_iter_init_find(&iter, bson, "j"));
ASSERT(!bson_iter_init_find(&iter, gle, "w"));
ASSERT(bson);
mongoc_write_concern_destroy(write_concern);
}
void
mongoc_database_destroy (mongoc_database_t *database)
{
ENTRY;
BSON_ASSERT (database);
if (database->read_prefs) {
mongoc_read_prefs_destroy(database->read_prefs);
database->read_prefs = NULL;
}
if (database->read_concern) {
mongoc_read_concern_destroy(database->read_concern);
database->read_concern = NULL;
}
if (database->write_concern) {
mongoc_write_concern_destroy(database->write_concern);
database->write_concern = NULL;
}
bson_free(database);
EXIT;
}
static void
test_write_concern_wtimeout_validity (void)
{
mongoc_write_concern_t *write_concern = mongoc_write_concern_new();
/* Test defaults */
ASSERT(write_concern);
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(mongoc_write_concern_get_wtimeout(write_concern) == 0);
ASSERT(!mongoc_write_concern_get_wmajority(write_concern));
/* mongoc_write_concern_set_wtimeout() ignores invalid wtimeout */
mongoc_write_concern_set_wtimeout(write_concern, -1);
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(mongoc_write_concern_get_wtimeout(write_concern) == 0);
ASSERT(!mongoc_write_concern_get_wmajority(write_concern));
ASSERT(mongoc_write_concern_is_valid (write_concern));
/* mongoc_write_concern_set_wmajority() ignores invalid wtimeout */
mongoc_write_concern_set_wmajority(write_concern, -1);
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_MAJORITY);
ASSERT(mongoc_write_concern_get_wtimeout(write_concern) == 0);
ASSERT(mongoc_write_concern_get_wmajority(write_concern));
ASSERT(mongoc_write_concern_is_valid (write_concern));
/* Manually assigning a negative wtimeout will make the write concern invalid */
write_concern->wtimeout = -1;
ASSERT(!mongoc_write_concern_is_valid (write_concern));
mongoc_write_concern_destroy(write_concern);
}
void
mongoc_bulk_operation_destroy (mongoc_bulk_operation_t *bulk) /* IN */
{
mongoc_write_command_t *command;
int i;
if (bulk) {
for (i = 0; i < bulk->commands.len; i++) {
command = &_mongoc_array_index (&bulk->commands,
mongoc_write_command_t, i);
_mongoc_write_command_destroy (command);
}
bson_free (bulk->database);
bson_free (bulk->collection);
mongoc_write_concern_destroy (bulk->write_concern);
_mongoc_array_destroy (&bulk->commands);
if (bulk->executed) {
_mongoc_write_result_destroy (&bulk->result);
}
bson_free (bulk);
}
}
static void
test_write_concern_basic (void)
{
mongoc_write_concern_t *write_concern;
const bson_t *b;
bson_iter_t iter;
write_concern = mongoc_write_concern_new();
/*
* Test defaults.
*/
assert(write_concern);
assert(!mongoc_write_concern_get_fsync(write_concern));
assert(!mongoc_write_concern_get_journal(write_concern));
assert(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
assert(!mongoc_write_concern_get_wtimeout(write_concern));
assert(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_fsync(write_concern, TRUE);
assert(mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_fsync(write_concern, FALSE);
assert(!mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_journal(write_concern, TRUE);
assert(mongoc_write_concern_get_journal(write_concern));
mongoc_write_concern_set_journal(write_concern, FALSE);
assert(!mongoc_write_concern_get_journal(write_concern));
/*
* Test changes to w.
*/
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY);
assert(mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
assert(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_wmajority(write_concern, 1000);
assert(mongoc_write_concern_get_wmajority(write_concern));
assert(mongoc_write_concern_get_wtimeout(write_concern) == 1000);
mongoc_write_concern_set_wtimeout(write_concern, 0);
assert(!mongoc_write_concern_get_wtimeout(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
assert(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
mongoc_write_concern_set_w(write_concern, 3);
assert(mongoc_write_concern_get_w(write_concern) == 3);
/*
* Check generated bson.
*/
mongoc_write_concern_set_fsync(write_concern, TRUE);
mongoc_write_concern_set_journal(write_concern, TRUE);
b = _mongoc_write_concern_freeze(write_concern);
assert(bson_iter_init_find(&iter, b, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
assert(bson_iter_init_find(&iter, b, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
assert(bson_iter_init_find(&iter, b, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);
assert(b);
mongoc_write_concern_destroy(write_concern);
}
void
mongoc_transaction_opts_set_write_concern (
mongoc_transaction_opt_t *opts, const mongoc_write_concern_t *write_concern)
{
BSON_ASSERT (opts);
mongoc_write_concern_destroy (opts->write_concern);
opts->write_concern = mongoc_write_concern_copy (write_concern);
}
void
mongoc_uri_set_write_concern (mongoc_uri_t *uri,
const mongoc_write_concern_t *wc)
{
BSON_ASSERT (uri);
BSON_ASSERT (wc);
mongoc_write_concern_destroy (uri->write_concern);
uri->write_concern = mongoc_write_concern_copy (wc);
}
static void
test_invalid_write_concern (void)
{
mongoc_bulk_write_flags_t write_flags = MONGOC_BULK_WRITE_FLAGS_INIT;
mongoc_write_command_t command;
mongoc_write_result_t result;
mongoc_collection_t *collection;
mongoc_client_t *client;
mongoc_write_concern_t *write_concern;
mongoc_server_stream_t *server_stream;
bson_t *doc;
bson_t reply = BSON_INITIALIZER;
bson_error_t error;
bool r;
client = test_framework_client_new ();
assert(client);
collection = get_test_collection(client, "test_invalid_write_concern");
assert(collection);
write_concern = mongoc_write_concern_new();
assert(write_concern);
mongoc_write_concern_set_w(write_concern, 0);
mongoc_write_concern_set_journal(write_concern, true);
assert(!mongoc_write_concern_is_valid (write_concern));
doc = BCON_NEW("_id", BCON_INT32(0));
_mongoc_write_command_init_insert(&command, doc, write_flags,
++client->cluster.operation_id, true);
_mongoc_write_result_init (&result);
server_stream = mongoc_cluster_stream_for_writes (&client->cluster, &error);
ASSERT_OR_PRINT (server_stream, error);
_mongoc_write_command_execute (&command, client, server_stream,
collection->db, collection->collection,
write_concern, 0, &result);
r = _mongoc_write_result_complete (&result, 2, collection->write_concern,
&reply, &error);
assert(!r);
ASSERT_CMPINT(error.domain, ==, MONGOC_ERROR_COMMAND);
ASSERT_CMPINT(error.code, ==, MONGOC_ERROR_COMMAND_INVALID_ARG);
_mongoc_write_command_destroy (&command);
_mongoc_write_result_destroy (&result);
bson_destroy(doc);
mongoc_server_stream_cleanup (server_stream);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
mongoc_write_concern_destroy(write_concern);
}
static void
txn_opts_cleanup (mongoc_transaction_opt_t *opts)
{
/* null inputs are ok */
mongoc_read_concern_destroy (opts->read_concern);
mongoc_write_concern_destroy (opts->write_concern);
mongoc_read_prefs_destroy (opts->read_prefs);
/* prepare opts for reuse */
opts->read_concern = NULL;
opts->write_concern = NULL;
opts->read_prefs = NULL;
}
static void
test_regex (void)
{
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_write_concern_t *wr;
mongoc_client_t *client;
bson_error_t error = { 0 };
int64_t count;
bson_t q = BSON_INITIALIZER;
bson_t *doc;
bool r;
client = mongoc_client_new (gTestUri);
ASSERT (client);
database = get_test_database (client);
ASSERT (database);
collection = get_test_collection (client, "test_regex");
ASSERT (collection);
wr = mongoc_write_concern_new ();
mongoc_write_concern_set_journal (wr, true);
doc = BCON_NEW ("hello", "/world");
r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, doc, wr, &error);
ASSERT (r);
BSON_APPEND_REGEX (&q, "hello", "^/wo", "i");
count = mongoc_collection_count (collection,
MONGOC_QUERY_NONE,
&q,
0,
0,
NULL,
&error);
ASSERT (count > 0);
ASSERT (!error.domain);
r = mongoc_collection_drop (collection, &error);
ASSERT (r);
mongoc_write_concern_destroy (wr);
bson_destroy (&q);
bson_destroy (doc);
mongoc_collection_destroy (collection);
mongoc_database_destroy(database);
mongoc_client_destroy (client);
}
static void
test_invalid_write_concern (void)
{
mongoc_write_command_t command;
mongoc_write_result_t result;
mongoc_collection_t *collection;
mongoc_client_t *client;
mongoc_write_concern_t *write_concern;
bson_t **docs;
bson_t reply = BSON_INITIALIZER;
bson_error_t error;
bool r;
client = test_framework_client_new (NULL);
assert(client);
collection = get_test_collection(client, "test_invalid_write_concern");
assert(collection);
write_concern = mongoc_write_concern_new();
assert(write_concern);
mongoc_write_concern_set_w(write_concern, 0);
mongoc_write_concern_set_journal(write_concern, true);
assert(!_mongoc_write_concern_is_valid(write_concern));
docs = bson_malloc(sizeof(bson_t*));
docs[0] = BCON_NEW("_id", BCON_INT32(0));
_mongoc_write_command_init_insert(&command, (const bson_t * const *)docs, 1, true, true);
_mongoc_write_result_init (&result);
_mongoc_write_command_execute (&command, client, 0, collection->db,
collection->collection, write_concern, 0,
&result);
r = _mongoc_write_result_complete (&result, &reply, &error);
assert(!r);
assert(error.domain = MONGOC_ERROR_COMMAND);
assert(error.code = MONGOC_ERROR_COMMAND_INVALID_ARG);
_mongoc_write_command_destroy (&command);
_mongoc_write_result_destroy (&result);
bson_destroy(docs[0]);
bson_free(docs);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
mongoc_write_concern_destroy(write_concern);
}
void
mongoc_client_set_write_concern (mongoc_client_t *client,
const mongoc_write_concern_t *write_concern)
{
BSON_ASSERT (client);
if (write_concern != client->write_concern) {
if (client->write_concern) {
mongoc_write_concern_destroy(client->write_concern);
}
client->write_concern = write_concern ?
mongoc_write_concern_copy(write_concern) :
mongoc_write_concern_new();
}
}
void
mongoc_database_set_write_concern (mongoc_database_t *database,
const mongoc_write_concern_t *write_concern)
{
BSON_ASSERT (database);
if (database->write_concern) {
mongoc_write_concern_destroy(database->write_concern);
database->write_concern = NULL;
}
if (write_concern) {
database->write_concern = mongoc_write_concern_copy(write_concern);
}
}
void
mongoc_client_set_write_concern (mongoc_client_t *client,
const mongoc_write_concern_t *write_concern)
{
bson_return_if_fail(client);
if (write_concern != client->write_concern) {
if (client->write_concern) {
mongoc_write_concern_destroy(client->write_concern);
}
client->write_concern = write_concern ?
mongoc_write_concern_copy(write_concern) :
mongoc_write_concern_new();
}
}
void
mongoc_database_set_write_concern (mongoc_database_t *database,
const mongoc_write_concern_t *write_concern)
{
bson_return_if_fail(database);
if (database->write_concern) {
mongoc_write_concern_destroy(database->write_concern);
database->write_concern = NULL;
}
if (write_concern) {
database->write_concern = mongoc_write_concern_copy(write_concern);
}
}
void
mongoc_bulk_operation_set_write_concern (mongoc_bulk_operation_t *bulk,
const mongoc_write_concern_t *write_concern)
{
bson_return_if_fail (bulk);
if (bulk->write_concern) {
mongoc_write_concern_destroy (bulk->write_concern);
}
if (write_concern) {
bulk->write_concern = mongoc_write_concern_copy (write_concern);
} else {
bulk->write_concern = mongoc_write_concern_new ();
}
}
void
mongoc_bulk_operation_set_write_concern (
mongoc_bulk_operation_t *bulk, const mongoc_write_concern_t *write_concern)
{
BSON_ASSERT (bulk);
if (bulk->write_concern) {
mongoc_write_concern_destroy (bulk->write_concern);
}
if (write_concern) {
bulk->write_concern = mongoc_write_concern_copy (write_concern);
} else {
bulk->write_concern = mongoc_write_concern_new ();
}
}
void
mongoc_client_destroy (mongoc_client_t *client)
{
if (client) {
#ifdef MONGOC_ENABLE_SSL
bson_free (client->pem_subject);
#endif
mongoc_write_concern_destroy (client->write_concern);
mongoc_read_prefs_destroy (client->read_prefs);
_mongoc_cluster_destroy (&client->cluster);
mongoc_uri_destroy (client->uri);
bson_free (client);
mongoc_counter_clients_active_dec ();
mongoc_counter_clients_disposed_inc ();
}
}
void
mongoc_uri_destroy (mongoc_uri_t *uri)
{
if (uri) {
mongoc_host_list_destroy_all (uri->hosts);
bson_free(uri->str);
bson_free(uri->database);
bson_free(uri->username);
bson_destroy(&uri->options);
bson_destroy(&uri->credentials);
mongoc_read_prefs_destroy(uri->read_prefs);
mongoc_write_concern_destroy(uri->write_concern);
if (uri->password) {
bson_zero_free(uri->password, strlen(uri->password));
}
bson_free(uri);
}
}
void
mongoc_database_destroy (mongoc_database_t *database)
{
ENTRY;
bson_return_if_fail(database);
if (database->read_prefs) {
mongoc_read_prefs_destroy(database->read_prefs);
database->read_prefs = NULL;
}
if (database->write_concern) {
mongoc_write_concern_destroy(database->write_concern);
database->write_concern = NULL;
}
bson_free(database);
EXIT;
}
static void
bulk4 (mongoc_collection_t *collection)
{
mongoc_write_concern_t *wc;
mongoc_bulk_operation_t *bulk;
bson_error_t error;
bson_t *doc;
bson_t reply;
char *str;
bool ret;
wc = mongoc_write_concern_new ();
mongoc_write_concern_set_w (wc, 4);
mongoc_write_concern_set_wtimeout (wc, 100); /* milliseconds */
bulk = mongoc_collection_create_bulk_operation (collection, true, wc);
/* Two inserts */
doc = BCON_NEW ("_id", BCON_INT32 (10));
mongoc_bulk_operation_insert (bulk, doc);
bson_destroy (doc);
doc = BCON_NEW ("_id", BCON_INT32 (11));
mongoc_bulk_operation_insert (bulk, doc);
bson_destroy (doc);
ret = mongoc_bulk_operation_execute (bulk, &reply, &error);
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_free (str);
if (!ret) {
printf ("Error: %s\n", error.message);
}
bson_destroy (&reply);
mongoc_bulk_operation_destroy (bulk);
mongoc_write_concern_destroy (wc);
}
static void
insert_test_docs (mongoc_collection_t *collection)
{
mongoc_write_concern_t *write_concern;
bson_error_t error;
bson_oid_t oid;
bson_t b;
int i;
write_concern = mongoc_write_concern_new();
mongoc_write_concern_set_w(write_concern, 3);
{
const bson_t *wc;
char *str;
wc = _mongoc_write_concern_get_gle(write_concern);
str = bson_as_json(wc, NULL);
fprintf(stderr, "Write Concern: %s\n", str);
bson_free(str);
}
for (i = 0; i < 200; i++) {
bson_init(&b);
bson_oid_init(&oid, NULL);
bson_append_oid(&b, "_id", 3, &oid);
ASSERT_OR_PRINT (mongoc_collection_insert(collection,
MONGOC_INSERT_NONE,
&b,
write_concern,
&error), error);
bson_destroy(&b);
}
mongoc_write_concern_destroy(write_concern);
}
static void
test_write_concern_append (void)
{
mongoc_write_concern_t *wc;
bson_t *cmd;
cmd = tmp_bson ("{'foo': 1}");
capture_logs (true);
/* cannot append invalid writeConcern */
wc = NULL;
assert (!mongoc_write_concern_append (wc, cmd));
/* append valid writeConcern */
wc = mongoc_write_concern_new ();
mongoc_write_concern_set_w (wc, 1);
assert (mongoc_write_concern_append (wc, cmd));
ASSERT (match_bson (cmd,
tmp_bson ("{'foo': 1, 'writeConcern': {'w': 1}}"),
true));
mongoc_write_concern_destroy (wc);
}
static void
test_bypass_validation (void *context)
{
mongoc_collection_t *collection;
bson_t reply = BSON_INITIALIZER;
mongoc_bulk_operation_t *bulk;
mongoc_database_t *database;
mongoc_write_concern_t *wr;
mongoc_client_t *client;
bson_error_t error;
bson_t *options;
char *collname;
char *dbname;
int r;
int i;
client = test_framework_client_new ();
assert (client);
dbname = gen_collection_name ("dbtest");
collname = gen_collection_name ("bypass");
database = mongoc_client_get_database (client, dbname);
collection = mongoc_database_get_collection (database, collname);
assert (collection);
options = tmp_bson ("{'validator': {'number': {'$gte': 5}}, 'validationAction': 'error'}");
ASSERT_OR_PRINT (mongoc_database_create_collection (database, collname, options, &error), error);
/* {{{ Default fails validation */
bulk = mongoc_collection_create_bulk_operation(collection, true, NULL);
for (i = 0; i < 3; i++) {
bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i));
mongoc_bulk_operation_insert (bulk, doc);
}
r = mongoc_bulk_operation_execute (bulk, &reply, &error);
ASSERT(!r);
ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, 121, "Document failed validation");
mongoc_bulk_operation_destroy (bulk);
/* }}} */
/* {{{ bypass_document_validation=false Fails validation */
bulk = mongoc_collection_create_bulk_operation(collection, true, NULL);
mongoc_bulk_operation_set_bypass_document_validation (bulk, false);
for (i = 0; i < 3; i++) {
bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i));
mongoc_bulk_operation_insert (bulk, doc);
}
r = mongoc_bulk_operation_execute (bulk, &reply, &error);
ASSERT(!r);
ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, 121, "Document failed validation");
mongoc_bulk_operation_destroy (bulk);
/* }}} */
/* {{{ bypass_document_validation=true ignores validation */
bulk = mongoc_collection_create_bulk_operation(collection, true, NULL);
mongoc_bulk_operation_set_bypass_document_validation (bulk, true);
for (i = 0; i < 3; i++) {
bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i));
mongoc_bulk_operation_insert (bulk, doc);
}
r = mongoc_bulk_operation_execute (bulk, &reply, &error);
ASSERT_OR_PRINT(r, error);
mongoc_bulk_operation_destroy (bulk);
/* }}} */
/* {{{ w=0 and bypass_document_validation=set fails */
bulk = mongoc_collection_create_bulk_operation(collection, true, NULL);
wr = mongoc_write_concern_new ();
mongoc_write_concern_set_w (wr, 0);
mongoc_bulk_operation_set_write_concern (bulk, wr);
mongoc_bulk_operation_set_bypass_document_validation (bulk, true);
for (i = 0; i < 3; i++) {
bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i));
mongoc_bulk_operation_insert (bulk, doc);
}
r = mongoc_bulk_operation_execute (bulk, &reply, &error);
ASSERT_OR_PRINT(!r, error);
ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot set bypassDocumentValidation for unacknowledged writes");
mongoc_bulk_operation_destroy (bulk);
mongoc_write_concern_destroy (wr);
/* }}} */
ASSERT_OR_PRINT (mongoc_collection_drop (collection, &error), error);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
}
static void
test_write_concern_basic (void)
{
mongoc_write_concern_t *write_concern;
const bson_t *gle;
const bson_t *bson;
bson_iter_t iter;
write_concern = mongoc_write_concern_new();
BEGIN_IGNORE_DEPRECATIONS;
/*
* Test defaults.
*/
ASSERT(write_concern);
ASSERT(!mongoc_write_concern_get_fsync(write_concern));
ASSERT(!mongoc_write_concern_get_journal(write_concern));
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(!mongoc_write_concern_get_wtimeout(write_concern));
ASSERT(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_fsync(write_concern, true);
ASSERT(mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_fsync(write_concern, false);
ASSERT(!mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_journal(write_concern, true);
ASSERT(mongoc_write_concern_get_journal(write_concern));
mongoc_write_concern_set_journal(write_concern, false);
ASSERT(!mongoc_write_concern_get_journal(write_concern));
/*
* Test changes to w.
*/
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY);
ASSERT(mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_wmajority(write_concern, 1000);
ASSERT(mongoc_write_concern_get_wmajority(write_concern));
ASSERT(mongoc_write_concern_get_wtimeout(write_concern) == 1000);
mongoc_write_concern_set_wtimeout(write_concern, 0);
ASSERT(!mongoc_write_concern_get_wtimeout(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
mongoc_write_concern_set_w(write_concern, 3);
ASSERT(mongoc_write_concern_get_w(write_concern) == 3);
/*
* Check generated bson.
*/
mongoc_write_concern_set_fsync(write_concern, true);
mongoc_write_concern_set_journal(write_concern, true);
gle = _mongoc_write_concern_get_gle(write_concern);
ASSERT(bson_iter_init_find(&iter, gle, "getlasterror") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 1);
ASSERT(bson_iter_init_find(&iter, gle, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, gle, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, gle, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);
ASSERT(gle);
bson = _mongoc_write_concern_get_bson(write_concern);
ASSERT(!bson_iter_init_find(&iter, bson, "getlasterror"));
ASSERT(bson_iter_init_find(&iter, bson, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, bson, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
ASSERT(bson_iter_init_find(&iter, bson, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);
ASSERT(bson);
mongoc_write_concern_destroy(write_concern);
END_IGNORE_DEPRECATIONS;
}
static void
test_write_concern_fsync_and_journal_gle_and_validity (void)
{
mongoc_write_concern_t *write_concern = mongoc_write_concern_new();
/*
* Journal and fsync should imply GLE regardless of w; however, journal and
* fsync logically conflict with w=0 and w=-1, so a write concern with such
* a combination of options will be considered invalid.
*/
/* No write concern needs GLE, but not "valid" */
ASSERT(mongoc_write_concern_is_acknowledged (NULL));
ASSERT(!mongoc_write_concern_is_valid (NULL));
/* Default write concern needs GLE and is valid */
ASSERT(write_concern);
ASSERT(mongoc_write_concern_is_acknowledged (write_concern));
ASSERT(mongoc_write_concern_is_valid (write_concern));
ASSERT(!mongoc_write_concern_journal_is_set (write_concern));
/* w=0 does not need GLE and is valid */
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED);
ASSERT(!mongoc_write_concern_is_acknowledged (write_concern));
ASSERT(mongoc_write_concern_is_valid (write_concern));
ASSERT(!mongoc_write_concern_journal_is_set (write_concern));
/* fsync=true needs GLE, but it conflicts with w=0 */
mongoc_write_concern_set_fsync(write_concern, true);
ASSERT(mongoc_write_concern_is_acknowledged (write_concern));
ASSERT(!mongoc_write_concern_is_valid (write_concern));
ASSERT(!mongoc_write_concern_journal_is_set (write_concern));
mongoc_write_concern_set_fsync(write_concern, false);
/* journal=true needs GLE, but it conflicts with w=0 */
mongoc_write_concern_set_journal(write_concern, true);
ASSERT(mongoc_write_concern_is_acknowledged (write_concern));
ASSERT(!mongoc_write_concern_is_valid (write_concern));
ASSERT(mongoc_write_concern_journal_is_set (write_concern));
mongoc_write_concern_set_journal(write_concern, false);
/* w=-1 does not need GLE and is valid */
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED);
ASSERT(!mongoc_write_concern_is_acknowledged (write_concern));
ASSERT(mongoc_write_concern_is_valid (write_concern));
ASSERT(mongoc_write_concern_journal_is_set (write_concern));
/* fsync=true needs GLE, but it conflicts with w=-1 */
mongoc_write_concern_set_fsync(write_concern, true);
ASSERT(mongoc_write_concern_is_acknowledged (write_concern));
ASSERT(!mongoc_write_concern_is_valid (write_concern));
ASSERT(mongoc_write_concern_journal_is_set (write_concern));
/* journal=true needs GLE, but it conflicts with w=-1 */
mongoc_write_concern_set_fsync(write_concern, false);
mongoc_write_concern_set_journal(write_concern, true);
ASSERT(mongoc_write_concern_is_acknowledged (write_concern));
ASSERT(mongoc_write_concern_journal_is_set (write_concern));
/* fsync=true with w=default needs GLE and is valid */
mongoc_write_concern_set_journal(write_concern, false);
mongoc_write_concern_set_fsync(write_concern, true);
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(mongoc_write_concern_is_acknowledged (write_concern));
ASSERT(mongoc_write_concern_is_valid (write_concern));
ASSERT(mongoc_write_concern_journal_is_set (write_concern));
/* journal=true with w=default needs GLE and is valid */
mongoc_write_concern_set_journal(write_concern, false);
mongoc_write_concern_set_fsync(write_concern, true);
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(mongoc_write_concern_is_acknowledged (write_concern));
ASSERT(mongoc_write_concern_is_valid (write_concern));
ASSERT(mongoc_write_concern_journal_is_set (write_concern));
mongoc_write_concern_destroy(write_concern);
}
static void
test_find_and_modify_write_concern (int wire_version)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
mock_server_t *server;
request_t *request;
future_t *future;
bson_error_t error;
bson_t *update;
bson_t doc = BSON_INITIALIZER;
bson_t reply;
mongoc_find_and_modify_opts_t *opts;
mongoc_write_concern_t *write_concern;
server = mock_server_new ();
mock_server_run (server);
client = mongoc_client_new_from_uri (mock_server_get_uri (server));
ASSERT (client);
collection =
mongoc_client_get_collection (client, "test", "test_find_and_modify");
auto_ismaster (server,
wire_version, /* max_wire_version */
48000000, /* max_message_size */
16777216, /* max_bson_size */
1000); /* max_write_batch_size */
BSON_APPEND_INT32 (&doc, "superduper", 77889);
update = BCON_NEW ("$set", "{", "superduper", BCON_INT32 (1234), "}");
write_concern = mongoc_write_concern_new ();
mongoc_write_concern_set_w (write_concern, 42);
opts = mongoc_find_and_modify_opts_new ();
mongoc_collection_set_write_concern (collection, write_concern);
mongoc_find_and_modify_opts_set_update (opts, update);
mongoc_find_and_modify_opts_set_flags (opts,
MONGOC_FIND_AND_MODIFY_RETURN_NEW);
future = future_collection_find_and_modify_with_opts (
collection, &doc, opts, &reply, &error);
if (wire_version >= 4) {
request = mock_server_receives_command (
server,
"test",
MONGOC_QUERY_NONE,
"{ 'findAndModify' : 'test_find_and_modify', "
"'query' : { 'superduper' : 77889 },"
"'update' : { '$set' : { 'superduper' : 1234 } },"
"'new' : true,"
"'writeConcern' : { 'w' : 42 } }");
} else {
request = mock_server_receives_command (
server,
"test",
MONGOC_QUERY_NONE,
"{ 'findAndModify' : 'test_find_and_modify', "
"'query' : { 'superduper' : 77889 },"
"'update' : { '$set' : { 'superduper' : 1234 } },"
"'new' : true }");
}
mock_server_replies_simple (request, "{ 'value' : null, 'ok' : 1 }");
ASSERT_OR_PRINT (future_get_bool (future), error);
future_destroy (future);
mongoc_find_and_modify_opts_destroy (opts);
bson_destroy (&reply);
bson_destroy (update);
mongoc_write_concern_destroy (write_concern);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (&doc);
mock_server_destroy (server);
}
int
main ()
{
bson_t empty = BSON_INITIALIZER;
const bson_t *doc;
bson_t *to_insert = BCON_NEW ("x", BCON_INT32 (1));
const bson_t *err_doc;
bson_error_t error;
const char *uri_string;
mongoc_uri_t *uri;
mongoc_client_t *client;
mongoc_collection_t *coll;
mongoc_change_stream_t *stream;
mongoc_write_concern_t *wc = mongoc_write_concern_new ();
bson_t opts = BSON_INITIALIZER;
bool r;
mongoc_init ();
uri_string = "mongodb://"
"localhost:27017,localhost:27018,localhost:"
"27019/db?replicaSet=rs0";
uri = mongoc_uri_new_with_error (uri_string, &error);
if (!uri) {
fprintf (stderr,
"failed to parse URI: %s\n"
"error message: %s\n",
uri_string,
error.message);
return EXIT_FAILURE;
}
client = mongoc_client_new_from_uri (uri);
if (!client) {
return EXIT_FAILURE;
}
coll = mongoc_client_get_collection (client, "db", "coll");
stream = mongoc_collection_watch (coll, &empty, NULL);
mongoc_write_concern_set_wmajority (wc, 10000);
mongoc_write_concern_append (wc, &opts);
r = mongoc_collection_insert_one (coll, to_insert, &opts, NULL, &error);
if (!r) {
fprintf (stderr, "Error: %s\n", error.message);
return EXIT_FAILURE;
}
while (mongoc_change_stream_next (stream, &doc)) {
char *as_json = bson_as_relaxed_extended_json (doc, NULL);
fprintf (stderr, "Got document: %s\n", as_json);
bson_free (as_json);
}
if (mongoc_change_stream_error_document (stream, &error, &err_doc)) {
if (!bson_empty (err_doc)) {
fprintf (stderr,
"Server Error: %s\n",
bson_as_relaxed_extended_json (err_doc, NULL));
} else {
fprintf (stderr, "Client Error: %s\n", error.message);
}
return EXIT_FAILURE;
}
bson_destroy (to_insert);
mongoc_write_concern_destroy (wc);
bson_destroy (&opts);
mongoc_change_stream_destroy (stream);
mongoc_collection_destroy (coll);
mongoc_uri_destroy (uri);
mongoc_client_destroy (client);
mongoc_cleanup ();
return EXIT_SUCCESS;
}
