blob: 0f88d6db5aa4b18ace13e1afa2ec50801338b6e0 [file] [log] [blame]
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
"""module for generating mock classes/objects for testing purposes"""
import socket
from import (REQID, OutgoingPacket,
IncomingPacket, StatusCode,
from import HeronClient
import heron.instance.tests.python.mock_protobuf as mock_protobuf
# pylint: disable=missing-docstring
# pylint: disable=unused-argument
# Python's primitive type list
prim_list = [1000, -234, 0.00023, "string",
["abc", "def", "ghi"], True, False,
("tuple", 123, True), None, {}]
def convert_to_incoming_packet(reqid, message):
"""Convert (reqid, message) pair to IncomingPacket object"""
raw = OutgoingPacket.create_packet(reqid, message).raw
dispatcher = MockDispatcher()
packet = IncomingPacket() =
return packet
# Returns a list of mock request packets (REQID is non-zero)
def get_mock_requst_packets(is_message):
"""Returns a list of valid IncomingPackets with non-zero REQID and the corresponding raw data"""
pkt_list = []
raw_list = []
message_list = [mock_protobuf.get_mock_register_response(),
# normal packet (PhysicalPlan as request)
for message in message_list:
if is_message:
reqid = REQID.generate_zero()
reqid = REQID.generate()
normal_pkt = convert_to_incoming_packet(reqid, message)
raw_list.append((reqid, message))
return pkt_list, raw_list
def get_a_mock_request_packet_and_raw():
"""Returns a tuple of mock (IncomingPacket, REQID, RegisterResponse message)"""
reqid = REQID.generate()
message = mock_protobuf.get_mock_register_response()
pkt = convert_to_incoming_packet(reqid, message)
return pkt, reqid, message
def get_a_mock_message_list_and_builder():
"""Get a list of IncomingPackets, the corresponding mock messages, builder and typename"""
pkt_list = []
raw_list = mock_protobuf.get_many_mock_pplans()
for msg in raw_list:
reqid = REQID.generate_zero()
pkt = convert_to_incoming_packet(reqid, msg)
builder, typename = mock_protobuf.get_pplan_builder_and_typename()
return pkt_list, raw_list, builder, typename
def get_fail_packet():
"""Returns an incomplete IncomingPacket object"""
raw = OutgoingPacket.create_packet(REQID.generate(), mock_protobuf.get_mock_pplan()).raw
packet = IncomingPacket.create_packet(raw[:4], raw[4:])
packet.is_complete = False
return packet
class MockDispatcher(object):
"""Mock asyncore.dispatcher class, supporting only recv() and send() method
This dispatcher provides several options as to how to prepare its receive buffer.
def __init__(self):
self.to_be_received = ""
self.eagain_test = False
self.fatal_error_test = False
def prepare_with_raw(self, raw):
"""the content of ``raw`` will be prepared in the recv buffer"""
self.to_be_received = raw
def prepare_valid_response(self):
"""a number of valid packets will be prepared in the recv buffer"""
pkt_list, _ = get_mock_requst_packets(is_message=False)
for pkt in pkt_list:
self.to_be_received += pkt.convert_to_raw()
def prepare_header_only(self):
"""a packet with just a header (incomplete packet) will be prepared in the recv buffer"""
pkt = get_mock_requst_packets(is_message=False)[0][0]
self.to_be_received = pkt.header
def prepare_partial_data(self):
"""a partial data packet will be prepared in the recv buffer"""
pkt = get_mock_requst_packets(is_message=False)[0][0]
self.to_be_received = pkt.header +[:self.PARTIAL_DATA_SIZE]
def prepare_eagain(self):
"""prepare so that EAGAIN error is raised when recv() is called """
self.eagain_test = True
def prepare_fatal(self):
"""prepare so that RuntimeError is raised when recv() is called"""
self.fatal_error_test = True
def recv(self, numbytes):
"""reads ``numbytes`` from the recv buffer"""
if self.fatal_error_test:
raise RuntimeError("Fatal Error Test")
elif self.eagain_test:
raise socket.error(socket.errno.EAGAIN, "EAGAIN Test")
ret = self.to_be_received[:numbytes]
self.to_be_received = self.to_be_received[numbytes:]
return ret
# pylint: disable=no-self-use
def send(self, buf):
"""mock sends the content of a given buffer"""
return len(buf)
class MockHeronClient(HeronClient):
HOST = ''
PORT = 9090
def __init__(self):
socket_options = SocketOptions(32768, 16, 32768, 16, 1024000, 1024000)
HeronClient.__init__(self, None, self.HOST, self.PORT, {}, socket_options)
self.on_connect_called = False
self.on_response_status = None
self.called_handle_packet = False
self.dispatcher = MockDispatcher()
self.incoming_msg = None
self.on_error_called = False
def on_connect(self, status):
if status == StatusCode.OK:
self.on_connect_called = True
def on_response(self, status, context, response):
self.on_response_status = status
def on_error(self):
self.on_error_called = True
def on_incoming_message(self, message):
self.incoming_msg = message
def recv(self, numbytes):
return self.dispatcher.recv(numbytes)
def _handle_packet(self, packet):
# should only be called when packet is complete
self.called_handle_packet = True
HeronClient._handle_packet(self, packet)
def _handle_close(self):