← Back to branch summary

~ubuntu-branches/ubuntu/vivid/neutron/vivid-updates

« back to all changes in this revision

Viewing changes to neutron/tests/unit/vmware/apiclient/test_api_eventlet_request.py

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2015-03-30 11:17:19 UTC
  • mfrom: (1.1.21)
  • Revision ID: package-import@ubuntu.com-20150330111719-h0gx7233p4jkkgfh
Tags: 1:2015.1~b3-0ubuntu1
https://launchpad.net/bugs/1263539
* New upstream milestone release:
  - d/control: Align version requirements with upstream.
  - d/control: Add new dependency on oslo-log.
  - d/p/*: Rebase.
  - d/control,d/neutron-plugin-hyperv*: Dropped, decomposed into
    separate project upstream.
  - d/control,d/neutron-plugin-openflow*: Dropped, decomposed into
    separate project upstream.
  - d/neutron-common.install: Add neutron-rootwrap-daemon and 
    neutron-keepalived-state-change binaries.
  - d/rules: Ignore neutron-hyperv-agent when installing; only for Windows.
  - d/neutron-plugin-cisco.install: Drop neutron-cisco-cfg-agent as
    decomposed into separate project upstream.
  - d/neutron-plugin-vmware.install: Drop neutron-check-nsx-config and
    neutron-nsx-manage as decomposed into separate project upstream.
  - d/control: Add dependency on python-neutron-fwaas to neutron-l3-agent.
* d/pydist-overrides: Add overrides for oslo packages.
* d/control: Fixup type in package description (LP: #1263539).
* d/p/fixup-driver-test-execution.patch: Cherry pick fix from upstream VCS
  to support unit test exection in out-of-tree vendor drivers.
* d/neutron-common.postinst: Allow general access to /etc/neutron but limit
  access to root/neutron to /etc/neutron/neutron.conf to support execution
  of unit tests in decomposed vendor drivers.
* d/control: Add dependency on python-neutron-fwaas to neutron-l3-agent
  package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
neutron/tests/unit/vmware/apiclient/test_api_eventlet_request.py
1
 
# Copyright (C) 2009-2012 VMware, Inc. All Rights Reserved.
2
 
#
3
 
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
4
 
#    not use this file except in compliance with the License. You may obtain
5
 
#    a copy of the License at
6
 
#
7
 
#         http://www.apache.org/licenses/LICENSE-2.0
8
 
#
9
 
#    Unless required by applicable law or agreed to in writing, software
10
 
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11
 
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12
 
#    License for the specific language governing permissions and limitations
13
 
#    under the License.
14
 
 
15
 
import httplib
16
 
import random
17
 
 
18
 
import eventlet
19
 
from eventlet.green import urllib2
20
 
import mock
21
 
 
22
 
from neutron.i18n import _LI
23
 
from neutron.openstack.common import log as logging
24
 
from neutron.plugins.vmware.api_client import eventlet_client as client
25
 
from neutron.plugins.vmware.api_client import eventlet_request as request
26
 
from neutron.tests import base
27
 
from neutron.tests.unit import vmware
28
 
 
29
 
 
30
 
LOG = logging.getLogger(__name__)
31
 
 
32
 
 
33
 
REQUEST_TIMEOUT = 1
34
 
 
35
 
 
36
 
def fetch(url):
37
 
    return urllib2.urlopen(url).read()
38
 
 
39
 
 
40
 
class ApiRequestEventletTest(base.BaseTestCase):
41
 
 
42
 
    def setUp(self):
43
 
 
44
 
        super(ApiRequestEventletTest, self).setUp()
45
 
        self.client = client.EventletApiClient(
46
 
            [("127.0.0.1", 4401, True)], "admin", "admin")
47
 
        self.url = "/ws.v1/_debug"
48
 
        self.req = request.EventletApiRequest(self.client, self.url)
49
 
 
50
 
    def tearDown(self):
51
 
        self.client = None
52
 
        self.req = None
53
 
        super(ApiRequestEventletTest, self).tearDown()
54
 
 
55
 
    def test_construct_eventlet_api_request(self):
56
 
        e = request.EventletApiRequest(self.client, self.url)
57
 
        self.assertIsNotNone(e)
58
 
 
59
 
    def test_apirequest_spawn(self):
60
 
        def x(id):
61
 
            eventlet.greenthread.sleep(random.random())
62
 
            LOG.info(_LI('spawned: %d'), id)
63
 
 
64
 
        for i in range(10):
65
 
            request.EventletApiRequest._spawn(x, i)
66
 
 
67
 
    def test_apirequest_start(self):
68
 
        for i in range(10):
69
 
            a = request.EventletApiRequest(
70
 
                self.client, self.url)
71
 
            a._handle_request = mock.Mock()
72
 
            a.start()
73
 
            eventlet.greenthread.sleep(0.1)
74
 
            LOG.info(_LI('_handle_request called: %s'),
75
 
                     a._handle_request.called)
76
 
        request.EventletApiRequest.joinall()
77
 
 
78
 
    def test_join_with_handle_request(self):
79
 
        self.req._handle_request = mock.Mock()
80
 
        self.req.start()
81
 
        self.req.join()
82
 
        self.assertTrue(self.req._handle_request.called)
83
 
 
84
 
    def test_join_without_handle_request(self):
85
 
        self.req._handle_request = mock.Mock()
86
 
        self.req.join()
87
 
        self.assertFalse(self.req._handle_request.called)
88
 
 
89
 
    def test_copy(self):
90
 
        req = self.req.copy()
91
 
        for att in [
92
 
                '_api_client', '_url', '_method', '_body', '_headers',
93
 
                '_http_timeout', '_request_timeout', '_retries',
94
 
                '_redirects', '_auto_login']:
95
 
            self.assertTrue(getattr(req, att) is getattr(self.req, att))
96
 
 
97
 
    def test_request_error(self):
98
 
        self.assertIsNone(self.req.request_error)
99
 
 
100
 
    def test_run_and_handle_request(self):
101
 
        self.req._request_timeout = None
102
 
        self.req._handle_request = mock.Mock()
103
 
        self.req.start()
104
 
        self.req.join()
105
 
        self.assertTrue(self.req._handle_request.called)
106
 
 
107
 
    def test_run_and_timeout(self):
108
 
        def my_handle_request():
109
 
            LOG.info('my_handle_request() self: %s' % self.req)
110
 
            LOG.info('my_handle_request() dir(self): %s' % dir(self.req))
111
 
            eventlet.greenthread.sleep(REQUEST_TIMEOUT * 2)
112
 
 
113
 
        with mock.patch.object(
114
 
            self.req,
115
 
            '_handle_request',
116
 
            new=my_handle_request
117
 
        ):
118
 
            self.req._request_timeout = REQUEST_TIMEOUT
119
 
            self.req.start()
120
 
            self.assertIsNone(self.req.join())
121
 
 
122
 
    def prep_issue_request(self):
123
 
        mysock = mock.Mock()
124
 
        mysock.gettimeout.return_value = 4242
125
 
 
126
 
        myresponse = mock.Mock()
127
 
        myresponse.read.return_value = 'body'
128
 
        myresponse.getheaders.return_value = 'headers'
129
 
        myresponse.status = httplib.MOVED_PERMANENTLY
130
 
 
131
 
        myconn = mock.Mock()
132
 
        myconn.request.return_value = None
133
 
        myconn.sock = mysock
134
 
        myconn.getresponse.return_value = myresponse
135
 
        myconn.__str__ = mock.Mock()
136
 
        myconn.__str__.return_value = 'myconn string'
137
 
 
138
 
        req = self.req
139
 
        req._redirect_params = mock.Mock()
140
 
        req._redirect_params.return_value = (myconn, 'url')
141
 
        req._request_str = mock.Mock()
142
 
        req._request_str.return_value = 'http://cool/cool'
143
 
 
144
 
        client = self.client
145
 
        client.need_login = False
146
 
        client._auto_login = False
147
 
        client._auth_cookie = False
148
 
        client.acquire_connection = mock.Mock()
149
 
        client.acquire_connection.return_value = myconn
150
 
        client.release_connection = mock.Mock()
151
 
 
152
 
        return (mysock, myresponse, myconn)
153
 
 
154
 
    def test_issue_request_trigger_exception(self):
155
 
        (mysock, myresponse, myconn) = self.prep_issue_request()
156
 
        self.client.acquire_connection.return_value = None
157
 
 
158
 
        self.req._issue_request()
159
 
        self.assertIsInstance(self.req._request_error, Exception)
160
 
        self.assertTrue(self.client.acquire_connection.called)
161
 
 
162
 
    def test_issue_request_handle_none_sock(self):
163
 
        (mysock, myresponse, myconn) = self.prep_issue_request()
164
 
        myconn.sock = None
165
 
        self.req.start()
166
 
        self.assertIsNone(self.req.join())
167
 
        self.assertTrue(self.client.acquire_connection.called)
168
 
 
169
 
    def test_issue_request_exceed_maximum_retries(self):
170
 
        (mysock, myresponse, myconn) = self.prep_issue_request()
171
 
        self.req.start()
172
 
        self.assertIsNone(self.req.join())
173
 
        self.assertTrue(self.client.acquire_connection.called)
174
 
 
175
 
    def test_issue_request_trigger_non_redirect(self):
176
 
        (mysock, myresponse, myconn) = self.prep_issue_request()
177
 
        myresponse.status = httplib.OK
178
 
        self.req.start()
179
 
        self.assertIsNone(self.req.join())
180
 
        self.assertTrue(self.client.acquire_connection.called)
181
 
 
182
 
    def test_issue_request_trigger_internal_server_error(self):
183
 
        (mysock, myresponse, myconn) = self.prep_issue_request()
184
 
        self.req._redirect_params.return_value = (myconn, None)
185
 
        self.req.start()
186
 
        self.assertIsNone(self.req.join())
187
 
        self.assertTrue(self.client.acquire_connection.called)
188
 
 
189
 
    def test_redirect_params_break_on_location(self):
190
 
        myconn = mock.Mock()
191
 
        (conn, retval) = self.req._redirect_params(
192
 
            myconn, [('location', None)])
193
 
        self.assertIsNone(retval)
194
 
 
195
 
    def test_redirect_params_parse_a_url(self):
196
 
        myconn = mock.Mock()
197
 
        (conn, retval) = self.req._redirect_params(
198
 
            myconn, [('location', '/path/a/b/c')])
199
 
        self.assertIsNotNone(retval)
200
 
 
201
 
    def test_redirect_params_invalid_redirect_location(self):
202
 
        myconn = mock.Mock()
203
 
        (conn, retval) = self.req._redirect_params(
204
 
            myconn, [('location', '+path/a/b/c')])
205
 
        self.assertIsNone(retval)
206
 
 
207
 
    def test_redirect_params_invalid_scheme(self):
208
 
        myconn = mock.Mock()
209
 
        (conn, retval) = self.req._redirect_params(
210
 
            myconn, [('location', 'invalidscheme://hostname:1/path')])
211
 
        self.assertIsNone(retval)
212
 
 
213
 
    def test_redirect_params_setup_https_with_cooki(self):
214
 
        with mock.patch(vmware.CLIENT_NAME) as mock_client:
215
 
            api_client = mock_client.return_value
216
 
            self.req._api_client = api_client
217
 
            myconn = mock.Mock()
218
 
            (conn, retval) = self.req._redirect_params(
219
 
                myconn, [('location', 'https://host:1/path')])
220
 
 
221
 
            self.assertIsNotNone(retval)
222
 
            self.assertTrue(api_client.acquire_redirect_connection.called)
223
 
 
224
 
    def test_redirect_params_setup_htttps_and_query(self):
225
 
        with mock.patch(vmware.CLIENT_NAME) as mock_client:
226
 
            api_client = mock_client.return_value
227
 
            self.req._api_client = api_client
228
 
            myconn = mock.Mock()
229
 
            (conn, retval) = self.req._redirect_params(myconn, [
230
 
                ('location', 'https://host:1/path?q=1')])
231
 
 
232
 
            self.assertIsNotNone(retval)
233
 
            self.assertTrue(api_client.acquire_redirect_connection.called)
234
 
 
235
 
    def test_redirect_params_setup_https_connection_no_cookie(self):
236
 
        with mock.patch(vmware.CLIENT_NAME) as mock_client:
237
 
            api_client = mock_client.return_value
238
 
            self.req._api_client = api_client
239
 
            myconn = mock.Mock()
240
 
            (conn, retval) = self.req._redirect_params(myconn, [
241
 
                ('location', 'https://host:1/path')])
242
 
 
243
 
            self.assertIsNotNone(retval)
244
 
            self.assertTrue(api_client.acquire_redirect_connection.called)
245
 
 
246
 
    def test_redirect_params_setup_https_and_query_no_cookie(self):
247
 
        with mock.patch(vmware.CLIENT_NAME) as mock_client:
248
 
            api_client = mock_client.return_value
249
 
            self.req._api_client = api_client
250
 
            myconn = mock.Mock()
251
 
            (conn, retval) = self.req._redirect_params(
252
 
                myconn, [('location', 'https://host:1/path?q=1')])
253
 
            self.assertIsNotNone(retval)
254
 
            self.assertTrue(api_client.acquire_redirect_connection.called)
255
 
 
256
 
    def test_redirect_params_path_only_with_query(self):
257
 
        with mock.patch(vmware.CLIENT_NAME) as mock_client:
258
 
            api_client = mock_client.return_value
259
 
            api_client.wait_for_login.return_value = None
260
 
            api_client.auth_cookie = None
261
 
            api_client.acquire_connection.return_value = True
262
 
            myconn = mock.Mock()
263
 
            (conn, retval) = self.req._redirect_params(myconn, [
264
 
                ('location', '/path?q=1')])
265
 
            self.assertIsNotNone(retval)
266
 
 
267
 
    def test_handle_request_auto_login(self):
268
 
        self.req._auto_login = True
269
 
        self.req._api_client = mock.Mock()
270
 
        self.req._api_client.need_login = True
271
 
        self.req._request_str = mock.Mock()
272
 
        self.req._request_str.return_value = 'http://cool/cool'
273
 
        self.req.spawn = mock.Mock()
274
 
        self.req._handle_request()
275
 
 
276
 
    def test_handle_request_auto_login_unauth(self):
277
 
        self.req._auto_login = True
278
 
        self.req._api_client = mock.Mock()
279
 
        self.req._api_client.need_login = True
280
 
        self.req._request_str = mock.Mock()
281
 
        self.req._request_str.return_value = 'http://cool/cool'
282
 
 
283
 
        import socket
284
 
        resp = httplib.HTTPResponse(socket.socket())
285
 
        resp.status = httplib.UNAUTHORIZED
286
 
        mywaiter = mock.Mock()
287
 
        mywaiter.wait = mock.Mock()
288
 
        mywaiter.wait.return_value = resp
289
 
        self.req.spawn = mock.Mock(return_value=mywaiter)
290
 
        self.req._handle_request()
291
 
 
292
 
    def test_construct_eventlet_login_request(self):
293
 
        r = request.LoginRequestEventlet(self.client, 'user', 'password')
294
 
        self.assertIsNotNone(r)
295
 
 
296
 
    def test_session_cookie_session_cookie_retrieval(self):
297
 
        r = request.LoginRequestEventlet(self.client, 'user', 'password')
298
 
        r.successful = mock.Mock()
299
 
        r.successful.return_value = True
300
 
        r.value = mock.Mock()
301
 
        r.value.get_header = mock.Mock()
302
 
        r.value.get_header.return_value = 'cool'
303
 
        self.assertIsNotNone(r.session_cookie())
304
 
 
305
 
    def test_session_cookie_not_retrieved(self):
306
 
        r = request.LoginRequestEventlet(self.client, 'user', 'password')
307
 
        r.successful = mock.Mock()
308
 
        r.successful.return_value = False
309
 
        r.value = mock.Mock()
310
 
        r.value.get_header = mock.Mock()
311
 
        r.value.get_header.return_value = 'cool'
312
 
        self.assertIsNone(r.session_cookie())
313
 
 
314
 
    def test_construct_eventlet_get_api_providers_request(self):
315
 
        r = request.GetApiProvidersRequestEventlet(self.client)
316
 
        self.assertIsNotNone(r)
317
 
 
318
 
    def test_api_providers_none_api_providers(self):
319
 
        r = request.GetApiProvidersRequestEventlet(self.client)
320
 
        r.successful = mock.Mock(return_value=False)
321
 
        self.assertIsNone(r.api_providers())
322
 
 
323
 
    def test_api_providers_non_none_api_providers(self):
324
 
        r = request.GetApiProvidersRequestEventlet(self.client)
325
 
        r.value = mock.Mock()
326
 
        r.value.body = """{
327
 
          "results": [
328
 
            { "roles": [
329
 
              { "role": "api_provider",
330
 
                "listen_addr": "pssl:1.1.1.1:1" }]}]}"""
331
 
        r.successful = mock.Mock(return_value=True)
332
 
        LOG.info('%s' % r.api_providers())
333
 
        self.assertIsNotNone(r.api_providers())