← Back to branch summary

~ubuntu-branches/ubuntu/wily/pymongo/wily

« back to all changes in this revision

Viewing changes to test/test_bson.py

  • Committer: Package Import Robot
  • Author(s): Federico Ceratto
  • Date: 2012-05-10 21:21:40 UTC
  • mfrom: (1.1.11)
  • Revision ID: package-import@ubuntu.com-20120510212140-9c66c00zz850h6l9
Tags: 2.2-1
http://bugs.debian.org/670268
* New upstream release.
* Dependencies added (Closes: #670268)

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test_bson.py
1
1
# -*- coding: utf-8 -*-
2
2
#
3
 
# Copyright 2009-2010 10gen, Inc.
 
3
# Copyright 2009-2012 10gen, Inc.
4
4
#
5
5
# Licensed under the Apache License, Version 2.0 (the "License");
6
6
# you may not use this file except in compliance with the License.
37
37
from bson.code import Code
38
38
from bson.objectid import ObjectId
39
39
from bson.dbref import DBRef
 
40
from bson.py3compat import b
40
41
from bson.son import SON
41
42
from bson.timestamp import Timestamp
42
43
from bson.errors import (InvalidDocument,
46
47
from bson.tz_util import (FixedOffset,
47
48
                          utc)
48
49
import pymongo
49
 
import qcheck
 
50
 
 
51
from test import qcheck
 
52
 
 
53
PY3 = sys.version_info[0] == 3
50
54
 
51
55
 
52
56
class TestBSON(unittest.TestCase):
59
63
        self.assertRaises(TypeError, is_valid, u"test")
60
64
        self.assertRaises(TypeError, is_valid, 10.4)
61
65
 
62
 
        self.assertFalse(is_valid("test"))
 
66
        self.assertFalse(is_valid(b("test")))
63
67
 
64
68
        # the simplest valid BSON document
65
 
        self.assert_(is_valid("\x05\x00\x00\x00\x00"))
66
 
        self.assert_(is_valid(BSON("\x05\x00\x00\x00\x00")))
67
 
        self.assertFalse(is_valid("\x04\x00\x00\x00\x00"))
68
 
        self.assertFalse(is_valid("\x05\x00\x00\x00\x01"))
69
 
        self.assertFalse(is_valid("\x05\x00\x00\x00"))
70
 
        self.assertFalse(is_valid("\x05\x00\x00\x00\x00\x00"))
71
 
        self.assertFalse(is_valid("\x07\x00\x00\x00\x02a\x00\x78\x56\x34\x12"))
72
 
        self.assertFalse(is_valid("\x09\x00\x00\x00\x10a\x00\x05\x00"))
 
69
        self.assertTrue(is_valid(b("\x05\x00\x00\x00\x00")))
 
70
        self.assertTrue(is_valid(BSON(b("\x05\x00\x00\x00\x00"))))
 
71
        self.assertFalse(is_valid(b("\x04\x00\x00\x00\x00")))
 
72
        self.assertFalse(is_valid(b("\x05\x00\x00\x00\x01")))
 
73
        self.assertFalse(is_valid(b("\x05\x00\x00\x00")))
 
74
        self.assertFalse(is_valid(b("\x05\x00\x00\x00\x00\x00")))
 
75
        self.assertFalse(is_valid(b("\x07\x00\x00\x00\x02a\x00\x78\x56\x34\x12")))
 
76
        self.assertFalse(is_valid(b("\x09\x00\x00\x00\x10a\x00\x05\x00")))
73
77
 
74
78
    def test_random_data_is_not_bson(self):
75
79
        qcheck.check_unittest(self, qcheck.isnt(is_valid),
77
81
 
78
82
    def test_basic_decode(self):
79
83
        self.assertEqual({"test": u"hello world"},
80
 
                         BSON("\x1B\x00\x00\x00\x0E\x74\x65\x73\x74\x00\x0C"
81
 
                              "\x00\x00\x00\x68\x65\x6C\x6C\x6F\x20\x77\x6F"
82
 
                              "\x72\x6C\x64\x00\x00").decode())
 
84
                         BSON(b("\x1B\x00\x00\x00\x0E\x74\x65\x73\x74\x00\x0C"
 
85
                                "\x00\x00\x00\x68\x65\x6C\x6C\x6F\x20\x77\x6F"
 
86
                                "\x72\x6C\x64\x00\x00")).decode())
83
87
        self.assertEqual([{"test": u"hello world"}, {}],
84
 
                         decode_all("\x1B\x00\x00\x00\x0E\x74\x65\x73\x74\x00"
85
 
                                    "\x0C\x00\x00\x00\x68\x65\x6C\x6C\x6F\x20"
86
 
                                    "\x77\x6F\x72\x6C\x64\x00\x00\x05\x00\x00"
87
 
                                    "\x00\x00"))
 
88
                         decode_all(b("\x1B\x00\x00\x00\x0E\x74\x65\x73\x74"
 
89
                                      "\x00\x0C\x00\x00\x00\x68\x65\x6C\x6C"
 
90
                                      "\x6f\x20\x77\x6F\x72\x6C\x64\x00\x00"
 
91
                                      "\x05\x00\x00\x00\x00")))
88
92
 
89
93
    def test_data_timestamp(self):
90
94
        self.assertEqual({"test": Timestamp(4, 20)},
91
 
                         BSON("\x13\x00\x00\x00\x11\x74\x65\x73\x74\x00\x14"
92
 
                              "\x00\x00\x00\x04\x00\x00\x00\x00").decode())
 
95
                         BSON(b("\x13\x00\x00\x00\x11\x74\x65\x73\x74\x00\x14"
 
96
                                "\x00\x00\x00\x04\x00\x00\x00\x00")).decode())
93
97
 
94
98
    def test_basic_encode(self):
95
99
        self.assertRaises(TypeError, BSON.encode, 100)
97
101
        self.assertRaises(TypeError, BSON.encode, None)
98
102
        self.assertRaises(TypeError, BSON.encode, [])
99
103
 
100
 
        self.assertEqual(BSON.encode({}), BSON("\x05\x00\x00\x00\x00"))
 
104
        self.assertEqual(BSON.encode({}), BSON(b("\x05\x00\x00\x00\x00")))
101
105
        self.assertEqual(BSON.encode({"test": u"hello world"}),
102
 
                         "\x1B\x00\x00\x00\x02\x74\x65\x73\x74\x00\x0C\x00\x00"
103
 
                         "\x00\x68\x65\x6C\x6C\x6F\x20\x77\x6F\x72\x6C\x64\x00"
104
 
                         "\x00")
 
106
                         b("\x1B\x00\x00\x00\x02\x74\x65\x73\x74\x00\x0C\x00"
 
107
                           "\x00\x00\x68\x65\x6C\x6C\x6F\x20\x77\x6F\x72\x6C"
 
108
                           "\x64\x00\x00"))
105
109
        self.assertEqual(BSON.encode({u"mike": 100}),
106
 
                         "\x0F\x00\x00\x00\x10\x6D\x69\x6B\x65\x00\x64\x00\x00"
107
 
                         "\x00\x00")
 
110
                         b("\x0F\x00\x00\x00\x10\x6D\x69\x6B\x65\x00\x64\x00"
 
111
                           "\x00\x00\x00"))
108
112
        self.assertEqual(BSON.encode({"hello": 1.5}),
109
 
                         "\x14\x00\x00\x00\x01\x68\x65\x6C\x6C\x6F\x00\x00\x00"
110
 
                         "\x00\x00\x00\x00\xF8\x3F\x00")
 
113
                         b("\x14\x00\x00\x00\x01\x68\x65\x6C\x6C\x6F\x00\x00"
 
114
                           "\x00\x00\x00\x00\x00\xF8\x3F\x00"))
111
115
        self.assertEqual(BSON.encode({"true": True}),
112
 
                         "\x0C\x00\x00\x00\x08\x74\x72\x75\x65\x00\x01\x00")
 
116
                         b("\x0C\x00\x00\x00\x08\x74\x72\x75\x65\x00\x01\x00"))
113
117
        self.assertEqual(BSON.encode({"false": False}),
114
 
                         "\x0D\x00\x00\x00\x08\x66\x61\x6C\x73\x65\x00\x00"
115
 
                         "\x00")
 
118
                         b("\x0D\x00\x00\x00\x08\x66\x61\x6C\x73\x65\x00\x00"
 
119
                           "\x00"))
116
120
        self.assertEqual(BSON.encode({"empty": []}),
117
 
                         "\x11\x00\x00\x00\x04\x65\x6D\x70\x74\x79\x00\x05\x00"
118
 
                         "\x00\x00\x00\x00")
 
121
                         b("\x11\x00\x00\x00\x04\x65\x6D\x70\x74\x79\x00\x05"
 
122
                           "\x00\x00\x00\x00\x00"))
119
123
        self.assertEqual(BSON.encode({"none": {}}),
120
 
                         "\x10\x00\x00\x00\x03\x6E\x6F\x6E\x65\x00\x05\x00\x00"
121
 
                         "\x00\x00\x00")
122
 
        self.assertEqual(BSON.encode({"test": Binary("test", 0)}),
123
 
                         "\x14\x00\x00\x00\x05\x74\x65\x73\x74\x00\x04\x00\x00"
124
 
                         "\x00\x00\x74\x65\x73\x74\x00")
125
 
        self.assertEqual(BSON.encode({"test": Binary("test", 2)}),
126
 
                         "\x18\x00\x00\x00\x05\x74\x65\x73\x74\x00\x08\x00\x00"
127
 
                         "\x00\x02\x04\x00\x00\x00\x74\x65\x73\x74\x00")
128
 
        self.assertEqual(BSON.encode({"test": Binary("test", 128)}),
129
 
                         "\x14\x00\x00\x00\x05\x74\x65\x73\x74\x00\x04\x00\x00"
130
 
                         "\x00\x80\x74\x65\x73\x74\x00")
 
124
                         b("\x10\x00\x00\x00\x03\x6E\x6F\x6E\x65\x00\x05\x00"
 
125
                           "\x00\x00\x00\x00"))
 
126
        self.assertEqual(BSON.encode({"test": Binary(b("test"), 0)}),
 
127
                         b("\x14\x00\x00\x00\x05\x74\x65\x73\x74\x00\x04\x00"
 
128
                           "\x00\x00\x00\x74\x65\x73\x74\x00"))
 
129
        self.assertEqual(BSON.encode({"test": Binary(b("test"), 2)}),
 
130
                         b("\x18\x00\x00\x00\x05\x74\x65\x73\x74\x00\x08\x00"
 
131
                           "\x00\x00\x02\x04\x00\x00\x00\x74\x65\x73\x74\x00"))
 
132
        self.assertEqual(BSON.encode({"test": Binary(b("test"), 128)}),
 
133
                         b("\x14\x00\x00\x00\x05\x74\x65\x73\x74\x00\x04\x00"
 
134
                           "\x00\x00\x80\x74\x65\x73\x74\x00"))
131
135
        self.assertEqual(BSON.encode({"test": None}),
132
 
                         "\x0B\x00\x00\x00\x0A\x74\x65\x73\x74\x00\x00")
 
136
                         b("\x0B\x00\x00\x00\x0A\x74\x65\x73\x74\x00\x00"))
133
137
        self.assertEqual(BSON.encode({"date": datetime.datetime(2007, 1, 8,
134
138
                                                                0, 30, 11)}),
135
 
                         "\x13\x00\x00\x00\x09\x64\x61\x74\x65\x00\x38\xBE\x1C"
136
 
                         "\xFF\x0F\x01\x00\x00\x00")
137
 
        self.assertEqual(BSON.encode({"regex": re.compile("a*b",
 
139
                         b("\x13\x00\x00\x00\x09\x64\x61\x74\x65\x00\x38\xBE"
 
140
                           "\x1C\xFF\x0F\x01\x00\x00\x00"))
 
141
        self.assertEqual(BSON.encode({"regex": re.compile(b("a*b"),
138
142
                                                          re.IGNORECASE)}),
139
 
                         "\x12\x00\x00\x00\x0B\x72\x65\x67\x65\x78\x00\x61\x2A"
140
 
                         "\x62\x00\x69\x00\x00")
 
143
                         b("\x12\x00\x00\x00\x0B\x72\x65\x67\x65\x78\x00\x61"
 
144
                           "\x2A\x62\x00\x69\x00\x00"))
141
145
        self.assertEqual(BSON.encode({"$where": Code("test")}),
142
 
                         "\x1F\x00\x00\x00\x0F\x24\x77\x68\x65\x72\x65\x00\x12"
143
 
                         "\x00\x00\x00\x05\x00\x00\x00\x74\x65\x73\x74\x00\x05"
144
 
                         "\x00\x00\x00\x00\x00")
145
 
        a = ObjectId("\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B")
 
146
                         b("\x16\x00\x00\x00\r$where\x00\x05\x00\x00\x00test"
 
147
                           "\x00\x00"))
 
148
        self.assertEqual(BSON.encode({"$field":
 
149
                         Code("function(){ return true;}", scope=None)}),
 
150
                         b("+\x00\x00\x00\r$field\x00\x1a\x00\x00\x00"
 
151
                           "function(){ return true;}\x00\x00"))
 
152
        self.assertEqual(BSON.encode({"$field":
 
153
                          Code("return function(){ return x; }",
 
154
                            scope={'x': False})}),
 
155
                         b("=\x00\x00\x00\x0f$field\x000\x00\x00\x00\x1f\x00"
 
156
                           "\x00\x00return function(){ return x; }\x00\t\x00"
 
157
                           "\x00\x00\x08x\x00\x00\x00\x00"))
 
158
        a = ObjectId(b("\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B"))
146
159
        self.assertEqual(BSON.encode({"oid": a}),
147
 
                         "\x16\x00\x00\x00\x07\x6F\x69\x64\x00\x00\x01\x02\x03"
148
 
                         "\x04\x05\x06\x07\x08\x09\x0A\x0B\x00")
 
160
                         b("\x16\x00\x00\x00\x07\x6F\x69\x64\x00\x00\x01\x02"
 
161
                           "\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x00"))
149
162
        self.assertEqual(BSON.encode({"ref": DBRef("coll", a)}),
150
 
                         "\x2F\x00\x00\x00\x03ref\x00\x25\x00\x00\x00\x02$ref"
151
 
                         "\x00\x05\x00\x00\x00coll\x00\x07$id\x00\x00\x01\x02"
152
 
                         "\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x00\x00")
 
163
                         b("\x2F\x00\x00\x00\x03ref\x00\x25\x00\x00\x00\x02"
 
164
                           "$ref\x00\x05\x00\x00\x00coll\x00\x07$id\x00\x00"
 
165
                           "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x00"
 
166
                           "\x00"))
153
167
 
154
168
    def test_encode_then_decode(self):
155
169
 
157
171
            self.assertEqual(dict, (BSON.encode(dict)).decode())
158
172
        helper({})
159
173
        helper({"test": u"hello"})
160
 
        self.assert_(isinstance(BSON.encode({"hello": "world"})
 
174
        self.assertTrue(isinstance(BSON.encode({"hello": "world"})
161
175
                                .decode()["hello"],
162
176
                                unicode))
163
177
        helper({"mike": -10120})
168
182
        helper({"false": False})
169
183
        helper({"an array": [1, True, 3.8, u"world"]})
170
184
        helper({"an object": {"test": u"something"}})
171
 
        helper({"a binary": Binary("test", 100)})
172
 
        helper({"a binary": Binary("test", 128)})
173
 
        helper({"a binary": Binary("test", 254)})
174
 
        helper({"another binary": Binary("test")})
 
185
        helper({"a binary": Binary(b("test"), 100)})
 
186
        helper({"a binary": Binary(b("test"), 128)})
 
187
        helper({"a binary": Binary(b("test"), 254)})
 
188
        helper({"another binary": Binary(b("test"), 2)})
175
189
        helper(SON([(u'test dst', datetime.datetime(1993, 4, 4, 2))]))
176
190
        helper(SON([(u'test negative dst', datetime.datetime(1, 1, 1, 1, 1, 1))]))
177
191
        helper({"big float": float(10000000000)})
182
196
        helper({"ref": Timestamp(1, 2)})
183
197
        helper({"foo": MinKey()})
184
198
        helper({"foo": MaxKey()})
185
 
 
186
 
        def encode_then_decode(dict):
187
 
            return dict == (BSON.encode(dict)).decode()
 
199
        helper({"$field": Code("function(){ return true; }")})
 
200
        helper({"$field": Code("return function(){ return x; }", scope={'x': False})})
 
201
 
 
202
        doc_class = dict
 
203
        # Work around http://bugs.jython.org/issue1728
 
204
        if (sys.platform.startswith('java') and
 
205
            sys.version_info[:3] == (2, 5, 2)):
 
206
            doc_class = SON
 
207
 
 
208
        def encode_then_decode(doc):
 
209
            return doc == (BSON.encode(doc)).decode(as_class=doc_class)
188
210
 
189
211
        qcheck.check_unittest(self, encode_then_decode,
190
212
                              qcheck.gen_mongo_dict(3))
191
213
 
 
214
    def test_bytes_as_keys(self):
 
215
        doc = {b("foo"): 'bar'}
 
216
        # Since `bytes` are stored as Binary you can't use them
 
217
        # as keys in python 3.x. Using binary data as a key makes
 
218
        # no sense in BSON anyway and little sense in python.
 
219
        if PY3:
 
220
            self.assertRaises(InvalidDocument, BSON.encode, doc)
 
221
        else:
 
222
            self.assertTrue(BSON.encode(doc))
 
223
 
192
224
    def test_datetime_encode_decode(self):
193
225
        # Negative timestamps
194
226
        dt1 = datetime.datetime(1, 1, 1, 1, 1, 1)
232
264
        self.assertEqual(d, BSON.encode(d).decode())
233
265
 
234
266
    def test_bad_encode(self):
235
 
        self.assertRaises(InvalidStringData, BSON.encode,
236
 
                          {"lalala": '\xf4\xe0\xf0\xe1\xc0 Color Touch'})
 
267
        if not PY3:
 
268
            # Python3 treats this as a unicode string which won't raise
 
269
            # an exception. If we passed the string as bytes instead we
 
270
            # still wouldn't get an error since we store bytes as BSON
 
271
            # binary subtype 0.
 
272
            self.assertRaises(InvalidStringData, BSON.encode,
 
273
                              {"lalala": '\xf4\xe0\xf0\xe1\xc0 Color Touch'})
237
274
        evil_list = {'a': []}
238
275
        evil_list['a'].append(evil_list)
239
276
        evil_dict = {}
242
279
            self.assertRaises(RuntimeError, BSON.encode, evil_data)
243
280
 
244
281
    def test_overflow(self):
245
 
        self.assert_(BSON.encode({"x": 9223372036854775807L}))
 
282
        self.assertTrue(BSON.encode({"x": 9223372036854775807L}))
246
283
        self.assertRaises(OverflowError, BSON.encode,
247
284
                          {"x": 9223372036854775808L})
248
285
 
249
 
        self.assert_(BSON.encode({"x": -9223372036854775808L}))
 
286
        self.assertTrue(BSON.encode({"x": -9223372036854775808L}))
250
287
        self.assertRaises(OverflowError, BSON.encode,
251
288
                          {"x": -9223372036854775809L})
252
289
 
253
290
    def test_small_long_encode_decode(self):
 
291
        if PY3:
 
292
            raise SkipTest("No long type in Python 3.")
 
293
 
254
294
        encoded1 = BSON.encode({'x': 256})
255
295
        decoded1 = BSON.decode(encoded1)['x']
256
296
        self.assertEqual(256, decoded1)
274
314
        id = uuid.uuid4()
275
315
        transformed_id = (BSON.encode({"id": id})).decode()["id"]
276
316
 
277
 
        self.assert_(isinstance(transformed_id, uuid.UUID))
 
317
        self.assertTrue(isinstance(transformed_id, uuid.UUID))
278
318
        self.assertEqual(id, transformed_id)
279
319
        self.assertNotEqual(uuid.uuid4(), transformed_id)
280
320
 
284
324
 
285
325
        id = uuid.uuid4()
286
326
        legacy = UUIDLegacy(id)
287
 
        self.assertEquals(3, legacy.subtype)
 
327
        self.assertEqual(3, legacy.subtype)
288
328
        transformed = (BSON.encode({"uuid": legacy})).decode()["uuid"]
289
 
        self.assert_(isinstance(transformed, uuid.UUID))
 
329
        self.assertTrue(isinstance(transformed, uuid.UUID))
290
330
        self.assertEqual(id, transformed)
291
331
        self.assertNotEqual(UUIDLegacy(uuid.uuid4()), UUIDLegacy(transformed))
292
332
 
303
343
        w = {u"aéあ": u"aéあ"}
304
344
        self.assertEqual(w, BSON.encode(w).decode())
305
345
 
306
 
        x = {u"aéあ".encode("utf-8"): u"aéあ".encode("utf-8")}
307
 
        self.assertEqual(w, BSON.encode(x).decode())
308
 
 
309
 
        y = {"hello": u"aé".encode("iso-8859-1")}
310
 
        self.assertRaises(InvalidStringData, BSON.encode, y)
311
 
 
312
 
        z = {u"aé".encode("iso-8859-1"): "hello"}
313
 
        self.assertRaises(InvalidStringData, BSON.encode, z)
 
346
        if not PY3:
 
347
            # In python3 this would be stored as BSON binary
 
348
            # subtype 0 and wouldn't raise an exception.
 
349
            y = {"hello": u"aé".encode("iso-8859-1")}
 
350
            self.assertRaises(InvalidStringData, BSON.encode, y)
 
351
 
 
352
            # The next two tests only make sense in python 2.x since
 
353
            # you can't use `bytes` type as document keys in python 3.x.
 
354
            x = {u"aéあ".encode("utf-8"): u"aéあ".encode("utf-8")}
 
355
            self.assertEqual(w, BSON.encode(x).decode())
 
356
 
 
357
            z = {u"aé".encode("iso-8859-1"): "hello"}
 
358
            self.assertRaises(InvalidStringData, BSON.encode, z)
314
359
 
315
360
    def test_null_character(self):
316
361
        doc = {"a": "\x00"}
317
362
        self.assertEqual(doc, BSON.encode(doc).decode())
318
363
 
 
364
        # This test doesn't make much sense in Python2
 
365
        # since {'a': '\x00'} == {'a': u'\x00'}.
 
366
        # Decoding here actually returns {'a': '\x00'}
319
367
        doc = {"a": u"\x00"}
320
368
        self.assertEqual(doc, BSON.encode(doc).decode())
321
369
 
322
 
        self.assertRaises(InvalidDocument, BSON.encode, {"\x00": "a"})
 
370
        self.assertRaises(InvalidDocument, BSON.encode, {b("\x00"): "a"})
323
371
        self.assertRaises(InvalidDocument, BSON.encode, {u"\x00": "a"})
324
372
 
325
373
        self.assertRaises(InvalidDocument, BSON.encode,
326
 
                          {"a": re.compile("ab\x00c")})
 
374
                          {"a": re.compile(b("ab\x00c"))})
327
375
        self.assertRaises(InvalidDocument, BSON.encode,
328
376
                          {"a": re.compile(u"ab\x00c")})
329
377
 
330
378
    def test_move_id(self):
331
 
        self.assertEqual("\x19\x00\x00\x00\x02_id\x00\x02\x00\x00\x00a\x00"
332
 
                         "\x02a\x00\x02\x00\x00\x00a\x00\x00",
 
379
        self.assertEqual(b("\x19\x00\x00\x00\x02_id\x00\x02\x00\x00\x00a\x00"
 
380
                           "\x02a\x00\x02\x00\x00\x00a\x00\x00"),
333
381
                         BSON.encode(SON([("a", "a"), ("_id", "a")])))
334
382
 
335
 
        self.assertEqual("\x2c\x00\x00\x00"
336
 
                         "\x02_id\x00\x02\x00\x00\x00b\x00"
337
 
                         "\x03b\x00"
338
 
                         "\x19\x00\x00\x00\x02a\x00\x02\x00\x00\x00a\x00"
339
 
                         "\x02_id\x00\x02\x00\x00\x00a\x00\x00\x00",
 
383
        self.assertEqual(b("\x2c\x00\x00\x00"
 
384
                           "\x02_id\x00\x02\x00\x00\x00b\x00"
 
385
                           "\x03b\x00"
 
386
                           "\x19\x00\x00\x00\x02a\x00\x02\x00\x00\x00a\x00"
 
387
                           "\x02_id\x00\x02\x00\x00\x00a\x00\x00\x00"),
340
388
                         BSON.encode(SON([("b",
341
389
                                           SON([("a", "a"), ("_id", "a")])),
342
390
                                          ("_id", "b")])))
354
402
                raise
355
403
 
356
404
    def test_custom_class(self):
357
 
        self.assert_(isinstance(BSON.encode({}).decode(), dict))
 
405
        self.assertTrue(isinstance(BSON.encode({}).decode(), dict))
358
406
        self.assertFalse(isinstance(BSON.encode({}).decode(), SON))
359
 
        self.assert_(isinstance(BSON.encode({}).decode(SON), SON))
 
407
        self.assertTrue(isinstance(BSON.encode({}).decode(SON), SON))
360
408
 
361
409
        self.assertEqual(1, BSON.encode({"x": 1}).decode(SON)["x"])
362
410
 
363
411
        x = BSON.encode({"x": [{"y": 1}]})
364
 
        self.assert_(isinstance(x.decode(SON)["x"][0], SON))
 
412
        self.assertTrue(isinstance(x.decode(SON)["x"][0], SON))
365
413
 
366
414
    def test_subclasses(self):
367
415
        # make sure we can serialize subclasses of native Python types.