Пример #1
0
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()
Пример #2
0
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()
Пример #3
0
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()
Пример #4
0
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()
Пример #5
0
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()