bson_ext 1.5.0 → 1.5.1

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

@@ -0,0 +1,169 @@
+/* testjson.c */
+
+#include "test.h"
+#include <stdio.h>
+#include <string.h>
+
+#include "mongo.h"
+#include "json/json.h"
+#include "md5.h"
+
+void json_to_bson_append_element( bson_buffer * bb , const char * k , struct json_object * v );
+
+/**
+   should already have called start_array
+   this will not call start/finish
+ */
+void json_to_bson_append_array( bson_buffer * bb , struct json_object * a ){
+    int i;
+    char buf[10];
+    for ( i=0; i<json_object_array_length( a ); i++){
+        sprintf( buf , "%d" , i );
+        json_to_bson_append_element( bb , buf , json_object_array_get_idx( a , i ) );
+    }
+}
+
+void json_to_bson_append( bson_buffer * bb , struct json_object * o ){
+    json_object_object_foreach(o,k,v){
+        json_to_bson_append_element( bb , k , v );
+    }
+}
+
+void json_to_bson_append_element( bson_buffer * bb , const char * k , struct json_object * v ){
+    if ( ! v ){
+        bson_append_null( bb , k );
+        return;
+    }
+    
+    switch ( json_object_get_type( v ) ){
+    case json_type_int:
+        bson_append_int( bb , k , json_object_get_int( v ) );
+        break;
+    case json_type_boolean:
+        bson_append_bool( bb , k , json_object_get_boolean( v ) );
+        break;
+    case json_type_double:
+        bson_append_double( bb , k , json_object_get_double( v ) );
+        break;
+    case json_type_string:
+        bson_append_string( bb , k , json_object_get_string( v ) );
+        break;
+    case json_type_object:
+        bson_append_start_object( bb , k );
+        json_to_bson_append( bb , v );
+        bson_append_finish_object( bb );
+        break;
+    case json_type_array:
+        bson_append_start_array( bb , k );
+        json_to_bson_append_array( bb , v );
+        bson_append_finish_object( bb );
+        break;
+    default:
+        fprintf( stderr , "can't handle type for : %s\n" , json_object_to_json_string(v) );
+    }
+}
+
+
+char * json_to_bson( char * js ){
+    struct json_object * o = json_tokener_parse(js);
+    bson_buffer bb;
+    
+    if ( is_error( o ) ){
+        fprintf( stderr , "\t ERROR PARSING\n" );
+        return 0;
+    }
+    
+    if ( ! json_object_is_type( o , json_type_object ) ){
+        fprintf( stderr , "json_to_bson needs a JSON object, not type\n" );
+        return 0;
+    }
+    
+    bson_buffer_init( &bb );
+    json_to_bson_append( &bb , o );
+    return bson_buffer_finish( &bb );
+}
+
+int json_to_bson_test( char * js , int size , const char * hash ){
+    bson b;
+    mongo_md5_state_t st;
+    mongo_md5_byte_t digest[16];
+    char myhash[33];
+    int i;
+
+    fprintf( stderr , "----\n%s\n" , js );
+
+    
+    bson_init( &b , json_to_bson( js ) , 1 );
+
+    if ( b.data == 0 ){
+        if ( size == 0 )
+            return 1;
+        fprintf( stderr , "failed when wasn't supposed to: %s\n" , js );
+        return 0;
+        
+    }
+    
+    if ( size != bson_size( &b ) ){
+        fprintf( stderr , "sizes don't match [%s] want != got %d != %d\n" , js , size , bson_size(&b) );
+        bson_destroy( &b );
+        return 0;
+    }    
+
+    mongo_md5_init(&st);
+    mongo_md5_append( &st , (const mongo_md5_byte_t*)b.data , bson_size( &b ) );
+    mongo_md5_finish(&st, digest);
+
+    for ( i=0; i<16; i++ )
+        sprintf( myhash + ( i * 2 ) , "%.2x" , digest[i] );
+    myhash[32] = 0;
+
+    if ( strlen( hash ) != 32 ){
+        printf( "\tinvalid hash given got %s\n" , myhash );
+        bson_destroy( &b );
+        return 0;
+    }
+    else if ( strstr( myhash , hash ) != myhash ){
+        printf( "  hashes don't match\n");
+        printf( "    JSON:  %s\n\t%s\n", hash, js );
+        printf( "    BSON:  %s\n", myhash);
+        bson_print( &b );
+        bson_destroy( &b );
+        return 0;
+    }
+
+    bson_destroy( &b );
+    return 1;
+}
+
+int total = 0;
+int fails = 0;
+
+int run_json_to_bson_test( char * js , int size , const char * hash ){
+    total++;
+    if ( ! json_to_bson_test( js , size , hash ) )
+        fails++;
+    
+    return fails;
+}
+
+#define JSONBSONTEST run_json_to_bson_test
+
+int main(){
+
+    run_json_to_bson_test( "1" , 0 , 0 );
+    
+    JSONBSONTEST( "{ 'x' : true }" , 9 , "6fe24623e4efc5cf07f027f9c66b5456" );
+    JSONBSONTEST( "{ 'x' : null }" , 8 , "12d43430ff6729af501faf0638e68888" );
+    JSONBSONTEST( "{ 'x' : 5.2 }" , 16 , "aaeeac4a58e9c30eec6b0b0319d0dff2" );
+    JSONBSONTEST( "{ 'x' : 'eliot' }" , 18 , "331a3b8b7cbbe0706c80acdb45d4ebbe" );
+    JSONBSONTEST( "{ 'x' : 5.2 , 'y' : 'truth' , 'z' : 1.1 }" , 40 , "7c77b3a6e63e2f988ede92624409da58" );
+    JSONBSONTEST( "{ 'x' : 4 }" , 12 , "d1ed8dbf79b78fa215e2ded74548d89d" );
+    JSONBSONTEST( "{ 'x' : 5.2 , 'y' : 'truth' , 'z' : 1 }" , 36 , "8993953de080e9d4ef449d18211ef88a" );
+    JSONBSONTEST( "{ 'x' : 'eliot' , 'y' : true , 'z' : 1 }" , 29 , "24e79c12e6c746966b123310cb1a3290" );
+    JSONBSONTEST( "{ 'a' : { 'b' : 1.1 } }" , 24 , "31887a4b9d55cd9f17752d6a8a45d51f" );
+    JSONBSONTEST( "{ 'x' : 5.2 , 'y' : { 'a' : 'eliot' , 'b' : true } , 'z' : null }" , 44 , "b3de8a0739ab329e7aea138d87235205" );
+    JSONBSONTEST( "{ 'x' : 5.2 , 'y' : [ 'a' , 'eliot' , 'b' , true ] , 'z' : null }" , 62 , "cb7bad5697714ba0cbf51d113b6a0ee8" );
+
+    fprintf( stderr,  "----\ntotal: %d\nfails : %d\n" , total , fails );
+    return fails;
+}

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

@@ -0,0 +1,41 @@
+#include "test.h"
+#include "mongo.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+static mongo_connection conn[1];
+static mongo_connection_options left;
+static mongo_connection_options right;
+
+int main(){
+
+    INIT_SOCKETS_FOR_WINDOWS;
+
+    strncpy(left.host, TEST_SERVER, 255);
+    left.host[254] = '\0';
+    left.port = 27017;
+
+    strncpy(right.host, "0.0.0.0", 255);
+    right.port = 12345;
+
+    ASSERT(mongo_connect_pair(conn, &left, &right) == mongo_conn_success);
+    ASSERT(conn->left_opts->port == 27017);
+    ASSERT(conn->right_opts->port == 12345);
+    ASSERT(mongo_cmd_ismaster(conn, NULL));
+
+    mongo_destroy(conn);
+
+    ASSERT(mongo_connect_pair(conn, &right, &left) == mongo_conn_success);
+    ASSERT(conn->left_opts->port == 27017); /* should have swapped left and right */
+    ASSERT(conn->right_opts->port == 12345);
+    ASSERT(mongo_cmd_ismaster(conn, NULL));
+
+    ASSERT(mongo_reconnect(conn) == mongo_conn_success);
+    ASSERT(conn->left_opts->port == 27017); /* should have swapped left and right */
+    ASSERT(conn->right_opts->port == 12345);
+    ASSERT(mongo_cmd_ismaster(conn, NULL));
+
+    mongo_destroy(conn);
+    return 0;
+}

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

@@ -0,0 +1,81 @@
+/* test.c */
+
+#include "test.h"
+#include "mongo.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int test_connect( const char* set_name ) {
+
+    mongo_connection conn[1];
+    int res;
+
+    INIT_SOCKETS_FOR_WINDOWS;
+
+    mongo_replset_init_conn( conn, set_name );
+    mongo_replset_add_seed( conn, TEST_SERVER, 30000 );
+    mongo_replset_add_seed( conn, TEST_SERVER, 30001 );
+
+    if( res = mongo_replset_connect( conn ) ) {
+        mongo_destroy( conn );
+        return res;
+    }
+    else {
+        mongo_disconnect( conn );
+        return mongo_reconnect( conn );
+    }
+}
+
+int test_reconnect( const char* set_name ) {
+
+    mongo_connection conn[1];
+    int res;
+    int e = 0;
+    bson b;
+
+    INIT_SOCKETS_FOR_WINDOWS;
+
+    mongo_replset_init_conn( conn, set_name );
+    mongo_replset_add_seed( conn, TEST_SERVER, 30000 );
+    mongo_replset_add_seed( conn, TEST_SERVER, 30001 );
+
+    if( res = mongo_replset_connect( conn ) ) {
+        mongo_destroy( conn );
+        return res;
+    }
+    else {
+      fprintf( stderr, "Disconnect now:\n");
+      sleep( 10 );
+    do {
+        MONGO_TRY {
+          e = 1;
+          res = mongo_find_one( conn, "foo.bar", bson_empty(&b), bson_empty(&b), NULL);
+          e = 0;
+        } MONGO_CATCH {
+          sleep( 2 );
+          if( e++ < 30) {
+            fprintf( stderr, "Attempting reconnect %d.\n", e);
+            mongo_reconnect( conn );
+          } else {
+            fprintf( stderr, "Fail.\n");
+            return -1;
+          }
+        }
+    } while(e);
+  }
+
+  return 0;
+}
+
+int main() {
+    ASSERT( test_connect( "test-rs" ) == 0 );
+    ASSERT( test_connect( "test-foobar" ) == mongo_conn_bad_set_name );
+
+    /* Run this for testing failover.
+    ASSERT( test_reconnect( "test-rs" ) == 0 );
+    */
+
+    return 0;
+}

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

@@ -0,0 +1,35 @@
+/* resize.c */
+
+#include "test.h"
+#include "bson.h"
+#include <string.h>
+
+/* 64 Xs */
+const char* bigstring = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
+
+int main(){
+    bson_buffer bb;
+    bson b;
+
+    bson_buffer_init(&bb);
+    bson_append_string(&bb, "a", bigstring);
+    bson_append_start_object(&bb, "sub");
+        bson_append_string(&bb,"a", bigstring);
+        bson_append_start_object(&bb, "sub");
+            bson_append_string(&bb,"a", bigstring);
+            bson_append_start_object(&bb, "sub");
+                bson_append_string(&bb,"a", bigstring);
+                bson_append_string(&bb,"b", bigstring);
+                bson_append_string(&bb,"c", bigstring);
+                bson_append_string(&bb,"d", bigstring);
+                bson_append_string(&bb,"e", bigstring);
+                bson_append_string(&bb,"f", bigstring);
+            bson_append_finish_object(&bb);
+        bson_append_finish_object(&bb);
+    bson_append_finish_object(&bb);
+    bson_from_buffer(&b, &bb);
+
+    /* bson_print(&b); */
+    bson_destroy(&b);
+    return 0;
+}

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

@@ -0,0 +1,110 @@
+/* test.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;
+    mongo_cursor * cursor;
+    int i;
+    char hex_oid[25];
+    bson_timestamp_t ts = { 1, 2 };
+
+    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_find_one(conn, ns, bson_empty(&b), bson_empty(&b), NULL)){
+        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_timestamp( &bb, "ts", &ts );
+        bson_append_double( &bb , "a" , 17 );
+        bson_append_int( &bb , "b" , 17 );
+        bson_append_string( &bb , "c" , "17" );
+
+        {
+            bson_buffer * sub = bson_append_start_object(  &bb , "d" );
+            bson_append_int( sub, "i", 71 );
+            bson_append_finish_object(sub);
+        }
+        {
+            bson_buffer * arr = bson_append_start_array(  &bb , "e" );
+            bson_append_int( arr, "0", 71 );
+            bson_append_string( arr, "1", "71" );
+            bson_append_finish_object(arr);
+        }
+
+        bson_from_buffer(&b, &bb);
+        mongo_insert( conn , ns , &b );
+        bson_destroy(&b);
+    }
+
+    cursor = mongo_find( conn , ns , bson_empty(&b) , 0 , 0 , 0 , 0 );
+
+    while (mongo_cursor_next(cursor)){
+        bson_iterator it;
+        bson_iterator_init(&it, cursor->current.data);
+        while(bson_iterator_next(&it)){
+            fprintf(stderr, "  %s: ", bson_iterator_key(&it));
+
+            switch(bson_iterator_type(&it)){
+                case bson_double:
+                    fprintf(stderr, "(double) %e\n", bson_iterator_double(&it));
+                    break;
+                case bson_int:
+                    fprintf(stderr, "(int) %d\n", bson_iterator_int(&it));
+                    break;
+                case bson_string:
+                    fprintf(stderr, "(string) \"%s\"\n", bson_iterator_string(&it));
+                    break;
+                case bson_oid:
+                    bson_oid_to_string(bson_iterator_oid(&it), hex_oid);
+                    fprintf(stderr, "(oid) \"%s\"\n", hex_oid);
+                    break;
+                case bson_object:
+                    fprintf(stderr, "(subobject) {...}\n");
+                    break;
+                case bson_array:
+                    fprintf(stderr, "(array) [...]\n");
+                    break;
+                case bson_timestamp:
+                    fprintf(stderr, "(timestamp) [...]\n");
+                    break;
+                default:
+                    fprintf(stderr, "(type %d)\n", bson_iterator_type(&it));
+                    break;
+            }
+        }
+        fprintf(stderr, "\n");
+    }
+
+    mongo_cursor_destroy(cursor);
+    mongo_cmd_drop_db(conn, "test");
+    mongo_disconnect( conn );
+
+    mongo_reconnect( conn );
+
+    ASSERT( mongo_simple_int_command( conn, "admin", "ping", 1, NULL ) );
+
+    mongo_destroy( conn );
+    return 0;
+}

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

@@ -0,0 +1,22 @@
+/* sizes.c */
+
+#include "test.h"
+#include "mongo.h"
+#include <stdio.h>
+
+int main(){
+    mongo_reply mr;
+
+    ASSERT(sizeof(int) == 4);
+    ASSERT(sizeof(int64_t) == 8);
+    ASSERT(sizeof(double) == 8);
+    ASSERT(sizeof(bson_oid_t) == 12);
+
+    ASSERT(sizeof(mongo_header) == 4+4+4+4);
+    ASSERT(sizeof(mongo_reply_fields) == 4+8+4+4);
+
+    /* field offset of obj in mongo_reply */
+    ASSERT((&mr.objs - (char*)&mr) == (4+4+4+4 + 4+8+4+4));
+
+    return 0;
+}