void test_mongo_sync_gridfs_chunked_find (void) { mongo_sync_connection *conn; mongo_sync_gridfs *gfs; bson *query; query = bson_build (BSON_TYPE_STRING, "filename", "bogus-fn", -1, BSON_TYPE_NONE); bson_finish (query); ok (mongo_sync_gridfs_chunked_find (NULL, query) == NULL, "mongo_sync_gridfs_chunked_find() fails with a NULL GridFS"); begin_network_tests (2); 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_find (gfs, NULL) == NULL, "mongo_sync_gridfs_chunked_find() fails with a NULL query"); ok (mongo_sync_gridfs_chunked_find (gfs, query) == NULL, "mongo_sync_gridfs_chunked_find() fails when the file is not found"); mongo_sync_gridfs_free (gfs, TRUE); end_network_tests (); bson_free (query); }
void test_mongo_sync_cmd_kill_cursors_net (void) { mongo_packet *p; mongo_sync_connection *conn; bson *b; gint i; mongo_reply_packet_header rh; gint64 cid; begin_network_tests (3); conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE); mongo_sync_conn_set_auto_reconnect (conn, TRUE); b = bson_new (); for (i = 0; i < 40; i++) { bson_reset (b); bson_append_string (b, "test-name", __FILE__, -1); bson_append_int32 (b, "seq", i); bson_finish (b); mongo_sync_cmd_insert (conn, config.ns, b, NULL); } bson_free (b); b = bson_new (); bson_append_string (b, "test-name", __FILE__, -1); bson_finish (b); p = mongo_sync_cmd_query (conn, config.ns, MONGO_WIRE_FLAG_QUERY_NO_CURSOR_TIMEOUT, 0, 2, b, NULL); mongo_wire_reply_packet_get_header (p, &rh); cid = rh.cursor_id; mongo_wire_packet_free (p); ok (mongo_sync_cmd_kill_cursors (conn, 1, cid) == TRUE, "mongo_sync_kill_cursors() works"); p = mongo_sync_cmd_query (conn, config.ns, MONGO_WIRE_FLAG_QUERY_NO_CURSOR_TIMEOUT, 0, 2, b, NULL); bson_free (b); mongo_wire_reply_packet_get_header (p, &rh); cid = rh.cursor_id; mongo_wire_packet_free (p); shutdown (conn->super.fd, SHUT_RDWR); sleep (3); ok (mongo_sync_cmd_kill_cursors (conn, 1, cid) == TRUE, "mongo_sync_cmd_kill_cursors() automatically reconnects"); mongo_sync_disconnect (conn); test_mongo_sync_cmd_kill_cursors_net_secondary (); end_network_tests (); }
void test_mongo_sync_gridfs_get_set_chunk_size (void) { mongo_sync_gridfs *gfs; ok (mongo_sync_gridfs_get_chunk_size (NULL) == -1, "mongo_sync_gridfs_get_chunk_size() fails with a NULL gfs"); ok (mongo_sync_gridfs_set_chunk_size (NULL, 16 * 1024) == FALSE, "mongo_sync_gridfs_set_chunk_size() fails with a NULL gfs"); begin_network_tests (3); gfs = mongo_sync_gridfs_new (mongo_sync_connect (config.primary_host, config.primary_port, FALSE), config.gfs_prefix); ok (mongo_sync_gridfs_set_chunk_size (gfs, -1) == FALSE, "mongo_sync_gridfs_set_chunk_size() fails if the size is invalid"); ok (mongo_sync_gridfs_set_chunk_size (gfs, 12345), "mongo_sync_gridfs_set_chunk_size() works"); cmp_ok (mongo_sync_gridfs_get_chunk_size (gfs), "==", 12345, "mongo_sync_gridfs_get_chunk_size() works"); mongo_sync_gridfs_free (gfs, TRUE); end_network_tests (); }
void test_mongo_connection_set_timeout (void) { mongo_connection c, *conn; c.fd = -1; ok (mongo_connection_set_timeout (NULL, 100) == FALSE, "mongo_connection_set_timeout() should fail with a NULL connection"); ok (mongo_connection_set_timeout (&c, -1) == FALSE, "mongo_connection_set_timeout() should fail with a negative timeout"); ok (mongo_connection_set_timeout (&c, 100) == FALSE, "mongo_connection_set_timeout() should fail with an invalid FD"); begin_network_tests (0); conn = mongo_connect (config.primary_host, config.primary_port); /* No verification here, as some systems may or may not support this, thus, failing in a test is not fatal. */ mongo_connection_set_timeout (conn, 100); mongo_disconnect (conn); end_network_tests (); }
void test_mongo_sync_cmd_user_add_net (void) { mongo_sync_connection *c; begin_network_tests (3); c = mongo_sync_connect (config.primary_host, config.primary_port, TRUE); mongo_sync_conn_set_auto_reconnect (c, TRUE); ok (mongo_sync_cmd_user_add (c, config.db, "test", "s3kr1+") == TRUE, "mongo_sync_cmd_user_add() works"); shutdown (c->super.fd, SHUT_RDWR); sleep (3); ok (mongo_sync_cmd_user_add (c, config.db, "test", "s3kr1+") == TRUE, "mongo_sync_cmd_user_add() automatically reconnects"); mongo_sync_disconnect (c); test_mongo_sync_cmd_user_add_net_secondary (); end_network_tests (); }
void test_mongo_sync_gridfs_stream_seek (void) { mongo_sync_connection *conn; mongo_sync_gridfs *gfs; mongo_sync_gridfs_stream *stream; mongo_util_oid_init (0); ok (mongo_sync_gridfs_stream_seek (NULL, 0, SEEK_SET) == FALSE, "mongo_sync_gridfs_stream_seek() fails with a NULL stream"); begin_network_tests (8); conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE); gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix); stream = mongo_sync_gridfs_stream_new (gfs, NULL); ok (mongo_sync_gridfs_stream_seek (stream, 0, SEEK_SET) == FALSE, "mongo_sync_gridfs_stream_seek() fails with a write stream"); stream->file.type = LMC_GRIDFS_FILE_STREAM_READER; ok (mongo_sync_gridfs_stream_seek (stream, -1, SEEK_SET) == FALSE, "mongo_sync_gridfs_stream_seek() fails with SEEK_SET and a negative " "position"); ok (mongo_sync_gridfs_stream_seek (stream, 10, SEEK_SET) == FALSE, "mongo_sync_gridfs_stream_seek() fails with SEEK_SET and a position " "past EOF"); ok (mongo_sync_gridfs_stream_seek (stream, -1, SEEK_CUR) == FALSE, "mongo_sync_gridfs_stream_seek() fails with SEEK_CUR and a position " "before the start"); ok (mongo_sync_gridfs_stream_seek (stream, 10, SEEK_CUR) == FALSE, "mongo_sync_gridfs_stream_seek() fails with SEEK_CUR and a position " "past EOF"); ok (mongo_sync_gridfs_stream_seek (stream, 1, SEEK_END) == FALSE, "mongo_sync_gridfs_stream_seek() fails with SEEK_END and a position " "past EOF"); ok (mongo_sync_gridfs_stream_seek (stream, -1, SEEK_END) == FALSE, "mongo_sync_gridfs_stream_seek() fails with SEEK_END and a position " "before the start"); ok (mongo_sync_gridfs_stream_seek (stream, 0, 42) == FALSE, "mongo_sync_gridfs_stream_seek() fails with an invalid whence"); mongo_sync_gridfs_stream_close (stream); mongo_sync_gridfs_free (gfs, TRUE); end_network_tests (); }
void test_mongo_sync_cmd_is_master_net (void) { mongo_sync_connection *conn; begin_network_tests (2); conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE); ok (mongo_sync_cmd_is_master (conn) == TRUE, "mongo_sync_cmd_is_master() works"); mongo_sync_disconnect (conn); test_mongo_sync_cmd_is_master_net_secondary (); end_network_tests (); }
void test_mongo_sync_cmd_create_net (void) { mongo_sync_connection *conn; gchar *cc; begin_network_tests (5); conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE); cc = g_strconcat (config.coll, ".capped", NULL); mongo_sync_cmd_drop (conn, config.db, config.coll); mongo_sync_cmd_drop (conn, config.db, cc); ok (mongo_sync_cmd_create (conn, config.db, config.coll, MONGO_COLLECTION_DEFAULTS) == TRUE, "mongo_sync_cmd_create() can create normal collections"); mongo_sync_cmd_drop (conn, config.db, config.coll); ok (mongo_sync_cmd_create (conn, config.db, config.coll, MONGO_COLLECTION_SIZED, (gint64) 64 * 1024 * 10) == TRUE, "mongo_sync_cmd_create() can create pre-allocated collections"); ok (mongo_sync_cmd_create (conn, config.db, cc, MONGO_COLLECTION_CAPPED, (gint64) -1) == FALSE, "mongo_sync_cmd_create() fails when trying to create a capped " "collection with an invalid size"); ok (mongo_sync_cmd_create (conn, config.db, cc, MONGO_COLLECTION_CAPPED_MAX, (gint64) (64 * 1024 * 10), (gint64) -1) == FALSE, "mongo_sync_cmd_create() fails when trying to create a capped " "collection with invalid max."); ok (mongo_sync_cmd_create (conn, config.db, cc, MONGO_COLLECTION_CAPPED_MAX | MONGO_COLLECTION_AUTO_INDEX_ID, (gint64)(64 * 1024 * 10), (gint64) 10) == TRUE, "mongo_sync_cmd_create() can create capped collections"); mongo_sync_cmd_drop (conn, config.db, cc); g_free (cc); mongo_sync_disconnect (conn); end_network_tests (); }
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_connect (void) { mongo_sync_connection *c; ok (mongo_sync_connect (NULL, 27017, FALSE) == NULL, "mongo_sync_connect() fails with a NULL host"); begin_network_tests (1); ok ((c = mongo_sync_connect (config.primary_host, config.primary_port, FALSE)) != NULL, "mongo_sync_connect() works"); mongo_sync_disconnect (c); end_network_tests (); }
void test_mongo_packet_recv (void) { mongo_connection c, *conn; mongo_packet *p; bson *b; c.fd = -1; ok (mongo_packet_recv (NULL) == NULL, "mongo_packet_recv() fails with a NULL connection"); ok (errno == ENOTCONN, "mongo_packet_recv() sets errno to ENOTCONN if connection is NULL"); ok (mongo_packet_recv (&c) == NULL, "mongo_packet_recv() fails if the FD is less than zero"); ok (errno == EBADF, "mongo_packet_recv() sets errno to EBADF is the FD is bad"); begin_network_tests (2); b = bson_new (); bson_append_int32 (b, "getnonce", 1); bson_finish (b); p = mongo_wire_cmd_custom (42, config.db, 0, b); bson_free (b); conn = mongo_connect (config.primary_host, config.primary_port); mongo_packet_send (conn, p); mongo_wire_packet_free (p); ok ((p = mongo_packet_recv (conn)) != NULL, "mongo_packet_recv() works"); mongo_wire_packet_free (p); close (conn->fd); sleep (3); ok (mongo_packet_recv (conn) == NULL, "mongo_packet_recv() fails on a closed socket"); mongo_disconnect (conn); end_network_tests (); }
void test_mongo_sync_gridfs_stream_write (void) { mongo_sync_connection *conn; mongo_sync_gridfs *gfs; mongo_sync_gridfs_stream *stream; bson *meta; guint8 buffer[4096]; mongo_util_oid_init (0); meta = bson_build (BSON_TYPE_STRING, "my-id", "sync_gridfs_stream_write", -1, BSON_TYPE_NONE); bson_finish (meta); ok (mongo_sync_gridfs_stream_write (NULL, buffer, sizeof (buffer)) == FALSE, "mongo_sync_gridfs_stream_write() should fail with a NULL connection"); begin_network_tests (4); conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE); gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix); stream = mongo_sync_gridfs_stream_new (gfs, meta); ok (mongo_sync_gridfs_stream_write (stream, NULL, sizeof (buffer)) == FALSE, "mongo_sync_gridfs_stream_write() should fail with a NULL buffer"); ok (mongo_sync_gridfs_stream_write (stream, buffer, 0) == FALSE, "mongo_sync_gridfs_stream_write() should fail with 0 size"); ok (mongo_sync_gridfs_stream_write (stream, buffer, sizeof (buffer)) == TRUE, "mongo_sync_gridfs_stream_write() works"); stream->file.type = LMC_GRIDFS_FILE_STREAM_READER; ok (mongo_sync_gridfs_stream_write (stream, buffer, sizeof (buffer)) == FALSE, "mongo_sync_gridfs_stream_write() should fail with a read stream"); mongo_sync_gridfs_stream_close (stream); mongo_sync_gridfs_free (gfs, TRUE); end_network_tests (); bson_free (meta); }
void test_mongo_sync_gridfs_stream_new (void) { mongo_sync_connection *conn; mongo_sync_gridfs *gfs; mongo_sync_gridfs_stream *stream; bson *meta; mongo_util_oid_init (0); meta = bson_build (BSON_TYPE_STRING, "my-id", "sync_gridfs_stream_new", -1, BSON_TYPE_NONE); bson_finish (meta); ok (mongo_sync_gridfs_stream_new (NULL, meta) == FALSE, "mongo_sync_gridfs_stream_new() should fail with a NULL connection"); begin_network_tests (2); conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE); gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix); stream = mongo_sync_gridfs_stream_new (gfs, NULL); ok (stream != NULL, "mongo_sync_gridfs_stream_new() works with NULL metadata"); mongo_sync_gridfs_stream_close (stream); stream = mongo_sync_gridfs_stream_new (gfs, meta); ok (stream != NULL, "mongo_sync_gridfs_stream_new() works with metadata"); mongo_sync_gridfs_stream_close (stream); mongo_sync_gridfs_free (gfs, TRUE); end_network_tests (); bson_free (meta); }
void test_mongo_connection_get_requestid (void) { mongo_connection c, *conn; mongo_packet *p; bson *b; gint reqid; c.request_id = 42; ok (mongo_connection_get_requestid (NULL) == -1, "mongo_connection_get_requestid() fails with a NULL connection"); ok (mongo_connection_get_requestid (&c) == 42, "mongo_connection_get_requestid() works"); begin_network_tests (2); b = bson_new (); bson_append_int32 (b, "getnonce", 1); bson_finish (b); p = mongo_wire_cmd_custom (42, config.db, 0, b); bson_free (b); conn = mongo_connect (config.primary_host, config.primary_port); cmp_ok ((reqid = mongo_connection_get_requestid (conn)), "==", 0, "Initial request id is 0"); mongo_packet_send (conn, p); mongo_wire_packet_free (p); cmp_ok (reqid, "<", mongo_connection_get_requestid (conn), "Old request ID is smaller than the new one"); mongo_disconnect (conn); end_network_tests (); }
void test_mongo_sync_gridfs_stream_read (void) { mongo_sync_connection *conn; mongo_sync_gridfs *gfs; mongo_sync_gridfs_stream *stream; guint8 buffer[4096]; mongo_util_oid_init (0); ok (mongo_sync_gridfs_stream_read (NULL, buffer, sizeof (buffer)) == -1, "mongo_sync_gridfs_stream_read() should fail with a NULL connection"); begin_network_tests (3); conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE); gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix); stream = mongo_sync_gridfs_stream_new (gfs, NULL); ok (mongo_sync_gridfs_stream_read (stream, buffer, sizeof (buffer)) == -1, "mongo-sync_gridfs_stream_read() should fail when the stream is " "write-only"); stream->file.type = LMC_GRIDFS_FILE_STREAM_READER; ok (mongo_sync_gridfs_stream_read (stream, NULL, sizeof (buffer)) == -1, "mongo_sync_gridfs_stream_read() should fail with a NULL buffer"); ok (mongo_sync_gridfs_stream_read (stream, buffer, 0) == -1, "mongo_sync_gridfs_stream_read() should fail with a 0 size"); mongo_sync_gridfs_stream_close (stream); mongo_sync_gridfs_free (gfs, TRUE); end_network_tests (); }
void test_mongo_sync_cmd_custom_net (void) { mongo_sync_connection *conn; bson *cmd; mongo_packet *p; begin_network_tests (3); conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE); mongo_sync_cmd_is_master (conn); mongo_sync_conn_set_auto_reconnect (conn, TRUE); cmd = bson_build (BSON_TYPE_INT32, "getnonce", 1, BSON_TYPE_NONE); bson_finish (cmd); p = mongo_sync_cmd_custom (conn, config.db, cmd); ok (p != NULL, "mongo_sync_cmd_custom() works"); mongo_wire_packet_free (p); shutdown (conn->super.fd, SHUT_RDWR); sleep (3); p = mongo_sync_cmd_custom (conn, config.db, cmd); ok (p != NULL, "mongo_sync_cmd_custom() automatically reconnects"); mongo_wire_packet_free (p); bson_free (cmd); mongo_sync_disconnect (conn); test_mongo_sync_cmd_custom_net_secondary (); 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 (); }
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 (); }