def test_put_tasks_creates_with_optimistic_lock(self):
        # GIVEN
        table_client = mock.Mock()
        table_client.query = mock.Mock(return_value={'Items': []})

        key = DdbRecordKey(cluster_arn='a', service_name='b')
        records_table = RecordsTableAccessor(table_client=table_client)

        running = [
            TaskInfo(task_arn='TASK1_ARN',
                     enis=[
                         EniInfo(eni_id='TASK1_ENI1_ID',
                                 public_ipv4='1.1.1.1'),
                     ])
        ]

        # WHEN
        records_table.put_update_optimistically(
            key=key, update=RecordUpdate(running_tasks=running))

        # THEN
        table_client.put_item.assert_called()
        item = table_client.put_item.call_args.kwargs['Item']
        self.assertEqual(item['version'], 1)

        condition_expression = table_client.put_item.call_args.kwargs[
            'ConditionExpression']
        expr, atts, vals = ConditionExpressionBuilder().build_expression(
            condition_expression)
        self.assertEqual(expr, '(attribute_not_exists(#n0) OR #n1 = :v0)')
        self.assertEqual(atts, {'#n0': 'version', '#n1': 'version'})
        self.assertEqual(vals, {':v0': 0})
    def test_put_tasks_updates_with_optimistic_lock(self):
        # GIVEN
        table_client = mock.Mock()
        table_client.query = mock.Mock(
            return_value={'Items': [dict(DDB_RECORD_ENCODED)]})

        key = DdbRecordKey(cluster_arn='FOO',
                           service_name='test.myexample.com')
        records_table = RecordsTableAccessor(table_client=table_client)

        running = [
            TaskInfo(task_arn='TASK1_ARN',
                     enis=[
                         EniInfo(eni_id='TASK1_ENI1_ID',
                                 public_ipv4='1.1.1.1'),
                     ])
        ]

        # WHEN
        records_table.put_update_optimistically(
            key=key, update=RecordUpdate(running_tasks=running))

        # THEN
        condition_expression = table_client.put_item.call_args.kwargs[
            'ConditionExpression']
        expr, atts, vals = ConditionExpressionBuilder().build_expression(
            condition_expression)
        self.assertEqual(vals, {':v0': 12})
Exemple #3
0
 def _stringify_conditions(self, request_data):
     """
     convert Key and Attr object of DynamoDB to strings.
     :param request_data: DynamoDB request data
     :return: updated request data
     """
     for field in self.CONDITION_FIELDS:
         if field in request_data:
             try:
                 request_data[field] = str(
                     ConditionExpressionBuilder().build_expression(
                         request_data[field],
                         field == 'KeyConditionExpression'))
             except Exception:  # pylint: disable=W0703
                 pass
     return request_data
Exemple #4
0
    def __init__(self, transformer=None, condition_builder=None,
                 serializer=None, deserializer=None):
        self._transformer = transformer
        if transformer is None:
            self._transformer = ParameterTransformer()

        self._condition_builder = condition_builder
        if condition_builder is None:
            self._condition_builder = ConditionExpressionBuilder()

        self._serializer = serializer
        if serializer is None:
            self._serializer = TypeSerializer()

        self._deserializer = deserializer
        if deserializer is None:
            self._deserializer = TypeDeserializer()
Exemple #5
0
 def setUp(self):
     self.builder = ConditionExpressionBuilder()