276 lines
8.7 KiB
Python
276 lines
8.7 KiB
Python
# Copyright (c) 2014 Rackspace, Inc.
|
|
#
|
|
# 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 uuid
|
|
|
|
import ddt
|
|
|
|
from zaqar.tests.functional import base
|
|
from zaqar.tests.functional import helpers
|
|
|
|
|
|
@ddt.ddt
|
|
class TestClaims(base.V1_1FunctionalTestBase):
|
|
"""Tests for Claims."""
|
|
|
|
server_class = base.ZaqarServer
|
|
|
|
def setUp(self):
|
|
super(TestClaims, self).setUp()
|
|
|
|
self.headers = helpers.create_zaqar_headers(self.cfg)
|
|
self.client.headers = self.headers
|
|
|
|
self.queue = uuid.uuid1()
|
|
self.queue_url = ("{url}/{version}/queues/{queue}".format(
|
|
url=self.cfg.zaqar.url,
|
|
version="v1.1",
|
|
queue=self.queue))
|
|
|
|
self.client.put(self.queue_url)
|
|
|
|
self.claim_url = self.queue_url + '/claims'
|
|
self.client.set_base_url(self.claim_url)
|
|
|
|
# Post Messages
|
|
url = self.queue_url + '/messages'
|
|
doc = helpers.create_message_body_v1_1(
|
|
messagecount=self.limits.max_messages_per_page)
|
|
|
|
for i in range(10):
|
|
self.client.post(url, data=doc)
|
|
|
|
@ddt.data({}, {'limit': 2})
|
|
def test_claim_messages(self, params):
|
|
"""Claim messages."""
|
|
message_count = params.get('limit',
|
|
self.limits.max_messages_per_claim_or_pop)
|
|
|
|
doc = {"ttl": 300, "grace": 100}
|
|
|
|
result = self.client.post(params=params, data=doc)
|
|
self.assertEqual(result.status_code, 201)
|
|
|
|
actual_message_count = len(result.json())
|
|
self.assertMessageCount(actual_message_count, message_count)
|
|
|
|
response_headers = set(result.headers.keys())
|
|
self.assertIsSubset(self.headers_response_with_body, response_headers)
|
|
|
|
test_claim_messages.tags = ['smoke', 'positive']
|
|
|
|
def test_query_claim(self):
|
|
"""Query Claim."""
|
|
params = {'limit': 1}
|
|
doc = {"ttl": 300, "grace": 100}
|
|
|
|
result = self.client.post(params=params, data=doc)
|
|
location = result.headers['Location']
|
|
|
|
url = self.cfg.zaqar.url + location
|
|
|
|
result = self.client.get(url)
|
|
self.assertEqual(result.status_code, 200)
|
|
|
|
test_query_claim.tags = ['smoke', 'positive']
|
|
|
|
@ddt.data(None, {}, {"grace": 100})
|
|
def test_claim_default_ttl(self, doc):
|
|
"""Create claim with default TTL and grace values."""
|
|
params = {'limit': 1}
|
|
|
|
result = self.client.post(params=params, data=doc)
|
|
self.assertEqual(result.status_code, 201)
|
|
|
|
location = result.headers['Location']
|
|
|
|
url = self.cfg.zaqar.url + location
|
|
|
|
result = self.client.get(url)
|
|
self.assertEqual(result.status_code, 200)
|
|
|
|
default_ttl = result.json()['ttl']
|
|
self.assertEqual(default_ttl, self.resource_defaults.claim_ttl)
|
|
|
|
test_claim_default_ttl.tags = ['smoke', 'positive']
|
|
|
|
def test_claim_more_than_allowed(self):
|
|
"""Claim more than max allowed per request.
|
|
|
|
Zaqar allows a maximum of 20 messages per claim by default.
|
|
"""
|
|
params = {"limit": self.limits.max_messages_per_claim_or_pop + 1}
|
|
doc = {"ttl": 300, "grace": 100}
|
|
|
|
result = self.client.post(params=params, data=doc)
|
|
self.assertEqual(result.status_code, 400)
|
|
|
|
test_claim_more_than_allowed.tags = ['negative']
|
|
|
|
def test_claim_patch(self):
|
|
"""Update Claim."""
|
|
|
|
# Test Setup - Post Claim
|
|
doc = {"ttl": 300, "grace": 400}
|
|
result = self.client.post(data=doc)
|
|
self.assertEqual(result.status_code, 201)
|
|
|
|
# Patch Claim
|
|
claim_location = result.headers['Location']
|
|
url = self.cfg.zaqar.url + claim_location
|
|
doc_updated = {"ttl": 300}
|
|
|
|
result = self.client.patch(url, data=doc_updated)
|
|
self.assertEqual(result.status_code, 204)
|
|
|
|
# verify that the claim TTL is updated
|
|
result = self.client.get(url)
|
|
new_ttl = result.json()['ttl']
|
|
self.assertEqual(new_ttl, 300)
|
|
|
|
test_claim_patch.tags = ['smoke', 'positive']
|
|
|
|
def test_delete_claimed_message(self):
|
|
"""Delete message belonging to a Claim."""
|
|
# Test Setup - Post claim
|
|
doc = {"ttl": 60, "grace": 60}
|
|
|
|
result = self.client.post(data=doc)
|
|
self.assertEqual(result.status_code, 201)
|
|
|
|
# Delete Claimed Messages
|
|
for rst in result.json():
|
|
href = rst['href']
|
|
url = self.cfg.zaqar.url + href
|
|
result = self.client.delete(url)
|
|
self.assertEqual(result.status_code, 204)
|
|
|
|
test_delete_claimed_message.tags = ['smoke', 'positive']
|
|
|
|
def test_claim_release(self):
|
|
"""Release Claim."""
|
|
doc = {"ttl": 300, "grace": 100}
|
|
|
|
result = self.client.post(data=doc)
|
|
self.assertEqual(result.status_code, 201)
|
|
|
|
# Extract claim location and construct the claim URL.
|
|
location = result.headers['Location']
|
|
url = self.cfg.zaqar.url + location
|
|
|
|
# Release Claim.
|
|
result = self.client.delete(url)
|
|
self.assertEqual(result.status_code, 204)
|
|
|
|
test_claim_release.tags = ['smoke', 'positive']
|
|
|
|
@ddt.data(10000000000000000000, -100, 1, 59, 43201, -10000000000000000000)
|
|
def test_claim_invalid_ttl(self, ttl):
|
|
"""Post Claim with invalid TTL.
|
|
|
|
The request JSON body will have a TTL value
|
|
outside the allowed range.Allowed ttl values is
|
|
60 <= ttl <= 43200.
|
|
"""
|
|
doc = {"ttl": ttl, "grace": 100}
|
|
|
|
result = self.client.post(data=doc)
|
|
self.assertEqual(result.status_code, 400)
|
|
|
|
test_claim_invalid_ttl.tags = ['negative']
|
|
|
|
@ddt.data(10000000000000000000, -100, 1, 59, 43201, -10000000000000000000)
|
|
def test_claim_invalid_grace(self, grace):
|
|
"""Post Claim with invalid grace.
|
|
|
|
The request JSON body will have a grace value
|
|
outside the allowed range.Allowed grace values is
|
|
60 <= grace <= 43200.
|
|
"""
|
|
doc = {"ttl": 100, "grace": grace}
|
|
|
|
result = self.client.post(data=doc)
|
|
self.assertEqual(result.status_code, 400)
|
|
|
|
test_claim_invalid_grace.tags = ['negative']
|
|
|
|
@ddt.data(0, -100, 30, 10000000000000000000)
|
|
def test_claim_invalid_limit(self, grace):
|
|
"""Post Claim with invalid limit.
|
|
|
|
The request url will have a limit outside the allowed range.
|
|
Allowed limit values are 0 < limit <= 20(default max).
|
|
"""
|
|
doc = {"ttl": 100, "grace": grace}
|
|
|
|
result = self.client.post(data=doc)
|
|
self.assertEqual(result.status_code, 400)
|
|
|
|
test_claim_invalid_limit.tags = ['negative']
|
|
|
|
@ddt.data(10000000000000000000, -100, 1, 59, 43201, -10000000000000000000)
|
|
def test_patch_claim_invalid_ttl(self, ttl):
|
|
"""Patch Claim with invalid TTL.
|
|
|
|
The request JSON body will have a TTL value
|
|
outside the allowed range.Allowed ttl values is
|
|
60 <= ttl <= 43200.
|
|
"""
|
|
doc = {"ttl": 100, "grace": 100}
|
|
|
|
result = self.client.post(data=doc)
|
|
self.assertEqual(result.status_code, 201)
|
|
|
|
# Extract claim location and construct the claim URL.
|
|
location = result.headers['Location']
|
|
url = self.cfg.zaqar.url + location
|
|
|
|
# Patch Claim.
|
|
doc = {"ttl": ttl}
|
|
result = self.client.patch(url, data=doc)
|
|
self.assertEqual(result.status_code, 400)
|
|
|
|
test_patch_claim_invalid_ttl.tags = ['negative']
|
|
|
|
def test_query_non_existing_claim(self):
|
|
"""Query Non Existing Claim."""
|
|
path = '/non-existing-claim'
|
|
result = self.client.get(path)
|
|
self.assertEqual(result.status_code, 404)
|
|
|
|
test_query_non_existing_claim.tags = ['negative']
|
|
|
|
def test_patch_non_existing_claim(self):
|
|
"""Patch Non Existing Claim."""
|
|
path = '/non-existing-claim'
|
|
doc = {"ttl": 400}
|
|
result = self.client.patch(path, data=doc)
|
|
self.assertEqual(result.status_code, 404)
|
|
|
|
test_patch_non_existing_claim.tags = ['negative']
|
|
|
|
def test_delete_non_existing_claim(self):
|
|
"""Patch Non Existing Claim."""
|
|
path = '/non-existing-claim'
|
|
result = self.client.delete(path)
|
|
self.assertEqual(result.status_code, 204)
|
|
|
|
test_delete_non_existing_claim.tags = ['negative']
|
|
|
|
def tearDown(self):
|
|
"""Delete Queue after Claim Test."""
|
|
super(TestClaims, self).tearDown()
|
|
self.client.delete(self.queue_url)
|