From fd841e416881cc0392e61ec312c1870f3a0004bd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Tue, 2 Dec 2014 10:06:21 +0100 Subject: Initial import of libmongo-client version 0.1.8-2 --- .../mongo/sync-gridfs-chunk/f_sync_gridfs_chunk.c | 499 +++++++++++++++++++++ 1 file changed, 499 insertions(+) create mode 100644 tests/func/mongo/sync-gridfs-chunk/f_sync_gridfs_chunk.c (limited to 'tests/func/mongo/sync-gridfs-chunk/f_sync_gridfs_chunk.c') diff --git a/tests/func/mongo/sync-gridfs-chunk/f_sync_gridfs_chunk.c b/tests/func/mongo/sync-gridfs-chunk/f_sync_gridfs_chunk.c new file mode 100644 index 0000000..cac6e28 --- /dev/null +++ b/tests/func/mongo/sync-gridfs-chunk/f_sync_gridfs_chunk.c @@ -0,0 +1,499 @@ +#include "test.h" +#include "mongo.h" + +#define FILE_SIZE 1024 * 1024 + 12345 + +static guint8 noname_oid[12]; +static guint8 named_oid[12]; +static guint8 binsub_oid[12]; + +void +test_func_sync_gridfs_put (void) +{ + mongo_sync_connection *conn; + mongo_sync_gridfs *gfs; + mongo_sync_gridfs_chunked_file *gfile; + bson *meta; + guint8 *data, *oid; + gchar *oid_s; + + conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE); + gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix); + oid = mongo_util_oid_new (1); + meta = bson_build (BSON_TYPE_STRING, "filename", "libmongo-test", -1, + BSON_TYPE_OID, "_id", oid, + BSON_TYPE_NONE); + g_free (oid); + bson_finish (meta); + + data = g_malloc (FILE_SIZE); + memset (data, 'x', FILE_SIZE); + + gfile = mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, meta, + data, FILE_SIZE); + ok (gfile != NULL, + "GridFS file upload (with metadata) works!"); + memcpy (named_oid, mongo_sync_gridfs_file_get_id (gfile), 12); + oid_s = mongo_util_oid_as_string (named_oid); + note ("Named file ID : %s\n", oid_s); + g_free (oid_s); + mongo_sync_gridfs_chunked_file_free (gfile); + + gfile = mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, NULL, + data, FILE_SIZE); + ok (gfile != NULL, + "GridFS file upload (w/o metadata) works!"); + memcpy (noname_oid, mongo_sync_gridfs_file_get_id (gfile), 12); + oid_s = mongo_util_oid_as_string (noname_oid); + note ("Noname file ID: %s\n", oid_s); + g_free (oid_s); + mongo_sync_gridfs_chunked_file_free (gfile); + + g_free (data); + bson_free (meta); + mongo_sync_gridfs_free (gfs, TRUE); +} + +void +test_func_sync_gridfs_put_invalid (void) +{ + mongo_sync_connection *conn; + bson *meta; + gchar *ns; + + conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE); + ns = g_strconcat (config.gfs_prefix, ".files", NULL); + + /* Insert metadata without any of the required fields but ID. */ + meta = bson_build (BSON_TYPE_STRING, "my-id", "id-only", -1, + BSON_TYPE_NONE); + bson_finish (meta); + + mongo_sync_cmd_insert (conn, ns, meta, NULL); + bson_free (meta); + + /* Insert metadata with an ID that's not an ObjectID. */ + meta = bson_build (BSON_TYPE_STRING, "_id", "I'm a teapot", -1, + BSON_TYPE_STRING, "my-id", "string-id", -1, + BSON_TYPE_NONE); + bson_finish (meta); + + mongo_sync_cmd_insert (conn, ns, meta, NULL); + bson_free (meta); + + /* Insert metadata with invalid length type. */ + meta = bson_build (BSON_TYPE_DOUBLE, "length", 1.0, + BSON_TYPE_STRING, "my-id", "invalid-length", -1, + BSON_TYPE_NONE); + bson_finish (meta); + + mongo_sync_cmd_insert (conn, ns, meta, NULL); + bson_free (meta); + + /* Insert metadata with invalid chunkSize type. */ + meta = bson_build (BSON_TYPE_INT32, "length", 10, + BSON_TYPE_DOUBLE, "chunkSize", 12.5, + BSON_TYPE_STRING, "my-id", "invalid-chunkSize", -1, + BSON_TYPE_NONE); + bson_finish (meta); + + mongo_sync_cmd_insert (conn, ns, meta, NULL); + bson_free (meta); + + /* Insert metadata with invalid uploadDate type. */ + meta = bson_build (BSON_TYPE_INT32, "length", 10, + BSON_TYPE_INT32, "chunkSize", 12, + BSON_TYPE_STRING, "my-id", "invalid-date", -1, + BSON_TYPE_INT32, "uploadDate", 1234, + BSON_TYPE_NONE); + bson_finish (meta); + + mongo_sync_cmd_insert (conn, ns, meta, NULL); + bson_free (meta); + + /* Insert metadata with invalid md5 type. */ + meta = bson_build (BSON_TYPE_INT32, "length", 32, + BSON_TYPE_INT32, "chunkSize", 12, + BSON_TYPE_UTC_DATETIME, "uploadDate", (gint64)1234, + BSON_TYPE_INT32, "md5", 0, + BSON_TYPE_STRING, "my-id", "invalid-md5", -1, + BSON_TYPE_NONE); + bson_finish (meta); + + mongo_sync_cmd_insert (conn, ns, meta, NULL); + bson_free (meta); + + /* Insert a valid metadata, without chunks. */ + meta = bson_build (BSON_TYPE_INT32, "length", 32, + BSON_TYPE_INT32, "chunkSize", 12, + BSON_TYPE_UTC_DATETIME, "uploadDate", (gint64)1234, + BSON_TYPE_STRING, "md5", "deadbeef", -1, + BSON_TYPE_STRING, "my-id", "no-chunks", -1, + BSON_TYPE_NONE); + bson_finish (meta); + + mongo_sync_cmd_insert (conn, ns, meta, NULL); + bson_free (meta); + + g_free (ns); + mongo_sync_disconnect (conn); +} + +void +validate_file (mongo_sync_gridfs *gfs, const bson *query, guint8 *oid, + gboolean validate_md5) +{ + mongo_sync_gridfs_chunked_file *f; + mongo_sync_cursor *cursor; + gint64 n = 0, tsize = 0; + const bson *meta; + gchar *oid_s; + + f = mongo_sync_gridfs_chunked_find (gfs, query); + + ok (f != NULL, + "File not found"); + ok (memcmp (mongo_sync_gridfs_file_get_id (f), oid, 12) == 0, + "File _id matches"); + cmp_ok (mongo_sync_gridfs_file_get_length (f), "==", FILE_SIZE, + "File length matches"); + cmp_ok (mongo_sync_gridfs_file_get_chunk_size (f), "==", + mongo_sync_gridfs_get_chunk_size (gfs), + "File chunk size matches"); + + oid_s = mongo_util_oid_as_string (mongo_sync_gridfs_file_get_id (f)); + note ("File info:\n\tid = %s; length = %" G_GINT64_FORMAT "; " + "chunk_size = %d; date = %" G_GINT64_FORMAT "; " + "md5 = %s; n = %" G_GINT64_FORMAT "\n", + + oid_s, + mongo_sync_gridfs_file_get_length (f), + mongo_sync_gridfs_file_get_chunk_size (f), + mongo_sync_gridfs_file_get_date (f), + mongo_sync_gridfs_file_get_md5 (f), + mongo_sync_gridfs_file_get_chunks (f)); + g_free (oid_s); + meta = mongo_sync_gridfs_file_get_metadata (f); + ok (meta != NULL, + "mongo_sync_gridfs_file_get_metadata() works"); + + cursor = mongo_sync_gridfs_chunked_file_cursor_new (f, 0, 0); + while (mongo_sync_cursor_next (cursor)) + { + gint32 size; + guint8 *data; + + data = mongo_sync_gridfs_chunked_file_cursor_get_chunk (cursor, &size); + g_free (data); + + tsize += size; + n++; + } + mongo_sync_cursor_free (cursor); + + if (validate_md5) + cmp_ok (mongo_sync_gridfs_file_get_length (f), "==", tsize, + "File size matches the sum of its chunks"); + cmp_ok (mongo_sync_gridfs_file_get_chunks (f), "==", n, + "Number of chunks matches the expected number"); + + mongo_sync_gridfs_chunked_file_free (f); +} + +void +test_func_sync_gridfs_get (void) +{ + mongo_sync_connection *conn; + mongo_sync_gridfs *gfs; + bson *query; + + conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE); + gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix); + + query = bson_build (BSON_TYPE_STRING, "filename", "libmongo-test", -1, + BSON_TYPE_NONE); + bson_finish (query); + validate_file (gfs, query, named_oid, TRUE); + bson_free (query); + + query = bson_build (BSON_TYPE_OID, "_id", noname_oid, + BSON_TYPE_NONE); + bson_finish (query); + validate_file (gfs, query, noname_oid, TRUE); + bson_free (query); + + mongo_sync_gridfs_free (gfs, TRUE); +} + +void +test_get_invalid (mongo_sync_gridfs *gfs, gchar *name, gchar *msg) +{ + bson *query; + + query = bson_build (BSON_TYPE_STRING, "my-id", name, -1, + BSON_TYPE_NONE); + bson_finish (query); + ok (mongo_sync_gridfs_chunked_find (gfs, query) == NULL, msg); + bson_free (query); +} + +void +test_func_sync_gridfs_get_invalid (void) +{ + mongo_sync_connection *conn; + mongo_sync_gridfs *gfs; + mongo_sync_cursor *cursor; + bson *query; + gchar *ns; + + conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE); + gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix); + + test_get_invalid (gfs, "unknown", + "mongo_sync_gridfs_chunked_find() should fail when no file " + "is found"); + test_get_invalid (gfs, "id-only", + "mongo_sync_gridfs_chunked__find() should fail if the metadata " + "is incomplete"); + test_get_invalid (gfs, "string-id", + "mongo_sync_gridfs_chunked__find() should fail if the _id is " + "not an ObjectID"); + test_get_invalid (gfs, "invalid-length", + "mongo_sync_gridfs_chunked__find() should fail if length is " + "of inappropriate type"); + test_get_invalid (gfs, "invalid-chunkSize", + "mongo_sync_gridfs_chunked__find() should fail if chunkSize is " + "of inappropriate type"); + test_get_invalid (gfs, "invalid-date", + "mongo_sync_gridfs_chunked__find() should fail if uploadDate is " + "of inappropriate type"); + test_get_invalid (gfs, "invalid-md5", + "mongo_sync_gridfs_chunked__find() should fail if md5 is of " + "inappropriate type"); + + ns = g_strconcat (config.gfs_prefix, ".files", NULL); + query = bson_build (BSON_TYPE_STRING, "my-id", "id-only", -1, + BSON_TYPE_NONE); + bson_finish (query); + + cursor = mongo_sync_cursor_new (conn, ns, + mongo_sync_cmd_query (conn, ns, 0, 0, 0, + query, NULL)); + bson_free (query); + mongo_sync_cursor_next (cursor); + ok (mongo_sync_gridfs_chunked_file_cursor_get_chunk (cursor, NULL) == NULL, + "mongo_sync_gridfs_chunked_file_cursor_get_chunk() should fail with " + "invalid data"); + + mongo_sync_gridfs_free (gfs, TRUE); +} + +void +test_func_sync_gridfs_list (void) +{ + mongo_sync_gridfs *gfs; + bson *query, *data; + mongo_sync_cursor *cursor; + bson_cursor *c; + const gchar *str; + gboolean found_named = FALSE, found_noname = FALSE; + const guint8 *oid; + + gfs = mongo_sync_gridfs_new + (mongo_sync_connect (config.primary_host, config.primary_port, TRUE), + config.gfs_prefix); + + /* Test list with an invalid query */ + query = bson_build (BSON_TYPE_STRING, "no-such-field", + "You're not seeing this field.", -1, + BSON_TYPE_NONE); + bson_finish (query); + + cursor = mongo_sync_gridfs_list (gfs, query); + ok (cursor == NULL, + "mongo_sync_gridfs_list() should fail if there query " + "does not match anything"); + bson_free (query); + + /* Test list with a query */ + query = bson_build (BSON_TYPE_OID, "_id", named_oid, + BSON_TYPE_NONE); + bson_finish (query); + + cursor = mongo_sync_gridfs_list (gfs, query); + ok (cursor != NULL, + "mongo_sync_gridfs_list() correctly finds files by query"); + + mongo_sync_cursor_next (cursor); + data = mongo_sync_cursor_get_data (cursor); + c = bson_find (data, "filename"); + bson_cursor_get_string (c, &str); + bson_cursor_free (c); + + is (str, "libmongo-test", + "The listed file is named correctly"); + bson_free (data); + mongo_sync_cursor_free (cursor); + + bson_free (query); + + /* Test list without a query */ + cursor = mongo_sync_gridfs_list (gfs, NULL); + while (mongo_sync_cursor_next (cursor)) + { + data = mongo_sync_cursor_get_data (cursor); + + c = bson_find (data, "_id"); + bson_cursor_get_oid (c, (const guint8 **)&oid); + bson_cursor_free (c); + + if (memcmp (oid, named_oid, 12) == 0) + found_named = TRUE; + if (memcmp (oid, noname_oid, 12) == 0) + found_noname = TRUE; + + bson_free (data); + } + mongo_sync_cursor_free (cursor); + + ok (found_named == TRUE && found_noname == TRUE, + "mongo_sync_gridfs_list() finds both uploaded files without a query"); + + mongo_sync_gridfs_free (gfs, TRUE); +} + +void +test_fync_sync_gridfs_remove (void) +{ + mongo_sync_gridfs *gfs; + bson *query; + + gfs = mongo_sync_gridfs_new + (mongo_sync_connect (config.primary_host, config.primary_port, TRUE), + config.gfs_prefix); + + /* Test with a non-matching query */ + query = bson_build (BSON_TYPE_STRING, "no-such-field", + "You're not seeing this field.", -1, + BSON_TYPE_NONE); + bson_finish (query); + + ok (mongo_sync_gridfs_remove (gfs, query) == FALSE, + "mongo_sync_gridfs_remove() should fail if there's nothing to delete."); + bson_free (query); + + /* Test with a non-string id */ + query = bson_build (BSON_TYPE_STRING, "my-id", "string-id", -1, + BSON_TYPE_NONE); + bson_finish (query); + + ok (mongo_sync_gridfs_remove (gfs, query) == FALSE, + "mongo_sync_gridfs_remove() should fail if the file id is not " + "an ObjectId"); + bson_free (query); + + /* Test with a working query */ + query = bson_build (BSON_TYPE_OID, "_id", named_oid, + BSON_TYPE_NONE); + bson_finish (query); + + ok (mongo_sync_gridfs_remove (gfs, query) == TRUE, + "mongo_sync_gridfs_remove() works"); + bson_finish (query); + + mongo_sync_gridfs_free (gfs, TRUE); +} + +void +test_func_sync_gridfs_put_binary_subtype (void) +{ + mongo_sync_connection *conn; + mongo_sync_gridfs *gfs; + mongo_sync_gridfs_chunked_file *gfile; + bson *meta, *query, *update; + guint8 *data; + gchar *chunk_ns; + guint32 size = GINT32_TO_LE(FILE_SIZE); + + conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE); + gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix); + meta = bson_build (BSON_TYPE_STRING, "filename", "binsub-libmongo-test", -1, + BSON_TYPE_NONE); + bson_finish (meta); + + data = g_malloc (FILE_SIZE + 4); + memcpy (data, &size, 4); + memset (data + 4, 'x', FILE_SIZE); + + gfile = mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, meta, + data + 4, FILE_SIZE); + memcpy (binsub_oid, mongo_sync_gridfs_file_get_id (gfile), 12); + + query = bson_build (BSON_TYPE_OID, "files_id", + mongo_sync_gridfs_file_get_id (gfile), + BSON_TYPE_NONE); + bson_finish (query); + + mongo_sync_gridfs_chunked_file_free (gfile); + bson_free (meta); + + update = bson_build_full (BSON_TYPE_DOCUMENT, "$set", TRUE, + bson_build (BSON_TYPE_BINARY, "data", + BSON_BINARY_SUBTYPE_BINARY, + data, FILE_SIZE + 4, + BSON_TYPE_NONE), + BSON_TYPE_NONE); + bson_finish (update); + g_free (data); + + chunk_ns = g_strconcat (config.gfs_prefix, ".chunks", NULL); + mongo_sync_cmd_update (conn, chunk_ns, MONGO_WIRE_FLAG_UPDATE_UPSERT, + query, update); + + bson_free (query); + bson_free (update); + g_free (chunk_ns); + + mongo_sync_gridfs_free (gfs, TRUE); +} + +void +test_func_sync_gridfs_get_binary_subtype (void) +{ + mongo_sync_connection *conn; + mongo_sync_gridfs *gfs; + bson *query; + + conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE); + gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix); + + query = bson_build (BSON_TYPE_STRING, "filename", "binsub-libmongo-test", -1, + BSON_TYPE_NONE); + bson_finish (query); + validate_file (gfs, query, binsub_oid, FALSE); + bson_free (query); + + mongo_sync_gridfs_free (gfs, TRUE); +} + +void +test_func_sync_gridfs_chunk (void) +{ + mongo_util_oid_init (0); + + test_func_sync_gridfs_put (); + test_func_sync_gridfs_get (); + test_func_sync_gridfs_list (); + + sleep (2); + + test_func_sync_gridfs_put_binary_subtype (); + test_func_sync_gridfs_get_binary_subtype (); + + test_func_sync_gridfs_put_invalid (); + test_func_sync_gridfs_get_invalid (); + + test_fync_sync_gridfs_remove (); +} + +RUN_NET_TEST (37, func_sync_gridfs_chunk); -- cgit v1.2.3