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)