bson_ext 1.5.0 → 1.5.1

data/ext/cmongo/c-driver/test/count_delete.c

@@ -0,0 +1,64 @@
+/* count_delete.c */
+
+#include "test.h"
+#include "mongo.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+int main(){
+    mongo_connection conn[1];
+    bson_buffer bb;
+    bson b;
+    int i;
+
+    const char * db = "test";
+    const char * col = "c.simple";
+    const char * ns = "test.c.simple";
+
+    INIT_SOCKETS_FOR_WINDOWS;
+
+    if (mongo_connect( conn , TEST_SERVER , 27017 )){
+        printf("failed to connect\n");
+        exit(1);
+    }
+
+    /* if the collection doesn't exist dropping it will fail */
+    if (!mongo_cmd_drop_collection(conn, "test", col, NULL)
+          && mongo_count(conn, db, col, NULL) != 0){
+        printf("failed to drop collection\n");
+        exit(1);
+    }
+
+    for(i=0; i< 5; i++){
+        bson_buffer_init( & bb );
+
+        bson_append_new_oid( &bb, "_id" );
+        bson_append_int( &bb , "a" , i+1 ); /* 1 to 5 */
+        bson_from_buffer(&b, &bb);
+
+        mongo_insert( conn , ns , &b );
+        bson_destroy(&b);
+    }
+
+    /* query: {a: {$gt: 3}} */
+    bson_buffer_init( & bb );
+    {
+        bson_buffer * sub = bson_append_start_object(&bb, "a");
+        bson_append_int(sub, "$gt", 3);
+        bson_append_finish_object(sub);
+    }
+    bson_from_buffer(&b, &bb);
+    
+    ASSERT(mongo_count(conn, db, col, NULL) == 5);
+    ASSERT(mongo_count(conn, db, col, &b) == 2);
+
+    mongo_remove(conn, ns, &b);
+
+    ASSERT(mongo_count(conn, db, col, NULL) == 3);
+    ASSERT(mongo_count(conn, db, col, &b) == 0);
+
+    mongo_cmd_drop_db(conn, db);
+    mongo_destroy(conn);
+    return 0;
+}

data/ext/cmongo/c-driver/test/endian_swap.c

@@ -0,0 +1,31 @@
+/* endian_swap.c */
+
+#include "test.h"
+#include "platform_hacks.h"
+#include <stdio.h>
+
+int main(){
+    int small = 0x00112233;
+    int64_t big = 0x0011223344556677;
+    double d = 1.2345;
+
+    int small_swap;
+    int64_t big_swap;
+    int64_t d_swap;
+
+    bson_swap_endian32(&small_swap, &small);
+    ASSERT( small_swap == 0x33221100);
+    bson_swap_endian32(&small, &small_swap);
+    ASSERT(small == 0x00112233);
+
+    bson_swap_endian64(&big_swap, &big);
+    ASSERT(big_swap == 0x7766554433221100);
+    bson_swap_endian64(&big, &big_swap);
+    ASSERT(big == 0x0011223344556677);
+
+    bson_swap_endian64(&d_swap, &d);
+    bson_swap_endian64(&d, &d_swap);
+    ASSERT(d == 1.2345);
+
+    return 0;
+}

data/ext/cmongo/c-driver/test/errors.c

@@ -0,0 +1,71 @@
+#include "test.h"
+#include "mongo.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+static mongo_connection conn[1];
+static const char* db = "test";
+static const char* ns = "test.c.error";
+
+int main(){
+    bson obj;
+
+    INIT_SOCKETS_FOR_WINDOWS;
+
+    if (mongo_connect( conn , TEST_SERVER, 27017 )){
+        printf("failed to connect\n");
+        exit(1);
+    }
+
+
+    /*********************/
+    ASSERT(!mongo_cmd_get_prev_error(conn, db, NULL));
+    ASSERT(!mongo_cmd_get_last_error(conn, db, NULL));
+
+    ASSERT(!mongo_cmd_get_prev_error(conn, db, &obj));
+    bson_destroy(&obj);
+
+    ASSERT(!mongo_cmd_get_last_error(conn, db, &obj));
+    bson_destroy(&obj);
+
+    /*********************/
+    mongo_simple_int_command(conn, db, "forceerror", 1, NULL);
+
+    ASSERT(mongo_cmd_get_prev_error(conn, db, NULL));
+    ASSERT(mongo_cmd_get_last_error(conn, db, NULL));
+
+    ASSERT(mongo_cmd_get_prev_error(conn, db, &obj));
+    bson_destroy(&obj);
+
+    ASSERT(mongo_cmd_get_last_error(conn, db, &obj));
+    bson_destroy(&obj);
+
+    /* should clear lasterror but not preverror */
+    mongo_find_one(conn, ns, bson_empty(&obj), bson_empty(&obj), NULL);
+
+    ASSERT(mongo_cmd_get_prev_error(conn, db, NULL));
+    ASSERT(!mongo_cmd_get_last_error(conn, db, NULL));
+
+    ASSERT(mongo_cmd_get_prev_error(conn, db, &obj));
+    bson_destroy(&obj);
+
+    ASSERT(!mongo_cmd_get_last_error(conn, db, &obj));
+    bson_destroy(&obj);
+
+    /*********************/
+    mongo_cmd_reset_error(conn, db);
+
+    ASSERT(!mongo_cmd_get_prev_error(conn, db, NULL));
+    ASSERT(!mongo_cmd_get_last_error(conn, db, NULL));
+
+    ASSERT(!mongo_cmd_get_prev_error(conn, db, &obj));
+    bson_destroy(&obj);
+
+    ASSERT(!mongo_cmd_get_last_error(conn, db, &obj));
+    bson_destroy(&obj);
+
+    mongo_cmd_drop_db(conn, db);
+    mongo_destroy(conn);
+    return 0;
+}

data/ext/cmongo/c-driver/test/examples.c

@@ -0,0 +1,75 @@
+#include "test.h"
+#include "bson.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+int main(){
+    bson_buffer bb;
+    bson b, sub;
+    bson_iterator it;
+
+    /* Create a rich document like this one:
+     *
+     * { _id: ObjectId("4d95ea712b752328eb2fc2cc"),
+     *   user_id: ObjectId("4d95ea712b752328eb2fc2cd"),
+     *
+     *   items: [
+     *     { sku: "col-123",
+     *       name: "John Coltrane: Impressions",
+     *       price: 1099,
+     *     },
+     *
+     *     { sku: "young-456",
+     *       name: "Larry Young: Unity",
+     *       price: 1199
+     *     }
+     *   ],
+     *
+     *   address: {
+     *     street: "59 18th St.",
+     *     zip: 10010
+     *   },
+     *
+     *   total: 2298
+     * }
+     */
+    bson_buffer_init( &bb );
+    bson_append_new_oid( &bb, "_id" );
+    bson_append_new_oid( &bb, "user_id" );
+
+    bson_append_start_array( &bb, "items" );
+        bson_append_start_object( &bb, "0" );
+            bson_append_string( &bb, "name", "John Coltrane: Impressions" );
+            bson_append_int( &bb, "price", 1099 );
+        bson_append_finish_object( &bb );
+
+        bson_append_start_object( &bb, "1" );
+            bson_append_string( &bb, "name", "Larry Young: Unity" );
+            bson_append_int( &bb, "price", 1199 );
+        bson_append_finish_object( &bb );
+    bson_append_finish_object( &bb );
+
+    bson_append_start_object( &bb, "address" );
+        bson_append_string( &bb, "street", "59 18th St." );
+        bson_append_int( &bb, "zip", 10010 );
+    bson_append_finish_object( &bb );
+
+    bson_append_int( &bb, "total", 2298 );
+
+    /* Convert from a buffer to a raw BSON object that
+     * can be sent to the server:
+     */
+    bson_from_buffer( &b, &bb );
+
+    /* Advance to the 'items' array */
+    bson_find( &it, &b, "items" );
+
+    /* Get the subobject representing items */
+    bson_iterator_subobject( &it, &sub );
+
+    /* Now iterate that object */
+    bson_print( &sub );
+
+   return 0;
+}

data/ext/cmongo/c-driver/test/gridfs.c

@@ -0,0 +1,217 @@
+#include "test.h"
+#include "md5.h"
+#include "mongo.h"
+#include "gridfs.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#define LARGE 3*1024*1024
+#define UPPER 2000*1024
+#define LOWER 1024*128
+#define DELTA 1024*128
+
+void fill_buffer_randomly(char * data, int64_t length)
+{
+    int64_t i;
+    int random;
+    char * letters = "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    int nletters = strlen(letters)+1;
+
+    for (i = 0; i < length; i++) {
+        random = rand() % nletters;
+        *(data + i) = letters[random];
+    }
+}
+
+static void digest2hex(mongo_md5_byte_t digest[16], char hex_digest[33]){
+    static const char hex[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
+    int i;
+    for (i=0; i<16; i++){
+        hex_digest[2*i]     = hex[(digest[i] & 0xf0) >> 4];
+        hex_digest[2*i + 1] = hex[ digest[i] & 0x0f      ];
+    }
+    hex_digest[32] = '\0';
+}
+
+void test_gridfile(gridfs *gfs, char *data_before, int64_t length, char *filename, char *content_type) {
+    gridfile gfile[1];
+    char data_after[LARGE];
+    FILE * fd;
+    mongo_md5_state_t pms[1];
+    mongo_md5_byte_t digest[16];
+    char hex_digest[33];
+
+    gridfs_find_filename(gfs, filename, gfile);
+    ASSERT(gridfile_exists(gfile));
+
+    fd = fopen("output", "w+");
+    gridfile_write_file(gfile, fd);
+    fseek(fd, 0, SEEK_SET);
+    ASSERT(fread(data_after, length, sizeof(char), fd));
+    fclose(fd);
+    ASSERT( strncmp(data_before, data_after, length) == 0 );
+
+    gridfile_read( gfile, length, data_after );
+    ASSERT( strncmp(data_before, data_after, length) == 0 );
+
+    ASSERT( strcmp( gridfile_get_filename( gfile ), filename ) == 0 );
+
+    ASSERT( gridfile_get_contentlength( gfile ) == length );
+
+    ASSERT( gridfile_get_chunksize( gfile ) == DEFAULT_CHUNK_SIZE );
+
+    ASSERT( strcmp( gridfile_get_contenttype( gfile ), content_type ) == 0) ;
+
+    mongo_md5_init(pms);
+    mongo_md5_append(pms, (const mongo_md5_byte_t *)data_before, (int)length);
+    mongo_md5_finish(pms, digest);
+    digest2hex(digest, hex_digest);
+    ASSERT( strcmp( gridfile_get_md5( gfile ), hex_digest ) == 0 );
+
+    gridfile_destroy(gfile);
+    gridfs_remove_filename(gfs, filename);
+}
+
+void test_basic() {
+    mongo_connection conn[1];
+    gridfs gfs[1];
+    char data_before[UPPER];
+    int64_t i;
+    FILE *fd;
+
+    srand(time(NULL));
+
+    INIT_SOCKETS_FOR_WINDOWS;
+
+    if (mongo_connect( conn, TEST_SERVER, 27017 )){
+        printf("failed to connect 2\n");
+        exit(1);
+    }
+
+    gridfs_init(conn, "test", "fs", gfs);
+
+    for (i = LOWER; i <= UPPER; i+=DELTA) {
+        fill_buffer_randomly(data_before, i);
+
+        /* Input from buffer */
+        gridfs_store_buffer(gfs, data_before, i, "input-buffer", "text/html");
+        test_gridfile(gfs, data_before, i, "input-buffer", "text/html");
+
+        /* Input from file */
+        fd = fopen("input-file", "w");
+        fwrite(data_before, sizeof(char), i, fd);
+        fclose(fd);
+        gridfs_store_file(gfs, "input-file", "input-file", "text/html");
+        test_gridfile(gfs, data_before, i, "input-file", "text/html");
+    }
+
+    gridfs_destroy(gfs);
+    mongo_disconnect(conn);
+    mongo_destroy(conn);
+}
+
+void test_streaming() {
+    mongo_connection conn[1];
+    gridfs gfs[1];
+    gridfile gfile[1];
+    char buf[LARGE];
+    char small[LOWER];
+    int n;
+
+    srand(time(NULL));
+
+    INIT_SOCKETS_FOR_WINDOWS;
+
+    if (mongo_connect( conn , TEST_SERVER, 27017 )){
+        printf("failed to connect 3\n");
+        exit(1);
+    }
+
+    fill_buffer_randomly(small, (int64_t)LOWER);
+    fill_buffer_randomly(buf, (int64_t)LARGE);
+
+    gridfs_init(conn, "test", "fs", gfs);
+
+    gridfs_store_buffer(gfs, small, LOWER, "small", "text/html");
+    test_gridfile(gfs, small, LOWER, "small", "text/html");
+    gridfs_destroy(gfs);
+
+    gridfs_init(conn, "test", "fs", gfs);
+    gridfile_writer_init(gfile, gfs, "large", "text/html");
+    for(n=0; n < (LARGE / 1024); n++) {
+      gridfile_write_buffer(gfile, buf + (n * 1024), 1024);
+    }
+    gridfile_writer_done( gfile );
+    test_gridfile(gfs, buf, LARGE, "large", "text/html");
+
+    gridfs_destroy(gfs);
+    mongo_destroy(conn);
+}
+
+void test_large() {
+    mongo_connection conn[1];
+    gridfs gfs[1];
+    gridfile gfile[1];
+    FILE *fd;
+    int i, n;
+    char buffer[LARGE];
+    int64_t filesize = (int64_t)1024 * (int64_t)LARGE;
+
+    srand(time(NULL));
+
+    INIT_SOCKETS_FOR_WINDOWS;
+
+    if (mongo_connect( conn, TEST_SERVER, 27017 )){
+        printf("failed to connect 1\n");
+        exit(1);
+    }
+
+    gridfs_init(conn, "test", "fs", gfs);
+
+    /* Create a very large file */
+    fill_buffer_randomly(buffer, (int64_t)LARGE);
+    fd = fopen("bigfile", "w");
+    for(i=0; i<1024; i++) {
+      fwrite(buffer, 1, LARGE, fd);
+    }
+    fclose(fd);
+
+    /* Now read the file into GridFS */
+    gridfs_store_file(gfs, "bigfile", "bigfile", "text/html");
+
+    gridfs_find_filename(gfs, "bigfile", gfile);
+
+    ASSERT( strcmp( gridfile_get_filename( gfile ), "bigfile" ) == 0 );
+    ASSERT( gridfile_get_contentlength( gfile ) ==  filesize );
+
+    /* Read the file using the streaming interface */
+    gridfile_writer_init( gfile, gfs, "bigfile-stream", "text/html");
+
+    fd = fopen("bigfile", "r");
+
+    while((n = fread(buffer, 1, 1024, fd)) != 0) {
+      gridfile_write_buffer(gfile, buffer, n);
+    }
+    gridfile_writer_done( gfile );
+
+    gridfs_find_filename(gfs, "bigfile-stream", gfile);
+
+    ASSERT( strcmp( gridfile_get_filename( gfile ), "bigfile-stream" ) == 0 );
+    ASSERT( gridfile_get_contentlength( gfile ) ==  filesize );
+
+    gridfs_destroy(gfs);
+    mongo_disconnect(conn);
+    mongo_destroy(conn);
+}
+
+int main(void) {
+    test_basic();
+    test_streaming();
+
+  /* Normally not necessary to run test_large(), as it
+   * deals with very large (3GB) files and is therefore slow.
+   * test_large();
+   */
+    return 0;
+}