void
test_mongo_sync_cmd_get_last_error (void)
{
mongo_sync_connection *c;
gchar *error;
test_env_setup ();
c = test_make_fake_sync_conn (-1, FALSE);
errno = 0;
ok (mongo_sync_cmd_get_last_error (NULL, config.db, &error) == FALSE,
"mongo_sync_cmd_get_last_error() returns FALSE with a NULL connection");
cmp_ok (errno, "==", ENOTCONN,
"errno is set to ENOTCONN");
ok (mongo_sync_cmd_get_last_error (c, NULL, &error) == FALSE,
"mongo_sync_cmd_get_last_error() fails with a NULL db");
errno = 0;
ok (mongo_sync_cmd_get_last_error (c, config.db, NULL) == FALSE,
"mongo_sync_cmd_get_last_error() fails with a NULL error destination");
cmp_ok (errno, "==", EINVAL,
"errno is set to EINVAL");
mongo_sync_disconnect (c);
test_env_free ();
}
void
test_mongo_sync_get_set_auto_reconnect (void)
{
mongo_sync_connection *c;
c = test_make_fake_sync_conn (-1, FALSE);
errno = 0;
ok (mongo_sync_conn_get_auto_reconnect (NULL) == FALSE,
"mongo_sync_conn_get_auto_reconnect() returns FALSE with a "
"NULL connection");
cmp_ok (errno, "==", ENOTCONN,
"errno is now set to ENOTCONN");
ok (mongo_sync_conn_get_auto_reconnect (c) == FALSE,
"mongo_sync_get_auto_reconnect() works");
cmp_ok (errno, "==", 0,
"errno is now cleared");
errno = 0;
mongo_sync_conn_set_auto_reconnect (NULL, TRUE);
cmp_ok (errno, "==", ENOTCONN,
"errno is set to ENOTCONN after "
"mongo_sync_conn_set_auto_reconnect(NULL)");
ok (mongo_sync_conn_set_auto_reconnect (c, TRUE),
"mongo_sync_auto_reconnect() works");
ok (mongo_sync_conn_get_auto_reconnect (c) == TRUE,
"mongo_sync_set_auto_reconnect() worked");
mongo_sync_disconnect (c);
}
void
test_mongo_sync_cmd_custom (void)
{
mongo_sync_connection *c;
bson *cmd;
c = test_make_fake_sync_conn (-1, FALSE);
cmd = bson_new ();
bson_append_int32 (cmd, "getnonce", 1);
bson_finish (cmd);
ok (mongo_sync_cmd_custom (NULL, "test", cmd) == NULL,
"mongo_sync_cmd_custom() fails with a NULL connection");
ok (mongo_sync_cmd_custom (c, NULL, cmd) == NULL,
"mongo_sync_cmd_custom() fails with a NULL namespace");
ok (mongo_sync_cmd_custom (c, "test", cmd) == NULL,
"mongo_sync_cmd_custom() fails with a bogus FD");
mongo_sync_conn_set_slaveok (c, TRUE);
ok (mongo_sync_cmd_custom (c, "test", cmd) == NULL,
"mongo_sync_cmd_custom() fails with a bogus FD");
bson_free (cmd);
mongo_sync_disconnect (c);
test_mongo_sync_cmd_custom_net ();
}
void
test_mongo_sync_gridfs_new (void)
{
mongo_sync_connection *conn;
mongo_sync_gridfs *gfs;
gchar *f, *c;
conn = test_make_fake_sync_conn (4, TRUE);
ok (mongo_sync_gridfs_new (NULL, "test.fs") == NULL,
"mongo_sync_gridfs_new() should fail with a NULL connection");
ok (mongo_sync_gridfs_new (conn, "test.fs") == NULL,
"mongo_sync_gridfs_new() should fail with a bogus connection");
ok (mongo_sync_gridfs_new (conn, NULL) == NULL,
"mongo_sync_gridfs_new() should fail with a NULL ns prefix");
ok (mongo_sync_gridfs_new (conn, "bogus") == NULL,
"mongo_sync_gridfs_new() should fail with a bogus ns prefix");
mongo_sync_disconnect (conn);
begin_network_tests (4);
f = g_strconcat (config.gfs_prefix, ".files", NULL);
c = g_strconcat (config.gfs_prefix, ".chunks", NULL);
conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE);
gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix);
ok (gfs != NULL,
"mongo_sync_gridfs_new() works");
is (gfs->ns.prefix, config.gfs_prefix,
"The namespace prefix is as specified");
is (gfs->ns.files, f,
"The files namespace is correct");
is (gfs->ns.chunks, c,
"The chunks namespace is correct");
mongo_sync_gridfs_free (gfs, FALSE);
mongo_sync_disconnect (conn);
g_free (f);
g_free (c);
end_network_tests ();
}
void
test_mongo_sync_cmd_kill_cursors (void)
{
mongo_sync_connection *c;
c = test_make_fake_sync_conn (-1, FALSE);
ok (mongo_sync_cmd_kill_cursors (NULL, 1, (gint64)1234) == FALSE,
"mongo_sync_cmd_kill_cursors() fails with a NULL connection");
ok (mongo_sync_cmd_kill_cursors (c, 0, (gint64)1234) == FALSE,
"mongo_sync_cmd_kill_cursors() fails with a negative number of cursors");
ok (mongo_sync_cmd_kill_cursors (c, 1, (gint64)1234) == FALSE,
"mongo_sync_cmd_kill_cursors() fails with a bogus FD");
mongo_sync_disconnect (c);
test_mongo_sync_cmd_kill_cursors_net ();
}
void
test_mongo_sync_conn_seed_add (void)
{
mongo_sync_connection *c;
c = test_make_fake_sync_conn (42, TRUE);
ok (mongo_sync_conn_seed_add (NULL, "localhost", 27017) == FALSE,
"mongo_sync_conn_seed_add() should fail with a NULL connection");
ok (mongo_sync_conn_seed_add (c, NULL, 27017) == FALSE,
"mongo_sync_conn_seed_add() should fail with a NULL host");
ok (mongo_sync_conn_seed_add (c, "localhost", -1) == FALSE,
"mongo_sync_conn_seed_add() should fail with an invalid port");
ok (mongo_sync_conn_seed_add (c, "localhost", 27017),
"mongo_sync_conn_seed_add() works");
mongo_sync_disconnect (c);
}
void
test_mongo_sync_cmd_create (void)
{
mongo_sync_connection *c;
c = test_make_fake_sync_conn (-1, FALSE);
ok (mongo_sync_cmd_create (NULL, "test", "db",
MONGO_COLLECTION_DEFAULTS) == FALSE,
"mongo_sync_cmd_create() fails with a NULL connection");
ok (mongo_sync_cmd_create (c, NULL, "db",
MONGO_COLLECTION_DEFAULTS) == FALSE,
"mongo_sync_cmd_create() fails with a NULL db");
ok (mongo_sync_cmd_create (c, "test", NULL,
MONGO_COLLECTION_DEFAULTS) == FALSE,
"mongo_sync_cmd_create() fails with a NULL collection");
mongo_sync_disconnect (c);
test_mongo_sync_cmd_create_net ();
}
void
test_mongo_sync_cmd_user_add (void)
{
mongo_sync_connection *c;
c = test_make_fake_sync_conn (-1, FALSE);
errno = 0;
ok (mongo_sync_cmd_user_add (NULL, "test", "test", "s3kr1+") == FALSE,
"mongo_sync_cmd_user_add() fails with a NULL connection");
cmp_ok (errno, "==", ENOTCONN,
"errno is set to ENOTCONN");
errno = 0;
ok (mongo_sync_cmd_user_add (c, NULL, "test", "s3kr1+") == FALSE,
"mongo_sync_cmd_user_add() fails with a NULL db");
cmp_ok (errno, "==", EINVAL,
"errno is set to EINVAL");
errno = 0;
ok (mongo_sync_cmd_user_add (c, "test", NULL, "s3kr1+") == FALSE,
"mongo_sync_cmd_user_add() fails with a NULL user");
cmp_ok (errno, "==", EINVAL,
"errno is set to EINVAL");
errno = 0;
ok (mongo_sync_cmd_user_add (c, "test", "test", NULL) == FALSE,
"mongo_sync_cmd_user_add() fails with a NULL password");
cmp_ok (errno, "==", EINVAL,
"errno is set to EINVAL");
ok (mongo_sync_cmd_user_add (c, "test", "test", "s3kr1+") == FALSE,
"mongo_sync_cmd_user_add() fails with a bogus FD");
mongo_sync_disconnect (c);
test_mongo_sync_cmd_user_add_net ();
}
void
test_mongo_sync_cmd_is_master (void)
{
mongo_sync_connection *c;
c = test_make_fake_sync_conn (-1, FALSE);
errno = 0;
ok (mongo_sync_cmd_is_master (NULL) == FALSE,
"mongo_sync_cmd_is_master fails with a NULL connection");
cmp_ok (errno, "==", ENOTCONN,
"errno is set to ENOTCONN");
errno = 0;
ok (mongo_sync_cmd_is_master (c) == FALSE,
"mongo_sync_cmd_is_master() works");
cmp_ok (errno, "!=", 0,
"errno is not 0");
mongo_sync_disconnect (c);
test_mongo_sync_cmd_is_master_net ();
}
void
test_mongo_sync_gridfs_chunked_file_new_from_buffer (void)
{
mongo_sync_connection *conn;
mongo_sync_gridfs *gfs;
bson *metadata;
guint8 *buffer;
mongo_sync_gridfs_chunked_file *gfile;
buffer = g_malloc (BUFFER_SIZE);
memset (buffer, 'a', BUFFER_SIZE);
conn = test_make_fake_sync_conn (4, TRUE);
gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix);
metadata = bson_build (BSON_TYPE_STRING, "filename",
"gridfs_file_new_from_buffer", -1,
BSON_TYPE_NONE);
bson_finish (metadata);
ok (mongo_sync_gridfs_chunked_file_new_from_buffer (NULL, metadata,
buffer, BUFFER_SIZE) == FALSE,
"mongo_sync_gridfs_chunked_file_new_from_buffer() fails with a NULL GridFS");
mongo_sync_gridfs_free (gfs, TRUE);
begin_network_tests (5);
conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE);
gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix);
ok (mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, metadata,
NULL, BUFFER_SIZE) == FALSE,
"mongo_sync_gridfs_chunked_file_new_from_buffer() fails with NULL data");
ok (mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, metadata,
buffer, 0) == FALSE,
"mongo_sync_gridfs_chunked_file_new_from_buffer() fails with an invalid data size");
ok (mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, metadata, buffer,
BUFFER_SIZE) == FALSE,
"mongo_sync_gridfs_chunked_file_new_from_buffer() fails with uninitialized OID");
mongo_util_oid_init (0);
gfile = mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, metadata,
buffer, BUFFER_SIZE);
ok (gfile != NULL,
"mongo_sync_gridfs_chunked_file_new_from_buffer() works with metadata");
mongo_sync_gridfs_chunked_file_free (gfile);
gfile = mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, NULL,
buffer, BUFFER_SIZE);
ok (gfile != NULL,
"mongo_sync_gridfs_chunked_file_new_from_buffer() works without metadata");
mongo_sync_gridfs_chunked_file_free (gfile);
mongo_sync_gridfs_free (gfs, TRUE);
end_network_tests ();
bson_free (metadata);
g_free (buffer);
}
void
test_mongo_sync_reconnect (void)
{
mongo_sync_connection *conn, *o;
GList *l;
ok (mongo_sync_reconnect (NULL, FALSE) == NULL,
"mongo_sync_reconnect() fails with a NULL connection");
cmp_ok (errno, "==", ENOTCONN,
"errno is ENOTCONN");
conn = test_make_fake_sync_conn (-1, FALSE);
ok (mongo_sync_reconnect (conn, FALSE) == NULL,
"mongo_sync_reconnect() fails with a bogus FD");
cmp_ok (errno, "==", EHOSTUNREACH,
"errno is EHOSTUNREACH");
mongo_sync_disconnect (conn);
begin_network_tests (15);
/* Connect & reconnect to master */
o = conn = mongo_sync_connect (config.primary_host,
config.primary_port, TRUE);
ok ((conn = mongo_sync_reconnect (conn, TRUE)) != NULL,
"mongo_sync_reconnect() works when reconnecting to self");
ok (o == conn,
"Reconnect to an existing master results in the same object");
mongo_sync_disconnect (conn);
/* Connect to master, kill FD, reconnect */
conn = mongo_sync_connect (config.primary_host,
config.primary_port, TRUE);
mongo_sync_cmd_is_master (conn);
shutdown (conn->super.fd, SHUT_RDWR);
sleep (3);
ok ((conn = mongo_sync_reconnect (conn, TRUE)) != NULL,
"mongo_sync_reconnect() succeed when the connection drops");
mongo_sync_disconnect (conn);
/* Connect, kill, reconnect; w/o knowing other hosts */
o = conn = mongo_sync_connect (config.primary_host,
config.primary_port, TRUE);
shutdown (conn->super.fd, SHUT_RDWR);
sleep (3);
l = conn->rs.hosts;
while (l)
{
g_free (l->data);
l = g_list_delete_link (l, l);
}
conn->rs.hosts = NULL;
conn = mongo_sync_reconnect (conn, FALSE);
ok (conn != o && conn == NULL,
"mongo_sync_reconnect() fails if it can't reconnect anywhere");
mongo_sync_disconnect (o);
/* Gracefully ignore unparsable hosts during reconnect */
o = conn = mongo_sync_connect (config.primary_host,
config.primary_port, TRUE);
mongo_sync_cmd_is_master (conn);
conn->rs.hosts = g_list_prepend (conn->rs.hosts,
g_strdup ("invalid:-42"));
shutdown (conn->super.fd, SHUT_RDWR);
sleep (3);
conn = mongo_sync_reconnect (conn, TRUE);
ok (conn == o,
"mongo_sync_reconnect() gracefully ignores unparsable hosts "
"during reconnect");
mongo_sync_disconnect (conn);
/* Ignore unreachable hosts during reconnect */
o = conn = mongo_sync_connect (config.primary_host,
config.primary_port, TRUE);
mongo_sync_cmd_is_master (conn);
conn->rs.hosts = g_list_prepend (conn->rs.hosts,
g_strdup ("example.com:27017"));
shutdown (conn->super.fd, SHUT_RDWR);
sleep (3);
conn = mongo_sync_reconnect (conn, TRUE);
ok (conn == o,
"mongo_sync_reconnect() gracefully ignores unparsable hosts "
"during reconnect");
mongo_sync_disconnect (conn);
/*
* Tests involving a secondary
*/
skip (!config.secondary_host, 9,
"Secondary host not set up");
/* Connect to secondary & reconnect to master */
o = conn = mongo_sync_connect (config.secondary_host,
config.secondary_port, TRUE);
ok (conn != NULL, "Connecting to secondary");
ok (mongo_sync_cmd_is_master (conn) == FALSE,
"Connected to a secondary");
ok ((conn = mongo_sync_reconnect (conn, TRUE)) != NULL,
"Reconnecting from slave to master succeeds");
ok (conn == o, "Connection object updated in-place");
ok (mongo_sync_cmd_is_master (conn),
"Correctly reconnected to master");
mongo_sync_disconnect (conn);
/* Connect to secondary & reconnect to self */
o = conn = mongo_sync_connect (config.secondary_host,
config.secondary_port, TRUE);
ok (conn != NULL, "Connecting to secondary");
ok ((conn = mongo_sync_reconnect (conn, FALSE)) != NULL,
"Reconnecting from slave to self succeeds");
ok (conn == o, "Connection object updated in-place");
ok (mongo_sync_cmd_is_master (conn) == FALSE,
"Correctly reconnected to self");
mongo_sync_disconnect (conn);
endskip;
end_network_tests ();
}
void
test_mongo_sync_cmd_insert (void)
{
mongo_sync_connection *c;
bson *b1, *b2;
c = test_make_fake_sync_conn (-1, FALSE);
b1 = test_bson_generate_full ();
b2 = test_bson_generate_full ();
ok (mongo_sync_cmd_insert (NULL, "test.ns", b1, b2, NULL) == FALSE,
"mongo_sync_cmd_insert() fails with a NULL connection");
ok (mongo_sync_cmd_insert (c, NULL, b1, b2, NULL) == FALSE,
"mongo_sync_cmd_insert() fails with a NULL namespace");
ok (mongo_sync_cmd_insert (c, "test.ns", NULL) == FALSE,
"mongo_sync_cmd_insert() fails with no documents to insert");
ok (mongo_sync_cmd_insert (c, "test.ns", b1, b2, NULL) == FALSE,
"mongo_sync_cmd_insert() fails with a bogus FD");
mongo_sync_disconnect (c);
bson_free (b1);
bson_free (b2);
begin_network_tests (4);
b1 = bson_new ();
bson_append_string (b1, "sync_cmd_insert", "works", -1);
bson_finish (b1);
b2 = bson_new ();
bson_append_int32 (b2, "int32", 1984);
bson_finish (b2);
c = mongo_sync_connect (config.primary_host, config.primary_port,
TRUE);
mongo_sync_conn_set_auto_reconnect (c, TRUE);
ok (mongo_sync_cmd_insert (c, config.ns, b1, b2, NULL) == TRUE,
"mongo_sync_cmd_insert() works");
shutdown (c->super.fd, SHUT_RDWR);
sleep (3);
ok (mongo_sync_cmd_insert (c, config.ns, b1, b2, NULL) == TRUE,
"mongo_sync_cmd_insert() automatically reconnects");
mongo_sync_disconnect (c);
/*
* Tests involving a secondary
*/
skip (!config.secondary_host, 2, "Secondary host not set up");
c = mongo_sync_connect (config.secondary_host, config.secondary_port,
TRUE);
mongo_sync_conn_set_auto_reconnect (c, TRUE);
ok (c && mongo_sync_cmd_is_master (c) == FALSE,
"Connected to a secondary");
ok (mongo_sync_cmd_insert (c, config.ns, b1, b2, NULL) == TRUE,
"mongo_sync_cmd_insert() automatically reconnects to master");
mongo_sync_disconnect (c);
endskip;
bson_free (b1);
bson_free (b2);
end_network_tests ();
}