Example #1
0
    def test_always_fails_and_slow(self):
        self.app = helpers.makeTestApp(user = "******")
        from ddbmock import connect_boto_patch, config
        delay = 1
        config.config["always_fail_and_slow"]["DELAY_OPERATIONS"] = delay
        connect_boto_patch()
        expected = {
            u'message': u"The server encountered an internal error trying to fulfill the request",
            u'__type': u'com.amazonaws.dynamodb.v20120810#InternalServerError'
        }
        request = {}

        HEADERS = {
            'x-amz-target': 'dynamodb_20111205.list_tables',
            'content-type': 'application/x-amz-json-1.0',
        }

        start = time()
        res = self.app.post_json('/', request, headers=HEADERS, status=500)
        end = time()
        self.assertEqual(expected, json.loads(res.body))
        self.assertEqual('application/x-amz-json-1.0; charset=UTF-8',
                         res.headers['Content-Type'])

        self.assertAlmostEqual(delay, end-start, delta = 0.1)
Example #2
0
    def test_intermittent_failure(self):
        self.app = helpers.makeTestApp(user = "******")
        from ddbmock import connect_boto_patch, config
        connect_boto_patch()
        request = {}

        HEADERS = {
            'x-amz-target': 'dynamodb_20111205.list_tables',
            'content-type': 'application/x-amz-json-1.0',
        }

        for _ in range(3):
            expected = {
                u'TableNames': []
            }

            res = self.app.post_json('/', request, headers=HEADERS, status=200)
            self.assertEqual(expected, json.loads(res.body))
            self.assertEqual('application/x-amz-json-1.0; charset=UTF-8',
                             res.headers['Content-Type'])

            expected = {
                u'message': u"The server encountered an internal error trying to fulfill the request",
                u'__type': u'com.amazonaws.dynamodb.v20120810#InternalServerError'
            }
            res = self.app.post_json('/', request, headers=HEADERS, status=500)
            self.assertEqual(expected, json.loads(res.body))
            self.assertEqual('application/x-amz-json-1.0; charset=UTF-8',
                             res.headers['Content-Type'])
Example #3
0
    def test_invalid_user(self):
        self.app = helpers.makeTestApp(user = "******")
        from ddbmock import connect_boto_patch
        connect_boto_patch()

        expected = {
            u'message': u"Can't find invalid_user in users",
            u'__type': u'com.amazonaws.dynamodb.v20120810#AccessDeniedException'
        }

        res = self.app.post_json('/', {}, headers={}, status=400)
        self.assertEqual(expected, json.loads(res.body))
        self.assertEqual('application/x-amz-json-1.0; charset=UTF-8',
                         res.headers['Content-Type'])
Example #4
0
    def test_list_tables(self):
        from ddbmock import connect_boto_patch
        connect_boto_patch()

        request = {}

        expected = {
            "TableNames": [TABLE_NAME1, TABLE_NAME2],
        }

        res = self.app.post_json('/', request, headers=HEADERS, status=200)
        self.assertEqual(expected, json.loads(res.body))
        self.assertEqual('application/x-amz-json-1.0; charset=UTF-8',
                         res.headers['Content-Type'])
    def describe_table_404(self):
        from ddbmock import connect_boto_patch
        db = connect_boto_patch()

        self.assertRaises(DDBValidationErr, db.get_table,
            TABLE_NAME_404,
        )
Example #6
0
    def test_scan_validation_error(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb
        from boto.dynamodb.exceptions import DynamoDBValidationError

        expected = {
            u"Count": 1,
            u"ScannedCount": 6,
            u"Items": [
                {u"relevant_data": {u"S": u"toto"}},
            ],
            u"ConsumedCapacityUnits": 1.5,
        }

        conditions = {
            "relevant_data": {
                "AttributeValueList": [{"S":"to"},{"S":"ta"}],
                "ComparisonOperator": "CONTAINS",
            }
        }
        fields = [u'relevant_data']

        db = connect_boto_patch()

        self.assertRaises(DynamoDBValidationError, db.layer1.scan,
            TABLE_NAME, conditions, fields
        )
Example #7
0
    def setUp(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb
        from ddbmock.database.table import Table
        from ddbmock.database.key import PrimaryKey

        # Do a full database wipe
        dynamodb.hard_reset()

        # Instanciate the keys
        hash_key = PrimaryKey(self.TABLE_HK_NAME, self.TABLE_HK_TYPE)

        # Create a test table
        new_table = Table(self.TABLE_NAME, self.TABLE_RT, self.TABLE_WT,
                          hash_key, None)

        # Very important: register the table in the DB
        dynamodb.data[self.TABLE_NAME] = new_table

        # Create the database connection ie: patch boto
        self.db = connect_boto_patch()

        self.table = self.db.get_table(self.TABLE_NAME)
        self.sns_conn = boto.connect_sns()

        self.memon = MEMon()
        self.memon.debug = False
        self.memon.table = self.table
        self.memon.sns_conn = self.sns_conn
        self.memon.server_time = False
Example #8
0
    def setUp(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb
        from ddbmock.database.table import Table
        from ddbmock.database.key import PrimaryKey

        # Do a full database wipe
        dynamodb.hard_reset()

        # Instanciate the keys
        hash_key = PrimaryKey(self.TABLE_HK_NAME, self.TABLE_HK_TYPE)

        # Create a test table
        new_table = Table(self.TABLE_NAME,
                          self.TABLE_RT,
                          self.TABLE_WT,
                          hash_key,
                          None)

        # Very important: register the table in the DB
        dynamodb.data[self.TABLE_NAME] = new_table

        # Create the database connection ie: patch boto
        self.db = connect_boto_patch()

        self.table = self.db.get_table(self.TABLE_NAME)
        self.sns_conn = boto.connect_sns()

        self.memon = MEMon()
        self.memon.debug = False
        self.memon.table = self.table
        self.memon.sns_conn = self.sns_conn
        self.memon.server_time = False
Example #9
0
    def describe_table_404(self):
        from ddbmock import connect_boto_patch
        db = connect_boto_patch()

        self.assertRaises(DDBValidationErr, db.get_table,
            TABLE_NAME_404,
        )
Example #10
0
    def test_create_table_hash(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb

        db = connect_boto_patch()

        table = db.create_table(
            name=TABLE_NAME2,
            schema=db.create_schema(**TABLE_SCHEMA2),
            read_units=TABLE_RT,
            write_units=TABLE_WT,
        )

        self.assertEqual(TABLE_NAME2, table.name)
        self.assertEqual(TABLE_RT, table.read_units)
        self.assertEqual(TABLE_WT, table.write_units)
        self.assertEqual(u'CREATING', table.status)
        self.assertEqual(TABLE_SCHEMA2['hash_key_name'], table.schema.hash_key_name)
        self.assertEqual(u'N', table.schema.hash_key_type)
        self.assertIsNone(table.schema.range_key_name)
        self.assertIsNone(table.schema.range_key_type)

        data = dynamodb.data
        assert TABLE_NAME2 in data
        table = data[TABLE_NAME2]

        self.assertEqual(TABLE_NAME2, table.name)
        self.assertEqual(TABLE_RT, table.rt)
        self.assertEqual(TABLE_WT, table.wt)
        self.assertEqual(TABLE_SCHEMA2['hash_key_name'], table.hash_key.name)
        self.assertEqual(u'N', table.hash_key.typename)
        self.assertIsNone(table.range_key)
Example #11
0
    def test_scan_all_filter_fields(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb

        self.maxDiff = None

        expected = {
            u"Count": 6,
            u"ScannedCount": 6,
            u"Items": [
                {u"relevant_data": {u"S": u"tete"}},
                {u"relevant_data": {u"S": u"tata"}},
                {u"relevant_data": {u"S": u"tyty"}},
                {u"relevant_data": {u"S": u"tutu"}},
                {u"relevant_data": {u"S": u"toto"}},
                {u"relevant_data": {u"S": u"titi"}},
            ],
            u"ConsumedCapacityUnits": 1.5,
        }
        fields = [u'relevant_data']

        db = connect_boto_patch()

        ret = db.layer1.scan(TABLE_NAME, None, fields)
        self.assertEqual(expected, ret)
Example #12
0
    def test_scan_condition_filter_fields_contains(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb

        expected = {
            u"Count": 1,
            u"ScannedCount": 6,
            u"Items": [
                {u"relevant_data": {u"S": u"toto"}},
            ],
            u"ConsumedCapacityUnits": 1.5,
        }

        conditions = {
            "relevant_data": {
                "AttributeValueList": [{"S":"to"}],
                "ComparisonOperator": "CONTAINS",
            },
        }
        fields = [u'relevant_data']

        db = connect_boto_patch()

        ret = db.layer1.scan(TABLE_NAME, conditions, fields)
        self.assertEqual(expected, ret)
Example #13
0
    def test_update_item_push_to_set_ok(self):
        from ddbmock import connect_boto_patch
        from boto.dynamodb.exceptions import DynamoDBValidationError

        db = connect_boto_patch()

        expected1 = {u'SS': [u'item1', u'item2', u'item3', u'item4']}
        expected2 = {u'SS': [u'item2', u'item3', u'item1', u'item4', u'item5']}

        key = {
            u"HashKeyElement":  {TABLE_HK_TYPE: HK_VALUE},
            u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE},
        }

        self.assertRaises(DynamoDBValidationError,
            db.layer1.update_item,
            TABLE_NAME, key, {
                FIELD_SET_NAME: {'Action': 'ADD', u'Value': {u'S': u'item5'}},
            }
        )
        self.assertEqual(expected1, self.t1.store[HK_VALUE, RK_VALUE][FIELD_SET_NAME])

        db.layer1.update_item(TABLE_NAME, key, {
            FIELD_SET_NAME: {'Action': 'ADD', u'Value': {u'SS': [u'item5']}},
        })
        self.assertEqual(expected2, self.t1.store[HK_VALUE, RK_VALUE][FIELD_SET_NAME])
Example #14
0
    def test_update_item_delete_field_set_bad_type(self):
        from ddbmock import connect_boto_patch
        from boto.dynamodb.exceptions import DynamoDBValidationError

        db = connect_boto_patch()

        expected = {u'SS': [u'item1', u'item2', u'item3', u'item4']}

        key = {
            u"HashKeyElement":  {TABLE_HK_TYPE: HK_VALUE},
            u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE},
        }

        self.assertRaises(DynamoDBValidationError,
            db.layer1.update_item,
            TABLE_NAME, key, {
                FIELD_SET_NAME: {'Action': 'DELETE', u'Value': {u'B': u'item1'}},
            }
        )
        self.assertEqual(expected, self.t1.store[HK_VALUE, RK_VALUE][FIELD_SET_NAME])

        self.assertRaises(DynamoDBValidationError,
            db.layer1.update_item,
            TABLE_NAME, key, {
                FIELD_SET_NAME: {'Action': 'DELETE', u'Value': {u'BS': [u'item2', u'item4', u'item6']}},
            }
        )
        self.assertEqual(expected, self.t1.store[HK_VALUE, RK_VALUE][FIELD_SET_NAME])
    def test_batch_write_item_table_404(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb
        from boto.exception import BotoServerError

        db = connect_boto_patch()

        self.assertRaises(BotoServerError, db.layer1.batch_write_item, {
            TABLE_NAME_404: [
                {
                    u"DeleteRequest": {
                        u"Key": {
                            u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE1},
                            u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE1},
                        },
                    },
                },
                {u"PutRequest": {u"Item": ITEM2}},
                {u"PutRequest": {u"Item": ITEM3}},
            ],
            TABLE_NAME2: [
                {
                    u"DeleteRequest": {
                        u"Key": {
                            u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE2},
                        },
                    },
                },
                {u"PutRequest": {u"Item":ITEM5}},
            ],
        })
    def test_batch_get_item_filter_one(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb

        db = connect_boto_patch()

        expected = {
            "Responses": {
                "Table-HR": {
                    "Items": [{"relevant_data": {"S": "tata"}}, {"relevant_data": {"S": "tata"}}],
                    "ConsumedCapacityUnits": 1.0,
                },
                "Table-H": {
                    "Items": [
                        {"relevant_data": {"S": "tutu"}, "hash_key": {"N": "789"}, "range_key": {"S": "Waldo-5"}}
                    ],
                    "ConsumedCapacityUnits": 0.5,
                },
            }
        }

        ret = db.layer1.batch_get_item(
            {
                TABLE_NAME1: {
                    u"Keys": [
                        {u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE1}, u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE1}},
                        {u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE1}, u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE1}},
                    ],
                    u"AttributesToGet": [u"relevant_data"],
                },
                TABLE_NAME2: {u"Keys": [{u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE3}}]},
            }
        )
        self.assertEqual(expected, ret)
Example #17
0
    def test_update_item_delete_field_set_ok(self):
        from ddbmock import connect_boto_patch
        from boto.dynamodb.exceptions import DynamoDBValidationError

        db = connect_boto_patch()

        expected1 = {u"SS": [u"item1", u"item2", u"item3", u"item4"]}
        expected2 = {u"SS": [u"item3", u"item1"]}

        key = {u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE}, u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE}}

        # Can not remove a scalar value, even from a set
        self.assertRaises(
            DynamoDBValidationError,
            db.layer1.update_item,
            TABLE_NAME,
            key,
            {FIELD_SET_NAME: {"Action": "DELETE", u"Value": {u"S": u"item1"}}},
        )
        self.assertEqual(expected1, self.t1.store[HK_VALUE, RK_VALUE][FIELD_SET_NAME])

        # remove a couple of existing or not item from the field
        db.layer1.update_item(
            TABLE_NAME, key, {FIELD_SET_NAME: {"Action": "DELETE", u"Value": {u"SS": [u"item2", u"item4", u"item6"]}}}
        )
        self.assertEqual(expected2, self.t1.store[HK_VALUE, RK_VALUE][FIELD_SET_NAME])

        # Field shoud disapear (Empty)
        db.layer1.update_item(
            TABLE_NAME, key, {FIELD_SET_NAME: {"Action": "DELETE", u"Value": {u"SS": [u"item1", u"item3", u"item6"]}}}
        )
        self.assertNotIn(FIELD_SET_NAME, self.t1.store[HK_VALUE, RK_VALUE])
Example #18
0
    def test_list_tables(self):
        from ddbmock import connect_boto_patch
        db = connect_boto_patch()

        expected = [TABLE_NAME1, TABLE_NAME2]

        self.assertEqual(expected, db.list_tables())
Example #19
0
    def test_scan_paged(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb
        from boto.dynamodb.exceptions import DynamoDBValidationError

        esk = {
            u'HashKeyElement': {u'N': u'789'},
            u'RangeKeyElement': {u'S': u'Waldo-5'},
        }

        expected1 = {
            u"Count": 4,
            u"ScannedCount": 4,
            u"Items": [ITEM2, ITEM1, ITEM6, ITEM5],
            u"ConsumedCapacityUnits": 1.5,
            u'LastEvaluatedKey': esk,
        }
        expected2 = {
            u"Count": 2,
            u"ScannedCount": 2,
            u"Items": [ITEM4, ITEM3],
            u"ConsumedCapacityUnits": 0.5,
        }

        db = connect_boto_patch()

        ret = db.layer1.scan(TABLE_NAME, limit=4)
        self.assertEqual(expected1, ret)
        ret = db.layer1.scan(TABLE_NAME, exclusive_start_key=esk)
        self.assertEqual(expected2, ret)
Example #20
0
    def test_update_item_put_hr(self):
        from ddbmock import connect_boto_patch

        db = connect_boto_patch()

        key = {u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE}, u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE}}

        key2 = {u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE2}, u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE}}

        # use PUT as default action, champs existant
        db.layer1.update_item(
            TABLE_NAME, key, {"relevant_data": {"Value": RELEVANT_FIELD}}  # Move type from 'B' to 'S'
        )
        self.assertEqual(RELEVANT_FIELD, self.t1.store[HK_VALUE, RK_VALUE]["relevant_data"])

        # PUT explicite, champ non existant
        db.layer1.update_item(TABLE_NAME, key, {"irelevant_data": {"Action": "PUT", "Value": IRELEVANT_FIELD}})
        self.assertEqual(RELEVANT_FIELD, self.t1.store[HK_VALUE, RK_VALUE]["relevant_data"])
        self.assertEqual(IRELEVANT_FIELD, self.t1.store[HK_VALUE, RK_VALUE]["irelevant_data"])

        # PUT explicite, item non existant(full item creation)
        db.layer1.update_item(TABLE_NAME, key2, {"relevant_data": {"Action": "PUT", "Value": RELEVANT_FIELD}})
        self.assertEqual({TABLE_HK_TYPE: HK_VALUE2}, self.t1.store[HK_VALUE2, RK_VALUE][TABLE_HK_NAME])
        self.assertEqual({TABLE_RK_TYPE: RK_VALUE}, self.t1.store[HK_VALUE2, RK_VALUE][TABLE_RK_NAME])
        self.assertEqual(RELEVANT_FIELD, self.t1.store[HK_VALUE2, RK_VALUE]["relevant_data"])
Example #21
0
    def test_update_item_delete_field_set_bad_type(self):
        from ddbmock import connect_boto_patch
        from boto.dynamodb.exceptions import DynamoDBValidationError

        db = connect_boto_patch()

        expected = {u"SS": [u"item1", u"item2", u"item3", u"item4"]}

        key = {u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE}, u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE}}

        self.assertRaises(
            DynamoDBValidationError,
            db.layer1.update_item,
            TABLE_NAME,
            key,
            {FIELD_SET_NAME: {"Action": "DELETE", u"Value": {u"B": u"item1"}}},
        )
        self.assertEqual(expected, self.t1.store[HK_VALUE, RK_VALUE][FIELD_SET_NAME])

        self.assertRaises(
            DynamoDBValidationError,
            db.layer1.update_item,
            TABLE_NAME,
            key,
            {FIELD_SET_NAME: {"Action": "DELETE", u"Value": {u"BS": [u"item2", u"item4", u"item6"]}}},
        )
        self.assertEqual(expected, self.t1.store[HK_VALUE, RK_VALUE][FIELD_SET_NAME])
Example #22
0
    def test_create_table_hash_range(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb

        db = connect_boto_patch()

        table = db.create_table(
            name=TABLE_NAME1,
            schema=[x.schema() for x in TABLE_SCHEMA1],
            read_units=TABLE_RT,
            write_units=TABLE_WT,
        )

        self.assertEqual(TABLE_NAME1, table.name)
        self.assertEqual(TABLE_RT, table.read_units)
        self.assertEqual(TABLE_WT, table.write_units)
        self.assertEqual(u'CREATING', table.status)
        self.assertEqual(TABLE_SCHEMA1['hash_key_name'], table.schema.hash_key_name)
        self.assertEqual(TABLE_SCHEMA1['range_key_name'], table.schema.range_key_name)
        self.assertEqual(u'N', table.schema.hash_key_type)
        self.assertEqual(u'S', table.schema.range_key_type)

        data = dynamodb.data
        assert TABLE_NAME1 in data
        table = data[TABLE_NAME1]

        self.assertEqual(TABLE_NAME1, table.name)
        self.assertEqual(TABLE_RT, table.rt)
        self.assertEqual(TABLE_WT, table.wt)
        self.assertEqual(TABLE_SCHEMA1['hash_key_name'], table.hash_key.name)
        self.assertEqual(TABLE_SCHEMA1['range_key_name'], table.range_key.name)
        self.assertEqual(u'N', table.hash_key.typename)
        self.assertEqual(u'S', table.range_key.typename)
    def test_batch_get_item_nominal(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb

        db = connect_boto_patch()

        expected = {
            "Responses": {
                "Table-HR": {"Items": [ITEM1, ITEM2], "ConsumedCapacityUnits": 1.0},
                "Table-H": {"Items": [ITEM5, ITEM_BIG], "ConsumedCapacityUnits": 1.5},
            }
        }

        ret = db.layer1.batch_get_item(
            {
                TABLE_NAME1: {
                    u"Keys": [
                        {u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE1}, u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE1}},
                        {u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE1}, u"RangeKeyElement": {TABLE_RK_TYPE: RK_VALUE2}},
                    ]
                },
                TABLE_NAME2: {
                    u"Keys": [
                        {u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE3}},
                        {u"HashKeyElement": {TABLE_HK_TYPE: HK_VALUE1}},
                        {u"HashKeyElement": {TABLE_HK_TYPE: u"404"}},
                    ]
                },
            }
        )
        self.assertEqual(expected, ret)
Example #24
0
    def test_update_item_put_h(self):
        from ddbmock import connect_boto_patch
        db = connect_boto_patch()

        key = {
            u"HashKeyElement":  {TABLE_HK_TYPE: HK_VALUE},
        }

        key2 = {
            u"HashKeyElement":  {TABLE_HK_TYPE: HK_VALUE2},
        }

        # use PUT as default action, champs existant
        db.layer1.update_item(TABLE_NAME2, key, {
            'relevant_data': {'Value': RELEVANT_FIELD}  # Move type from 'B' to 'S'
        })
        self.assertEqual(RELEVANT_FIELD, self.t2.store[HK_VALUE, False]['relevant_data'])

        # PUT explicite, champ non existant
        db.layer1.update_item(TABLE_NAME2, key, {
            'irelevant_data': {'Action': 'PUT', 'Value': IRELEVANT_FIELD}
        })
        self.assertEqual(RELEVANT_FIELD, self.t2.store[HK_VALUE, False]['relevant_data'])
        self.assertEqual(IRELEVANT_FIELD, self.t2.store[HK_VALUE, False]['irelevant_data'])

        # PUT explicite, item non existant(full item creation)
        db.layer1.update_item(TABLE_NAME2, key2, {
            'relevant_data': {'Action': 'PUT', 'Value': RELEVANT_FIELD}
        })
        self.assertEqual({TABLE_HK_TYPE: HK_VALUE2}, self.t2.store[HK_VALUE2, False][TABLE_HK_NAME])
        self.assertEqual(RELEVANT_FIELD, self.t2.store[HK_VALUE2, False]['relevant_data'])
Example #25
0
    def test_connect_boto_patch_patch(self):
        from ddbmock import connect_boto_patch, real_boto, layer1_mock_init
        from ddbmock.router.boto import boto_router

        db = connect_boto_patch()

        self.assertEqual(boto_router, db.layer1.make_request.im_func)
        self.assertEqual(layer1_mock_init, db.layer1.__init__.im_func)
        self.assertNotEqual(real_boto['Layer1.make_request'], boto_router)
        self.assertNotEqual(real_boto['Layer1.__init__'], layer1_mock_init)

        # do it twice to make sure it is safe
        db = connect_boto_patch()

        self.assertEqual(boto_router, db.layer1.make_request.im_func)
        self.assertEqual(layer1_mock_init, db.layer1.__init__.im_func)
        self.assertNotEqual(real_boto['Layer1.make_request'], boto_router)
        self.assertNotEqual(real_boto['Layer1.__init__'], layer1_mock_init)
Example #26
0
    def test_readonly_user_can(self, name):
        self.app = helpers.makeTestApp(user = "******")
        from ddbmock import connect_boto_patch
        connect_boto_patch()
        HEADERS = {
            'x-amz-target': 'dynamodb_20111205.%s'% name,
            'content-type': 'application/x-amz-json-1.0',
        }

        res = self.app.post_json('/', {}, headers=HEADERS, status=[200,400])
        ret = json.loads(res.body)
        self.assertEqual('application/x-amz-json-1.0; charset=UTF-8', res.headers['Content-Type'])

        # Because no arguments, we either get a 200 for things that require no args, or a 400 for things that need args
        if res.status_code == 200:
            return
        self.assertIn("__type", ret)
        self.assertEqual(u'com.amazonaws.dynamodb.v20120810#ValidationException', ret["__type"])
Example #27
0
    def test_delete_404(self):
        from ddbmock import connect_boto_patch
        from boto.exception import BotoServerError

        db = connect_boto_patch()

        self.assertRaises(BotoServerError, db.layer1.delete_table,
                          TABLE_NAME_404,
                         )
Example #28
0
    def test_put_boto_intergration(self):
        # This item comes directly from boto intergration test suite
        # we do no assertion. It should "just work"

        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb

        db = connect_boto_patch()
        db.layer1.put_item(TABLE_NAME2, ITEM_REGRESION)
Example #29
0
    def test_connect_boto_patch_patch(self):
        from ddbmock import connect_boto_patch, real_boto, noop
        from ddbmock.router.boto import boto_router

        db = connect_boto_patch()

        self.assertEqual(boto_router, db.layer1.make_request.im_func)
        self.assertEqual(noop, db.layer1.__init__.im_func)
        self.assertNotEqual(real_boto['Layer1.make_request'], boto_router)
        self.assertNotEqual(real_boto['Layer1.__init__'], noop)

        # do it twice to make sure it is safe
        db = connect_boto_patch()

        self.assertEqual(boto_router, db.layer1.make_request.im_func)
        self.assertEqual(noop, db.layer1.__init__.im_func)
        self.assertNotEqual(real_boto['Layer1.make_request'], boto_router)
        self.assertNotEqual(real_boto['Layer1.__init__'], noop)
Example #30
0
    def test_put_h_404(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb
        from boto.exception import DynamoDBResponseError

        db = connect_boto_patch()

        self.assertRaisesRegexp(DynamoDBResponseError, 'ResourceNotFoundException',
                                db.layer1.put_item,
                                TABLE_NAME_404, ITEM3)
Example #31
0
    def test_delete(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb

        db = connect_boto_patch()

        db.layer1.delete_table(TABLE_NAME)

        data = dynamodb.data
        self.assertEqual("DELETING", data[TABLE_NAME].status)
Example #32
0
    def test_put_h_missing_h(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb
        from boto.dynamodb.exceptions import DynamoDBValidationError

        db = connect_boto_patch()

        self.assertRaises(DynamoDBValidationError,
                          db.layer1.put_item,
                          TABLE_NAME2, ITEM5)
Example #33
0
    def test_delete_CREATING_status(self):
        from ddbmock import connect_boto_patch
        from ddbmock.database.db import dynamodb
        from boto.exception import DynamoDBResponseError

        db = connect_boto_patch()

        self.assertRaisesRegexp(DynamoDBResponseError, 'ResourceInUseException',
                                db.layer1.delete_table,
                                TABLE_NAME2)