fun

""" test.py - Test script for the COMPN socket assignment.

Copyright 2016 Maarten Vangeneugden

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.

Contact me at: maarten.vangeneugden@student.uhasselt.be

"""

# That was the legal hurr durr fluff. Now for the actual program:

from __future__ import print_function

# READ THIS IF YOU USE THIS TEST FOR THE FIRST TIME.

#

# This test was designed to test the interactive server assignment. It will run a

# series of tests to check whether the program works as supposed to.

#

# This test is built to deal with edge cases, extreme input, and attempts to

# break the server. If your server passes this test, you can be assured it's

# (relatively speaking) robust enough, even though I cannot make 100%

# guarantees.

#

# To run this test, start the server, and then run this file.

#

# There are a couple of flags you can set:

# -1: Let the tests run for the first server. EXPERIMENTAL, may not work!

# -2: Default. Let the tests run for the 'Interactive information server' task.

# --verbose: Print all details.

#

# This test sends large bogus strings to the server (which may have lengths of

# up to 100). Be sure to accept enough bytes on your server in order to not

# cause the data to queue up too much. (socket.recv(2048) should suffice)

# You can also set the max string length in the functions that create them.

#

# By Maarten Vangeneugden - 1438256

import socket as SocketModule  # Altered namespacing for readability.

import random  # For server input randomization

import string  # For 'em wacky bogus strings bitch

import time  # Time control.

import itertools  # For generating command permutations.

import sys  # For command-line argument handling.

# Constants and program settings (Not necessarily constant, although you can

# treat them as such)

CLIENT_IP = "127.0.0.1"  # If not on localhost, change accordingly.

SERVER_ADDRESS = "localhost"

SERVER_PORT = 2000

SERVER = 2  # The server to test for. 1 is the first, 2 the interactive one.

# The verbose mode can be turned on by the user using the --verbose flag, and

# will print all details. Defaults to False, printing only the most necessary

# data.

VERBOSE_MODE = False

RECONNECTIONS_AMOUNT = 2  # The amount of times the client will connect.

# The amount of seconds to wait in order to trigger a timeout.

# Don't make this as low as possible, but take a reasonable time. 5 is a nice

# minimum.

TIMEOUT_WAIT = 8  # SET THIS MANUALLY if your server takes longer before timeout.

# Functions

def verbose_print(string):

    """ Prints the given string to the output, but only if the user has set the

    verbose mode. """

    if VERBOSE_MODE:

        print(string)

def flag_handling(arguments):

    """ Checks the given flags, and sets the program's settings accordingly. """

    # Settings that can be altered:

    global SERVER

    global VERBOSE_MODE

    for argument in arguments:

        if argument == "--verbose":  # Activate verbose mode

            VERBOSE_MODE = True

            print("Verbose mode activated.")

        elif argument == "-1":

            SERVER = 1

            print("Set the server to test to 1.")

        elif argument == "-2":

            SERVER = 2

            print("Set the server to interactive (2).")

def run_after_erronous_input(socket):

    """ Sends a series of random bogus commands, and checks whether the server

    keeps running. """

    # Change these settings to your likings if you want to, but be aware that

    # extreme inputs (like strings of length 10000) may cause problems that

    # aren't really there.

    TEST_AMOUNT = 100  # The amount of bogus strings that will be generated.

    MAX_STRING_LENGTH = 100  # The maximum length of the bogus strings.

    no_error = True

    for i in range(TEST_AMOUNT):

        string_length = random.randint(0, MAX_STRING_LENGTH)

        bogus_command = \

        ''.join(random.SystemRandom().choice(string.printable) for _ in range(string_length))

        if bogus_command != "TIME" \

        and bogus_command != "IP" \

        and bogus_command != "EXIT":  # Just in case, but imagine the chance...

            try:

                verbose_print("Testing if "+ bogus_command +" makes the server \

                        crash...")

                socket.send(bogus_command)

                if SERVER == 2:

                    socket.send("\n")

                socket.recv(2048)  # Receiving what's being sent to discard it.

            except:

                print("The server would not accept any more commands after \

                receiving the following command: " + bogus_command)

                no_error = False

                break  # Abort looping the for loop

    return no_error

def check_command_validity(socket, command, answer):

    """ Initiates a series of tests that will attempt to make the server respond

    invalid when a correct command sequence is sent, or respond valid when a

    false command is sent.

    """

    assert command_handled_correctly(socket, command, answer)

    assert command_misspelled_reject(socket, command, answer)

def command_handled_correctly(socket, command, answer):

    """ Checks whether the server handles the given command correctly. """

    if SERVER == 1:  # Only test the first command.

        socket.send(command)

        response = socket.recv(2048)

        if response == time.ctime():

            return True

        else: 

            print("When sending "+ command +", the expected answer was "+ \

                    answer +", but "+ response +" was returned by the server.")

            return False

    elif SERVER == 2:  # Interactive server

        command_sequences = generate_correct_commands(command)

        for sequence in command_sequences:

            verbose_print("Checking if "+ str(sequence) +" is accepted...")

            for part in sequence:

                socket.send(part)

            socket.send("\n")  # Executes the command.

            response = socket.recv(2048)

            if response != answer:

                """ NOTE: It can happen that the time is off by 1 second,

                because of the time it takes to run tests. If so, this condition

                will update the answer accordingly.

                """

                if response == time.ctime():

                    answer = time.ctime()

                else:

                    print("When sending "+ command +", the expected answer was "+ \

                            answer +", but "+ response +" was returned by the server.")

                    print("This sequence was sent to the server:")

                    print(sequence)

                    return False

            else:

                verbose_print(str(sequence) +" returned a valid response.")

    # This stage is only reached when the command is handled properly.

    return True

def command_misspelled_reject(socket, correct_command, answer):

    """ Sends a series of misspelled variations of an accepted command, in an

    attempt to trick the server in returning a response to said command, which

    in fact, should be rejected.

    """

    false_commands = generate_false_commands(correct_command)

    trailing_space_false_commands = [" " + correct_command, correct_command + " "]

    false_commands.extend(trailing_space_false_commands)

    while correct_command in false_commands:  # FIXME

        false_commands.remove(correct_command)

    for false_command in false_commands:

        verbose_print("Checking if "+ false_command +" is rejected...")

        socket.send(false_command)

        if SERVER == 2:

            socket.send("\n")

        """ Note that waiting for an answer still breaks when nothing is

        returned, because:

        "Incorrect commandos entered by the client should be ignored, and an

        error must be returned to the client." ~Assignment

        """

        response = socket.recv(2048)

        if answer == response and false_command != correct_command:

            print(false_command +" was accepted, which should be rejected!")

            return False  # The server responded to a false command.

        else:

            verbose_print(false_command +" successfully rejected!")

    return True  # Not a single false command was accepted.

def generate_correct_commands(correct_command):

    """ Generates all sequences of the given command that, if passed to the

    interactive server, should yield a correct response.

    For example: Sending "ABC" makes this function return

    [

        ["ABC"],

        ["A", "BC"],

        ["AB", "C"],

        ["A", "B", "C"]

    ]

    """

    correct_commands = [[correct_command]]  # Trivial list.

    for i in range(1, len(correct_command)):

        # So this is actually kind of like Lisp, but it does the job: Decide

        # first and rest of the command, and then continue the function

        # recursively on the rest, concatenating that result on the first, and

        # appending all that to the list of correct commands.

        first = [correct_command[:i]]  # From begin to i

        rest = correct_command[i:]  # From i to end

        for recursive_command in generate_correct_commands(rest):

            correct_commands.append(first + recursive_command)

    # And finally, return that to the caller:

    return correct_commands

def generate_false_commands(correct_command):

    """ Generates a list of false commands, similar to the given command.

    Basically, it creates a permutation of the casing, divided in lists, and so

    on.

    It may not be exhaustive, that would actually make running the test run far

    too long.

    """

    false_commands = []  # This will contain all false commands.

    if len(correct_command) > 1:

        # Recursively handle commands less 1 character:

        false_commands.extend(generate_false_commands( \

                correct_command[0:len(correct_command)-1]))

        false_commands.extend(generate_false_commands( \

                correct_command[1:]))

    # Handling all possible variations of the current length:

    temp_false_commands = []

    for element in itertools.permutations(correct_command, \

            len(correct_command)):

        temp_false_commands.append("".join(element))

    swapped_false_commands = []

    for false_command in temp_false_commands:

        for i in range(len(false_command)):

            new_false_command = false_command[0:i] + \

                false_command[i:].swapcase()

            swapped_false_commands.append(new_false_command)

    temp_false_commands.extend(swapped_false_commands)

    # Putting all false commands together:

    false_commands.extend(temp_false_commands)

    return false_commands  # And returning them all.

# --- Start of program ---

if len(sys.argv) >= 2:  # If the user has set flags, handle them:

    flag_handling(sys.argv)

"""

The test will run as follows:

    1. A predetermined amount of times, a socket will be created, that will try

    to connect to the server using the given data.

    2. Random strings will be sent, in an attempt to make the server shut down.

    3. The client will try different ways to receive the time of the server.

    4. The client will timeout, and look if the server reacts properly.

    5. The client will check for IP address data.

    6. The socket will be closed, and reopened by the loop.

    7. If the loop ends, a last connection will be started, to shut the server

       down.

    8. When that succeeds, all tests have passed.

"""

for i in range(RECONNECTIONS_AMOUNT):

    print("Client test (#" + str(i+1) +")")

    # Creating the socket for use:

    socket = SocketModule.socket(SocketModule.AF_INET, SocketModule.SOCK_STREAM)

    socket.connect((SERVER_ADDRESS, SERVER_PORT))

    # Testing bogus input:

    print("Testing if the server breaks on bogus input...")

    assert run_after_erronous_input(socket)

    print("Server seems to not crash on erronous input.")

    # Testing time output:

    # XXX: It's very likely that the speed of the time test overlaps with the

    # previous test, causing the server to block TIME. A sleep of 1 should handle

    # this.

    time.sleep(1)

    print("Testing if time gets printed correctly...")

    check_command_validity(socket, "TIME", time.ctime())

    print("Time seems to be handled fine.")

    # Testing if we can connect after a timeout:

    print("Testing if timing out works correctly...")

    # A simple test: Test if it doesn't time out when it shouldn't, and test if

    # it times out when it should.

    verbose_print("Test whether the server can be tricked in timing out after 2\

    seconds...")

    time.sleep(2)  # This should NOT yield a timeout.

    socket.send("I didn't time out!")

    if SERVER == 2:

        socket.send("\n")

    data = socket.recv(2048)

    assert data != "", "The client timed out, but that wasn't supposed to \

            happen after 2 seconds!"

    verbose_print("Server didn't time out after 2 seconds.")

    verbose_print("Now we will trigger a timeout.")

    time.sleep(TIMEOUT_WAIT)

    data = socket.recv(2048)

    if data == "":  # TCP sends "" when a disconnect takes place.

        print("Timed out as expected!")

        socket = SocketModule.socket(SocketModule.AF_INET, SocketModule.SOCK_STREAM)

        socket.connect((SERVER_ADDRESS, SERVER_PORT))

    else:

        assert False, "The program was still connected to the server. The \

        client should have timed out by this point, but didn't."    

    # Testing IP data:

    time.sleep(1)

    print("Testing if the client's address is sent correctly...")

    check_command_validity(socket, "IP", CLIENT_IP)

    print("Addresses seem to be handled fine.")

    socket.close()  # Closing the socket.

    print("Client test #"+ str(i+1) +" passed!")

# Final test: Tell the server to close down, and assert that we can't connect

# anymore.

print("Checking if the server doesn't exit on wrong EXIT commands...")

socket = SocketModule.socket(SocketModule.AF_INET, SocketModule.SOCK_STREAM)

socket.connect((SERVER_ADDRESS, SERVER_PORT))

assert command_misspelled_reject(socket, "EXIT", None)

# Now, we close the server down, and attempt to connect.

socket.send("EXIT\n")

socket.close()

try:

    socket.connect((SERVER_ADDRESS, SERVER_PORT))

    assert False, "The program was able to connect to the server, despite \

    having sent a shutdown command."

except SocketModule.error:

    print("Server shut down on command.")

# At this stage, all loops have been done, and all tests have passed.

print("All tests passed!")