Python Response._content方法代码示例

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
    def test_upload_app_poll_status(self):
        mock_response = self.mock_post.return_value
        mock_response.ok = True
        mock_response.return_value = {
            'success': True,
            'status_url': 'http://example.com/status/'
        }

        response_not_completed = Response()
        response_not_completed.status_code = 200
        response_not_completed.encoding = 'utf-8'
        response_not_completed._content = json.dumps(
            {'completed': False, 'application_url': ''}).encode('utf-8')
        response_completed = Response()
        response_completed.status_code = 200
        response_completed.encoding = 'utf-8'
        response_completed._content = json.dumps(
            {'completed': True, 'revision': 14,
             'application_url': 'http://example.org'}).encode('utf-8')
        self.mock_get.side_effect = [
            response_not_completed,
            response_not_completed,
            response_completed,
        ]
        response = upload_app(self.package_name, self.data)
        self.assertEqual(response, {
            'success': True,
            'errors': [],
            'application_url': 'http://example.org',
            'revision': 14,
        })
        self.assertEqual(self.mock_get.call_count, 3)

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
    def test_avi_json(self):
        rsp = Response()
        rsp.status_code = 404
        rsp._content = 'Not found'
        try:
            avi_rsp = ApiResponse(rsp)
            avi_rsp.json()
            assert False
        except ObjectNotFound:
            pass
        except Exception:
            assert False

        rsp.status_code = 501
        try:
            avi_rsp = ApiResponse(rsp)
            avi_rsp.json()
            assert False
        except APIError:
            pass
        except Exception:
            assert False

        rsp.status_code = 200
        rsp._content = json.dumps({'count': 3, 'results': ['a', 'b', 'c']})
        try:
            avi_rsp = ApiResponse(rsp)
            obj = avi_rsp.json()
            assert obj['count']
            assert avi_rsp.count() == 3
            assert len(obj['results']) == 3
        except Exception as e:
            log.debug('exception %s', str(e))
            log.debug('%s', traceback.format_exc())
            assert False

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
    def test_should_contain1(self, requests):
        response = Response()
        response.status_code = 200
        response._content = """
        <CFRDOC>
            <AMDDATE>Jan 1, 2001</AMDDATE>
            <PARTS>Part 111 to 222</PARTS>
        </CFRDOC>"""
        response._content_consumed = True
        requests.get.return_value = response

        volume = annual.Volume(2001, 12, 2)
        self.assertFalse(volume.should_contain(1))
        self.assertFalse(volume.should_contain(100))
        self.assertFalse(volume.should_contain(300))
        self.assertFalse(volume.should_contain(250))
        self.assertTrue(volume.should_contain(111))
        self.assertTrue(volume.should_contain(211))
        self.assertTrue(volume.should_contain(222))

        response._content = """
        <CFRDOC>
            <AMDDATE>Jan 1, 2001</AMDDATE>
            <PARTS>Parts 587 to End</PARTS>
        </CFRDOC>"""
        response._content_consumed = True

        volume = annual.Volume(2001, 12, 2)
        self.assertFalse(volume.should_contain(111))
        self.assertFalse(volume.should_contain(586))
        self.assertTrue(volume.should_contain(587))
        self.assertTrue(volume.should_contain(600))
        self.assertTrue(volume.should_contain(999999))

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
def test_delete_operation():
    response = Response()
    response._content = '{"access_token":"CLIENT_ACCESS_TOKEN","token_type":"Bearer","expires_in":3887999}'
    requests.post = MagicMock(return_value=response)

    auth = APIManager('CLIENT_ID', 'CLIENT_SECRET', 'HOSTNAME')

    response = Response()
    response._content = '{"message": "SUCCESS"}'
    requests.delete = MagicMock(return_value=response)
    delete = auth.delete('ROUTE')
    assert delete.content == '{"message": "SUCCESS"}'

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
        def mock_response():
            global HIT_COUNT
            HIT_COUNT += 1
            r = Response()
            r.status_code = 200
            if HIT_COUNT == 1:
                with open("app/ciscoeox/tests/data/cisco_eox_response_page_1_of_2.json") as f:
                    r._content = f.read().encode("utf-8")

            else:
                with open("app/ciscoeox/tests/data/cisco_eox_response_page_2_of_2.json") as f:
                    r._content = f.read().encode("utf-8")
            return r

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
    def request(self, url, method, **kwargs):

        resp = Response()

        if url == '/role_assignments?scope.domain.id=default':
            json_data = open(UNIT_TEST_RESOURCES_FOLDER + LIST_ROLE_ASSIGNMENTS_RESPONSE_FILE_EXTENDED1).read()
            resp.status_code = OK
            resp._content = json_data
        elif url == '/role_assignments?user.id=fake3&scope.domain.id=default':
            json_data = open(UNIT_TEST_RESOURCES_FOLDER + LIST_USERS_RESPONSE_FILE2).read()
            resp.status_code = OK
            resp._content = json_data
        return resp

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
def test_authenticate_decorator():
    response = Response()
    response._content = '{"access_token":"ACCESS_TOKEN","token_type":"Bearer","expires_in":-5}'
    requests.post = MagicMock(return_value=response)

    auth = APIManager('CLIENT_ID', 'CLIENT_SECRET', 'HOSTNAME')

    assert auth.access_token['access_token'] == 'ACCESS_TOKEN'

    response._content = '{"access_token":"REFRESHED_ACCESS_TOKEN","token_type":"Bearer","expires_in":3887999}'
    auth.post('/')

    assert auth.access_token['access_token'] == 'REFRESHED_ACCESS_TOKEN'

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
        def _request(method, url, *args, **kwargs):
            assert method == 'GET'
            assert url == 'http://localhost:123/collection.txt'
            r = Response()
            r.status_code = 200
            try:
                with open(self.tmpfile, 'rb') as f:
                    r._content = f.read()
            except IOError:
                r._content = b''

            r.headers['Content-Type'] = 'text/icalendar'
            r.encoding = 'ISO-8859-1'
            return r

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
        def _request(method, url, *args, **kwargs):
            assert method == 'GET'
            assert url == 'http://localhost:123/collection.txt'
            assert 'vdirsyncer' in kwargs['headers']['User-Agent']
            r = Response()
            r.status_code = 200
            try:
                with open(self.tmpfile, 'rb') as f:
                    r._content = f.read()
            except IOError:
                r._content = b''

            r.headers['Content-Type'] = 'text/calendar'
            r.encoding = 'utf-8'
            return r

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
    def test_run_tests(self):
        rainforest = Rainforest('CLIENT_TOKEN')

        # Validate that the potential for an invalid client token raises an exception
        mocked_response = Response()
        mocked_response.status_code = 404
        mocked_response._content = '{"error":"Account not found"}'

        requests.post = Mock(return_value=mocked_response)

        with self.assertRaises(RainforestError):
            rainforest.run_tests([1,2,3])

        # Validate that the potential for an invalid client token raises an exception
        mocked_response = Response()
        mocked_response.status_code = 400
        mocked_response._content = '{"error":"You must specify the tags or tests parameter"}'

        requests.post = Mock(return_value=mocked_response)

        with self.assertRaises(RainforestError):
            rainforest.run_tests(["a","b","c"])

        # Validate that tests get returned properly on a successful case
        mocked_response = Response()
        mocked_response.status_code = 201
        mocked_response._content = '{"id":1,"object":"Run","created_at":"2014-04-19T06:06:47Z","environment_id":1770,"state_log":[],"state":"queued","result":"no_result","expected_wait_time":8100.0,"browsers":[{"name":"chrome","state":"disabled"},{"name":"firefox","state":"disabled"},{"name":"ie8","state":"disabled"},{"name":"ie9","state":"disabled"},{"name":"safari","state":"disabled"}],"requested_tests":[1,2,3]}'

        requests.post = Mock(return_value=mocked_response)

        test_run = rainforest.run_tests([1,2,3])

        requests.post.assert_called_with('https://app.rainforestqa.com/api/1/runs', data='{"tests": [1, 2, 3]}', headers={
            'Content-Type'  : 'application/json',
            'Accept'        : 'application/json',
            'CLIENT_TOKEN'  : 'CLIENT_TOKEN',
        })

        self.assertIsInstance(test_run, TestRun)
        self.assertEqual(test_run.id, 1)
        self.assertEqual(test_run.object, 'Run')
        self.assertEqual(test_run.created_at, '2014-04-19T06:06:47Z')
        self.assertEqual(test_run.environment_id, 1770)
        self.assertEqual(test_run.state, 'queued')
        self.assertEqual(test_run.result, 'no_result')
        self.assertEqual(test_run.expected_wait_time, 8100.0)
        self.assertEqual(test_run.browsers, [{"name":"chrome","state":"disabled"},{"name":"firefox","state":"disabled"},{"name":"ie8","state":"disabled"},{"name":"ie9","state":"disabled"},{"name":"safari","state":"disabled"}])
        self.assertEqual(test_run.requested_tests, [1,2,3])

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
 def new_response(self, response):
     """Convert an tornado.HTTPResponse object to a requests.Response object"""
     new = Response()
     new._content = response.body
     new.status_code = response.code
     new.headers = dict(response.headers.get_all())
     return new

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
    def test_upload_app_ok(self):
        # fake upload response
        mock_response = self.mock_post.return_value
        mock_response.ok = True
        mock_response.return_value = {
            'success': True,
            'status_url': 'http://example.com/status/',
        }
        # fake poll status response
        application_url = 'http://example.com/app/1'
        revision = '1'
        ok_response = Response()
        ok_response.status_code = 200
        ok_response.encoding = 'utf-8'
        ok_response._content = json.dumps(
            {'completed': True, 'revision': revision,
             'application_url': application_url}).encode('utf-8')
        self.mock_get.return_value = ok_response

        success = upload(self.binary_file.name, 'foo')

        self.assertTrue(success)
        self.assertIn(
            call('Application uploaded successfully (as revision {})'.format(
                revision)),
            self.mock_logger.info.call_args_list)
        self.assertIn(call('Please check out the application at: %s\n',
                           application_url),
                      self.mock_logger.info.call_args_list)

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
    def test_upload_app_ignore_non_ok_responses(self):
        mock_response = self.mock_post.return_value
        mock_response.ok = True
        mock_response.return_value = {
            'success': True,
            'status_url': 'http://example.com/status/',
        }

        ok_response = Response()
        ok_response.status_code = 200
        ok_response.encoding = 'utf-8'
        ok_response._content = json.dumps(
            {'completed': True, 'revision': 14}).encode('utf-8')
        nok_response = Response()
        nok_response.status_code = 503

        self.mock_get.side_effect = [nok_response, nok_response, ok_response]
        response = upload_app(self.package_name, self.data)
        self.assertEqual(response, {
            'success': True,
            'errors': [],
            'application_url': '',
            'revision': 14,
        })
        self.assertEqual(self.mock_get.call_count, 3)

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
    def test_keystone_client_exception(self, logger):
        """
        ``keystoneclient.openstack.common.apiclient.exceptions.BadRequest`` is
        treated similarly to ``novaclient.exceptions.ClientException``.

        See ``test_novaclient_exception``.
        """
        response = Response()
        response._content = "hello world"
        result = KeystoneHttpError(
            message="Some things went wrong with some other things.",
            details={"key": "value"},
            response=response,
            request_id="abcdefghijklmnopqrstuvwxyz",
            url="/foo/bar",
            method="POST",
            http_status=INTERNAL_SERVER_ERROR,
        )
        logging_dummy = LoggingDummy(Dummy(result))
        self.assertRaises(KeystoneHttpError, logging_dummy.raise_method)

        logged = LoggedMessage.of_type(
            logger.messages, KEYSTONE_HTTP_ERROR,
        )[0]
        assertContainsFields(
            self, logged.message, {
                u"code": result.http_status,
                u"message": result.message,
                u"details": result.details,
                u"request_id": result.request_id,
                u"url": result.url,
                u"method": result.method,
                u"response": "hello world",
            },
        )

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import _content [as 别名]
    def test_snap_already_downloaded(self):
        snap_content = b'1234567890'
        snap_sha512 = ('12b03226a6d8be9c6e8cd5e55dc6c7920caaa39df14aab92d5e'
                       '3ea9340d1c8a4d3d0b8e4314f1f6ef131ba4bf1ceb9186ab87c'
                       '801af0d5c95b1befb8cedae2b9')

        with open('os.snap', 'wb') as f:
            f.write(snap_content)

        mock_details = self.mock_get.return_value
        mock_details.ok = True
        mock_details.content = json.dumps({
            'download_url': 'http://localhost',
            'download_sha512': snap_sha512,
        }).encode('utf-8')
        mock_snap = Response()
        mock_snap.status_code = 200
        mock_snap._content = snap_content

        self.mock_get.side_effect = [mock_details, mock_snap]

        download('os', 'os.snap', None, 'amd64')

        self.mock_logger.info.assert_has_calls([
            call("Getting details for 'os'"),
            call("Already downloaded 'os'")])
        self.assertTrue(os.path.exists('os.snap'))