Python Mocks.make_txns方法代码示例

# 需要导入模块: from components import Mocks [as 别名]
# 或者: from components.Mocks import make_txns [as 别名]
    async def test_txn_list_with_ids(self):
        """Verifies GET /transactions with an id filter works properly.

        It will receive a Protobuf response with:
            - a head id of ID_C
            - a paging response with a start of ID_C and limit of 100
            - two transactions with ids of ID_A and ID_C

        It should send a Protobuf request with:
            - a transaction_ids property of [ID_A, ID_C]
            - empty paging controls

        It should send back a JSON response with:
            - a response status of 200
            - a head property of ID_C, the latest
            - a link property that ends in
                '/transactions?head={}&start={}&limit=100&id={},{}'
                    .format(ID_C, ID_C, ID_A, ID_C))
            - a paging property that matches the paging response
            - a data property that is a list of 2 dicts
            - those dicts are full transactions with ids ID_A and ID_C
        """
        paging = Mocks.make_paging_response("", ID_C, DEFAULT_LIMIT)
        transactions = Mocks.make_txns(ID_A, ID_C)
        self.connection.preset_response(
            head_id=ID_C, paging=paging, transactions=transactions)

        response = await self.get_assert_200('/transactions?id={},{}'.format(
            ID_A, ID_C))
        controls = Mocks.make_paging_controls()
        self.connection.assert_valid_request_sent(
            transaction_ids=[ID_A, ID_C], paging=controls)

        self.assert_has_valid_head(response, ID_C)
        link =\
            '/transactions?head={ID_C}&start={ID_C}&limit=100&id={ID_A},{ID_C}'

        self.assert_has_valid_link(
            response,
            link.format(ID_C=ID_C, ID_A=ID_A))
        self.assert_has_valid_paging(response, paging)
        self.assert_has_valid_data_list(response, 2)
        self.assert_txns_well_formed(response['data'], ID_A, ID_C)

# 需要导入模块: from components import Mocks [as 别名]
# 或者: from components.Mocks import make_txns [as 别名]
    async def test_txn_list_sorted_in_reverse(self):
        """Verifies a GET /transactions can send proper sort parameters.

        It will receive a Protobuf response with:
            - a head id of ID_C
            - a paging response with start of ID_C and limit of 100
            - three transactions with ids ID_C, ID_B, and ID_A

        It should send a Protobuf request with:
            - empty paging controls
            - sort controls with a key of 'header_signature' that is reversed

        It should send back a JSON response with:
            - a status of 200
            - a head property of ID_C
            - a link property ending in
                '/transactions?head={}&start={}&limit=100&reverse'
                    .format(ID_C, ID_C))
            - a paging property that matches the paging response
            - a data property that is a list of 3 dicts
            - and those dicts are full transactions with ids ID_C,
              ID_B, and ID_A
        """
        paging = Mocks.make_paging_response("", ID_C, DEFAULT_LIMIT)
        transactions = Mocks.make_txns(ID_C, ID_B, ID_A)
        self.connection.preset_response(
            head_id=ID_C, paging=paging, transactions=transactions)
        response = await self.get_assert_200('/transactions?reverse')
        page_controls = Mocks.make_paging_controls()
        sorting = Mocks.make_sort_controls("default", reverse=True)
        self.connection.assert_valid_request_sent(
            paging=page_controls,
            sorting=sorting)

        self.assert_has_valid_head(response, ID_C)
        self.assert_has_valid_link(
            response,
            '/transactions?head={ID_C}&start={ID_C}&limit=100&reverse'.format(
                ID_C=ID_C))
        self.assert_has_valid_paging(response, paging)
        self.assert_has_valid_data_list(response, 3)
        self.assert_txns_well_formed(response['data'], ID_C, ID_B, ID_A)

# 需要导入模块: from components import Mocks [as 别名]
# 或者: from components.Mocks import make_txns [as 别名]
    async def test_txn_list_with_head_and_ids(self):
        """Verifies GET /transactions with head and id parameters work
        properly.

        It should send a Protobuf request with:
            - a head_id property of ID_B
            - a paging response with a start of ID_B and limit of 100
            - a transaction_ids property of [ID_A]

        It will receive a Protobuf response with:
            - a head id of ID_B
            - one transaction with an id of ID_A
            - empty paging controls

        It should send back a JSON response with:
            - a response status of 200
            - a head property of ID_B
            - a link property that ends in
                '/transactions?head={}&start={}&limit=100&id={}'
                    .format(ID_B, ID_B, ID_A))
            - a paging property that matches the paging response
            - a data property that is a list of 1 dict
            - that dict is a full transaction with an id of ID_A
        """
        paging = Mocks.make_paging_response("", ID_B, DEFAULT_LIMIT)
        self.connection.preset_response(
            head_id=ID_B, paging=paging, transactions=Mocks.make_txns(ID_A))

        response = await self.get_assert_200(
            '/transactions?id={}&head={}'.format(ID_A, ID_B))
        controls = Mocks.make_paging_controls()
        self.connection.assert_valid_request_sent(
            head_id=ID_B, transaction_ids=[ID_A], paging=controls)

        self.assert_has_valid_head(response, ID_B)
        link = '/transactions?head={ID_B}&start={ID_B}&limit=100&id={ID_A}'
        self.assert_has_valid_link(
            response,
            link.format(ID_B=ID_B, ID_A=ID_A))
        self.assert_has_valid_paging(response, paging)
        self.assert_has_valid_data_list(response, 1)
        self.assert_txns_well_formed(response['data'], ID_A)

# 需要导入模块: from components import Mocks [as 别名]
# 或者: from components.Mocks import make_txns [as 别名]
    async def test_txn_list_paginated_with_just_limit(self):
        """Verifies GET /transactions paginated just by limit works properly.

        It will receive a Protobuf response with:
            - a head id of ID_D
            - a paging response with a start of ID_D, next of ID_B and
              limit of 2
            - two transactions with the ids ID_D and ID_C

        It should send a Protobuf request with:
            - paging controls with a limit of 2

        It should send back a JSON response with:
            - a response status of 200
            - a head property of ID_D
            - a link property that ends in
                '/transactions?head={}&start={}&limit=2'.format(ID_D, ID_D))
            - paging that matches the response with a next link
            - a data property that is a list of 2 dicts
            - those dicts are full transactions with ids ID_D and ID_C
        """
        paging = Mocks.make_paging_response(ID_B, ID_D, 2)
        self.connection.preset_response(
            head_id=ID_D,
            paging=paging,
            transactions=Mocks.make_txns(ID_D, ID_C))

        response = await self.get_assert_200('/transactions?limit=2')
        controls = Mocks.make_paging_controls(2)
        self.connection.assert_valid_request_sent(paging=controls)

        self.assert_has_valid_head(response, ID_D)
        self.assert_has_valid_link(
            response, '/transactions?head={ID_D}&start={ID_D}&limit=2'.format(
                ID_D=ID_D))
        self.assert_has_valid_paging(
            response, paging, '/transactions?head={}&start={}&limit=2'.format(
                ID_D, ID_B))
        self.assert_has_valid_data_list(response, 2)
        self.assert_txns_well_formed(response['data'], ID_D, ID_C)

# 需要导入模块: from components import Mocks [as 别名]
# 或者: from components.Mocks import make_txns [as 别名]
    async def test_txn_list_with_head(self):
        """Verifies a GET /transactions with a head parameter works properly.

        It will receive a Protobuf response with:
            - a head id of ID_B
            - a paging response with a start of ID_B and limit of 100
            - two transactions with ids of 1' and ID_A

        It should send a Protobuf request with:
            - a head_id property of ID_B
            - empty paging controls

        It should send back a JSON response with:
            - a response status of 200
            - a head property of ID_B
            - a link property that ends in
                '/transactions?head={}&start={}&limit=100'.format(ID_B, ID_B))
            - a paging property that matches the paging response
            - a data property that is a list of 2 dicts
            - those dicts are full transactions with ids ID_B and ID_A
        """
        paging = Mocks.make_paging_response("", ID_B, DEFAULT_LIMIT)
        self.connection.preset_response(
            head_id=ID_B,
            paging=paging,
            transactions=Mocks.make_txns(ID_B, ID_A))

        response = await self.get_assert_200(
            '/transactions?head={}'.format(ID_B))
        controls = Mocks.make_paging_controls()
        self.connection.assert_valid_request_sent(
            head_id=ID_B, paging=controls)
        self.assert_has_valid_head(response, ID_B)
        self.assert_has_valid_link(
            response,
            '/transactions?head={ID_B}&start={ID_B}&limit=100'.format(
                ID_B=ID_B))
        self.assert_has_valid_paging(response, paging)
        self.assert_has_valid_data_list(response, 2)
        self.assert_txns_well_formed(response['data'], ID_B, ID_A)

# 需要导入模块: from components import Mocks [as 别名]
# 或者: from components.Mocks import make_txns [as 别名]
    async def test_txn_list_paginated_by_start_id(self):
        """Verifies GET /transactions paginated by a start id works properly.

        It will receive a Protobuf response with:
            - a head id of ID_D
            - a paging response with start of ID_C and limit of 5
            - three transactions with the ids ID_C, ID_B and ID_A

        It should send a Protobuf request with:
            - paging controls with a count of 5, and a start_id of ID_C

        It should send back a JSON response with:
            - a response status of 200
            - a head property of ID_D
            - a link property that ends in
                '/transactions?head={}&start={}&limit=5'.format(ID_D, ID_C))
            - paging that matches the response, with a previous link
            - a data property that is a list of 3 dicts
            - those dicts are full transactions with ids ID_C, ID_B, and ID_A
        """
        paging = Mocks.make_paging_response("", ID_C, 5)
        self.connection.preset_response(
            head_id=ID_D,
            paging=paging,
            transactions=Mocks.make_txns(ID_C, ID_B, ID_A))

        response = await self.get_assert_200(
            '/transactions?start={}&limit=5'.format(ID_C))
        controls = Mocks.make_paging_controls(5, start=ID_C)
        self.connection.assert_valid_request_sent(paging=controls)

        self.assert_has_valid_head(response, ID_D)
        self.assert_has_valid_link(
            response, '/transactions?head={}&start={}&limit=5'.format(
                ID_D, ID_C))
        self.assert_has_valid_paging(response, paging)
        self.assert_has_valid_data_list(response, 3)
        self.assert_txns_well_formed(response['data'], ID_C, ID_B, ID_A)

# 需要导入模块: from components import Mocks [as 别名]
# 或者: from components.Mocks import make_txns [as 别名]
    async def test_txn_get(self):
        """Verifies a GET /transactions/{transaction_id} works properly.

        It should send a Protobuf request with:
            - a transaction_id property of ID_B

        It will receive a Protobuf response with:
            - a transaction with an id of ID_B

        It should send back a JSON response with:
            - a response status of 200
            - no head property
            - a link property that ends in '/transactions/{}'.format(ID_B)
            - a data property that is a full batch with an id of ID_B
        """
        self.connection.preset_response(transaction=Mocks.make_txns(ID_B)[0])

        response = await self.get_assert_200('/transactions/{}'.format(ID_B))
        self.connection.assert_valid_request_sent(transaction_id=ID_B)

        self.assertNotIn('head', response)
        self.assert_has_valid_link(response, '/transactions/{}'.format(ID_B))
        self.assertIn('data', response)
        self.assert_txns_well_formed(response['data'], ID_B)