~ubuntu-branches/ubuntu/trusty/cinder/trusty

« back to all changes in this revision

Viewing changes to cinder/tests/api/openstack/test_common.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-11-23 08:39:28 UTC
  • mfrom: (1.1.9)
  • Revision ID: package-import@ubuntu.com-20121123083928-xvzet603cjfj9p1t
Tags: 2013.1~g1-0ubuntu1
* New upstream release.
* debian/patches/avoid_setuptools_git_dependency.patch:
  Avoid git installation. (LP: #1075948) 

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2
 
 
3
 
# Copyright 2010 OpenStack LLC.
4
 
# All Rights Reserved.
5
 
#
6
 
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
7
 
#    not use this file except in compliance with the License. You may obtain
8
 
#    a copy of the License at
9
 
#
10
 
#         http://www.apache.org/licenses/LICENSE-2.0
11
 
#
12
 
#    Unless required by applicable law or agreed to in writing, software
13
 
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14
 
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15
 
#    License for the specific language governing permissions and limitations
16
 
#    under the License.
17
 
 
18
 
"""
19
 
Test suites for 'common' code used throughout the OpenStack HTTP API.
20
 
"""
21
 
 
22
 
import webob
23
 
import webob.exc
24
 
 
25
 
from cinder import test
26
 
from cinder.api.openstack import common
27
 
 
28
 
 
29
 
NS = "{http://docs.openstack.org/compute/api/v1.1}"
30
 
ATOMNS = "{http://www.w3.org/2005/Atom}"
31
 
 
32
 
 
33
 
class LimiterTest(test.TestCase):
34
 
    """
35
 
    Unit tests for the `cinder.api.openstack.common.limited` method which takes
36
 
    in a list of items and, depending on the 'offset' and 'limit' GET params,
37
 
    returns a subset or complete set of the given items.
38
 
    """
39
 
 
40
 
    def setUp(self):
41
 
        """ Run before each test. """
42
 
        super(LimiterTest, self).setUp()
43
 
        self.tiny = range(1)
44
 
        self.small = range(10)
45
 
        self.medium = range(1000)
46
 
        self.large = range(10000)
47
 
 
48
 
    def test_limiter_offset_zero(self):
49
 
        """ Test offset key works with 0. """
50
 
        req = webob.Request.blank('/?offset=0')
51
 
        self.assertEqual(common.limited(self.tiny, req), self.tiny)
52
 
        self.assertEqual(common.limited(self.small, req), self.small)
53
 
        self.assertEqual(common.limited(self.medium, req), self.medium)
54
 
        self.assertEqual(common.limited(self.large, req), self.large[:1000])
55
 
 
56
 
    def test_limiter_offset_medium(self):
57
 
        """ Test offset key works with a medium sized number. """
58
 
        req = webob.Request.blank('/?offset=10')
59
 
        self.assertEqual(common.limited(self.tiny, req), [])
60
 
        self.assertEqual(common.limited(self.small, req), self.small[10:])
61
 
        self.assertEqual(common.limited(self.medium, req), self.medium[10:])
62
 
        self.assertEqual(common.limited(self.large, req), self.large[10:1010])
63
 
 
64
 
    def test_limiter_offset_over_max(self):
65
 
        """ Test offset key works with a number over 1000 (max_limit). """
66
 
        req = webob.Request.blank('/?offset=1001')
67
 
        self.assertEqual(common.limited(self.tiny, req), [])
68
 
        self.assertEqual(common.limited(self.small, req), [])
69
 
        self.assertEqual(common.limited(self.medium, req), [])
70
 
        self.assertEqual(
71
 
            common.limited(self.large, req), self.large[1001:2001])
72
 
 
73
 
    def test_limiter_offset_blank(self):
74
 
        """ Test offset key works with a blank offset. """
75
 
        req = webob.Request.blank('/?offset=')
76
 
        self.assertRaises(
77
 
            webob.exc.HTTPBadRequest, common.limited, self.tiny, req)
78
 
 
79
 
    def test_limiter_offset_bad(self):
80
 
        """ Test offset key works with a BAD offset. """
81
 
        req = webob.Request.blank(u'/?offset=\u0020aa')
82
 
        self.assertRaises(
83
 
            webob.exc.HTTPBadRequest, common.limited, self.tiny, req)
84
 
 
85
 
    def test_limiter_nothing(self):
86
 
        """ Test request with no offset or limit """
87
 
        req = webob.Request.blank('/')
88
 
        self.assertEqual(common.limited(self.tiny, req), self.tiny)
89
 
        self.assertEqual(common.limited(self.small, req), self.small)
90
 
        self.assertEqual(common.limited(self.medium, req), self.medium)
91
 
        self.assertEqual(common.limited(self.large, req), self.large[:1000])
92
 
 
93
 
    def test_limiter_limit_zero(self):
94
 
        """ Test limit of zero. """
95
 
        req = webob.Request.blank('/?limit=0')
96
 
        self.assertEqual(common.limited(self.tiny, req), self.tiny)
97
 
        self.assertEqual(common.limited(self.small, req), self.small)
98
 
        self.assertEqual(common.limited(self.medium, req), self.medium)
99
 
        self.assertEqual(common.limited(self.large, req), self.large[:1000])
100
 
 
101
 
    def test_limiter_limit_medium(self):
102
 
        """ Test limit of 10. """
103
 
        req = webob.Request.blank('/?limit=10')
104
 
        self.assertEqual(common.limited(self.tiny, req), self.tiny)
105
 
        self.assertEqual(common.limited(self.small, req), self.small)
106
 
        self.assertEqual(common.limited(self.medium, req), self.medium[:10])
107
 
        self.assertEqual(common.limited(self.large, req), self.large[:10])
108
 
 
109
 
    def test_limiter_limit_over_max(self):
110
 
        """ Test limit of 3000. """
111
 
        req = webob.Request.blank('/?limit=3000')
112
 
        self.assertEqual(common.limited(self.tiny, req), self.tiny)
113
 
        self.assertEqual(common.limited(self.small, req), self.small)
114
 
        self.assertEqual(common.limited(self.medium, req), self.medium)
115
 
        self.assertEqual(common.limited(self.large, req), self.large[:1000])
116
 
 
117
 
    def test_limiter_limit_and_offset(self):
118
 
        """ Test request with both limit and offset. """
119
 
        items = range(2000)
120
 
        req = webob.Request.blank('/?offset=1&limit=3')
121
 
        self.assertEqual(common.limited(items, req), items[1:4])
122
 
        req = webob.Request.blank('/?offset=3&limit=0')
123
 
        self.assertEqual(common.limited(items, req), items[3:1003])
124
 
        req = webob.Request.blank('/?offset=3&limit=1500')
125
 
        self.assertEqual(common.limited(items, req), items[3:1003])
126
 
        req = webob.Request.blank('/?offset=3000&limit=10')
127
 
        self.assertEqual(common.limited(items, req), [])
128
 
 
129
 
    def test_limiter_custom_max_limit(self):
130
 
        """ Test a max_limit other than 1000. """
131
 
        items = range(2000)
132
 
        req = webob.Request.blank('/?offset=1&limit=3')
133
 
        self.assertEqual(
134
 
            common.limited(items, req, max_limit=2000), items[1:4])
135
 
        req = webob.Request.blank('/?offset=3&limit=0')
136
 
        self.assertEqual(
137
 
            common.limited(items, req, max_limit=2000), items[3:])
138
 
        req = webob.Request.blank('/?offset=3&limit=2500')
139
 
        self.assertEqual(
140
 
            common.limited(items, req, max_limit=2000), items[3:])
141
 
        req = webob.Request.blank('/?offset=3000&limit=10')
142
 
        self.assertEqual(common.limited(items, req, max_limit=2000), [])
143
 
 
144
 
    def test_limiter_negative_limit(self):
145
 
        """ Test a negative limit. """
146
 
        req = webob.Request.blank('/?limit=-3000')
147
 
        self.assertRaises(
148
 
            webob.exc.HTTPBadRequest, common.limited, self.tiny, req)
149
 
 
150
 
    def test_limiter_negative_offset(self):
151
 
        """ Test a negative offset. """
152
 
        req = webob.Request.blank('/?offset=-30')
153
 
        self.assertRaises(
154
 
            webob.exc.HTTPBadRequest, common.limited, self.tiny, req)
155
 
 
156
 
 
157
 
class PaginationParamsTest(test.TestCase):
158
 
    """
159
 
    Unit tests for the `cinder.api.openstack.common.get_pagination_params`
160
 
    method which takes in a request object and returns 'marker' and 'limit'
161
 
    GET params.
162
 
    """
163
 
 
164
 
    def test_no_params(self):
165
 
        """ Test no params. """
166
 
        req = webob.Request.blank('/')
167
 
        self.assertEqual(common.get_pagination_params(req), {})
168
 
 
169
 
    def test_valid_marker(self):
170
 
        """ Test valid marker param. """
171
 
        req = webob.Request.blank(
172
 
                '/?marker=263abb28-1de6-412f-b00b-f0ee0c4333c2')
173
 
        self.assertEqual(common.get_pagination_params(req),
174
 
                         {'marker': '263abb28-1de6-412f-b00b-f0ee0c4333c2'})
175
 
 
176
 
    def test_valid_limit(self):
177
 
        """ Test valid limit param. """
178
 
        req = webob.Request.blank('/?limit=10')
179
 
        self.assertEqual(common.get_pagination_params(req), {'limit': 10})
180
 
 
181
 
    def test_invalid_limit(self):
182
 
        """ Test invalid limit param. """
183
 
        req = webob.Request.blank('/?limit=-2')
184
 
        self.assertRaises(
185
 
            webob.exc.HTTPBadRequest, common.get_pagination_params, req)
186
 
 
187
 
    def test_valid_limit_and_marker(self):
188
 
        """ Test valid limit and marker parameters. """
189
 
        marker = '263abb28-1de6-412f-b00b-f0ee0c4333c2'
190
 
        req = webob.Request.blank('/?limit=20&marker=%s' % marker)
191
 
        self.assertEqual(common.get_pagination_params(req),
192
 
                         {'marker': marker, 'limit': 20})
193
 
 
194
 
 
195
 
class MiscFunctionsTest(test.TestCase):
196
 
 
197
 
    def test_remove_major_version_from_href(self):
198
 
        fixture = 'http://www.testsite.com/v1/images'
199
 
        expected = 'http://www.testsite.com/images'
200
 
        actual = common.remove_version_from_href(fixture)
201
 
        self.assertEqual(actual, expected)
202
 
 
203
 
    def test_remove_version_from_href(self):
204
 
        fixture = 'http://www.testsite.com/v1.1/images'
205
 
        expected = 'http://www.testsite.com/images'
206
 
        actual = common.remove_version_from_href(fixture)
207
 
        self.assertEqual(actual, expected)
208
 
 
209
 
    def test_remove_version_from_href_2(self):
210
 
        fixture = 'http://www.testsite.com/v1.1/'
211
 
        expected = 'http://www.testsite.com/'
212
 
        actual = common.remove_version_from_href(fixture)
213
 
        self.assertEqual(actual, expected)
214
 
 
215
 
    def test_remove_version_from_href_3(self):
216
 
        fixture = 'http://www.testsite.com/v10.10'
217
 
        expected = 'http://www.testsite.com'
218
 
        actual = common.remove_version_from_href(fixture)
219
 
        self.assertEqual(actual, expected)
220
 
 
221
 
    def test_remove_version_from_href_4(self):
222
 
        fixture = 'http://www.testsite.com/v1.1/images/v10.5'
223
 
        expected = 'http://www.testsite.com/images/v10.5'
224
 
        actual = common.remove_version_from_href(fixture)
225
 
        self.assertEqual(actual, expected)
226
 
 
227
 
    def test_remove_version_from_href_bad_request(self):
228
 
        fixture = 'http://www.testsite.com/1.1/images'
229
 
        self.assertRaises(ValueError,
230
 
                          common.remove_version_from_href,
231
 
                          fixture)
232
 
 
233
 
    def test_remove_version_from_href_bad_request_2(self):
234
 
        fixture = 'http://www.testsite.com/v/images'
235
 
        self.assertRaises(ValueError,
236
 
                          common.remove_version_from_href,
237
 
                          fixture)
238
 
 
239
 
    def test_remove_version_from_href_bad_request_3(self):
240
 
        fixture = 'http://www.testsite.com/v1.1images'
241
 
        self.assertRaises(ValueError,
242
 
                          common.remove_version_from_href,
243
 
                          fixture)