def main(): options = options_handler() c = demisto.DemistoClient(options.key, options.server) postData = {'sort': [{'field': 'value', 'asc': True}]} if options.filter: postData['query'] = options.filter if options.delta: postData['fromDate'] = fromDate(options.delta) indicatorsResponse = c.req('POST', 'indicators/search', postData) if indicatorsResponse.status_code != 200: raise RuntimeError( 'Error getting indicators data - %d (%s)' % (indicatorsResponse.status_code, indicatorsResponse.reason)) indicators = indicatorsResponse.json() with open(options.output, 'w') as csvfile: writer = csv.DictWriter(csvfile, fieldnames=[ 'Value', 'Type', 'Source', 'FirstSeen', 'LastSeen', 'Score' ]) writer.writeheader() for i in indicators['iocObjects']: writer.writerow({ 'Value': i['value'], 'Type': i['indicator_type'], 'Source': i['source'], 'FirstSeen': i['firstSeen'], 'LastSeen': i['lastSeen'], 'Score': i['score'] })
def main(): username, password = get_username_password() ready_ami_list = [] with open('./Tests/instance_ips.txt', 'r') as instance_file: instance_ips = instance_file.readlines() instance_ips = [line.strip('\n').split(":") for line in instance_ips] for i in range(MAX_TRIES * SLEEP_TIME): if len(instance_ips) > len(ready_ami_list): for ami_instance_name, ami_instance_ip in instance_ips: if ami_instance_name not in ready_ami_list: c = demisto.DemistoClient(None, "https://{}".format(ami_instance_ip), username, password) res = c.Login() if res.status_code == 200: print "[{}] {} is ready for use".format(datetime.datetime.now(), ami_instance_name) ready_ami_list.append(ami_instance_name) elif i % 30 == 0: # printing the message every 30 seconds print "{} is not ready yet - waiting for it to start".format(ami_instance_name) if len(instance_ips) > len(ready_ami_list): sleep(1) else: break if len(ready_ami_list) != len(instance_ips): print_error("The server is not ready :(") sys.exit(1)
def main(): options = options_handler() c = demisto.DemistoClient(options.key, options.server) incidents = c.SearchIncidents(options.page, 0, options.filter) print('using filter %s' % options.filter) print('Total #incidents: %d, incidents going to be updated' % incidents['total']) proceed = raw_input('OK to proceed (type y, yes or leave empty)? ') proceed = proceed.lower() if proceed == 'y' or proceed == 'yes' or proceed == '': if options.action == 'close': data = {'closeReason': options.closeReason, 'closeNotes': options.closeNotes, 'filter': { 'page': options.page, 'size': options.size, 'query': options.filter}} data['all'] = True if options.customFields: data['CustomFields'] = json.loads(options.customFields) r = c.req('POST', 'incident/batchClose', data) if r.status_code != 200: raise RuntimeError( 'Error updating incidents - %d (%s)' % (r.status_code, r.reason)) rj = json.loads(r.content) if rj['notUpdated'] > 0: print('Updated %d and could not update %d' % (rj['total'], rj['notUpdated'])) else: print('Updated %d incidents' % rj['total']) else: print('action "%s" is not implemented.' % options.action)
def main(): options = options_handler() c = demisto.DemistoClient(options.key, options.server) p('using filter %s' % options.filter) incidents = c.SearchIncidents(0, 10000, options.filter) p('Total #incidents: %d' % (incidents['total'])) mttr = {} for i in incidents['data']: if not 'closed' in i or not i['closed']: continue created = parse_dt(i['created']) closed = parse_dt(i['closed']) d = closed - created field = '' if options.group == 'owner': field = i['owner'] if i['owner'] else 'dbot' else: field = i[options.group] if field in mttr: mttr[field]['mttr'] = mttr[field]['mttr'] + d.total_seconds() mttr[field]['incidents'] = mttr[field]['incidents'] + 1 else: mttr[field] = {'mttr': d.total_seconds(), 'incidents': 1} with open(options.output, 'w') as csvfile: writer = csv.DictWriter(csvfile, fieldnames=['Field', 'Incidents', 'MTTR']) writer.writeheader() for f in mttr: writer.writerow({'Field': f, 'Incidents': mttr[f]['incidents'], 'MTTR': int(mttr[f]['mttr'] / mttr[f]['incidents'] / 60)})
def get_demisto_instance_and_login(server, username, password): c = demisto.DemistoClient(None, server, username, password) res = c.Login() if res.status_code != 200: print_error("Login has failed with status code " + str(res.status_code)) sys.exit(1) return c
def main(): options = options_handler() c = demisto.DemistoClient(options.key, options.server) with open(options.widget, 'r') as widget_file: widget_data = widget_file.read() res = c.req('POST', 'widgets', json.loads(widget_data)) if res.status_code != 200: raise RuntimeError('Error uploading widget - %d (%s)' % (res.status_code, res.reason)) p('Widget successfully uploaded')
def is_correct_content_installed(username, password, ips, content_version): # type: (AnyStr, AnyStr, List[List], AnyStr) -> bool """ Checks if specific content version is installed on server list Args: username: for server connection password: for server connection ips: list with lists of [instance_name, instance_ip] content_version: content version that should be installed Returns: True: if all tests passed, False if one failure """ method = "post" suffix = "/content/installed/" for ami_instance_name, ami_instance_ip in ips: d = demisto.DemistoClient(None, "https://{}".format(ami_instance_ip), username, password) d.Login() resp = d.req(method, suffix, None) resp_json = None try: resp_json = resp.json() if not isinstance(resp_json, dict): raise ValueError( 'Response from server is not a Dict, got [{}].\n' 'Text: {}'.format(type(resp_json), resp.text)) release = resp_json.get("release") notes = resp_json.get("releaseNotes") installed = resp_json.get("installed") if not (release and content_version in release and notes and installed): print_error( "Failed install content on instance [{}]\nfound content version [{}], expected [{}]" "".format(ami_instance_name, release, content_version)) return False else: print_color( "Instance [{instance_name}] content verified with version [{content_version}]" .format(instance_name=ami_instance_name, content_version=release), LOG_COLORS.GREEN) except ValueError as exception: err_msg = "Failed to verify content version on server [{}]\n" \ "Error: [{}]\n".format(ami_instance_name, str(exception)) if resp_json is not None: err_msg += "Server response: {}".format(resp_json) print_error(err_msg) return False print_color( "Content was installed successfully on all of the instances! :)", LOG_COLORS.GREEN) return True
def main(): options = options_handler() c = demisto.DemistoClient(options.key, options.server) labels = None if (options.labels is not None) and len(options.labels) > 0: labels = json.loads(options.labels) fields = None if (options.custom_fields is not None) and len(options.custom_fields) > 0: fields = json.loads(options.custom_fields) r = c.CreateIncident(options.name, options.type, severity_to_number(options.severity), options.owner, labels, options.details, fields) print(r)
def main(): options = options_handler() c = demisto.DemistoClient(options.key, options.server) integrationsResponse = c.req('GET', 'settings/integration-commands', None) if integrationsResponse.status_code != 200: raise RuntimeError( 'Error getting integration data - %d (%s)' % (integrationsResponse.status_code, integrationsResponse.reason)) integrations = sorted( integrationsResponse.json(), key=lambda m: m['category'].lower() + '---' + m['name'].lower()) with open(options.output, 'w') as csvfile: writer = csv.DictWriter(csvfile, fieldnames=[ 'Category', 'Product', 'ProductDescription', 'Command', 'CommandDescription' ]) writer.writeheader() for m in integrations: if 'commands' in m: for cmd in m['commands']: writer.writerow({ 'Category': m['category'], 'Product': m['display'], 'ProductDescription': m['description'].encode('ascii', 'ignore'), 'Command': cmd['name'], 'CommandDescription': cmd['description'].encode('ascii', 'ignore') }) else: writer.writerow({ 'Category': m['category'], 'Product': m['display'], 'ProductDescription': m['description'].encode('ascii', 'ignore') })
def main(): options = options_handler() username = options.user password = options.password server = options.server conf_path = options.conf secret_conf_path = options.secret is_nightly = options.nightly if not (username and password and server): print_error('You must provide server user & password arguments') sys.exit(1) c = demisto.DemistoClient(None, server, username, password) res = c.Login() if res.status_code is not 200: print_error("Login has failed with status code " + str(res.status_code)) sys.exit(1) with open(conf_path) as data_file: conf = json.load(data_file) secret_conf = None if secret_conf_path: with open(secret_conf_path) as data_file: secret_conf = json.load(data_file) tests = conf['tests'] secret_params = secret_conf['integrations'] if secret_conf else [] if not tests or len(tests) is 0: print('no integrations are configured for test') return succeed_playbooks = [] failed_playbooks = [] for t in tests: test_options = { 'timeout': t['timeout'] if 'timeout' in t else conf.get('testTimeout', 30), 'interval': conf.get('testInterval', 10) } playbook_id = t['playbookID'] integrations_conf = t.get('integrations', []) if not isinstance(integrations_conf, list): integrations_conf = [integrations_conf] integrations = [] for integration in integrations_conf: if type(integration) is dict: # dict description integrations.append({ 'name': integration.get('name'), 'byoi': integration.get('byoi', True), 'params': {} }) else: # string description integrations.append({ 'name': integration, 'byoi': True, 'params': {} }) for integration in integrations: integration_params = [ item for item in secret_params if item["name"] == integration['name'] ] if integration_params: integration['params'] = integration_params[0].get('params', {}) test_message = 'playbook: ' + playbook_id if integrations: integrations_names = [ integration['name'] for integration in integrations ] test_message = test_message + ' with integration(s): ' + ','.join( integrations_names) print '------ Test %s start ------' % (test_message, ) nightly_test = t.get('nightly', False) skip_test = True if nightly_test and not is_nightly else False if skip_test: print 'Skip test' else: # run test succeed = test_integration(c, integrations, playbook_id, test_options) # use results if succeed: print 'PASS: %s succeed' % (test_message, ) succeed_playbooks.append(playbook_id) else: print 'Failed: %s failed' % (test_message, ) failed_playbooks.append(playbook_id) print '------ Test %s end ------' % (test_message, ) print_test_summary(succeed_playbooks, failed_playbooks) if len(failed_playbooks): sys.exit(1)
def execute_testing(server, server_ip, server_version, server_numeric_version, is_ami=True): print("Executing tests with the server {} - and the server ip {}".format( server, server_ip)) options = options_handler() username = options.user password = options.password conf_path = options.conf secret_conf_path = options.secret is_nightly = options.nightly slack = options.slack circle_ci = options.circleci build_number = options.buildNumber build_name = options.buildName if not (username and password and server): print_error('You must provide server user & password arguments') sys.exit(1) c = demisto.DemistoClient(None, server, username, password) res = c.Login() if res.status_code != 200: print_error("Login has failed with status code " + str(res.status_code)) sys.exit(1) demisto_api_key = generate_demisto_api_key(c) conf, secret_conf = load_conf_files(conf_path, secret_conf_path) default_test_timeout = conf.get('testTimeout', 30) tests = conf['tests'] skipped_tests_conf = conf['skipped_tests'] nightly_integrations = conf['nigthly_integrations'] skipped_integrations_conf = conf['skipped_integrations'] unmockable_integrations = conf['unmockable_integrations'] secret_params = secret_conf['integrations'] if secret_conf else [] filtered_tests, is_filter_configured, run_all_tests = extract_filtered_tests( ) if is_filter_configured and not run_all_tests: is_nightly = True if not tests or len(tests) == 0: print('no integrations are configured for test') return proxy = None if is_ami: ami = AMIConnection(server_ip) ami.clone_mock_data() proxy = MITMProxy(c, server_ip) failed_playbooks = [] succeed_playbooks = [] skipped_tests = set([]) skipped_integration = set([]) disable_all_integrations(c) if is_ami: # move all mock tests to the top of the list mock_tests, mockless_tests = organize_tests(tests, unmockable_integrations, skipped_integrations_conf, nightly_integrations) else: # In case of a non AMI run we don't want to use the mocking mechanism mockless_tests = tests # first run the mock tests to avoid mockless side effects in container if is_ami and mock_tests: proxy.configure_proxy_in_demisto(proxy.ami.docker_ip + ':' + proxy.PROXY_PORT) for t in mock_tests: run_test_scenario(t, c, proxy, default_test_timeout, skipped_tests_conf, nightly_integrations, skipped_integrations_conf, skipped_integration, is_nightly, run_all_tests, is_filter_configured, filtered_tests, skipped_tests, demisto_api_key, secret_params, failed_playbooks, unmockable_integrations, succeed_playbooks, slack, circle_ci, build_number, server, build_name, server_numeric_version) print("\nRunning mock-disabled tests") proxy.configure_proxy_in_demisto('') print("Restarting demisto service") restart_demisto_service(ami, c) print("Demisto service restarted\n") for t in mockless_tests: run_test_scenario(t, c, proxy, default_test_timeout, skipped_tests_conf, nightly_integrations, skipped_integrations_conf, skipped_integration, is_nightly, run_all_tests, is_filter_configured, filtered_tests, skipped_tests, demisto_api_key, secret_params, failed_playbooks, unmockable_integrations, succeed_playbooks, slack, circle_ci, build_number, server, build_name, server_numeric_version, is_ami) print_test_summary(succeed_playbooks, failed_playbooks, skipped_tests, skipped_integration, unmockable_integrations, proxy, is_ami) create_result_files(failed_playbooks, skipped_integration, skipped_tests) if is_ami and build_name == 'master': print("Pushing new/updated mock files to mock git repo.") ami.upload_mock_files(build_name, build_number) if len(failed_playbooks): file_path = "./Tests/is_build_failed_{}.txt".format( server_version.replace(' ', '')) with open(file_path, "w") as is_build_failed_file: is_build_failed_file.write('Build failed') sys.exit(1)
def main(): options = options_handler() username = options.user password = options.password server = options.server conf_path = options.conf secret_conf_path = options.secret is_nightly = options.nightly if not (username and password and server): print_error('You must provide server user & password arguments') sys.exit(1) c = demisto.DemistoClient(None, server, username, password) res = c.Login() if res.status_code is not 200: print_error("Login has failed with status code " + str(res.status_code)) sys.exit(1) demisto_api_key = ''.join( random.choice(string.ascii_letters + string.digits) for _ in range(32)) apikey_json = {'name': 'test_apikey', 'apikey': demisto_api_key} c.req('POST', '/apikeys', apikey_json) with open(conf_path) as data_file: conf = json.load(data_file) secret_conf = None if secret_conf_path: with open(secret_conf_path) as data_file: secret_conf = json.load(data_file) tests = conf['tests'] skipped_tests_conf = conf['skipped_tests'] skipped_integrations_conf = conf['skipped_integrations'] secret_params = secret_conf['integrations'] if secret_conf else [] with open(FILTER_CONF, 'r') as filter_file: filterd_tests = filter_file.readlines() filterd_tests = [line.strip('\n') for line in filterd_tests] is_filter_configured = True if filterd_tests else False if not tests or len(tests) is 0: print('no integrations are configured for test') return succeed_playbooks = [] failed_playbooks = [] skipped_tests = [] for t in tests: playbook_id = t['playbookID'] integrations_conf = t.get('integrations', []) if playbook_id in skipped_tests_conf: skipped_tests.append(playbook_id) continue if is_filter_configured and not is_nightly and playbook_id not in filterd_tests: continue test_options = { 'timeout': t['timeout'] if 'timeout' in t else conf.get('testTimeout', 30), 'interval': conf.get('testInterval', 10) } if not isinstance(integrations_conf, list): integrations_conf = [integrations_conf] integrations = [] has_skipped_integration = False for integration in integrations_conf: if type(integration) is dict: if integration.get('name') in skipped_integrations_conf: has_skipped_integration = True break # dict description integrations.append({ 'name': integration.get('name'), 'byoi': integration.get('byoi', True), 'params': {} }) else: if integration in skipped_integrations_conf: has_skipped_integration = True break # string description integrations.append({ 'name': integration, 'byoi': True, 'params': {} }) if has_skipped_integration: continue for integration in integrations: integration_params = [ item for item in secret_params if item["name"] == integration['name'] ] if integration_params: integration['params'] = integration_params[0].get('params', {}) elif 'Demisto REST API' == integration['name']: integration['params'] = { 'url': 'https://localhost', 'apikey': demisto_api_key, 'insecure': True, } test_message = 'playbook: ' + playbook_id if integrations: integrations_names = [ integration['name'] for integration in integrations ] test_message = test_message + ' with integration(s): ' + ','.join( integrations_names) print '------ Test %s start ------' % (test_message, ) nightly_test = t.get('nightly', False) skip_test = True if nightly_test and not is_nightly else False if skip_test: print 'Skip test' else: # run test succeed = test_integration(c, integrations, playbook_id, test_options) # use results if succeed: print 'PASS: %s succeed' % (test_message, ) succeed_playbooks.append(playbook_id) else: print 'Failed: %s failed' % (test_message, ) failed_playbooks.append(playbook_id) print '------ Test %s end ------' % (test_message, ) print_test_summary(succeed_playbooks, failed_playbooks, skipped_tests) os.remove(FILTER_CONF) if len(failed_playbooks): sys.exit(1)
def main(): options = options_handler() username = options.user password = options.password server = options.server conf_path = options.conf secret_conf_path = options.secret is_nightly = options.nightly slack = options.slack CircleCI = options.circleci buildNumber = options.buildNumber if not (username and password and server): print_error('You must provide server user & password arguments') sys.exit(1) c = demisto.DemistoClient(None, server, username, password) res = c.Login() if res.status_code is not 200: print_error("Login has failed with status code " + str(res.status_code)) sys.exit(1) demisto_api_key = generate_demisto_api_key(c) conf, secret_conf = load_conf_files(conf_path, secret_conf_path) tests = conf['tests'] skipped_tests_conf = conf['skipped_tests'] skipped_integrations_conf = conf['skipped_integrations'] secret_params = secret_conf['integrations'] if secret_conf else [] filterd_tests, is_filter_configured = extract_filtered_tests() if is_filter_configured: is_nightly = True if not tests or len(tests) is 0: print('no integrations are configured for test') return skipped_tests = [] failed_playbooks = [] succeed_playbooks = [] skipped_integration = [] for t in tests: playbook_id = t['playbookID'] nightly_test = t.get('nightly', False) integrations_conf = t.get('integrations', []) skip_test = True if nightly_test and not is_nightly else False test_message = 'playbook: ' + playbook_id test_options = { 'timeout': t['timeout'] if 'timeout' in t else conf.get('testTimeout', 30), 'interval': conf.get('testInterval', 10) } if not isinstance(integrations_conf, list): integrations_conf = [integrations_conf] has_skipped_integration, integrations = collect_integrations( integrations_conf, is_filter_configured, skipped_integration, skipped_integrations_conf) # Skip nightly test if skip_test: print '------ Test %s start ------' % (test_message, ) print 'Skip test' print '------ Test %s end ------' % (test_message, ) continue # Skip filtered test if is_filter_configured and playbook_id not in filterd_tests: continue # Skip bad test if playbook_id in skipped_tests_conf: skipped_tests.append(playbook_id) continue # Skip integration if has_skipped_integration: continue set_integration_params(demisto_api_key, integrations, secret_params) test_message = update_test_msg(integrations, test_message) run_test(c, failed_playbooks, integrations, playbook_id, succeed_playbooks, test_message, test_options, slack, CircleCI, buildNumber, server) print_test_summary(succeed_playbooks, failed_playbooks, skipped_tests, skipped_integration) create_result_files(failed_playbooks, skipped_integration, skipped_tests) os.remove(FILTER_CONF) if len(failed_playbooks): sys.exit(1)
def main(): options = options_handler() username = options.user password = options.password server = options.server conf_path = options.conf secret_conf_path = options.secret is_nightly = options.nightly slack = options.slack CircleCI = options.circleci buildNumber = options.buildNumber build_name = options.buildName if not (username and password and server): print_error('You must provide server user & password arguments') sys.exit(1) c = demisto.DemistoClient(None, server, username, password) res = c.Login() if res.status_code != 200: print_error("Login has failed with status code " + str(res.status_code)) sys.exit(1) demisto_api_key = generate_demisto_api_key(c) conf, secret_conf = load_conf_files(conf_path, secret_conf_path) default_test_timeout = conf.get('testTimeout', 30) tests = conf['tests'] skipped_tests_conf = conf['skipped_tests'] nightly_integrations = conf['nigthly_integrations'] skipped_integrations_conf = conf['skipped_integrations'] secret_params = secret_conf['integrations'] if secret_conf else [] filterd_tests, is_filter_configured, run_all_tests = extract_filtered_tests() if is_filter_configured and not run_all_tests: is_nightly = True if not tests or len(tests) == 0: print('no integrations are configured for test') return failed_playbooks = [] succeed_playbooks = [] skipped_tests = set([]) skipped_integration = set([]) for t in tests: playbook_id = t['playbookID'] nightly_test = t.get('nightly', False) integrations_conf = t.get('integrations', []) instance_names_conf = t.get('instance_names', []) test_message = 'playbook: ' + playbook_id test_options = { 'timeout': t.get('timeout', default_test_timeout) } if not isinstance(integrations_conf, list): integrations_conf = [integrations_conf, ] if not isinstance(instance_names_conf, list): instance_names_conf = [instance_names_conf, ] has_skipped_integration, integrations, is_nightly_integration = collect_integrations( integrations_conf, skipped_integration, skipped_integrations_conf, nightly_integrations) skip_nightly_test = True if (nightly_test or is_nightly_integration) and not is_nightly else False # Skip nightly test if skip_nightly_test: print '------ Test %s start ------' % (test_message,) print 'Skip test' print '------ Test %s end ------' % (test_message,) continue if not run_all_tests: # Skip filtered test if is_filter_configured and playbook_id not in filterd_tests: continue # Skip bad test if playbook_id in skipped_tests_conf.keys(): skipped_tests.add("{0} - reason: {1}".format(playbook_id, skipped_tests_conf[playbook_id])) continue # Skip integration if has_skipped_integration: continue are_params_set = set_integration_params(demisto_api_key, integrations, secret_params, instance_names_conf, playbook_id) if not are_params_set: failed_playbooks.append(playbook_id) continue test_message = update_test_msg(integrations, test_message) run_test(c, failed_playbooks, integrations, playbook_id, succeed_playbooks, test_message, test_options, slack, CircleCI, buildNumber, server, build_name) print_test_summary(succeed_playbooks, failed_playbooks, skipped_tests, skipped_integration) create_result_files(failed_playbooks, skipped_integration, skipped_tests) os.remove(FILTER_CONF) if len(failed_playbooks): with open("./Tests/is_build_failed.txt", "w") as is_build_failed_file: is_build_failed_file.write('Build failed') sys.exit(1)
def execute_testing(server, server_ip, server_version): options = options_handler() username = options.user password = options.password conf_path = options.conf secret_conf_path = options.secret is_nightly = options.nightly slack = options.slack circle_ci = options.circleci build_number = options.buildNumber build_name = options.buildName if not (username and password and server): print_error('You must provide server user & password arguments') sys.exit(1) c = demisto.DemistoClient(None, server, username, password) res = c.Login() if res.status_code != 200: print_error("Login has failed with status code " + str(res.status_code)) sys.exit(1) demisto_api_key = generate_demisto_api_key(c) conf, secret_conf = load_conf_files(conf_path, secret_conf_path) default_test_timeout = conf.get('testTimeout', 30) tests = conf['tests'] skipped_tests_conf = conf['skipped_tests'] nightly_integrations = conf['nigthly_integrations'] skipped_integrations_conf = conf['skipped_integrations'] unmockable_integrations = conf['unmockable_integrations'] secret_params = secret_conf['integrations'] if secret_conf else [] filtered_tests, is_filter_configured, run_all_tests = extract_filtered_tests( ) if is_filter_configured and not run_all_tests: is_nightly = True if not tests or len(tests) == 0: print('no integrations are configured for test') return ami = AMIConnection(server_ip) ami.clone_mock_data() proxy = MITMProxy(c, server_ip) failed_playbooks = [] succeed_playbooks = [] skipped_tests = set([]) skipped_integration = set([]) # move all mock tests to the top of the list tests = organize_tests(tests, unmockable_integrations) for t in tests: playbook_id = t['playbookID'] nightly_test = t.get('nightly', False) integrations_conf = t.get('integrations', []) instance_names_conf = t.get('instance_names', []) test_message = 'playbook: ' + playbook_id test_options = {'timeout': t.get('timeout', default_test_timeout)} if not isinstance(integrations_conf, list): integrations_conf = [ integrations_conf, ] if not isinstance(instance_names_conf, list): instance_names_conf = [ instance_names_conf, ] has_skipped_integration, integrations, is_nightly_integration = collect_integrations( integrations_conf, skipped_integration, skipped_integrations_conf, nightly_integrations) skip_nightly_test = True if (nightly_test or is_nightly_integration ) and not is_nightly else False # Skip nightly test if skip_nightly_test: print '------ Test %s start ------' % (test_message, ) print 'Skip test' print '------ Test %s end ------' % (test_message, ) continue if not run_all_tests: # Skip filtered test if is_filter_configured and playbook_id not in filtered_tests: continue # Skip bad test if playbook_id in skipped_tests_conf.keys(): skipped_tests.add("{0} - reason: {1}".format( playbook_id, skipped_tests_conf[playbook_id])) continue # Skip integration if has_skipped_integration: continue are_params_set = set_integration_params(demisto_api_key, integrations, secret_params, instance_names_conf, playbook_id) if not are_params_set: failed_playbooks.append(playbook_id) continue test_message = update_test_msg(integrations, test_message) run_test(c, proxy, failed_playbooks, integrations, unmockable_integrations, playbook_id, succeed_playbooks, test_message, test_options, slack, circle_ci, build_number, server, build_name) print_test_summary(succeed_playbooks, failed_playbooks, skipped_tests, skipped_integration, unmockable_integrations, proxy) create_result_files(failed_playbooks, skipped_integration, skipped_tests) if build_name == 'master': print "Pushing new/updated mock files to mock git repo." ami.upload_mock_files(build_name, build_number) if len(failed_playbooks): file_path = "./Tests/is_build_failed_{}.txt".format( server_version.replace(' ', '')) with open(file_path, "w") as is_build_failed_file: is_build_failed_file.write('Build failed') sys.exit(1)
def main(): options = options_handler() username = options.user password = options.password server = options.server conf_path = options.conf secret_conf_path = options.secret is_nightly = options.nightly if not (username and password and server): print_error('You must provide server user & password arguments') exit(1) c = demisto.DemistoClient(None, server, username, password) res = c.Login() if res.status_code is not 200: print_error("Login has failed with status code " + str(res.status_code)) exit(1) with open(conf_path) as data_file: conf = json.load(data_file) secret_conf = None if secret_conf_path: with open(secret_conf_path) as data_file: secret_conf = json.load(data_file) integrations = conf['integrations'] secret_integrations = secret_conf['integrations'] if secret_conf else [] if not integrations or len(integrations) is 0: print('no integrations are configured for test') return succeed_playbooks = [] failed_playbooks = [] for integration in integrations: test_options = { 'timeout': integration['timeout'] if 'timeout' in integration else conf.get( 'testTimeout', 30), 'interval': conf.get('testInterval', 10) } integration_name = integration.get('name', None) playbook_id = integration['playbookID'] if 'params' in integration: integration_params = integration['params'] else: # get from secret conf secret_integration_match = [ item for item in secret_integrations if item["name"] == integration_name ] if len(secret_integration_match) > 0: integration_params = secret_integration_match[0].get('params') else: integration_params = {} if integration_name: test_message = 'integration: ' + integration_name + ' with playbook: ' + playbook_id else: test_message = 'playbook: ' + playbook_id print '------ Test %s start ------' % (test_message, ) nightly_test = integration.get('nightly', False) is_byoi = integration.get('byoi', True) skip_test = True if nightly_test and not is_nightly else False if skip_test: print 'Skip test' else: # run test succeed = test_integration(c, integration_name, integration_params, playbook_id, is_byoi, test_options) # use results if succeed: print 'PASS: %s succeed' % (test_message, ) succeed_playbooks.append(playbook_id) else: print 'Failed: %s failed' % (test_message, ) failed_playbooks.append(playbook_id) print '------ Test %s end ------' % (test_message, ) print_test_summary(succeed_playbooks, failed_playbooks) if len(failed_playbooks): sys.exit(1)