zaqar/marconi/tests/system/messages/msgfnlib.py

# Copyright (c) 2013 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.

from __future__ import with_statement
import json
import random

from marconi.tests.system.common import config
from marconi.tests.system.common import functionlib
from marconi.tests.system.common import http


CFG = config.Config()


def generate_dict(dict_length):
    """Returns dictionary of specified length. Key:Value is random data.

    :param dict_length: length of the dictionary
    """
    with open('/usr/share/dict/words', 'rt') as f:
        words = f.readlines()
    words = [w.rstrip() for w in words]

    dict = {}
    while len(dict) < dict_length:
        key, value = random.sample(words, 2)
        dict.update({key: value})
    return dict


def single_message_body(**kwargs):
    """Returns message body for one message .

    The ttl will be a random value (60 <= TTL <= 1209600).
    The message body will be random dict.
    :param **kwargs: can be {messagesize: x} , where x is message size
    :param **kwargs: can be {ttl: x} , where x is ttl in seconds
    """
    valid_ttl = random.randint(60, 1209600)

    if 'messagesize' in kwargs.keys():
        body = generate_dict(kwargs['messagesize'])
    else:
        body = generate_dict(2)

    if 'ttl' in kwargs.keys():
        ttl = kwargs['ttl']
    else:
        ttl = valid_ttl

    message_body = {'ttl': ttl, 'body': body}
    return message_body


def get_message_body(**kwargs):
    """Returns request body for post message tests.

    :param **kwargs: can be {messagecount: x} , where x is the # of messages.
    """
    message_count = kwargs['messagecount']
    multiple_message_body = []
    for i in range[message_count]:
        message_body = single_message_body(**kwargs)
        multiple_message_body.append(message_body)
    return multiple_message_body


def dummyget_message_body(dict):
    """Dummy function since Robot framework does not support **kwargs."""
    dict = get_message_body(**dict)
    return dict


def create_url(base_url=CFG.base_url, *msg_id_list):
    """Creates url list for retrieving messages with message id."""
    url = [(base_url + msg_id) for msg_id in msg_id_list]
    return url


def verify_msg_length(count=10, *msg_list):
    """Verifies the number of messages returned.

    :param count: limit specified in the GET url.
    :param *msg_list : list of message returned in the GET.
    """
    test_result_flag = False
    msg_body = json.loads(msg_list[0])
    msg_list = msg_body['messages']
    msg_count = len(msg_list)
    if (msg_count <= count):
        test_result_flag = True
    else:
        return test_result_flag
    return test_result_flag


def get_href(*msg_list):
    """Extracts href.

    :param *msg_list: list of messages returned by the server.
    """
    msg_body = json.loads(msg_list[0])
    link = msg_body['links']
    href = link[0]['href']
    return href


def verify_post_msg(msg_headers, posted_body):
    """Verifies the response of POST Message(s).

    Retrieves the posted Message(s) & validates the message metadata.
    :param msg_headers: headers returned for post message request.
    :param posted_body: message metadata(s) in the post message request.
    """
    test_result_flag = False

    location = msg_headers['location']
    url = functionlib.create_url_from_appender(location)
    header = functionlib.create_marconi_headers()

    getmsg = http.get(url, header)
    if getmsg.status_code == 200:
        test_result_flag = functionlib.verify_metadata(getmsg.text,
                                                       posted_body)
    else:
        print('Failed to GET {}'.format(url))
        print('Request Header')
        print header
        print('Response Headers')
        print getmsg.headers
        print('Response Body')
        print getmsg.text
        assert test_result_flag, 'HTTP code {}'.format(getmsg.status_code)


def get_next_msgset(responsetext):
    """Follows the href path & GETs the next batch of messages recursively."""
    test_result_flag = False

    href = get_href(responsetext)
    url = functionlib.create_url_from_appender(href)
    header = functionlib.create_marconi_headers()

    getmsg = http.get(url, header)
    if getmsg.status_code == 200:
        return get_next_msgset(getmsg.text)
    elif getmsg.status_code == 204:
        test_result_flag = True
        return test_result_flag
    else:
        test_result_flag = False
        print('Failed to GET {}'.format(url))
        print(getmsg.text)
        assert test_result_flag, 'HTTP code {}'.format(getmsg.status_code)


def verify_get_msgs(count, *getresponse):
    """Verifies GET message & does a recursive GET if needed.

    :param count: limit value specified in the get message request.
    :param *getresponse: [headers, body] returned for get message request.
    """
    test_result_flag = False

    body = getresponse[1]

    msglengthflag = verify_msg_length(count, body)
    if msglengthflag:
        test_result_flag = get_next_msgset(body)
    else:
        print('Messages returned exceed requested number of messages')
        test_result_flag = False

    if not test_result_flag:
        assert test_result_flag, 'Recursive Get Messages Failed'


def delete_msg(*postresponse):
    """Post DELETE message & verifies that a subsequent GET returns 404.

    :param *postresponse: [headers, body] returned for post message request.
    """
    test_result_flag = False
    headers = str(postresponse[0])
    headers = headers.replace("'", '"')
    headers = json.loads(headers)
    location = headers['location']
    url = functionlib.create_url_from_appender(location)
    header = functionlib.create_marconi_headers()
    deletemsg = http.delete(url, header)
    if deletemsg.status_code == 204:
        test_result_flag = functionlib.verify_delete(url, header)
    else:
        print('DELETE message failed')
        print('URL')
        print url
        print('headers')
        print header
        print('Response Body')
        print deletemsg.text
        assert test_result_flag, 'DELETE Code {}'.format(deletemsg.status_code)