Method test_vector

test/test_bson.py:737–813

Tests of subtype 9

(self)

        self.assertEqual(id, transformed)

    def test_vector(self):
        """Tests of subtype 9"""
        # We start with valid cases, across the 3 dtypes implemented.
        # Work with a simple vector that can be interpreted as int8, float32, or ubyte
        list_vector = [127, 8]
        # As INT8, vector has length 2
        binary_vector = Binary.from_vector(list_vector, BinaryVectorDtype.INT8)
        vector = binary_vector.as_vector()
        assert vector.data == list_vector
        # test encoding roundtrip
        assert {"vector": binary_vector} == decode(encode({"vector": binary_vector}))
        # test json roundtrip
        assert binary_vector == json_util.loads(json_util.dumps(binary_vector))

        # For vectors of bits, aka PACKED_BIT type, vector has length 8 * 2
        packed_bit_binary = Binary.from_vector(list_vector, BinaryVectorDtype.PACKED_BIT)
        packed_bit_vec = packed_bit_binary.as_vector()
        assert packed_bit_vec.data == list_vector

        # A padding parameter permits vectors of length that aren't divisible by 8
        # The following ignores the last 3 bits in list_vector,
        # hence it's length is 8 * len(list_vector) - padding
        padding = 3
        padded_vec = Binary.from_vector(list_vector, BinaryVectorDtype.PACKED_BIT, padding=padding)
        assert padded_vec.as_vector().data == list_vector
        # To visualize how this looks as a binary vector..
        uncompressed = ""
        for val in list_vector:
            uncompressed += format(val, "08b")
        assert uncompressed[:-padding] == "0111111100001"

        # It is worthwhile explicitly showing the values encoded to BSON
        padded_doc = {"padded_vec": padded_vec}
        assert (
            encode(padded_doc)
            == b"\x1a\x00\x00\x00\x05padded_vec\x00\x04\x00\x00\x00\t\x10\x03\x7f\x08\x00"
        )
        # and dumped to json
        assert (
            json_util.dumps(padded_doc)
            == '{"padded_vec": {"$binary": {"base64": "EAN/CA==", "subType": "09"}}}'
        )

        # FLOAT32 is also implemented
        float_binary = Binary.from_vector(list_vector, BinaryVectorDtype.FLOAT32)
        assert all(isinstance(d, float) for d in float_binary.as_vector().data)

        # Now some invalid cases
        for x in [-1, 257]:
            with self.assertRaises(struct.error):
                Binary.from_vector([x], BinaryVectorDtype.PACKED_BIT)

        # Test one must pass zeros for all ignored bits
        with self.assertRaises(ValueError):
            Binary.from_vector([255], BinaryVectorDtype.PACKED_BIT, padding=7)

        with self.assertWarns(DeprecationWarning):
            meta = struct.pack("<sB", BinaryVectorDtype.PACKED_BIT.value, 7)