Python Mock.json方法代码示例

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
    def test_unsubscribe_lookup_error(self, mock_requests_post, mock_requests_get):
        """Newsletter unsubscribe should report lookup failure"""
        # http://basket.readthedocs.io/newsletter_api.html#news-lookup-user
        expected_get_params = {
            'api_key': EXPECTED_BASKET_API_KEY,
            'email': self.user.email
        }
        mock_get_response = Mock()
        mock_get_json = Mock(return_value={
            'status': 'error',
            'desc': 'user not found'
        })
        mock_get_response.json = mock_get_json
        mock_requests_get.return_value = mock_get_response

        # http://basket.readthedocs.io/newsletter_api.html#news-unsubscribe
        mock_post_response = Mock()
        mock_post_json = Mock()
        mock_post_response.json = mock_post_json
        mock_requests_post.return_value = mock_post_response

        profile = UserProfile.objects.get_profile(self.user)
        result = profile.unsubscribe()

        self.assertEqual('email not found in basket', result)

        mock_requests_get.assert_called_with(EXPECTED_BASKET_LOOKUP_USER_URL,
                                             params=expected_get_params)
        mock_get_json.assert_called_with()

        self.assertFalse(mock_requests_post.called)
        self.assertFalse(mock_post_json.called)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
    def test_unsubscribe_request_exception(self, mock_requests_post, mock_requests_get):
        """Newsletter unsubscribe should gracefully handle request exceptions"""
        expected_get_params = {
            'api_key': EXPECTED_BASKET_API_KEY,
            'email': self.user.email
        }
        mock_get_response = Mock()
        mock_get_json = Mock(return_value={})
        mock_get_response.json = mock_get_json

        expected_result = Timeout()

        def raise_request_exception(*args, **kwargs):
            raise expected_result

        mock_requests_get.side_effect = raise_request_exception
        mock_requests_get.return_value = mock_get_response

        mock_post_response = Mock()
        mock_post_json = Mock()
        mock_post_response.json = mock_post_json
        mock_requests_post.return_value = mock_post_response

        profile = UserProfile.objects.get_profile(self.user)
        result = profile.unsubscribe()

        self.assertEqual(expected_result, result)

        mock_requests_get.assert_called_with(EXPECTED_BASKET_LOOKUP_USER_URL,
                                             params=expected_get_params)
        self.assertFalse(mock_get_json.called)
        self.assertFalse(mock_requests_post.called)
        self.assertFalse(mock_post_json.called)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
 def test_post_genre_serializer(self):
     """
     Test correct format for post serializers
     """
     data = {'name': 'rock', 'description': 'nice'}
     request = Mock()
     request.json = data
     PostGenreSerializer(request=request)
     data = {'description': 'nice'}
     request.json = data
     with pytest.raises(ValidationError) as excinfo:
         PostGenreSerializer(request=request)
     assert "'name' is a required property" in str(excinfo.value)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
    def _assert_is_vouched_on_mozillians(self, expected_vouched, email,
                                         mock_api_data, mock_requests_get):

        expected_api_url = '%(base_url)s/users/?api-key=%(api_key)s&email=%(email)s' % dict(
            base_url='https://example.com',
            api_key='8675309',
            email=email
        )

        mock_json = Mock(return_value={
            'count': 1,
            'next': None,
            'previous': None,
            'results': [
                {
                    '_url': 'https://mozillians.org/api/v2/users/12345/',
                    'is_vouched': expected_vouched,
                    'username': 'user'
                }
            ]
        })

        mock_response = Mock()
        mock_response.json = mock_json

        mock_requests_get.return_value = mock_response

        result_vouched = is_vouched_on_mozillians_org(User(email=email))
        self.assertEqual(expected_vouched, result_vouched)

        mock_json.assert_called_with()
        mock_requests_get.assert_called_with(expected_api_url)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
def mock_response(
        status=200,
        content="CONTENT",
        json_data=None,
        raise_for_status=None,
        url=None):
    """
    since we typically test a bunch of different
    requests calls for a service, we are going to do
    a lot of mock responses, so its usually a good idea
    to have a helper function that builds these things
    """
    mock_resp = Mock()
    # mock raise_for_status call w/optional error
    mock_resp.raise_for_status = Mock()
    if raise_for_status:
        mock_resp.raise_for_status.side_effect = raise_for_status
    # set status code and content
    mock_resp.status_code = status
    mock_resp.content = content
    mock_resp.url = url
    # add json data if provided
    if json_data:
        mock_resp.json = Mock(
            return_value=json_data
        )
    return mock_resp

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
    def test_checks_update_endpoint(self, json_response_mock):
        self.scheduler.scheduler.start()

        check = self.check

        async def _json():
            return check

        request = Mock()
        request.json = _json

        response = self.loop.run_until_complete(
            self.scheduler.update(request)
        )

        self.assertEqual(list(response), [])
        json_response_mock.assert_called_with(
            data={'status': 'scheduled'}, status=202
        )

        # test if already scheduled check will be removed
        check['triggers'] = []
        response = self.loop.run_until_complete(
            self.scheduler.update(request)
        )

        self.assertEqual(list(response), [])
        json_response_mock.assert_called_with(
            data={'status': 'deleted'}, status=202
        )

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
 def test_resp_on_failure(self):
     blk = RESTPolling()
     blk._retry = Mock()
     r = Mock()
     r.json = Exception()
     self.assertFalse(blk._retry.called)
     blk._on_failure(r, paging=False, url='the_url')
     self.assertTrue(blk._retry.called)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
def test_routing_mocked_pfs_bad_http_code(
        chain_state,
        payment_network_state,
        token_network_state,
        our_address,
):
    token_network_state, addresses, channel_states = create_square_network_topology(
        payment_network_state=payment_network_state,
        token_network_state=token_network_state,
        our_address=our_address,
    )
    address1, address2, address3 = addresses
    channel_state1, channel_state2 = channel_states

    # test routing with all nodes available
    chain_state.nodeaddresses_to_networkstates = {
        address1: NODE_NETWORK_REACHABLE,
        address2: NODE_NETWORK_REACHABLE,
        address3: NODE_NETWORK_REACHABLE,
    }

    # channel 1 and 2 are flipped here, to see when the PFS gets called
    json_data = {
        'result': [
            {
                'path': [to_checksum_address(our_address), to_checksum_address(address2)],
                'fees': 0,
            },
            {
                'path': [to_checksum_address(our_address), to_checksum_address(address1)],
                'fees': 0,
            },
        ],
    }

    response = Mock()
    response.configure_mock(status_code=400)
    response.json = Mock(return_value=json_data)

    with patch.object(requests, 'get', return_value=response):
        routes = get_best_routes(
            chain_state=chain_state,
            token_network_id=token_network_state.address,
            from_address=our_address,
            to_address=address1,
            amount=50,
            previous_address=None,
            config={
                'services': {
                    'pathfinding_service_address': 'my-pfs',
                    'pathfinding_max_paths': 3,
                },
            },
        )
        assert routes[0].node_address == address1
        assert routes[0].channel_identifier == channel_state1.identifier
        assert routes[1].node_address == address2
        assert routes[1].channel_identifier == channel_state2.identifier

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
    def setUp(self):
        # Mockando Objetos
        response_mock = Mock()

        def json():
            return {'avatar_url': 'https://avatars.githubusercontent.com/u/3457115?v=3'}

        response_mock.json = json
        self.response_mock = response_mock

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
 def test_get_next_number_bad_response(self):
     """Verify the client can handle bad responses for the next number."""
     mock_response = Mock()
     mock_response.status_code = 200
     mock_response.json = Mock(return_value={})
     mock_post = Mock(return_value=mock_response)
     # Act and assert
     with patch('requests.post', mock_post):
         self.assertRaises(DoorstopError, client.get_next_number, 'PREFIX')

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
 def test_generate_mailgun_response_json(self):
     """
     Tests that generate_mailgun_response_json() returns response.json()
     """
     response = Mock(
         spec=Response,
         status_code=status.HTTP_200_OK,
         json=mocked_json()
     )
     assert generate_mailgun_response_json(response) == response.json()

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
    def test_serializer_to_model(self):

        request = Mock()
        user_dict = {
            'username': 'userupdated', 'password': '123',
            'email': '[email protected]'}
        request.json = user_dict
        user_serializer = PostUserSerializer(request=request)
        user_model = User(serializer=user_serializer)
        assert user_dict['username'] == user_model.username
        assert user_model.email == user_dict['email']

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
 def test_get_next_number(self):
     """Verify the client can get the next number for a document."""
     mock_response = Mock()
     mock_response.status_code = 200
     mock_response.json = Mock(return_value={'next': 42})
     mock_post = Mock(return_value=mock_response)
     # Act
     with patch('requests.post', mock_post):
         number = client.get_next_number('PREFIX')
     # Assert
     url = 'http://1.2.3.4:8080/documents/PREFIX/numbers'
     headers = {'content-type': 'application/json'}
     mock_post.assert_called_once_with(url, headers=headers)
     self.assertEqual(42, number)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
    def test_unsubscribe(self, mock_requests_post, mock_requests_get):
        """Newsletter unsubscribe should call Basket API as expected"""
        # http://basket.readthedocs.io/newsletter_api.html#news-lookup-user
        expected_get_params = {
            'api_key': EXPECTED_BASKET_API_KEY,
            'email': self.user.email
        }
        expected_user_token = '8675309'
        mock_get_response = Mock()
        mock_get_json = Mock(return_value={
            'token': expected_user_token
        })
        mock_get_response.json = mock_get_json
        mock_requests_get.return_value = mock_get_response

        # http://basket.readthedocs.io/newsletter_api.html#news-unsubscribe
        expected_post_data = {
            'newsletters': 'test-pilot',
            'email': self.user.email
        }
        mock_post_response = Mock()
        mock_post_json = Mock(return_value={'status': 'ok'})
        mock_post_response.json = mock_post_json
        mock_requests_post.return_value = mock_post_response

        profile = UserProfile.objects.get_profile(self.user)
        profile.unsubscribe()

        mock_requests_get.assert_called_with(EXPECTED_BASKET_LOOKUP_USER_URL,
                                             params=expected_get_params)
        mock_get_json.assert_called_with()

        expected_url = '%s%s/' % (EXPECTED_BASKET_UNSUBSCRIBE_URL,
                                  expected_user_token)
        mock_requests_post.assert_called_with(expected_url,
                                              data=expected_post_data)
        mock_post_json.assert_called_with()

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import json [as 别名]
def should_get_download_info():
    revision = {'type': 'Revision',
                'attributes': {'url': sentinel.url}}

    s = Mock(spec=session.Session)
    s.session = Mock()
    response = Mock()
    response.json = Mock(return_value=sentinel.result)
    s.session.get = Mock(return_value=response)
    s.token = sentinel.token

    result = download.revision_download_info(s, revision)

    assert_equal(result, sentinel.result)
    s.session.get.assert_called_with(sentinel.url,
                                     headers={'accept': 'application/json'},
                                     params={'token': sentinel.token})