GDP

#!/usr/bin/env python

#

#        RESTful interface to GDP - Test Suite

#

#        ----- BEGIN LICENSE BLOCK -----

#        Applications for the Global Data Plane

#        From the Ubiquitous Swarm Lab, 490 Cory Hall, U.C. Berkeley.

#

#        Copyright (c) 2017, Regents of the University of California.

#        All rights reserved.

#

#        Permission is hereby granted, without written agreement and without

#        license or royalty fees, to use, copy, modify, and distribute this

#        software and its documentation for any purpose, provided that the above

#        copyright notice and the following two paragraphs appear in all copies

#        of this software.

#

#        IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,

#        SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST

#        PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,

#        EVEN IF REGENTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#

#        REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT

#        LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

#        FOR A PARTICULAR PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION,

#        IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO

#        OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,

#        OR MODIFICATIONS.

#        ----- END LICENSE BLOCK -----

import os

import sys

import requests

import json

import fcntl

import re

import socket

import subprocess

#

# sanity check invocations

#

testbed = socket.gethostname()

if testbed != "gdp-rest-01":

    print "host is {}".format(testbed)

    print "Error: this script is only safe to run on the RESTful server"

    sys.exit(1)

#

# Monitor the gdp-rest-v2.log for diagnostic detail

#

log_path = "/var/log/gdp/gdp-rest-v2.log"

log = open(log_path)

log.seek(0, os.SEEK_END)

log_fd = log.fileno()

flags = fcntl.fcntl(log_fd, fcntl.F_GETFL)

fcntl.fcntl(log_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)

# dev null to silence subprocess output

dn = open("/dev/null", "w")

test_auth = None

#

# Create a temporary test account on gdp-rest-01 (do not use sample strings):

#

# $cat /etc/lighttpd/.plainauth

# your_unique_testuser:your_unique_testpassword

# [other_permanent_user_accounts_left_untouched]

# $

#

# ...fill in test_auth to match the above, and uncomment it

#

# test_auth = ("your_unique_testuser", "your_unique_testpassword")

if test_auth == None:

    print "Error: modify gdp-rest-testcases.py to use a temporary test account"

    sys.exit(1)

json_header = { 'Content-type': 'application/json' }

# clean up test logs (defined to be gdp-rest-01 local logs), while

# being careful to only remove keys which go with test logs, as all

# other keys are for real logs located in the real GDP.

def clean_glogs_and_keys():

    output = subprocess.check_output([ "sudo", "-g", "gdp", "-u", "gdp",

                                       "/usr/bin/find",

                                       "/var/swarm/gdp/glogs/", 

                                       "-type", "f", "-name", "*.glog" ])

    lines = output.splitlines()

    for line in lines:

        # find <glog_id> in /var/swarm/gdp/glogs/<glog_id>.glog

        glog_id = line[25:-5]

        # check expectations, where file removal is involved

        if len(glog_id) == 43:

            print "Info: remove local GCL {}...".format(glog_id),

            subprocess.call([ "sudo", "-g", "gdp", "-u", "gdp",

                              "/usr/bin/find", "/var/swarm/gdp/glogs/", 

                              "-type", "f", "-name", glog_id + "*",

                              "-exec", "/bin/rm", "-f", "{}", ";"])

            print "done"

            print "Info: remove local key {}...".format(glog_id),

            subprocess.call([ "sudo", "-g", "gdp", "-u", "gdp",

                              "/usr/bin/find", "/etc/gdp/keys/", 

                              "-type", "f", "-name", glog_id + ".pem",

                              "-exec", "/bin/rm", "-f", "{}", ";"])

            print "done"

        else:

            print "Error: cleanup has unexpected glog_id: {}".format(glog_id)

def page_display(p):

    if p != None:

        print "STATUS:"

        print p.status_code

        print "HEADERS:"

        print p.headers

        print "CONTENT:"

        print p.content

    else:

        print "Error: no page"

#

def failed_page_display(p):

    print "FAILED"

    print "DIAGNOSTICS:"

    page_display(p)

    print "END DIAGNOSTICS"

#

def failed_log_and_page_display(p, l):

    print "FAILURE DIAGNOSTICS:"

    print "==== gdp-rest-v2.log:"

    print l.read(-1)

    print "==== end"

    print "==== response page:"

    page_display(p)

    print "==== end"

    print "END DIAGNOSTICS"

#

def test_write(tc, tid, gid, rn):

    json_body = {

        tid : rn,

        "gcl_id" : gid

    }

    page = requests.post("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl/" +

                         gid,

                         auth = test_auth,

                         timeout = 60,

                         headers = json_header,

                         data = json.dumps(json_body))

    print "{} WRITE {}".format(tc, rn),

    if page.status_code == 200:

        print ""

        return True

    else:

        failed_page_display(page)

        return False

#

def test_read(tc, tid, gid, rn):

    page = requests.get("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl/" +

                         gid + "?recno=" + rn,

                         auth = test_auth,

                         timeout = 60)

    pj = page.json()

    print "{} READ {}".format(tc, rn),

    passed = False

    if page.status_code == 200 and pj[tid] == rn:

        print ""

        return True

    else:

        failed_page_display(page)

        return False

#

def test_log(tc, tid, gcl_id):

    print "{} GCL {} write and read".format(tc, gcl_id)

    if (test_write(tc, tid, gcl_id, "1") and

        test_write(tc, tid, gcl_id, "2") and

        test_write(tc, tid, gcl_id, "3") and

        test_read(tc, tid, gcl_id, "3") and

        test_read(tc, tid, gcl_id, "2") and

        test_read(tc, tid, gcl_id, "1")):

        print "{} PASSED".format(tc)

    else:

        print "{} FAILED GCL write and read".format(tc)

#

#

# HTTP PUT TESTS

#

def test_put_01():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 01:"

    test_id = "test_put_01_log"

    print "{} HTTP PUT new log".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_01"

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 201:

        pj = page.json()

        gcl_name = pj["gcl_name"]

        # DEPRECATED gdplogd_name retrieval code block

        # gdplogd_name = pj["gdplogd_name"]

        # if gcl_name != None and gdplogd_name != None:

        #     print "{} PASSED \"{}\" \"{}\"".format(test_case,

        #     gcl_name, gdplogd_name)

        #     test_log(test_case, test_id, gcl_name)

        # else:

        #     print "{} FAILED page: \"{}\" \"{}\"".format(test_case,

        #                                                  gcl_name, gdplogd_name)

        #     failed_log_and_page_display(page, log)

        # END DEPRECATED gdplogd_name retrieval code block

        if gcl_name != None:

            print "{} PASSED \"{}\"".format(test_case, gcl_name)

            test_log(test_case, test_id, gcl_name)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, gcl_name)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_02():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 02:"

    print "{} HTTP PUT existing log (from TEST PUT 01)".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_01"

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 409:

        pj = page.json()

        detail = pj["detail"]

        if detail == "external-name already exists on gdplogd server":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_03():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 03:"

    print "{} HTTP PUT with no external-name".format(test_case)

    json_body = {

        "NO-external-name" : "edu.berkeley.eecs.gdp-rest.test_put_03"

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "mandatory external-name not found":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_04():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 04:"

    print "{} HTTP PUT with no request body".format(test_case)

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header)

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request body not recognized json format":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_05():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 05:"

    print "{} HTTP PUT with no request header or body".format(test_case)

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60)

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request body not recognized json format":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_06():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 06:"

    test_id = "test_put_06_log"

    print "{} HTTP PUT new log, verify all valid options".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_06",

        "-C" : "swarmlab@berkeley.edu",

        "-h" : "sha224",

        "-k" : "dsa",

        "-b" : "1024",

        "-c" : "ignored_for_dsa",

        "META" : [ "meta1=foo", "meta2=bar" ],

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 201:

        pj = page.json()

        gcl_name = pj["gcl_name"]

        # DEPRECATED gdplogd_name retrieval code block

        # gdplogd_name = pj["gdplogd_name"]

        # if gcl_name != None and gdplogd_name != None:

        #     print "{} PASSED \"{}\" \"{}\"".format(test_case,

        #     gcl_name, gdplogd_name)

        #     test_log(test_case, test_id, gcl_name)

        # else:

        #     print "{} FAILED page: \"{}\" \"{}\"".format(test_case,

        #                                                  gcl_name, gdplogd_name)

        #     failed_log_and_page_display(page, log)

        # END DEPRECATED gdplogd_name retrieval code block

        if gcl_name != None:

            print "{} PASSED \"{}\"".format(test_case, gcl_name)

            test_log(test_case, test_id, gcl_name)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, gcl_name)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

#

# server controlled options -e, -S, -K should not be accessible to clients

#

def test_put_07():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 07:"

    print "{} HTTP PUT create log, -e option is not permitted".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_07",

        "-e" : "none"

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request contains unrecognized json objects":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_08():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 09:"

    print "{} HTTP PUT create log, -S option is not permitted".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_08",

        "-S" : None

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request contains unrecognized json objects":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_09():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 09:"

    print "{} HTTP PUT create log, -K option is not permitted".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_09",

        "-K" : "/etc/gdp/keys"

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request contains unrecognized json objects":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

#

# unsupported options -G, -q, -s, -w, -W should not be accessible to clients

#

def test_put_10():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 10:"

    print "{} HTTP PUT create log, -G option is not permitted".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_10",

        "-G" : "127.0.0.1"

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request contains unrecognized json objects":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_11():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 11:"

    print "{} HTTP PUT create log, -q option is not permitted".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_11",

        "-q" : None

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request contains unrecognized json objects":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_12():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 12:"

    print "{} HTTP PUT create log, -s option is not permitted".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_12",

        "-s" : "edu.berkeley.eecs.service.creation"

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request contains unrecognized json objects":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_13():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 13:"

    print "{} HTTP PUT create log, -w option is not permitted".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_13",

        "-w" : None

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request contains unrecognized json objects":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_14():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 14:"

    print "{} HTTP PUT create log, -W option is not permitted".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_14",

        "-W" : "/etc/gdp/keys"

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request contains unrecognized json objects":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_15():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 15:"

    print "{} HTTP PUT create log, META list is None(s)".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_15",

        "META" : None

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request contains unrecognized json objects":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_put_16():

    log.seek(0, os.SEEK_END)

    test_case = "TEST PUT 16:"

    print "{} HTTP PUT create log, META list element bad(s)".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_put_16",

        "META" : [ "foo=1", "missing_equal", "bar=2" ],

    }

    page = requests.put("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request contains unrecognized json objects":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

#

# HTTP POST TESTS

#

def test_post_01():

    log.seek(0, os.SEEK_END)

    test_case = "TEST POST 01:"

    test_id = "test_post_01_log"

    print "{} HTTP POST new log".format(test_case)

    json_body = {

        "external-name" : None

    }

    page = requests.post("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 201:

        pj = page.json()

        gcl_name = pj["gcl_name"]

        # DEPRECATED gdplogd_name retrieval code block

        # gdplogd_name = pj["gdplogd_name"]

        # if gcl_name != None and gdplogd_name != None:

        #     print "{} PASSED \"{}\" \"{}\"".format(test_case,

        #     gcl_name, gdplogd_name)

        #     test_log(test_case, test_id, gcl_name)

        # else:

        #     print "{} FAILED page: \"{}\" \"{}\"".format(test_case,

        #                                                  gcl_name, gdplogd_name)

        #     failed_log_and_page_display(page, log)

        # END DEPRECATED gdplogd_name retrieval code block

        if gcl_name != None:

            print "{} PASSED \"{}\"".format(test_case, gcl_name)

            test_log(test_case, test_id, gcl_name)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, gcl_name)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_post_02():

    log.seek(0, os.SEEK_END)

    test_case = "TEST POST 02:"

    print "{} HTTP POST with an external-name".format(test_case)

    json_body = {

        "external-name" : "edu.berkeley.eecs.gdp-rest.test_post_02"

    }

    page = requests.post("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header,

                        data = json.dumps(json_body))

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "POST external-name must have null value":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_post_03():

    log.seek(0, os.SEEK_END)

    test_case = "TEST POST 03:"

    print "{} HTTP POST with no request body".format(test_case)

    page = requests.post("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60,

                        headers = json_header)

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request body not recognized json format":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_post_04():

    log.seek(0, os.SEEK_END)

    test_case = "TEST POST 04:"

    print "{} HTTP POST with no request header or body".format(test_case)

    page = requests.post("https://gdp-rest-01.eecs.berkeley.edu/gdp/v2/gcl",

                        auth = test_auth,

                        timeout = 60)

    if page.status_code == 400:

        pj = page.json()

        detail = pj["detail"]

        if detail == "request body not recognized json format":

            print "{} PASSED \"{}\"".format(test_case, detail)

        else:

            print "{} FAILED page: \"{}\"".format(test_case, detail)

            failed_log_and_page_display(page, log)

    else:

        print "{} FAILED status code: {}".format(test_case, page.status_code)

        failed_log_and_page_display(page, log)

#

def test_post_05():

    log.seek(0, os.SEEK_END)

    test_case = "TEST POST 05:"

    test_id = "test_post_05_log"

    print "{} HTTP POST new log, verify all valid options".format(test_case)

    json_body = {

        "external-name" : None,

        "-C" : "swarmlab@berkeley.edu",

        "-h" : "sha224",

        "-k" : "dsa",

        "-b" : "1024",