#   Copyright 2016 Huawei, Inc. All rights reserved.
#
#   Licensed under the Apache License, Version 2.0 (the "License"); you may
#   not use this file except in compliance with the License. You may obtain
#   a copy of the License at
#
#        http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#   License for the specific language governing permissions and limitations
#   under the License.
#


import socket

from keystoneauth1 import adapter
import mock
from osc_lib.tests import fakes as osc_fakes
from oslo_serialization import jsonutils
import six

from pankoclient.common import exceptions as exc
from pankoclient.common import http
from pankoclient.common import utils
from pankoclient.tests.unit import base
from pankoclient.tests.unit import fakes


@mock.patch('pankoclient.common.http.requests.request')
class TestHttpClient(base.TestBase):

    def setUp(self):
        super(TestHttpClient, self).setUp()

    def test_http_raw_request(self, mock_request):
        headers = {'User-Agent': 'python-pankoclient',
                   'Content-Type': 'application/octet-stream'}
        mock_request.return_value = fakes.FakeHTTPResponse(200, 'OK', {}, '')
        client = http.HTTPClient('http://example.com:6688')
        resp, body = client.raw_request('GET', '/prefix')
        self.assertEqual(200, resp.status_code)
        self.assertEqual('', ''.join([x for x in resp.content]))
        mock_request.assert_called_once_with('GET',
                                             'http://example.com:6688/prefix',
                                             allow_redirects=False,
                                             headers=headers)

    def test_token_or_credentials(self, mock_request):
        # Record a 200
        fake200 = fakes.FakeHTTPResponse(200, 'OK', {}, '')
        mock_request.side_effect = [fake200, fake200, fake200]

        # Replay, create client, assert
        client = http.HTTPClient('http://example.com:6688')
        resp, body = client.raw_request('GET', '')
        self.assertEqual(200, resp.status_code)

        client.username = osc_fakes.USERNAME
        client.password = osc_fakes.PASSWORD
        resp, body = client.raw_request('GET', '')
        self.assertEqual(200, resp.status_code)

        client.auth_token = osc_fakes.AUTH_TOKEN
        resp, body = client.raw_request('GET', '')
        self.assertEqual(200, resp.status_code)

        # no token or credentials
        mock_request.assert_has_calls([
            mock.call('GET', 'http://example.com:6688',
                      allow_redirects=False,
                      headers={'User-Agent': 'python-pankoclient',
                               'Content-Type': 'application/octet-stream'}),
            mock.call('GET', 'http://example.com:6688',
                      allow_redirects=False,
                      headers={'User-Agent': 'python-pankoclient',
                               'X-Auth-Key': osc_fakes.PASSWORD,
                               'X-Auth-User': osc_fakes.USERNAME,
                               'Content-Type': 'application/octet-stream'}),
            mock.call('GET', 'http://example.com:6688',
                      allow_redirects=False,
                      headers={'User-Agent': 'python-pankoclient',
                               'X-Auth-Token': osc_fakes.AUTH_TOKEN,
                               'Content-Type': 'application/octet-stream'})
        ])

    def test_region_name(self, mock_request):
        # Record a 200
        fake200 = fakes.FakeHTTPResponse(200, 'OK', {}, '')
        mock_request.return_value = fake200

        client = http.HTTPClient('http://example.com:6688')
        client.region_name = osc_fakes.REGION_NAME
        resp, body = client.raw_request('GET', '')
        self.assertEqual(200, resp.status_code)

        mock_request.assert_called_once_with(
            'GET', 'http://example.com:6688',
            allow_redirects=False,
            headers={'X-Region-Name': osc_fakes.REGION_NAME,
                     'User-Agent': 'python-pankoclient',
                     'Content-Type': 'application/octet-stream'})

    def test_http_json_request(self, mock_request):
        # Record a 200
        mock_request.return_value = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/json'}, '{}')

        client = http.HTTPClient('http://example.com:6688')
        resp, body = client.json_request('GET', '')
        self.assertEqual(200, resp.status_code)
        self.assertEqual({}, body)

        mock_request.assert_called_once_with(
            'GET', 'http://example.com:6688',
            allow_redirects=False,
            headers={'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'User-Agent': 'python-pankoclient'})

    def test_http_json_request_argument_passed_to_requests(self, mock_request):
        """Check that we have sent the proper arguments to requests."""
        # Record a 200
        mock_request.return_value = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/json'}, '{}')

        client = http.HTTPClient('http://example.com:6688')
        client.verify_cert = True
        client.cert_file = 'RANDOM_CERT_FILE'
        client.key_file = 'RANDOM_KEY_FILE'
        client.auth_url = osc_fakes.AUTH_URL
        resp, body = client.json_request('POST', '', data='text')
        self.assertEqual(200, resp.status_code)
        self.assertEqual({}, body)

        mock_request.assert_called_once_with(
            'POST', 'http://example.com:6688',
            allow_redirects=False,
            cert=('RANDOM_CERT_FILE', 'RANDOM_KEY_FILE'),
            verify=True,
            data='"text"',
            headers={'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'X-Auth-Url': osc_fakes.AUTH_URL,
                     'User-Agent': 'python-pankoclient'})

    def test_http_json_request_w_req_body(self, mock_request):
        # Record a 200
        mock_request.return_value = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/json'}, '{}')

        client = http.HTTPClient('http://example.com:6688')
        resp, body = client.json_request('POST', '', data='test-body')
        self.assertEqual(200, resp.status_code)
        self.assertEqual({}, body)
        mock_request.assert_called_once_with(
            'POST', 'http://example.com:6688',
            data='"test-body"',
            allow_redirects=False,
            headers={'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'User-Agent': 'python-pankoclient'})

    def test_http_json_request_non_json_resp_cont_type(self, mock_request):
        # Record a 200
        mock_request.return_value = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'not/json'}, '{}')

        client = http.HTTPClient('http://example.com:6688')
        resp, body = client.json_request('POST', '', data='test-data')
        self.assertEqual(200, resp.status_code)
        self.assertIsNone(body)
        mock_request.assert_called_once_with(
            'POST', 'http://example.com:6688', data='"test-data"',
            allow_redirects=False,
            headers={'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'User-Agent': 'python-pankoclient'})

    def test_http_json_request_invalid_json(self, mock_request):
        # Record a 200
        mock_request.return_value = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/json'}, 'invalid-json')

        client = http.HTTPClient('http://example.com:6688')
        resp, body = client.json_request('GET', '')
        self.assertEqual(200, resp.status_code)
        self.assertEqual('invalid-json', body)
        mock_request.assert_called_once_with(
            'GET', 'http://example.com:6688',
            allow_redirects=False,
            headers={'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'User-Agent': 'python-pankoclient'})

    def test_http_json_request_redirect_delete(self, mock_request):
        mock_request.side_effect = [
            fakes.FakeHTTPResponse(
                302, 'Found',
                {'location': 'http://example.com:6688/foo/bar'},
                ''),
            fakes.FakeHTTPResponse(
                200, 'OK',
                {'Content-Type': 'application/json'},
                '{}')]

        client = http.HTTPClient('http://example.com:6688/foo')
        resp, body = client.json_request('DELETE', '')

        self.assertEqual(200, resp.status_code)
        mock_request.assert_has_calls([
            mock.call('DELETE', 'http://example.com:6688/foo',
                      allow_redirects=False,
                      headers={'Content-Type': 'application/json',
                               'Accept': 'application/json',
                               'User-Agent': 'python-pankoclient'}),
            mock.call('DELETE', 'http://example.com:6688/foo/bar',
                      allow_redirects=False,
                      headers={'Content-Type': 'application/json',
                               'Accept': 'application/json',
                               'User-Agent': 'python-pankoclient'})
        ])

    def test_http_json_request_redirect_post(self, mock_request):
        mock_request.side_effect = [
            fakes.FakeHTTPResponse(
                302, 'Found',
                {'location': 'http://example.com:6688/foo/bar'},
                ''),
            fakes.FakeHTTPResponse(
                200, 'OK',
                {'Content-Type': 'application/json'},
                '{}')]

        client = http.HTTPClient('http://example.com:6688/foo')
        resp, body = client.json_request('POST', '')

        self.assertEqual(200, resp.status_code)
        mock_request.assert_has_calls([
            mock.call('POST', 'http://example.com:6688/foo',
                      allow_redirects=False,
                      headers={'Content-Type': 'application/json',
                               'Accept': 'application/json',
                               'User-Agent': 'python-pankoclient'}),
            mock.call('POST', 'http://example.com:6688/foo/bar',
                      allow_redirects=False,
                      headers={'Content-Type': 'application/json',
                               'Accept': 'application/json',
                               'User-Agent': 'python-pankoclient'})
        ])

    def test_http_json_request_redirect_put(self, mock_request):
        mock_request.side_effect = [
            fakes.FakeHTTPResponse(
                302, 'Found',
                {'location': 'http://example.com:6688/foo/bar'},
                ''),
            fakes.FakeHTTPResponse(
                200, 'OK',
                {'Content-Type': 'application/json'},
                '{}')]

        client = http.HTTPClient('http://example.com:6688/foo')
        resp, body = client.json_request('PUT', '')

        self.assertEqual(200, resp.status_code)
        mock_request.assert_has_calls([
            mock.call('PUT', 'http://example.com:6688/foo',
                      allow_redirects=False,
                      headers={'Content-Type': 'application/json',
                               'Accept': 'application/json',
                               'User-Agent': 'python-pankoclient'}),
            mock.call('PUT', 'http://example.com:6688/foo/bar',
                      allow_redirects=False,
                      headers={'Content-Type': 'application/json',
                               'Accept': 'application/json',
                               'User-Agent': 'python-pankoclient'})
        ])

    def test_http_json_request_redirect_diff_location(self, mock_request):
        mock_request.side_effect = [
            fakes.FakeHTTPResponse(
                302, 'Found',
                {'location': 'http://example.com:6688/diff_lcation'},
                ''),
            fakes.FakeHTTPResponse(
                200, 'OK',
                {'Content-Type': 'application/json'},
                '{}')]

        client = http.HTTPClient('http://example.com:6688/foo')
        resp, body = client.json_request('PUT', '')

        self.assertEqual(200, resp.status_code)
        mock_request.assert_has_calls([
            mock.call('PUT', 'http://example.com:6688/foo',
                      allow_redirects=False,
                      headers={'Content-Type': 'application/json',
                               'Accept': 'application/json',
                               'User-Agent': 'python-pankoclient'}),
            mock.call('PUT', 'http://example.com:6688/diff_lcation',
                      allow_redirects=False,
                      headers={'Content-Type': 'application/json',
                               'Accept': 'application/json',
                               'User-Agent': 'python-pankoclient'})
        ])

    def test_http_json_request_redirect_error_without_location(self,
                                                               mock_request):
        mock_request.return_value = fakes.FakeHTTPResponse(
            302, 'Found', {}, '')
        client = http.HTTPClient('http://example.com:6688/foo')
        self.assertRaises(exc.EndpointException,
                          client.json_request, 'DELETE', '')
        mock_request.assert_called_once_with(
            'DELETE', 'http://example.com:6688/foo',
            allow_redirects=False,
            headers={'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'User-Agent': 'python-pankoclient'})

    def test_http_json_request_redirect_get(self, mock_request):
        # Record the 302
        mock_request.side_effect = [
            fakes.FakeHTTPResponse(
                302, 'Found',
                {'location': 'http://example.com:6688'},
                ''),
            fakes.FakeHTTPResponse(
                200, 'OK',
                {'Content-Type': 'application/json'},
                '{}')]

        client = http.HTTPClient('http://example.com:6688')
        resp, body = client.json_request('GET', '')
        self.assertEqual(200, resp.status_code)
        self.assertEqual({}, body)

        mock_request.assert_has_calls([
            mock.call('GET', 'http://example.com:6688',
                      allow_redirects=False,
                      headers={'Content-Type': 'application/json',
                               'Accept': 'application/json',
                               'User-Agent': 'python-pankoclient'}),
            mock.call('GET', 'http://example.com:6688',
                      allow_redirects=False,
                      headers={'Content-Type': 'application/json',
                               'Accept': 'application/json',
                               'User-Agent': 'python-pankoclient'})
        ])

    def test_http_404_json_request(self, mock_request):
        mock_request.return_value = fakes.FakeHTTPResponse(
            404, 'Not Found', {'Content-Type': 'application/json'}, '')

        client = http.HTTPClient('http://example.com:6688')
        e = self.assertRaises(exc.NotFound, client.json_request, 'GET', '')
        # Assert that the raised exception can be converted to string
        self.assertIsNotNone(str(e))
        # Record a 404
        mock_request.assert_called_once_with(
            'GET', 'http://example.com:6688',
            allow_redirects=False,
            headers={'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'User-Agent': 'python-pankoclient'})

    def test_http_300_json_request(self, mock_request):
        mock_request.return_value = fakes.FakeHTTPResponse(
            300, 'OK', {'Content-Type': 'application/json'}, '')
        client = http.HTTPClient('http://example.com:6688')
        e = self.assertRaises(
            exc.MultipleChoices, client.json_request, 'GET', '')
        # Assert that the raised exception can be converted to string
        self.assertIsNotNone(str(e))

        # Record a 300
        mock_request.assert_called_once_with(
            'GET', 'http://example.com:6688',
            allow_redirects=False,
            headers={'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'User-Agent': 'python-pankoclient'})

    def test_fake_json_request(self, mock_request):
        headers = {'Content-Type': 'application/json',
                   'Accept': 'application/json',
                   'User-Agent': 'python-pankoclient'}
        mock_request.side_effect = [socket.gaierror]

        client = http.HTTPClient('fake://example.com:6688')
        self.assertRaises(exc.EndpointNotFound,
                          client.json_request, "GET", "/")
        mock_request.assert_called_once_with('GET', 'fake://example.com:6688/',
                                             allow_redirects=False,
                                             headers=headers)

    def test_http_request_socket_error(self, mock_request):
        headers = {'Content-Type': 'application/json',
                   'Accept': 'application/json',
                   'User-Agent': 'python-pankoclient'}
        mock_request.side_effect = [socket.error]

        client = http.HTTPClient('http://example.com:6688')
        self.assertRaises(exc.ConnectionError,
                          client.json_request, "GET", "/")
        mock_request.assert_called_once_with('GET', 'http://example.com:6688/',
                                             allow_redirects=False,
                                             headers=headers)

    def test_http_request_socket_timeout(self, mock_request):
        headers = {'Content-Type': 'application/json',
                   'Accept': 'application/json',
                   'User-Agent': 'python-pankoclient'}
        mock_request.side_effect = [socket.timeout]

        client = http.HTTPClient('http://example.com:6688')
        self.assertRaises(exc.ConnectionError,
                          client.json_request, "GET", "/")
        mock_request.assert_called_once_with('GET', 'http://example.com:6688/',
                                             allow_redirects=False,
                                             headers=headers)

    def test_http_request_specify_timeout(self, mock_request):
        mock_request.return_value = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/json'}, '{}')

        client = http.HTTPClient('http://example.com:6688', timeout='123')
        resp, body = client.json_request('GET', '')
        self.assertEqual(200, resp.status_code)
        self.assertEqual({}, body)
        mock_request.assert_called_once_with(
            'GET', 'http://example.com:6688',
            allow_redirects=False,
            headers={'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'User-Agent': 'python-pankoclient'},
            timeout=float(123))

    def test_get_system_ca_file(self, mock_request):
        chosen = '/etc/ssl/certs/ca-certificates.crt'
        with mock.patch('os.path.exists') as mock_os:
            mock_os.return_value = chosen

            ca = http.get_system_ca_file()
            self.assertEqual(chosen, ca)

            mock_os.assert_called_once_with(chosen)

    def test_insecure_verify_cert_none(self, mock_request):
        client = http.HTTPClient('https://foo', insecure=True)
        self.assertFalse(client.verify_cert)

    def test_passed_cert_to_verify_cert(self, mock_request):
        client = http.HTTPClient('https://foo', ca_file="NOWHERE")
        self.assertEqual("NOWHERE", client.verify_cert)

        with mock.patch('pankoclient.common.http.get_system_ca_file') as gsf:
            gsf.return_value = "SOMEWHERE"
            client = http.HTTPClient('https://foo')
            self.assertEqual("SOMEWHERE", client.verify_cert)

    def test_methods(self, mock_request):
        fake = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/json'}, '{}')
        mock_request.return_value = fake

        client = http.HTTPClient('http://example.com:6688')
        methods = [client.get, client.put, client.post, client.patch,
                   client.delete, client.head]
        for method in methods:
            resp, body = method('')
            self.assertEqual(200, resp.status_code)


class TestSessionClient(base.TestBase):

    def setUp(self):
        super(TestSessionClient, self).setUp()
        self.request = mock.patch.object(adapter.LegacyJsonAdapter,
                                         'request').start()

    def test_session_simple_request(self):
        resp = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/octet-stream'}, '{}')
        self.request.return_value = (resp, {})

        client = http.SessionClient(session=mock.ANY,
                                    auth=mock.ANY)
        resp, body = client.request(method='GET', url='')
        self.assertEqual(200, resp.status_code)
        self.assertEqual('{}', ''.join([x for x in resp.content]))
        self.assertEqual({}, body)

    def test_session_json_request(self):
        fake = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/json'},
            jsonutils.dumps({'some': 'body'}))
        self.request.return_value = (fake, {'some': 'body'})

        client = http.SessionClient(session=mock.ANY,
                                    auth=mock.ANY)

        resp, body = client.request('', 'GET')
        self.assertEqual(200, resp.status_code)
        self.assertEqual({'some': 'body'}, resp.json())
        self.assertEqual({'some': 'body'}, body)

    def test_404_error_response(self):
        fake = fakes.FakeHTTPResponse(
            404, 'Not Found', {'Content-Type': 'application/json'}, '')
        self.request.return_value = (fake, '')

        client = http.SessionClient(session=mock.ANY,
                                    auth=mock.ANY)
        e = self.assertRaises(exc.NotFound,
                              client.request, '', 'GET')
        # Assert that the raised exception can be converted to string
        self.assertIsNotNone(six.text_type(e))

    def test_redirect_302_location(self):
        fake1 = fakes.FakeHTTPResponse(
            302, 'OK', {'location': 'http://no.where/ishere'}, '')
        fake2 = fakes.FakeHTTPResponse(200, 'OK',
                                       {'Content-Type': 'application/json'},
                                       jsonutils.dumps({'Mount': 'Fuji'}))
        self.request.side_effect = [
            (fake1, None), (fake2, {'Mount': 'Fuji'})]

        client = http.SessionClient(session=mock.ANY,
                                    auth=mock.ANY,
                                    endpoint_override='http://no.where/')
        resp, body = client.request('', 'GET', redirect=True)

        self.assertEqual(200, resp.status_code)
        self.assertEqual({'Mount': 'Fuji'}, utils.get_response_body(resp))
        self.assertEqual({'Mount': 'Fuji'}, body)

        self.assertEqual(('', 'GET'), self.request.call_args_list[0][0])
        self.assertEqual(('ishere', 'GET'), self.request.call_args_list[1][0])
        for call in self.request.call_args_list:
            self.assertEqual({'user_agent': 'python-pankoclient',
                              'raise_exc': False,
                              'redirect': True}, call[1])

    def test_302_location_not_override(self):
        fake1 = fakes.FakeHTTPResponse(
            302, 'OK', {'location': 'http://no.where/ishere'}, '')
        fake2 = fakes.FakeHTTPResponse(200, 'OK',
                                       {'Content-Type': 'application/json'},
                                       jsonutils.dumps({'Mount': 'Fuji'}))
        self.request.side_effect = [
            (fake1, None), (fake2, {'Mount': 'Fuji'})]

        client = http.SessionClient(session=mock.ANY,
                                    auth=mock.ANY,
                                    endpoint_override='http://endpoint/')
        resp, body = client.request('', 'GET', redirect=True)

        self.assertEqual(200, resp.status_code)
        self.assertEqual({'Mount': 'Fuji'}, utils.get_response_body(resp))
        self.assertEqual({'Mount': 'Fuji'}, body)

        self.assertEqual(('', 'GET'), self.request.call_args_list[0][0])
        self.assertEqual(('http://no.where/ishere',
                          'GET'), self.request.call_args_list[1][0])
        for call in self.request.call_args_list:
            self.assertEqual({'user_agent': 'python-pankoclient',
                              'raise_exc': False,
                              'redirect': True}, call[1])

    def test_redirect_302_no_location(self):
        fake = fakes.FakeHTTPResponse(
            302, 'OK', {}, '')
        self.request.side_effect = [(fake, '')]

        client = http.SessionClient(session=mock.ANY,
                                    auth=mock.ANY)
        e = self.assertRaises(exc.EndpointException,
                              client.request, '', 'GET', redirect=True)
        self.assertEqual("Location not returned with redirect",
                         six.text_type(e))

    def test_no_redirect_302_no_location(self):
        fake = fakes.FakeHTTPResponse(302, 'OK',
                                      {'location': 'http://no.where/ishere'},
                                      '')
        self.request.side_effect = [(fake, '')]

        client = http.SessionClient(session=mock.ANY,
                                    auth=mock.ANY)
        resp, body = client.request('', 'GET')

        self.assertEqual(fake, resp)

    def test_300_error_response(self):
        fake = fakes.FakeHTTPResponse(
            300, 'FAIL', {'Content-Type': 'application/octet-stream'}, '')
        self.request.return_value = (fake, '')

        client = http.SessionClient(session=mock.ANY,
                                    auth=mock.ANY)
        e = self.assertRaises(exc.MultipleChoices,
                              client.request, '', 'GET')
        # Assert that the raised exception can be converted to string
        self.assertIsNotNone(six.text_type(e))

    def test_506_error_response(self):
        # for 506 we don't have specific exception type
        fake = fakes.FakeHTTPResponse(
            506, 'FAIL', {'Content-Type': 'application/octet-stream'}, '')
        self.request.return_value = (fake, '')

        client = http.SessionClient(session=mock.ANY,
                                    auth=mock.ANY)
        e = self.assertRaises(exc.HttpServerError,
                              client.request, '', 'GET')

        self.assertEqual(506, e.status_code)

    def test_kwargs(self):
        fake = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/json'}, '{}')
        kwargs = dict(endpoint_override='http://no.where/',
                      data='some_data')

        client = http.SessionClient(mock.ANY)

        self.request.return_value = (fake, {})

        resp, body = client.request('', 'GET', **kwargs)

        self.assertEqual({'endpoint_override': 'http://no.where/',
                          'json': 'some_data',
                          'user_agent': 'python-pankoclient',
                          'raise_exc': False}, self.request.call_args[1])
        self.assertEqual(200, resp.status_code)
        self.assertEqual({}, body)
        self.assertEqual({}, utils.get_response_body(resp))

    @mock.patch.object(jsonutils, 'dumps')
    def test_kwargs_with_files(self, mock_dumps):
        fake = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/json'}, '{}')
        mock_dumps.return_value = "{'files': test}}"
        data = six.BytesIO(b'test')
        kwargs = {'endpoint_override': 'http://no.where/',
                  'data': {'files': data}}
        client = http.SessionClient(mock.ANY)

        self.request.return_value = (fake, {})

        resp, body = client.request('', 'GET', **kwargs)

        self.assertEqual({'endpoint_override': 'http://no.where/',
                          'json': {'files': data},
                          'user_agent': 'python-pankoclient',
                          'raise_exc': False}, self.request.call_args[1])
        self.assertEqual(200, resp.status_code)
        self.assertEqual({}, body)
        self.assertEqual({}, utils.get_response_body(resp))

    def test_methods(self):
        fake = fakes.FakeHTTPResponse(
            200, 'OK', {'Content-Type': 'application/json'}, '{}')
        self.request.return_value = (fake, {})

        client = http.SessionClient(mock.ANY)
        methods = [client.get, client.put, client.post, client.patch,
                   client.delete, client.head]
        for method in methods:
            resp, body = method('')
            self.assertEqual(200, resp.status_code)

    def test_credentials_headers(self):
        client = http.SessionClient(mock.ANY)
        self.assertEqual({}, client.credentials_headers())