Ejemplos de GoodJSONEncoder en Python

Ejemplo n.º 1

 def setUp(self):
     """Set up class."""
     from base64 import b64encode
     self.encoder = GoodJSONEncoder()
     self.data = b"This is a test."
     self.expected = {
         "data": b64encode(self.data).decode("utf-8"),
         "type": 0
     }

Ejemplo n.º 2

 def setUp(self):
     """Set up class."""
     from bson.code import Code
     self.encoder = GoodJSONEncoder()
     self.expected = {
         "code": "console.log('HAAAAAAAAHHHH!!!')",
         "scope": {
             "data": "test"
         }
     }
     self.data = Code(**self.expected)

Ejemplo n.º 3

 def setUp(self):
     """Set up class."""
     from bson.timestamp import Timestamp
     from datetime import datetime
     from calendar import timegm
     from random import randint
     self.expected = {
         "time": timegm(datetime.utcnow().timetuple()),
         "inc": randint(0, 4294967295)
     }
     self.encoder = GoodJSONEncoder()
     self.data = Timestamp(**self.expected)

Ejemplo n.º 4

    def setUp(self):
        """Set up class."""
        from bson.binary import Binary, BINARY_SUBTYPE
        from base64 import b64encode

        self.encoder = GoodJSONEncoder()
        self.test_str = "This is a test"
        self.expected = {
            "data": b64encode(self.test_str.encode("utf-8")).decode("utf-8"),
            "type": BINARY_SUBTYPE
        }
        self.data = Binary(self.test_str.encode("utf-8"))

Ejemplo n.º 5

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

 def setUp(self):
     """Set up function."""
     self.encoder = GoodJSONEncoder()
     self.regex = re.compile("^[0-9]+$".encode())
     self.expected_result = {
         "regex": self.regex.pattern
     }

Ejemplo n.º 6

class NormalStuffEncodingTest(TestCase):
    """Normal stuff should be encoded."""
    def setUp(self):
        """Set up function."""
        self.encoder = GoodJSONEncoder()
        self.data = "test"

    @patch("json.JSONEncoder.default")
    def test_json_encoder(self, default):
        """The default json default function should be called."""
        self.encoder.default(self.data)
        default.assert_called_once_with(self.data)

    @patch("json.JSONEncoder.encode")
    def test_json_encode_class(self, encode):
        """The default json encode function should be called."""
        self.encoder.encode(self.data)
        encode.assert_called_once_with(self.data)

Ejemplo n.º 7

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

 def setUp(self):
     """Set up class."""
     from base64 import b64encode
     self.encoder = GoodJSONEncoder()
     self.data = b"This is a test."
     self.expected = {
         "data": b64encode(self.data).decode("utf-8"),
         "type": 0
     }

Ejemplo n.º 8

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

 def setUp(self):
     """Set up class."""
     from bson.code import Code
     self.encoder = GoodJSONEncoder()
     self.expected = {
         "code": "console.log('HAAAAAAAAHHHH!!!')",
         "scope": {"data": "test"}
     }
     self.data = Code(**self.expected)

Ejemplo n.º 9

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

class NormalStuffEncodingTest(TestCase):
    """Normal stuff should be encoded."""

    def setUp(self):
        """Set up function."""
        self.encoder = GoodJSONEncoder()
        self.data = "test"

    @patch("json.JSONEncoder.default")
    def test_json_encoder(self, default):
        """The default json default function should be called."""
        self.encoder.default(self.data)
        default.assert_called_once_with(self.data)

    @patch("json.JSONEncoder.encode")
    def test_json_encode_class(self, encode):
        """The default json encode function should be called."""
        self.encoder.encode(self.data)
        encode.assert_called_once_with(self.data)

Ejemplo n.º 10

class MaxKeyTest(TestCase):
    """MaxKey test."""
    def setUp(self):
        """Set up class."""
        from bson.max_key import MaxKey
        self.encoder = GoodJSONEncoder()
        self.data = MaxKey()

    def test_minkey(self):
        """Maxkey should be encoded."""
        self.assertDictEqual({"maxKey": True}, self.encoder.default(self.data))

Ejemplo n.º 11

class DatetimeISOEncodeTest(TestCase):
    """datetime encoding test."""
    def setUp(self):
        """Set up funciton."""
        from datetime import datetime
        self.now = datetime.utcnow()
        self.encoder = GoodJSONEncoder()

    def test_datetime(self):
        """Datetime should be serialized into ISOFormat."""
        self.assertEqual(self.encoder.default(self.now), self.now.isoformat())

Ejemplo n.º 12

class RegexNativeByteTest(TestCase):
    """Native Regex test class."""
    def setUp(self):
        """Set up function."""
        self.encoder = GoodJSONEncoder()
        self.regex = re.compile("^[0-9]+$".encode())
        self.expected_result = {"regex": self.regex.pattern}

    def test_regex(self):
        """The encoded value should be the expected value."""
        self.assertEqual(self.expected_result,
                         self.encoder.default(self.regex))

Ejemplo n.º 13

class UUIDTest(TestCase):
    """UUID Test."""
    def setUp(self):
        """Set up class."""
        from uuid import uuid5, NAMESPACE_DNS
        self.encoder = GoodJSONEncoder()
        self.data = uuid5(NAMESPACE_DNS, "This is a test")
        self.expected = str(self.data)

    def test_uuid(self):
        """The uuid should converted into str."""
        self.assertEqual(self.expected, self.encoder.default(self.data))

Ejemplo n.º 14

class ObjectIdEncodeTest(TestCase):
    """Object ID Encoding test."""
    def setUp(self):
        """Set up function."""
        from bson import ObjectId
        self.encoder = GoodJSONEncoder()
        self.oid = ObjectId()

    def test_object_id(self):
        """Encoder should return the object id as str."""
        result = self.encoder.default(self.oid)
        self.assertEqual(result, str(self.oid))

Ejemplo n.º 15

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

    def setUp(self):
        """Set up class."""
        from bson.binary import Binary, BINARY_SUBTYPE
        from base64 import b64encode

        self.encoder = GoodJSONEncoder()
        self.test_str = "This is a test"
        self.expected = {
            "data": b64encode(self.test_str.encode("utf-8")).decode("utf-8"),
            "type": BINARY_SUBTYPE
        }
        self.data = Binary(self.test_str.encode("utf-8"))

Ejemplo n.º 16

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

 def setUp(self):
     """Set up class."""
     from bson.timestamp import Timestamp
     from datetime import datetime
     from calendar import timegm
     from random import randint
     self.expected = {
         "time": timegm(datetime.utcnow().timetuple()),
         "inc": randint(0, 4294967295)
     }
     self.encoder = GoodJSONEncoder()
     self.data = Timestamp(**self.expected)

Ejemplo n.º 17

Archivo: test_encoder.py Proyecto: EloiZalczer/mongoengine-goodjson

class SONTest(TestCase):
    """SON test."""
    def setUp(self):
        """Set up class."""
        from bson.son import SON
        self.encoder = GoodJSONEncoder()
        self.expected = {"data": "test"}
        self.data = SON(data={"data": "test"})

    def test_son(self):
        """SON data should be expected value"""
        self.assertDictEqual(self.expected, self.encoder.default(self.data))

Ejemplo n.º 18

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

class UUIDTest(TestCase):
    """UUID Test."""

    def setUp(self):
        """Set up class."""
        from uuid import uuid5, NAMESPACE_DNS
        self.encoder = GoodJSONEncoder()
        self.data = uuid5(NAMESPACE_DNS, "This is a test")
        self.expected = str(self.data)

    def test_uuid(self):
        """The uuid should converted into str."""
        self.assertEqual(self.expected, self.encoder.default(self.data))

Ejemplo n.º 19

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

class ObjectIdEncodeTest(TestCase):
    """Object ID Encoding test."""

    def setUp(self):
        """Set up function."""
        from bson import ObjectId
        self.encoder = GoodJSONEncoder()
        self.oid = ObjectId()

    def test_object_id(self):
        """Encoder should return the object id as str."""
        result = self.encoder.default(self.oid)
        self.assertEqual(result, str(self.oid))

Ejemplo n.º 20

 def setUp(self):
     """Set up function."""
     from bson.dbref import DBRef
     from bson import ObjectId
     self.DBRef = DBRef
     self.encoder = GoodJSONEncoder()
     self.custom_argument = {
         "test key %d" % counter: "Test value %d" % counter
         for counter in range(3)
     }
     self.collection_name = "test.collection"
     self.doc_id = ObjectId()
     self.database = "test.db"

Ejemplo n.º 21

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

class DatetimeISOEncodeTest(TestCase):
    """datetime encoding test."""

    def setUp(self):
        """Set up funciton."""
        from datetime import datetime
        self.now = datetime.utcnow()
        self.encoder = GoodJSONEncoder()

    def test_datetime(self):
        """Datetime should be serialized into ISOFormat."""
        self.assertEqual(
            self.encoder.default(self.now), self.now.isoformat()
        )

Ejemplo n.º 22

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

class MaxKeyTest(TestCase):
    """MaxKey test."""

    def setUp(self):
        """Set up class."""
        from bson.max_key import MaxKey
        self.encoder = GoodJSONEncoder()
        self.data = MaxKey()

    def test_minkey(self):
        """Maxkey should be encoded."""
        self.assertDictEqual(
            {"maxKey": True},
            self.encoder.default(self.data)
        )

Ejemplo n.º 23

class DatetimeEpochEncodeTest(TestCase):
    """datetime encoding test."""
    def setUp(self):
        """Set up funciton."""
        from datetime import datetime
        self.now = datetime.utcnow()
        self.encoder = GoodJSONEncoder(epoch_mode=True)

    def test_datetime(self):
        """Datetime should be serialized into ISOFormat."""
        from calendar import timegm
        self.assertEqual(
            self.encoder.default(self.now),
            int((timegm(self.now.timetuple()) * 1000) +
                (self.now.microsecond / 1000)))

Ejemplo n.º 24

    class BytesTest(TestCase):
        """Bytes test."""
        def setUp(self):
            """Set up class."""
            from base64 import b64encode
            self.encoder = GoodJSONEncoder()
            self.data = b"This is a test."
            self.expected = {
                "data": b64encode(self.data).decode("utf-8"),
                "type": 0
            }

        def test_bytes(self):
            """The given bytes should be proper."""
            self.assertDictEqual(self.expected,
                                 self.encoder.default(self.data))

Ejemplo n.º 25

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

class RegexNativeByteTest(TestCase):
    """Native Regex test class."""

    def setUp(self):
        """Set up function."""
        self.encoder = GoodJSONEncoder()
        self.regex = re.compile("^[0-9]+$".encode())
        self.expected_result = {
            "regex": self.regex.pattern
        }

    def test_regex(self):
        """The encoded value should be the expected value."""
        self.assertEqual(
            self.expected_result, self.encoder.default(self.regex)
        )

Ejemplo n.º 26

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

class CodeTest(TestCase):
    """Code test."""

    def setUp(self):
        """Set up class."""
        from bson.code import Code
        self.encoder = GoodJSONEncoder()
        self.expected = {
            "code": "console.log('HAAAAAAAAHHHH!!!')",
            "scope": {"data": "test"}
        }
        self.data = Code(**self.expected)

    def test_code(self):
        """Code should be expected value."""
        self.assertDictEqual(self.expected, self.encoder.default(self.data))

Ejemplo n.º 27

class CodeTest(TestCase):
    """Code test."""
    def setUp(self):
        """Set up class."""
        from bson.code import Code
        self.encoder = GoodJSONEncoder()
        self.expected = {
            "code": "console.log('HAAAAAAAAHHHH!!!')",
            "scope": {
                "data": "test"
            }
        }
        self.data = Code(**self.expected)

    def test_code(self):
        """Code should be expected value."""
        self.assertDictEqual(self.expected, self.encoder.default(self.data))

Ejemplo n.º 28

class TimeStampTest(TestCase):
    """Timestamp test."""
    def setUp(self):
        """Set up class."""
        from bson.timestamp import Timestamp
        from datetime import datetime
        from calendar import timegm
        from random import randint
        self.expected = {
            "time": timegm(datetime.utcnow().timetuple()),
            "inc": randint(0, 4294967295)
        }
        self.encoder = GoodJSONEncoder()
        self.data = Timestamp(**self.expected)

    def test_timestamp(self):
        """The timestamp should be expected value."""
        self.assertDictEqual(self.expected, self.encoder.default(self.data))

Ejemplo n.º 29

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

    class BytesTest(TestCase):
        """Bytes test."""

        def setUp(self):
            """Set up class."""
            from base64 import b64encode
            self.encoder = GoodJSONEncoder()
            self.data = b"This is a test."
            self.expected = {
                "data": b64encode(self.data).decode("utf-8"),
                "type": 0
            }

        def test_bytes(self):
            """The given bytes should be proper."""
            self.assertDictEqual(
                self.expected, self.encoder.default(self.data)
            )

Ejemplo n.º 30

class BinaryTest(TestCase):
    """Binary test."""
    def setUp(self):
        """Set up class."""
        from bson.binary import Binary, BINARY_SUBTYPE
        from base64 import b64encode

        self.encoder = GoodJSONEncoder()
        self.test_str = "This is a test"
        self.expected = {
            "data": b64encode(self.test_str.encode("utf-8")).decode("utf-8"),
            "type": BINARY_SUBTYPE
        }
        self.data = Binary(self.test_str.encode("utf-8"))

    def test_binary(self):
        """Binary data should be encoded properly."""
        self.assertDictEqual(self.expected, self.encoder.default(self.data))

Ejemplo n.º 31

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

class BinaryTest(TestCase):
    """Binary test."""

    def setUp(self):
        """Set up class."""
        from bson.binary import Binary, BINARY_SUBTYPE
        from base64 import b64encode

        self.encoder = GoodJSONEncoder()
        self.test_str = "This is a test"
        self.expected = {
            "data": b64encode(self.test_str.encode("utf-8")).decode("utf-8"),
            "type": BINARY_SUBTYPE
        }
        self.data = Binary(self.test_str.encode("utf-8"))

    def test_binary(self):
        """Binary data should be encoded properly."""
        self.assertDictEqual(self.expected, self.encoder.default(self.data))

Ejemplo n.º 32

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

class TimeStampTest(TestCase):
    """Timestamp test."""

    def setUp(self):
        """Set up class."""
        from bson.timestamp import Timestamp
        from datetime import datetime
        from calendar import timegm
        from random import randint
        self.expected = {
            "time": timegm(datetime.utcnow().timetuple()),
            "inc": randint(0, 4294967295)
        }
        self.encoder = GoodJSONEncoder()
        self.data = Timestamp(**self.expected)

    def test_timestamp(self):
        """The timestamp should be expected value."""
        self.assertDictEqual(self.expected, self.encoder.default(self.data))

Ejemplo n.º 33

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

class DatetimeEpochEncodeTest(TestCase):
    """datetime encoding test."""

    def setUp(self):
        """Set up funciton."""
        from datetime import datetime
        self.now = datetime.utcnow()
        self.encoder = GoodJSONEncoder(epoch_mode=True)

    def test_datetime(self):
        """Datetime should be serialized into ISOFormat."""
        from calendar import timegm
        self.assertEqual(
            self.encoder.default(self.now),
            int(
                (timegm(self.now.timetuple()) * 1000) +
                (self.now.microsecond / 1000)
            )
        )

Ejemplo n.º 34

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

 def setUp(self):
     """Set up function."""
     self.encoder = GoodJSONEncoder()
     self.data = "test"

Ejemplo n.º 35

 def setUp(self):
     """Set up function."""
     self.encoder = GoodJSONEncoder()
     self.regex = re.compile("^[0-9]+$".encode())
     self.expected_result = {"regex": self.regex.pattern}

Ejemplo n.º 36

 def setUp(self):
     """Set up function."""
     from bson import ObjectId
     self.encoder = GoodJSONEncoder()
     self.oid = ObjectId()

Ejemplo n.º 37

 def setUp(self):
     """Set up class."""
     from uuid import uuid5, NAMESPACE_DNS
     self.encoder = GoodJSONEncoder()
     self.data = uuid5(NAMESPACE_DNS, "This is a test")
     self.expected = str(self.data)

Ejemplo n.º 38

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

 def setUp(self):
     """Set up class."""
     from bson.max_key import MaxKey
     self.encoder = GoodJSONEncoder()
     self.data = MaxKey()

Ejemplo n.º 39

 def setUp(self):
     """Set up function."""
     self.encoder = GoodJSONEncoder()
     self.data = "test"

Ejemplo n.º 40

 def setUp(self):
     """Set up funciton."""
     from datetime import datetime
     self.now = datetime.utcnow()
     self.encoder = GoodJSONEncoder(epoch_mode=True)

Ejemplo n.º 41

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

 def setUp(self):
     """Set up function."""
     from bson import ObjectId
     self.encoder = GoodJSONEncoder()
     self.oid = ObjectId()

Ejemplo n.º 42

 def setUp(self):
     """Set up class."""
     from bson.max_key import MaxKey
     self.encoder = GoodJSONEncoder()
     self.data = MaxKey()

Ejemplo n.º 43

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

 def setUp(self):
     """Set up class."""
     from uuid import uuid5, NAMESPACE_DNS
     self.encoder = GoodJSONEncoder()
     self.data = uuid5(NAMESPACE_DNS, "This is a test")
     self.expected = str(self.data)

Ejemplo n.º 44

Archivo: test_encoder.py Proyecto: EloiZalczer/mongoengine-goodjson

 def setUp(self):
     """Set up class."""
     from bson.son import SON
     self.encoder = GoodJSONEncoder()
     self.expected = {"data": "test"}
     self.data = SON(data={"data": "test"})

Ejemplo n.º 45

Archivo: test_encoder.py Proyecto: hiroaki-yamamoto/mongoengine-goodjson

 def setUp(self):
     """Set up funciton."""
     from datetime import datetime
     self.now = datetime.utcnow()
     self.encoder = GoodJSONEncoder(epoch_mode=True)