def test_run(debug_session, pyfile, run_as): @pyfile def code_to_debug(): import os import sys import backchannel print('begin') assert backchannel.read_json() == 'continue' backchannel.write_json(os.path.abspath(sys.modules['ptvsd'].__file__)) print('end') if run_as == 'file': debug_session.prepare_to_run(filename=code_to_debug, backchannel=True) elif run_as == 'module': debug_session.add_file_to_pythonpath(code_to_debug) debug_session.prepare_to_run(module='code_to_debug', backchannel=True) elif run_as == 'code': with open(code_to_debug, 'r') as f: code = f.read() debug_session.prepare_to_run(code=code, backchannel=True) else: pytest.fail() debug_session.start_debugging() assert debug_session.timeline.is_frozen process_event, = debug_session.all_occurrences_of(Event('process')) assert process_event == Event( 'process', ANY.dict_with({ 'name': ANY if run_as == 'code' else ANY.such_that(lambda name: ( # There can be a difference in file extension (.py/.pyc/.pyo) on clean runs. name == code_to_debug or name == code_to_debug + 'c' or name == code_to_debug + 'o')), })) debug_session.write_json('continue') ptvsd_path = debug_session.read_json() expected_ptvsd_path = os.path.abspath(ptvsd.__file__) assert (ptvsd_path == expected_ptvsd_path or ptvsd_path == expected_ptvsd_path + 'c' or ptvsd_path == expected_ptvsd_path + 'o') debug_session.wait_for_exit()
def test_run(pyfile, run_as, start_method): @pyfile def code_to_debug(): import os import sys import backchannel from dbgimporter import import_and_enable_debugger import_and_enable_debugger() print('begin') assert backchannel.read_json() == 'continue' backchannel.write_json(os.path.abspath(sys.modules['ptvsd'].__file__)) print('end') with DebugSession() as session: session.initialize(target=(run_as, code_to_debug), start_method=start_method, use_backchannel=True) session.start_debugging() assert session.timeline.is_frozen process_event, = session.all_occurrences_of(Event('process')) assert process_event == Event( 'process', ANY.dict_with({ 'name': ANY if run_as == 'code' else ANY.such_that(lambda name: ( # There can be a difference in file extension (.py/.pyc/.pyo) on clean runs. name == code_to_debug or name == code_to_debug + 'c' or name == code_to_debug + 'o')), })) session.write_json('continue') ptvsd_path = session.read_json() expected_ptvsd_path = os.path.abspath(ptvsd.__file__) assert (ptvsd_path == expected_ptvsd_path or ptvsd_path == expected_ptvsd_path + 'c' or ptvsd_path == expected_ptvsd_path + 'o') session.wait_for_exit()
def test_flask_breakpoint_no_multiproc(bp_target, start_method): bp_file, bp_line, bp_name = { 'code': (FLASK1_APP, 11, 'home'), 'template': (FLASK1_TEMPLATE, 8, 'template') }[bp_target] with DebugSession() as session: _initialize_flask_session_no_multiproc(session, start_method) bp_var_content = 'Flask-Jinja-Test' session.set_breakpoints(bp_file, [bp_line]) session.start_debugging() # wait for Flask web server to start wait_for_connection(FLASK_PORT) link = FLASK_LINK web_request = get_web_content(link, {}) thread_stopped = session.wait_for_next( Event('stopped'), ANY.dict_with({'reason': 'breakpoint'})) assert thread_stopped.body['threadId'] is not None tid = thread_stopped.body['threadId'] resp_stacktrace = session.send_request('stackTrace', arguments={ 'threadId': tid, }).wait_for_response() assert resp_stacktrace.body['totalFrames'] > 0 frames = resp_stacktrace.body['stackFrames'] assert frames[0] == { 'id': ANY.int, 'name': bp_name, 'source': { 'sourceReference': ANY.int, 'path': ANY.such_that(lambda s: compare_path(s, bp_file)), }, 'line': bp_line, 'column': 1, } fid = frames[0]['id'] resp_scopes = session.send_request('scopes', arguments={ 'frameId': fid }).wait_for_response() scopes = resp_scopes.body['scopes'] assert len(scopes) > 0 resp_variables = session.send_request( 'variables', arguments={ 'variablesReference': scopes[0]['variablesReference'] }).wait_for_response() variables = list(v for v in resp_variables.body['variables'] if v['name'] == 'content') assert variables == [{ 'name': 'content', 'type': 'str', 'value': repr(bp_var_content), 'presentationHint': { 'attributes': ['rawString'] }, 'evaluateName': 'content' }] session.send_request('continue').wait_for_response(freeze=False) web_content = web_request.wait_for_response() assert web_content.find(bp_var_content) != -1 # shutdown to web server link = FLASK_LINK + 'exit' get_web_content(link).wait_for_response() session.wait_for_exit()
def test_flask_breakpoint_multiproc(start_method): env = { 'FLASK_APP': 'app', 'FLASK_ENV': 'development', 'FLASK_DEBUG': '1', } if platform.system() != 'Windows': locale = 'en_US.utf8' if platform.system( ) == 'Linux' else 'en_US.UTF-8' env.update({ 'LC_ALL': locale, 'LANG': locale, }) with DebugSession() as parent_session: parent_session.initialize( start_method=start_method, target=('module', 'flask'), multiprocess=True, program_args=[ 'run', ], ignore_unobserved=[Event('stopped'), Event('continued')], debug_options=['Jinja'], cwd=FLASK1_ROOT, env=env, expected_returncode=ANY.int, # No clean way to kill Flask server ) bp_line = 11 bp_var_content = 'Flask-Jinja-Test' parent_session.set_breakpoints(FLASK1_APP, [bp_line]) parent_session.start_debugging() with parent_session.connect_to_next_child_session() as child_session: child_session.send_request('setBreakpoints', arguments={ 'source': { 'path': FLASK1_APP }, 'breakpoints': [ { 'line': bp_line }, ], }).wait_for_response() child_session.start_debugging() # wait for Flask server to start wait_for_connection(FLASK_PORT) web_request = get_web_content(FLASK_LINK, {}) thread_stopped = child_session.wait_for_next( Event('stopped', ANY.dict_with({'reason': 'breakpoint'}))) assert thread_stopped.body['threadId'] is not None tid = thread_stopped.body['threadId'] resp_stacktrace = child_session.send_request( 'stackTrace', arguments={ 'threadId': tid, }).wait_for_response() assert resp_stacktrace.body['totalFrames'] > 0 frames = resp_stacktrace.body['stackFrames'] assert frames[0] == { 'id': ANY.int, 'name': 'home', 'source': { 'sourceReference': ANY.int, 'path': ANY.such_that(lambda s: compare_path(s, FLASK1_APP)), }, 'line': bp_line, 'column': 1, } fid = frames[0]['id'] resp_scopes = child_session.send_request('scopes', arguments={ 'frameId': fid }).wait_for_response() scopes = resp_scopes.body['scopes'] assert len(scopes) > 0 resp_variables = child_session.send_request( 'variables', arguments={ 'variablesReference': scopes[0]['variablesReference'] }).wait_for_response() variables = [ v for v in resp_variables.body['variables'] if v['name'] == 'content' ] assert variables == [{ 'name': 'content', 'type': 'str', 'value': repr(bp_var_content), 'presentationHint': { 'attributes': ['rawString'] }, 'evaluateName': 'content' }] child_session.send_request('continue').wait_for_response( freeze=False) web_content = web_request.wait_for_response() assert web_content.find(bp_var_content) != -1 # shutdown to web server link = FLASK_LINK + 'exit' get_web_content(link).wait_for_response() child_session.wait_for_termination() parent_session.wait_for_exit()
def test_flask_exception_no_multiproc(ex_type, start_method): ex_line = { 'handled': 21, 'unhandled': 33, }[ex_type] with DebugSession() as session: _initialize_flask_session_no_multiproc(session, start_method) session.send_request('setExceptionBreakpoints', arguments={ 'filters': ['raised', 'uncaught'], }).wait_for_response() session.start_debugging() # wait for Flask web server to start wait_for_connection(FLASK_PORT) base_link = FLASK_LINK link = base_link + ex_type if base_link.endswith('/') else ('/' + ex_type) web_request = get_web_content(link, {}) thread_stopped = session.wait_for_next( Event('stopped', ANY.dict_with({'reason': 'exception'}))) assert thread_stopped == Event( 'stopped', ANY.dict_with({ 'reason': 'exception', 'text': ANY.such_that(lambda s: s.endswith('ArithmeticError')), 'description': 'Hello' })) tid = thread_stopped.body['threadId'] resp_exception_info = session.send_request('exceptionInfo', arguments={ 'threadId': tid, }).wait_for_response() exception = resp_exception_info.body assert exception == { 'exceptionId': ANY.such_that(lambda s: s.endswith('ArithmeticError')), 'breakMode': 'always', 'description': 'Hello', 'details': { 'message': 'Hello', 'typeName': ANY.such_that(lambda s: s.endswith('ArithmeticError')), 'source': ANY.such_that(lambda s: compare_path(s, FLASK1_APP)), 'stackTrace': ANY.such_that(lambda s: True) } } resp_stacktrace = session.send_request('stackTrace', arguments={ 'threadId': tid, }).wait_for_response() assert resp_stacktrace.body['totalFrames'] > 0 frames = resp_stacktrace.body['stackFrames'] assert frames[0] == { 'id': ANY.int, 'name': 'bad_route_' + ex_type, 'source': { 'sourceReference': ANY.int, 'path': ANY.such_that(lambda s: compare_path(s, FLASK1_APP)), }, 'line': ex_line, 'column': 1, } session.send_request('continue').wait_for_response(freeze=False) # ignore response for exception tests web_request.wait_for_response() # shutdown to web server link = base_link + 'exit' if base_link.endswith('/') else '/exit' get_web_content(link).wait_for_response() session.wait_for_exit()
def test_variables_and_evaluate(debug_session, pyfile, run_as, start_method): @pyfile def code_to_debug(): from dbgimporter import import_and_enable_debugger import_and_enable_debugger() a = 1 b = {"one": 1, "two": 2} c = 3 print([a, b, c]) bp_line = 6 bp_file = code_to_debug debug_session.initialize(target=(run_as, bp_file), start_method=start_method) debug_session.set_breakpoints(bp_file, [bp_line]) debug_session.start_debugging() hit = debug_session.wait_for_thread_stopped() resp_scopes = debug_session.send_request('scopes', arguments={ 'frameId': hit.frame_id, }).wait_for_response() scopes = resp_scopes.body['scopes'] assert len(scopes) > 0 resp_variables = debug_session.send_request( 'variables', arguments={ 'variablesReference': scopes[0]['variablesReference'] }).wait_for_response() variables = list(v for v in resp_variables.body['variables'] if v['name'] in ['a', 'b', 'c']) assert len(variables) == 3 # variables should be sorted alphabetically assert ['a', 'b', 'c'] == list(v['name'] for v in variables) # get contents of 'b' resp_b_variables = debug_session.send_request( 'variables', arguments={ 'variablesReference': variables[1]['variablesReference'] }).wait_for_response() b_variables = resp_b_variables.body['variables'] assert len(b_variables) == 3 assert b_variables[0] == { 'type': 'int', 'value': '1', 'name': ANY.such_that(lambda x: x.find('one') > 0), 'evaluateName': "b['one']" } assert b_variables[1] == { 'type': 'int', 'value': '2', 'name': ANY.such_that(lambda x: x.find('two') > 0), 'evaluateName': "b['two']" } assert b_variables[2] == { 'type': 'int', 'value': '2', 'name': '__len__', 'evaluateName': "b.__len__" } # simple variable resp_evaluate1 = debug_session.send_request('evaluate', arguments={ 'expression': 'a', 'frameId': hit.frame_id, }).wait_for_response() assert resp_evaluate1.body == ANY.dict_with({'type': 'int', 'result': '1'}) # dict variable resp_evaluate2 = debug_session.send_request('evaluate', arguments={ 'expression': 'b["one"]', 'frameId': hit.frame_id, }).wait_for_response() assert resp_evaluate2.body == ANY.dict_with({'type': 'int', 'result': '1'}) # expression evaluate resp_evaluate3 = debug_session.send_request('evaluate', arguments={ 'expression': 'a + b["one"]', 'frameId': hit.frame_id, }).wait_for_response() assert resp_evaluate3.body == ANY.dict_with({'type': 'int', 'result': '2'}) debug_session.send_request('continue').wait_for_response() debug_session.wait_for_next(Event('continued')) debug_session.wait_for_exit()
def test_return_values(pyfile, run_as, start_method): @pyfile def code_to_debug(): from dbgimporter import import_and_enable_debugger import_and_enable_debugger() class MyClass(object): def do_something(self): return 'did something' def my_func(): return 'did more things' MyClass().do_something() my_func() print('done') expected1 = ANY.dict_with({ 'name': '(return) MyClass.do_something', 'value': "'did something'", 'type': 'str', 'presentationHint': ANY.dict_with({'attributes': ANY.such_that(lambda x: 'readOnly' in x)}), }) expected2 = ANY.dict_with({ 'name': '(return) my_func', 'value': "'did more things'", 'type': 'str', 'presentationHint': ANY.dict_with({'attributes': ANY.such_that(lambda x: 'readOnly' in x)}), }) with DebugSession() as session: session.initialize(target=(run_as, code_to_debug), start_method=start_method, debug_options=['ShowReturnValue'], ignore_unobserved=[Event('continued')]) session.set_breakpoints(code_to_debug, [8]) session.start_debugging() hit = session.wait_for_thread_stopped() session.send_request('next', { 'threadId': hit.thread_id }).wait_for_response() hit = session.wait_for_thread_stopped(reason='step') resp_scopes = session.send_request('scopes', arguments={ 'frameId': hit.frame_id }).wait_for_response() scopes = resp_scopes.body['scopes'] assert len(scopes) > 0 resp_variables = session.send_request( 'variables', arguments={ 'variablesReference': scopes[0]['variablesReference'] }).wait_for_response() variables = list(v for v in resp_variables.body['variables'] if v['name'].startswith('(return)')) assert variables == [expected1] session.send_request('next', { 'threadId': hit.thread_id }).wait_for_response() hit = session.wait_for_thread_stopped(reason='step') # Scope should not have changed so use the same scope resp_variables = session.send_request( 'variables', arguments={ 'variablesReference': scopes[0]['variablesReference'] }).wait_for_response() variables = list(v for v in resp_variables.body['variables'] if v['name'].startswith('(return)')) assert variables == [expected1, expected2] session.send_request('continue').wait_for_response() session.wait_for_exit()
def test_django_breakpoint_no_multiproc(debug_session, bp_file, bp_line, bp_name, start_method): debug_session.initialize( start_method=start_method, target=('file', DJANGO1_MANAGE), program_args=['runserver', '--noreload', '--nothreading'], debug_options=['Django'], cwd=DJANGO1_ROOT, expected_returncode=ANY.int, # No clean way to kill Flask server ) bp_var_content = 'Django-Django-Test' debug_session.set_breakpoints(bp_file, [bp_line]) debug_session.start_debugging() # wait for Django server to start wait_for_connection(DJANGO_PORT) web_request = get_web_content(DJANGO_LINK, {}) thread_stopped = debug_session.wait_for_next( Event('stopped', ANY.dict_with({'reason': 'breakpoint'}))) assert thread_stopped.body['threadId'] is not None tid = thread_stopped.body['threadId'] resp_stacktrace = debug_session.send_request('stackTrace', arguments={ 'threadId': tid, }).wait_for_response() assert resp_stacktrace.body['totalFrames'] > 1 frames = resp_stacktrace.body['stackFrames'] assert frames[0] == { 'id': 1, 'name': bp_name, 'source': { 'sourceReference': ANY, 'path': ANY.such_that(lambda s: compare_path(s, bp_file)), }, 'line': bp_line, 'column': 1, } fid = frames[0]['id'] resp_scopes = debug_session.send_request('scopes', arguments={ 'frameId': fid }).wait_for_response() scopes = resp_scopes.body['scopes'] assert len(scopes) > 0 resp_variables = debug_session.send_request( 'variables', arguments={ 'variablesReference': scopes[0]['variablesReference'] }).wait_for_response() variables = list(v for v in resp_variables.body['variables'] if v['name'] == 'content') assert variables == [{ 'name': 'content', 'type': 'str', 'value': repr(bp_var_content), 'presentationHint': { 'attributes': ['rawString'] }, 'evaluateName': 'content' }] debug_session.send_request('continue').wait_for_response() debug_session.wait_for_next(Event('continued')) web_content = web_request.wait_for_response() assert web_content.find(bp_var_content) != -1 # shutdown to web server link = DJANGO_LINK + 'exit' get_web_content(link).wait_for_response()
def test_django_breakpoint_multiproc(debug_session, start_method): debug_session.initialize( start_method=start_method, target=('file', DJANGO1_MANAGE), multiprocess=True, program_args=[ 'runserver', ], debug_options=['Django'], cwd=DJANGO1_ROOT, ignore_events=[Event('stopped'), Event('continued')], expected_returncode=ANY.int, # No clean way to kill Flask server ) bp_line = 40 bp_var_content = 'Django-Django-Test' debug_session.set_breakpoints(DJANGO1_MANAGE, [bp_line]) debug_session.start_debugging() child_session = _wait_for_child_process(debug_session) child_session.send_request('setBreakpoints', arguments={ 'source': { 'path': DJANGO1_MANAGE }, 'breakpoints': [ { 'line': bp_line }, ], }).wait_for_response() child_session.start_debugging() # wait for Django server to start while True: child_session.proceed() o = child_session.wait_for_next(Event('output')) if get_url_from_str(o.body['output']) is not None: break web_request = get_web_content(DJANGO_LINK, {}) thread_stopped = child_session.wait_for_next( Event('stopped', ANY.dict_with({'reason': 'breakpoint'}))) assert thread_stopped.body['threadId'] is not None tid = thread_stopped.body['threadId'] resp_stacktrace = child_session.send_request('stackTrace', arguments={ 'threadId': tid, }).wait_for_response() assert resp_stacktrace.body['totalFrames'] > 0 frames = resp_stacktrace.body['stackFrames'] assert frames[0] == { 'id': ANY.int, 'name': 'home', 'source': { 'sourceReference': ANY.int, 'path': ANY.such_that(lambda s: compare_path(s, DJANGO1_MANAGE)), }, 'line': bp_line, 'column': 1, } fid = frames[0]['id'] resp_scopes = child_session.send_request('scopes', arguments={ 'frameId': fid }).wait_for_response() scopes = resp_scopes.body['scopes'] assert len(scopes) > 0 resp_variables = child_session.send_request( 'variables', arguments={ 'variablesReference': scopes[0]['variablesReference'] }).wait_for_response() variables = list(v for v in resp_variables.body['variables'] if v['name'] == 'content') assert variables == [{ 'name': 'content', 'type': 'str', 'value': repr(bp_var_content), 'presentationHint': { 'attributes': ['rawString'] }, 'evaluateName': 'content' }] child_session.send_request('continue').wait_for_response() child_session.wait_for_next(Event('continued')) web_content = web_request.wait_for_response() assert web_content.find(bp_var_content) != -1 # shutdown to web server link = DJANGO_LINK + 'exit' get_web_content(link).wait_for_response()
def test_django_exception_no_multiproc(debug_session, ex_type, ex_line, start_method): debug_session.initialize( start_method=start_method, target=('file', DJANGO1_MANAGE), program_args=['runserver', '--noreload', '--nothreading'], debug_options=['Django'], cwd=DJANGO1_ROOT, expected_returncode=ANY.int, # No clean way to kill Flask server ) debug_session.send_request('setExceptionBreakpoints', arguments={ 'filters': ['raised', 'uncaught'], }).wait_for_response() debug_session.start_debugging() wait_for_connection(DJANGO_PORT) base_link = DJANGO_LINK link = base_link + ex_type if base_link.endswith('/') else ('/' + ex_type) web_request = get_web_content(link, {}) thread_stopped = debug_session.wait_for_next( Event('stopped', ANY.dict_with({'reason': 'exception'}))) assert thread_stopped == Event( 'stopped', ANY.dict_with({ 'reason': 'exception', 'text': ANY.such_that(lambda s: s.endswith('ArithmeticError')), 'description': 'Hello' })) tid = thread_stopped.body['threadId'] resp_exception_info = debug_session.send_request('exceptionInfo', arguments={ 'threadId': tid, }).wait_for_response() exception = resp_exception_info.body assert exception == { 'exceptionId': ANY.such_that(lambda s: s.endswith('ArithmeticError')), 'breakMode': 'always', 'description': 'Hello', 'details': { 'message': 'Hello', 'typeName': ANY.such_that(lambda s: s.endswith('ArithmeticError')), 'source': ANY.such_that(lambda s: compare_path(s, DJANGO1_MANAGE)), 'stackTrace': ANY.such_that(lambda s: True), } } resp_stacktrace = debug_session.send_request('stackTrace', arguments={ 'threadId': tid, }).wait_for_response() assert resp_stacktrace.body['totalFrames'] > 1 frames = resp_stacktrace.body['stackFrames'] assert frames[0] == { 'id': ANY, 'name': 'bad_route_' + ex_type, 'source': { 'sourceReference': ANY, 'path': ANY.such_that(lambda s: compare_path(s, DJANGO1_MANAGE)), }, 'line': ex_line, 'column': 1, } debug_session.send_request('continue').wait_for_response() debug_session.wait_for_next(Event('continued')) # ignore response for exception tests web_request.wait_for_response() # shutdown to web server link = base_link + 'exit' if base_link.endswith('/') else '/exit' get_web_content(link).wait_for_response()
def test_vsc_exception_options_raise_without_except(pyfile, run_as, start_method, raised, uncaught): @pyfile def code_to_debug(): from dbgimporter import import_and_enable_debugger import_and_enable_debugger() def raise_without_except(): raise ArithmeticError('bad code') raise_without_except() ex_line = 4 filters = [] filters += ['raised'] if raised == 'raisedOn' else [] filters += ['uncaught'] if uncaught == 'uncaughtOn' else [] with DebugSession() as session: session.initialize( target=(run_as, code_to_debug), start_method=start_method, ignore_unobserved=[Event('continued'), Event('stopped')], expected_returncode=ANY.int, ) session.send_request('setExceptionBreakpoints', { 'filters': filters }).wait_for_response() session.start_debugging() expected = ANY.dict_with({ 'exceptionId': ANY.such_that(lambda s: s.endswith('ArithmeticError')), 'description': 'bad code', 'breakMode': 'always' if raised == 'raisedOn' else 'unhandled', 'details': ANY.dict_with({ 'typeName': ANY.such_that(lambda s: s.endswith('ArithmeticError')), 'message': 'bad code', 'source': ANY.such_that(lambda s: compare_path(code_to_debug, s)), }), }) if raised == 'raisedOn': hit = session.wait_for_thread_stopped(reason='exception') frames = hit.stacktrace.body['stackFrames'] assert ex_line == frames[0]['line'] resp_exc_info = session.send_request('exceptionInfo', { 'threadId': hit.thread_id }).wait_for_response() assert resp_exc_info.body == expected session.send_request('continue').wait_for_response(freeze=False) # NOTE: debugger stops at each frame if raised and is uncaught # This behavior can be changed by updating 'notify_on_handled_exceptions' # setting we send to pydevd to notify only once. In our test code, we have # two frames, hence two stops. session.wait_for_thread_stopped(reason='exception') session.send_request('continue').wait_for_response(freeze=False) if uncaught == 'uncaughtOn': hit = session.wait_for_thread_stopped(reason='exception') frames = hit.stacktrace.body['stackFrames'] assert ex_line == frames[0]['line'] resp_exc_info = session.send_request('exceptionInfo', { 'threadId': hit.thread_id }).wait_for_response() assert resp_exc_info.body == expected session.send_request('continue').wait_for_response(freeze=False) session.wait_for_exit()
def test_vsc_exception_options_raise_with_except(pyfile, run_as, start_method, raised, uncaught): @pyfile def code_to_debug(): from dbgimporter import import_and_enable_debugger import_and_enable_debugger() def raise_with_except(): try: raise ArithmeticError('bad code') except Exception: pass raise_with_except() ex_line = 5 filters = [] filters += ['raised'] if raised == 'raisedOn' else [] filters += ['uncaught'] if uncaught == 'uncaughtOn' else [] with DebugSession() as session: session.initialize( target=(run_as, code_to_debug), start_method=start_method, ignore_unobserved=[Event('continued')], ) session.send_request('setExceptionBreakpoints', { 'filters': filters }).wait_for_response() session.start_debugging() expected = ANY.dict_with({ 'exceptionId': ANY.such_that(lambda s: s.endswith('ArithmeticError')), 'description': 'bad code', 'breakMode': 'always' if raised == 'raisedOn' else 'unhandled', 'details': ANY.dict_with({ 'typeName': ANY.such_that(lambda s: s.endswith('ArithmeticError')), 'message': 'bad code', 'source': ANY.such_that(lambda s: compare_path(code_to_debug, s)), }), }) if raised == 'raisedOn': hit = session.wait_for_thread_stopped(reason='exception') frames = hit.stacktrace.body['stackFrames'] assert ex_line == frames[0]['line'] resp_exc_info = session.send_request('exceptionInfo', { 'threadId': hit.thread_id }).wait_for_response() assert resp_exc_info.body == expected session.send_request('continue').wait_for_response(freeze=False) # uncaught should not 'stop' matter since the exception is caught session.wait_for_exit()
def test_variables_and_evaluate(debug_session, simple_hit_paused_on_break): hit = simple_hit_paused_on_break resp_scopes = debug_session.send_request('scopes', arguments={ 'frameId': hit.frame_id, }).wait_for_response() scopes = resp_scopes.body['scopes'] assert len(scopes) > 0 resp_variables = debug_session.send_request( 'variables', arguments={ 'variablesReference': scopes[0]['variablesReference'] }).wait_for_response() variables = list(v for v in resp_variables.body['variables'] if v['name'] in ['a', 'b', 'c']) assert len(variables) == 3 # variables should be sorted alphabetically assert ['a', 'b', 'c'] == list(v['name'] for v in variables) # get contents of 'b' resp_b_variables = debug_session.send_request( 'variables', arguments={ 'variablesReference': variables[1]['variablesReference'] }).wait_for_response() b_variables = resp_b_variables.body['variables'] assert len(b_variables) == 3 assert b_variables[0] == { 'type': 'int', 'value': '1', 'name': ANY.such_that(lambda x: x.find('one') > 0), 'evaluateName': "b['one']" } assert b_variables[1] == { 'type': 'int', 'value': '2', 'name': ANY.such_that(lambda x: x.find('two') > 0), 'evaluateName': "b['two']" } assert b_variables[2] == { 'type': 'int', 'value': '2', 'name': '__len__', 'evaluateName': "b.__len__" } # simple variable resp_evaluate1 = debug_session.send_request('evaluate', arguments={ 'expression': 'a', 'frameId': hit.frame_id, }).wait_for_response() assert resp_evaluate1.body == ANY.dict_with({'type': 'int', 'result': '1'}) # dict variable resp_evaluate2 = debug_session.send_request('evaluate', arguments={ 'expression': 'b["one"]', 'frameId': hit.frame_id, }).wait_for_response() assert resp_evaluate2.body == ANY.dict_with({'type': 'int', 'result': '1'}) # expression evaluate resp_evaluate3 = debug_session.send_request('evaluate', arguments={ 'expression': 'a + b["one"]', 'frameId': hit.frame_id, }).wait_for_response() assert resp_evaluate3.body == ANY.dict_with({'type': 'int', 'result': '2'})
def test_variables_and_evaluate(debug_session, pyfile, run_as): @pyfile def code_to_debug(): a = 1 b = {"one": 1, "two": 2} c = 3 print([a, b, c]) bp_line = 4 bp_file = code_to_debug _common_setup(debug_session, bp_file, run_as) debug_session.send_request('setBreakpoints', arguments={ 'source': { 'path': bp_file }, 'breakpoints': [ { 'line': bp_line }, ], }).wait_for_response() debug_session.start_debugging() thread_stopped = debug_session.wait_for_next( Event('stopped'), ANY.dict_with({'reason': 'breakpoint'})) assert thread_stopped.body['threadId'] is not None tid = thread_stopped.body['threadId'] resp_stacktrace = debug_session.send_request('stackTrace', arguments={ 'threadId': tid, }).wait_for_response() assert resp_stacktrace.body['totalFrames'] > 0 frames = resp_stacktrace.body['stackFrames'] fid = frames[0]['id'] resp_scopes = debug_session.send_request('scopes', arguments={ 'frameId': fid }).wait_for_response() scopes = resp_scopes.body['scopes'] assert len(scopes) > 0 resp_variables = debug_session.send_request( 'variables', arguments={ 'variablesReference': scopes[0]['variablesReference'] }).wait_for_response() variables = list(v for v in resp_variables.body['variables'] if v['name'] in ['a', 'b', 'c']) assert len(variables) == 3 # variables should be sorted alphabetically assert ['a', 'b', 'c'] == list(v['name'] for v in variables) # get contents of 'b' resp_b_variables = debug_session.send_request( 'variables', arguments={ 'variablesReference': variables[1]['variablesReference'] }).wait_for_response() b_variables = resp_b_variables.body['variables'] assert len(b_variables) == 3 assert b_variables[0] == { 'type': 'int', 'value': '1', 'name': ANY.such_that(lambda x: x.find('one') > 0), 'evaluateName': "b['one']" } assert b_variables[1] == { 'type': 'int', 'value': '2', 'name': ANY.such_that(lambda x: x.find('two') > 0), 'evaluateName': "b['two']" } assert b_variables[2] == { 'type': 'int', 'value': '2', 'name': '__len__', 'evaluateName': "b.__len__" } # simple variable resp_evaluate1 = debug_session.send_request('evaluate', arguments={ 'expression': 'a', 'frameId': fid }).wait_for_response() assert resp_evaluate1.body == ANY.dict_with({'type': 'int', 'result': '1'}) # dict variable resp_evaluate2 = debug_session.send_request('evaluate', arguments={ 'expression': 'b["one"]', 'frameId': fid }).wait_for_response() assert resp_evaluate2.body == ANY.dict_with({'type': 'int', 'result': '1'}) # expression evaluate resp_evaluate3 = debug_session.send_request('evaluate', arguments={ 'expression': 'a + b["one"]', 'frameId': fid }).wait_for_response() assert resp_evaluate3.body == ANY.dict_with({'type': 'int', 'result': '2'}) debug_session.send_request('continue').wait_for_response() debug_session.wait_for_next(Event('continued')) debug_session.wait_for_exit()