def test_failed_get(self):
""" Test GET that should fail """
test = Test()
test.url = self.prefix + '/api/person/500/'
test_response = resttest.run_test(test)
self.assertEqual(False, test_response.passed)
self.assertEqual(404, test_response.response_code)
def test_use_validators_jmespath_fail(self):
try:
import jmespath
except ImportError:
print("Skipping jmespath import test because library absent")
raise unittest.SkipTest("JMESPath module absent")
""" Test validators that should fail """
test = Test()
test.url = self.prefix + '/api/person/'
test.validators = list()
cfg_exists = {'jmespath': 'objects[500]', 'test': 'exists'}
test.validators.append(
validators.parse_validator('extract_test', cfg_exists))
cfg_not_exists = {'jmespath': "objects[1]", 'test': 'not_exists'}
test.validators.append(
validators.parse_validator('extract_test', cfg_not_exists))
cfg_compare = {
'jmespath': "objects[1].last_name",
'expected': 'NotJenkins'
}
test.validators.append(
validators.parse_validator('compare', cfg_compare))
test_response = resttest.run_test(test)
self.assertFalse(test_response.passed)
self.assertTrue(test_response.failures)
self.assertEqual(3, len(test_response.failures))
def test_get(self):
""" Basic local get test """
test = Test()
test.url = self.prefix + '/api/person/'
test_response = resttest.run_test(test)
self.assertTrue(test_response.passed)
self.assertEqual(200, test_response.response_code)
def test_get_validators(self):
""" Test that validators work correctly """
test = Test()
test.url = self.prefix + '/api/person/'
# Validators need library calls to configure them
test.validators = list()
cfg_exists = {'jsonpath_mini': "objects.0", 'test':'exists'}
test.validators.append(validators.parse_validator('extract_test', cfg_exists))
cfg_exists_0 = {'jsonpath_mini': "meta.offset", 'test':'exists'}
test.validators.append(validators.parse_validator('extract_test', cfg_exists_0))
cfg_not_exists = {'jsonpath_mini': "objects.100", 'test':'not_exists'}
test.validators.append(validators.parse_validator('extract_test', cfg_not_exists))
cfg_compare_login = {'jsonpath_mini': 'objects.0.login', 'expected': 'gbaltar'}
test.validators.append(validators.parse_validator('compare', cfg_compare_login))
cfg_compare_id = {'jsonpath_mini': 'objects.1.id', 'comparator':'gt', 'expected': -1}
test.validators.append(validators.parse_validator('compare', cfg_compare_id))
test_response = resttest.run_test(test)
for failure in test_response.failures:
print "REAL FAILURE"
print "Test Failure, failure type: {0}, Reason: {1}".format(failure.failure_type, failure.message)
if failure.details:
print "Validator/Error details: "+str(failure.details)
self.assertFalse(test_response.failures)
self.assertTrue(test_response.passed)
def test_get_redirect(self):
""" Basic local get test """
test = Test()
test.curl_options = {'FOLLOWLOCATION': True}
test.url = self.prefix + '/api/person'
test_response = resttest.run_test(test)
self.assertTrue(test_response.passed)
self.assertEqual(200, test_response.response_code)
def parse_testsets(base_url, test_structure, test_files = set(), working_directory = None):
""" Convert a Python datastructure read from validated YAML to a set of structured testsets
The data stucture is assumed to be a list of dictionaries, each of which describes:
- a tests (test structure)
- a simple test (just a URL, and a minimal test is created)
- or overall test configuration for this testset
- an import (load another set of tests into this one, from a separate file)
- For imports, these are recursive, and will use the parent config if none is present
Note: test_files is used to track tests that import other tests, to avoid recursive loops
This returns a list of testsets, corresponding to imported testsets and in-line multi-document sets
"""
tests_out = list()
test_config = TestConfig()
testsets = list()
benchmarks = list()
if working_directory is None:
working_directory = os.path.abspath(os.getcwd())
#returns a testconfig and collection of tests
for node in test_structure: #Iterate through lists of test and configuration elements
if isinstance(node,dict): #Each config element is a miniature key-value dictionary
node = lowercase_keys(node)
for key in node:
if key == u'import':
importfile = node[key] #import another file
if importfile not in test_files:
logger.debug("Importing test sets: " + importfile)
test_files.add(importfile)
import_test_structure = read_test_file(importfile)
with cd(os.path.dirname(os.path.realpath(importfile))):
import_testsets = parse_testsets(base_url, import_test_structure, test_files)
testsets.extend(import_testsets)
elif key == u'url': #Simple test, just a GET to a URL
mytest = Test()
val = node[key]
assert isinstance(val,str) or isinstance(val,unicode)
mytest.url = base_url + val
tests_out.append(mytest)
elif key == u'test': #Complex test with additional parameters
with cd(working_directory):
child = node[key]
mytest = Test.parse_test(base_url, child)
tests_out.append(mytest)
elif key == u'benchmark':
benchmark = parse_benchmark(base_url, node[key])
benchmarks.append(benchmark)
elif key == u'config' or key == u'configuration':
test_config = parse_configuration(node[key])
testset = TestSet()
testset.tests = tests_out
testset.config = test_config
testset.benchmarks = benchmarks
testsets.append(testset)
return testsets
def test_post(self):
""" Test POST to create an item """
test = Test()
test.url = self.prefix + '/api/person/'
test.method = u'POST'
test.expected_status = [200, 201, 204]
test.body = '{"first_name": "Willim","last_name": "Adama","login": "******"}'
test.headers = {u'Content-Type': u'application/json'}
test_response = resttest.run_test(test)
self.assertEqual(True, test_response.passed)
self.assertEqual(201, test_response.response_code)
# Test user was created
test2 = Test()
test2.url = self.prefix + '/api/person/?login=theadmiral'
test_response2 = resttest.run_test(test2)
self.assertTrue(test_response2.passed)
obj = json.loads(str(test_response2.body))
print(json.dumps(obj))
def test_put_created(self):
""" Test PUT where item DOES NOT already exist """
test = Test()
test.url = self.prefix + '/api/person/100/'
test.method = u'PUT'
test.expected_status = [200,201,204]
test.body = '{"first_name": "Willim","last_name": "Adama","login":"******", "id": 100}'
test.headers = {u'Content-Type':u'application/json'}
test_response = resttest.run_test(test)
self.assertEqual(True, test_response.passed)
self.assertEqual(201, test_response.response_code)
# Test it was actually created
test2 = Test()
test2.url = test.url
test_response2 = resttest.run_test(test2)
self.assertTrue(test_response2.passed)
self.assertTrue(u'"last_name": "Adama"' in test_response2.unicode_body())
self.assertTrue(u'"login": "******"' in test_response2.unicode_body())
def test_put_inplace(self):
""" Test PUT where item already exists """
test = Test()
test.url = self.prefix + '/api/person/1/'
test.method = u'PUT'
test.body = '{"first_name": "Gaius","id": 1,"last_name": "Baltar","login": "******"}'
test.headers = {u'Content-Type': u'application/json'}
test_response = resttest.run_test(test)
self.assertEqual(True, test_response.passed)
self.assertEqual(200, test_response.response_code)
def test_head(self):
""" Calls github API to test the HEAD method, ugly but Django tastypie won't support it """
test = Test()
test.url = 'https://api.github.com/users/svanoort'
test_response = resttest.run_test(test)
self.assertTrue(test_response.passed)
self.assertEqual(200, test_response.response_code)
print("Github API response headers: \n{0}".format(
test_response.response_headers))
self.assertTrue(test_response.response_headers)
def test_patch(self):
""" Basic local get test """
test = Test()
test.url = self.prefix + '/api/person/2/'
test.method = 'PATCH'
test.body = '{"login":"******"}'
test.headers = {
u'Content-Type': u'application/json',
u'X-HTTP-Method-Override': u'PATCH'
}
test.expected_status = [202] # Django returns 202
test_response = resttest.run_test(test)
self.assertTrue(test_response.passed)
def test_post(self):
""" Test POST to create an item """
test = Test()
test.url = self.prefix + '/api/person/'
test.method = u'POST'
test.expected_status = [200, 201, 204]
test.body = '{"first_name": "Willim","last_name": "Adama","login": "******"}'
test.headers = {u'Content-Type': u'application/json'}
test_response = resttest.run_test(test)
self.assertEqual(True, test_response.passed)
self.assertEqual(201, test_response.response_code)
# Test user was created
test2 = Test()
test2.url = self.prefix + '/api/person/?login=theadmiral'
test_response2 = resttest.run_test(test2)
self.assertTrue(test_response2.passed)
# Test JSON load/dump round trip on body
bod = test_response2.body
if isinstance(bod, binary_type):
bod = text_type(bod, 'utf-8')
print(json.dumps(json.loads(bod)))
def test_delete(self):
""" Try removing an item """
test = Test()
test.url = self.prefix + '/api/person/1/'
test.expected_status = [200, 202, 204]
test.method = u'DELETE'
test_response = resttest.run_test(test)
self.assertEqual(True, test_response.passed)
self.assertEqual(204, test_response.response_code)
# Verify it's really gone
test.method = u'GET'
test.expected_status = [404]
test_response = resttest.run_test(test)
self.assertEqual(True, test_response.passed)
self.assertEqual(404, test_response.response_code)
# Check it's gone by name
test2 = Test()
test2.url = self.prefix + '/api/person/?first_name__contains=Gaius'
test_response2 = resttest.run_test(test2)
self.assertTrue(test_response2.passed)
self.assertTrue(u'"objects": []' in test_response2.unicode_body())
def test_get_validators_fail(self):
""" Test validators that should fail """
test = Test()
test.url = self.prefix + '/api/person/'
test.validators = list()
cfg_exists = {'jsonpath_mini': "objects.500", 'test':'exists'}
test.validators.append(validators.parse_validator('extract_test', cfg_exists))
cfg_not_exists = {'jsonpath_mini': "objects.1", 'test':'not_exists'}
test.validators.append(validators.parse_validator('extract_test', cfg_not_exists))
cfg_compare = {'jsonpath_mini': "objects.1.last_name", 'expected':'NotJenkins'}
test.validators.append(validators.parse_validator('compare', cfg_compare))
test_response = resttest.run_test(test)
self.assertFalse(test_response.passed)
self.assertTrue(test_response.failures)
self.assertEqual(3, len(test_response.failures))
def test_header_validators(self):
test = Test()
test.url = self.prefix + '/api/person/1/'
config = {
'header': 'server',
'comparator': 'contains',
'expected': 'WSGI'
}
test.validators = list()
test.validators.append(validators.parse_validator(
'comparator', config))
result = resttest.run_test(test)
if result.failures:
for fail in result.failures:
print(fail)
self.assertTrue(result.passed)
def test_header_extraction(self):
test = Test()
test.url = self.prefix + '/api/person/1/'
key1 = 'server-header'
key2 = 'server-header-mixedcase'
test.extract_binds = {
key1: validators.HeaderExtractor.parse('server'),
# Verify case-insensitive behavior
key2: validators.HeaderExtractor.parse('sErVer')
}
my_context = self()
test_response = resttest.run_test(test, context=my_context)
val1 = my_context.get_value(key1)
val2 = my_context.get_value(key2)
self.assertEqual(val1, val2)
self.assertTrue('wsgi' in val1.lower())
self.assertTrue('wsgi' in val2.lower())
def search():
details = extract_details()
try:
search_details(details)
except Exception as e:
error_message.set(str(e))
traceback.print_exc()
return
if __name__ == "__main__":
Test()
if False:
time = datetime.datetime.now()
for x in range(0, 10):
Benchmark()
current_time = datetime.datetime.now()
total_seconds = (current_time - time).total_seconds()
progress_file_name = f'benchmarks/{datetime.datetime.now().strftime("%Y_%b_%d_%H-%M-%S")}.csv'
with open(progress_file_name, 'w+') as progress_file:
progress = csv.writer(progress_file, lineterminator='\n')
progress.writerow([f"{total_seconds} seconds"])
def __init__(self,
config_file=configuration_file,
logname=logname,
logging_config_file=local_syslog_config_file):
"""
Will initialize the sensor, reading the configuration file
and creating the sensorinfo attributes
"""
# FIRST always init the logger, as it's used by rest of methods
self.logger = self.localsysloginitialization(logname,
logging_config_file)
# All information related with the wlan part of the sensor
# using the external Class Wireless(), that encapsulates the wlan
# needs for the sensor
self.wlan = Wireless(self.logname)
# All information related with the TESTs is managed with the external
# class Test(), encapsulating all information and methods needed for
# the tests to run
self.test = Test(self.logname)
# Read the sensor configuration
self.sensor = self.readconfigfile(config_file)
# Initialize the Main variable to use, a LIST with all the WLAN
# networks to test, with their connection information. Each WLAN OBJECT
# has two LISTS inside: TESTS, is the list of tests to run (bandwidth,
# delay, packet loss, dns test, etc.) and OUTPUTS, the list of output
# methods to use to send the information
# self.sensor = {
# "sensorinfo":{general information about sensor}}
# "wlans":[
# {
# "wlanid":1
# "configuration":{ssid, ip, etc.}
# "tests":[
# {test1},
# {test2},
# ...,
# {testN}
# ],
# "outputs":[
# {output1},
# {output2},
# ...,
# {outputN}
# ],
# "results":[
# {result_test1},
# {result_test2},
# ...,
# {result_testN}
# ]
# },
# {
# "wlanid":2
# "configuration":{ssid, ip, etc.}
# "tests":[
# {test1},
# {test2},
# ...,
# {testN}
# ],
# "outputs":[
# {output1},
# {output2},
# ...,
# {outputN}
# ],
# "results":[
# {result_test1},
# {result_test2},
# ...,
# {result_testN}
# ]
# },
# {
# "wlanid":3
# "configuration":{ssid, ip, etc.}
# "tests":[
# {test1},
# {test2},
# ...,
# {testN}
# ],
# "outputs":[
# {output1},
# {output2},
# ...,
# {outputN}
# ],
# "results":[
# {result_test1},
# {result_test2},
# ...,
# {result_testN}
# ]
# },
# ]
# }
# Init the output part of the sensor
self.output = Output(self)
print("\nResult: ", n, " * ", m, " = ", n * m, "\n")
elif command == "4":
n = self.readIntegerNumber()
m = self.getSmallIntegerNumber()
print("\n Result: ")
print(
n, " / ", m, " = ", n // m, " remainder ",
IntegerNumber(n.getNumericalBase(),
IntegerNumber.NumericalSymbols[n % m]))
elif command == "5":
n = self.readIntegerNumber()
m = int(input("Enter destination base: "))
print("\nResult: ", n, " = ", n.conversionToBase(m))
elif command == "x":
break
else:
print("\nUnknown command...\n")
except ValueError:
print("\nValue should be an integer number.\n")
except IntegerNumberException as ine:
print("\n\n" + str(ine) + "\n\n")
except Exception as e:
print("\n\n" + str(e) + "\n\n")
self.continuity()
c = ActionCalculator()
t = Test()
#t.test()
c.run()
def main(self, update_text, chat_id: int, database_name):
from tests import Test
return {chat_id: {'text': "\n".join(Test().run())}}
def test_detailed_get(self):
test = Test()
test.url = self.prefix + '/api/person/1/'
test_response = resttest.run_test(test)
self.assertEqual(True, test_response.passed)
self.assertEqual(200, test_response.response_code)
