rapydscript-ng 0.7.24 → 0.8.1

package/test/lint.pyj

@@ -2,15 +2,15 @@
 # License: BSD
 # Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
 
-linter = require('../tools/lint.js')
+linter = require('../tools/lint.mjs')
 
-def lint(code):
-    return linter.lint_code(code, {'filename':'<test>', 'report':def():
+async def lint(code):
+    return await linter.lint_code(code, {'filename':'<test>', 'report':def():
                                    pass
 })
 
-def err_test(code, ident, line, name, other_line):
-    msgs = lint(code)
+async def err_test(code, ident, line, name, other_line):
+    msgs = await lint(code)
     assrt.ok(len(msgs) > 0, 'failed to find error in: ' + code)
     assrt.equal(len(msgs), 1, 'found ' + (len(msgs) - 1) + ' extra errors in: ' + code)
     assrt.equal(msgs[0].ident, ident, 'incorrect ident: ' + msgs[0].ident + ' for: ' + code)
@@ -21,110 +21,111 @@ def err_test(code, ident, line, name, other_line):
     if other_line != undefined:
         assrt.equal(msgs[0].other_line, other_line, 'incorrect other_line: ' + msgs[0].other_line + ' for: ' + code)
 
-def ok_test(code):
-    msgs = lint(code)
+async def ok_test(code):
+    msgs = await lint(code)
     assrt.equal(msgs.length, 0, 'Got unexpected msg: ' + (msgs[0] or {}).message + ' for code: ' + code)
 
-# Imports
-err_test('import foo', 'unused-import', 1, 'foo')
-err_test('import foo.boo', 'unused-import', 1, 'foo')
-err_test('import foo as boo', 'unused-import', 1, 'boo')
-err_test('from x import foo', 'unused-import', 1, 'foo')
-err_test('from x import foo as boo', 'unused-import', 1, 'boo')
-ok_test('import foo\nfoo')
-
-# Function arguments
-ok_test('def f(a):\n return a')
-ok_test('def f(a=1):\n return a')
-ok_test('def f(*a):\n return a')
-ok_test('def f(**a):\n return a')
-ok_test('def f(a):\n return 1')
-
-# Extended slices
-ok_test('a = []; a[::2], a[1:-1]')
-
-# Top level unused ignored
-ok_test('a=1\ndef f():\n pass')
-
-# Destructuring assignment
-ok_test('def f():\n a, b = 1, 2; a, b')
-ok_test('def f():\n a = 1; b, c = a, 2; return b, c')
-ok_test('for x, (y, z) in [ [1, [2, 3]] ]:\n x + y + z')
-err_test('def f():\n a, b = 1, 1; return a', 'unused-local', 2, 'b')
-
-# Compound assignment
-err_test('a += 1', 'undef', 1, 'a')
-ok_test('def f():\n a = 1; a += 1')
-
-# Unused bindings
-err_test('def f():\n a=1', 'unused-local', 2, 'a')
-err_test('def f():\n def a():\n  pass', 'unused-local', 2, 'a')
-
-# Undefined references
-err_test('f()', 'undef', 1, 'f')
-err_test('a', 'undef', 1, 'a')
-err_test('def f():\n a=1; return a\na', 'undef', 3, 'a')
-
-# Comprehensions
-ok_test('[x for x in [1,2]]')
-ok_test('[1 for x in [1,2] if x]')
-ok_test('[1 for x in [1,2]]')
-ok_test('def f():\n l=[1,2];[x for x in l]')
-ok_test('def f():\n l=[1,2];{x:True for x in l}')
-err_test('def f():\n [x for x in [1,2]]; return x', 'undef', 2, 'x')
-
-# Loops
-ok_test('def f():\n for x in "":\n  pass\n return x')
-ok_test('def f():\n for x in "":\n  x += 1\n')
-ok_test('def f():\n for x, y in "":\n  pass\n return x, y')
-ok_test('for v"var i = 0; i < 1; i++":\n print(i)')
-err_test('def f():\n a = 1\n for a in "":\n  a', 'loop-shadowed', 3, 'a', 2)
-
-# Semi-colons
-err_test('a=1;;a', 'extra-semicolon', 1, ';')
-err_test('a=1;', 'eol-semicolon', 1, ';')
-ok_test('a = """\nhello;\n"""')
-ok_test("a = '''\nhello;\n'''")
-
-# Builtins
-for k in 'String Symbol this self window Map arguments print len range dir undefined'.split(' '):
-    ok_test(k)
-
-# noqa
-ok_test('f() # noqa')
-ok_test('f() # noqa:undef')
-err_test('f() # noqa:xxx', 'undef')
-
-# Named func in branch
-err_test('if 1:\n def f():\n  pass', 'func-in-branch', 2, 'f')
-err_test('if 1:\n pass\nelse:\n def f():\n  pass', 'func-in-branch', 4, 'f')
-err_test('try:\n def f():\n  pass\nexcept:\n pass', 'func-in-branch', 2, 'f')
-ok_test('if 1:\n a = def():\n  pass')
-
-# Syntax errors
-err_test('def f(:\n pass', 'syntax-err', 1)
-
-# Functions
-ok_test('def f():\n pass\nf()')
-
-# Non-locals
-err_test('def a():\n x = 1\n def b():\n  nonlocal x\n b()', 'unused-local', 2, 'x')
-ok_test('def a():\n x = 1\n def b():\n  nonlocal x\n  x\n b()')
-ok_test('def a():\n x = 1\n def b():\n  nonlocal x\n  x\n  x = 2\n b()')
-ok_test('def a():\n x = 1\n def ():\n  nonlocal x\n  x = 1\n  x')
-ok_test('nonlocal a\na()')
-
-# Define after use
-err_test('def g():\n f()\n f()\n def f():\n  pass', 'def-after-use', 3, 'f')
-
-# Decorators
-ok_test('from x import y\n@y\ndef f():\n pass')
-
-# try/except
-ok_test('try:\n 1\nexcept Error as e:\n e')
-
-# Classes
-ok_test('''
+async def run_tests():
+    # Imports
+    await err_test('import foo', 'unused-import', 1, 'foo')
+    await err_test('import foo.boo', 'unused-import', 1, 'foo')
+    await err_test('import foo as boo', 'unused-import', 1, 'boo')
+    await err_test('from x import foo', 'unused-import', 1, 'foo')
+    await err_test('from x import foo as boo', 'unused-import', 1, 'boo')
+    await ok_test('import foo\nfoo')
+
+    # Function arguments
+    await ok_test('def f(a):\n return a')
+    await ok_test('def f(a=1):\n return a')
+    await ok_test('def f(*a):\n return a')
+    await ok_test('def f(**a):\n return a')
+    await ok_test('def f(a):\n return 1')
+
+    # Extended slices
+    await ok_test('a = []; a[::2], a[1:-1]')
+
+    # Top level unused ignored
+    await ok_test('a=1\ndef f():\n pass')
+
+    # Destructuring assignment
+    await ok_test('def f():\n a, b = 1, 2; a, b')
+    await ok_test('def f():\n a = 1; b, c = a, 2; return b, c')
+    await ok_test('for x, (y, z) in [ [1, [2, 3]] ]:\n x + y + z')
+    await err_test('def f():\n a, b = 1, 1; return a', 'unused-local', 2, 'b')
+
+    # Compound assignment
+    await err_test('a += 1', 'undef', 1, 'a')
+    await ok_test('def f():\n a = 1; a += 1')
+
+    # Unused bindings
+    await err_test('def f():\n a=1', 'unused-local', 2, 'a')
+    await err_test('def f():\n def a():\n  pass', 'unused-local', 2, 'a')
+
+    # Undefined references
+    await err_test('f()', 'undef', 1, 'f')
+    await err_test('a', 'undef', 1, 'a')
+    await err_test('def f():\n a=1; return a\na', 'undef', 3, 'a')
+
+    # Comprehensions
+    await ok_test('[x for x in [1,2]]')
+    await ok_test('[1 for x in [1,2] if x]')
+    await ok_test('[1 for x in [1,2]]')
+    await ok_test('def f():\n l=[1,2];[x for x in l]')
+    await ok_test('def f():\n l=[1,2];{x:True for x in l}')
+    await err_test('def f():\n [x for x in [1,2]]; return x', 'undef', 2, 'x')
+
+    # Loops
+    await ok_test('def f():\n for x in "":\n  pass\n return x')
+    await ok_test('def f():\n for x in "":\n  x += 1\n')
+    await ok_test('def f():\n for x, y in "":\n  pass\n return x, y')
+    await ok_test('for v"var i = 0; i < 1; i++":\n print(i)')
+    await err_test('def f():\n a = 1\n for a in "":\n  a', 'loop-shadowed', 3, 'a', 2)
+
+    # Semi-colons
+    await err_test('a=1;;a', 'extra-semicolon', 1, ';')
+    await err_test('a=1;', 'eol-semicolon', 1, ';')
+    await ok_test('a = """\nhello;\n"""')
+    await ok_test("a = '''\nhello;\n'''")
+
+    # Builtins
+    for k in 'String Symbol this self window Map arguments print len range dir undefined'.split(' '):
+        await ok_test(k)
+
+    # noqa
+    await ok_test('f() # noqa')
+    await ok_test('f() # noqa:undef')
+    await err_test('f() # noqa:xxx', 'undef')
+
+    # Named func in branch
+    await err_test('if 1:\n def f():\n  pass', 'func-in-branch', 2, 'f')
+    await err_test('if 1:\n pass\nelse:\n def f():\n  pass', 'func-in-branch', 4, 'f')
+    await err_test('try:\n def f():\n  pass\nexcept:\n pass', 'func-in-branch', 2, 'f')
+    await ok_test('if 1:\n a = def():\n  pass')
+
+    # Syntax errors
+    await err_test('def f(:\n pass', 'syntax-err', 1)
+
+    # Functions
+    await ok_test('def f():\n pass\nf()')
+
+    # Non-locals
+    await err_test('def a():\n x = 1\n def b():\n  nonlocal x\n b()', 'unused-local', 2, 'x')
+    await ok_test('def a():\n x = 1\n def b():\n  nonlocal x\n  x\n b()')
+    await ok_test('def a():\n x = 1\n def b():\n  nonlocal x\n  x\n  x = 2\n b()')
+    await ok_test('def a():\n x = 1\n def ():\n  nonlocal x\n  x = 1\n  x')
+    await ok_test('nonlocal a\na()')
+
+    # Define after use
+    await err_test('def g():\n f()\n f()\n def f():\n  pass', 'def-after-use', 3, 'f')
+
+    # Decorators
+    await ok_test('from x import y\n@y\ndef f():\n pass')
+
+    # try/except
+    await ok_test('try:\n 1\nexcept Error as e:\n e')
+
+    # Classes
+    await ok_test('''
 class A:
 
     h = j = 1
@@ -146,21 +147,23 @@ class B(A):
     def __init__(self):
         A.__init__(self, 'b')
 ''')
-err_test('class A:\n def a(self):\n  a()', 'undef', 3, 'a')
-err_test('class A:\n def a(self):\n  pass\n def a(self):\n  pass', 'dup-method', 4, 'a')
+    await err_test('class A:\n def a(self):\n  a()', 'undef', 3, 'a')
+    await err_test('class A:\n def a(self):\n  pass\n def a(self):\n  pass', 'dup-method', 4, 'a')
 
-# Object literals
-err_test('{"a":1, "a":2}', 'dup-key', 1, 'a')
+    # Object literals
+    await err_test('{"a":1, "a":2}', 'dup-key', 1, 'a')
 
-# keyword arg values
-ok_test('def f():\n a=1\n f(b=a)')
-ok_test('def f():\n a={}\n f(**a)')
+    # keyword arg values
+    await ok_test('def f():\n a=1\n f(b=a)')
+    await ok_test('def f():\n a={}\n f(**a)')
 
-# with statement
-ok_test('''
+    # with statement
+    await ok_test('''
 def f():
     a = 1
     with a as b:
         b()
 ''')
-err_test('with a:\n pass', 'undef', '1', 'a')
+    await err_test('with a:\n pass', 'undef', '1', 'a')
+
+__test_async_done__ = run_tests()

package/test/lsp.pyj

@@ -0,0 +1,257 @@
+# globals: assrt, fs, require, test_path, compiler_dir, console, RapydScript
+
+# Tests for the "lsp" sub-command (tools/lsp.mjs), the RapydScript language
+# server. These drive the pure analysis functions directly (the same functions
+# the JSON-RPC layer calls) plus the parser's error-recovery mode.
+
+lsp = require('./lsp.mjs')
+path = require('path')
+os = require('os')
+url = require('url')
+
+base_path = path.resolve(compiler_dir, '..')
+libdir = path.join(base_path, 'src', 'lib')
+
+def uri_of(p):
+    return url.pathToFileURL(p).href
+
+def offset_of(text, needle, from_index):
+    return text.indexOf(needle, from_index or 0)
+
+def make_ctx(tmp):
+    return lsp.create_server_context({
+        'import_dirs': [tmp], 'libdir': libdir, 'workspace_roots': [tmp],
+        'line_length': 80, 'preferred_quote': 'single',
+    })
+
+def write_workspace():
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'rs-lsp-'))
+    fs.writeFileSync(path.join(tmp, 'util.pyj'),
+        'def helper(x):\n    return x + 1\n\nclass Widget:\n    def __init__(self):\n        self.n = 0\n')
+    fs.writeFileSync(path.join(tmp, 'main.pyj'),
+        'from util import helper\nimport util\n\ndef run():\n    w = util.Widget()\n    return helper(w)\n\nunused_var = 5\nmissing = undefined_thing()\nimport nonexistent_module\n')
+    return tmp
+
+def codes(diags):
+    ans = {}
+    for d in diags:
+        ans[d.code] = (ans[d.code] or 0) + 1
+    return ans
+
+async def test_diagnostics():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    diags = await lsp.compute_diagnostics(ctx, main_uri, text)
+    c = codes(diags)
+    assrt.ok(c['undef'], 'expected an undef diagnostic for undefined_thing')
+    assrt.ok(c['unused-import'], 'expected unused-import for nonexistent_module')
+    assrt.ok(c['import-unresolved'], 'expected import-unresolved for nonexistent_module')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_hover_and_definition():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    util_uri = uri_of(path.join(tmp, 'util.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    off = offset_of(text, 'helper(w)')
+    h = await lsp.hover(ctx, main_uri, text, off)
+    assrt.ok(h and h.contents.value.indexOf('helper') >= 0, 'hover should mention helper')
+
+    defs = await lsp.definition(ctx, main_uri, text, off)
+    assrt.ok(Array.isArray(defs) and defs.length >= 1, 'definition should return locations')
+    assrt.equal(defs[0].uri, util_uri, 'definition of helper should be in util.pyj')
+    assrt.equal(defs[0].range.start.line, 0, 'helper is defined on line 0 of util.pyj')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_cross_file_references():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    util_uri = uri_of(path.join(tmp, 'util.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    off = offset_of(text, 'helper(w)')
+    refs = await lsp.references(ctx, main_uri, text, off, True)
+    uris = {}
+    for r in refs:
+        uris[r.uri] = True
+    assrt.ok(uris[main_uri], 'references should include occurrences in main.pyj')
+    assrt.ok(uris[util_uri], 'references should include the definition file util.pyj')
+    assrt.ok(refs.length >= 3, 'expected at least 3 references to helper across files')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_cross_file_rename():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    util_uri = uri_of(path.join(tmp, 'util.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    off = offset_of(text, 'helper(w)')
+    we = await lsp.rename(ctx, main_uri, text, off, 'compute')
+    assrt.ok(we and we.changes, 'rename should return a workspace edit')
+    assrt.ok(we.changes[main_uri] and we.changes[main_uri].length >= 2, 'main.pyj should have >= 2 edits')
+    assrt.ok(we.changes[util_uri] and we.changes[util_uri].length >= 1, 'util.pyj should have the definition edit')
+    for e in we.changes[util_uri]:
+        assrt.equal(e.newText, 'compute', 'edit should insert the new name')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_invalid_rename():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    off = offset_of(text, 'helper(w)')
+    threw = False
+    try:
+        await lsp.rename(ctx, main_uri, text, off, 'not a name')
+    except:
+        threw = True
+    assrt.ok(threw, 'renaming to an invalid identifier must be rejected')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_local_rename():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    uri = uri_of(path.join(tmp, 'local.pyj'))
+    text = 'def f():\n    total = 0\n    total = total + 1\n    return total\n'
+    we = await lsp.rename(ctx, uri, text, offset_of(text, 'return total') + 'return '.length, 'sum')
+    assrt.ok(we and we.changes and we.changes[uri], 'local rename should return edits')
+    assrt.equal(we.changes[uri].length, 4, 'total is used 4 times (1 def + 3 refs)')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_completion():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    # After "util." we should be offered the module's exports.
+    dot_off = offset_of(text, 'util.Widget') + 'util.'.length
+    items = await lsp.completions(ctx, main_uri, text, dot_off)
+    labels = [it.label for it in items]
+    assrt.ok(labels.indexOf('Widget') >= 0, 'member completion should include Widget')
+    assrt.ok(labels.indexOf('helper') >= 0, 'member completion should include helper')
+
+    # Bare completion should include in-scope symbols, builtins and keywords.
+    bare = await lsp.completions(ctx, main_uri, text, offset_of(text, 'unused_var'))
+    blabels = [it.label for it in bare]
+    assrt.ok(blabels.indexOf('run') >= 0, 'completion should include the top-level function run')
+    assrt.ok(blabels.indexOf('print') >= 0, 'completion should include builtins')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_formatting():
+    ctx = lsp.create_server_context({'line_length': 80, 'preferred_quote': 'single'})
+    edits = lsp.format_document(ctx, 'x=1;y=2\n')
+    assrt.equal(edits.length, 1, 'formatting a mis-spaced document should yield one edit')
+    assrt.equal(edits[0].newText, 'x = 1; y = 2\n', 'formatter should normalize spacing')
+    # An already-formatted document yields no edits.
+    assrt.equal(lsp.format_document(ctx, 'x = 1\n').length, 0, 'well formatted input needs no edits')
+
+async def test_error_recovery_still_analyzes():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    uri = uri_of(path.join(tmp, 'broke.pyj'))
+    # alpha() has a syntax error but beta() must still be analyzable.
+    text = 'def alpha():\n    x = \n    return x\n\ndef beta():\n    y = 1\n    return y + y\n'
+    diags = await lsp.compute_diagnostics(ctx, uri, text)
+    assrt.ok(codes(diags)['syntax-err'], 'a syntax error should be reported')
+    off = offset_of(text, 'return y + y') + 'return '.length
+    h = await lsp.hover(ctx, uri, text, off)
+    assrt.ok(h and h.contents.value.indexOf('y') >= 0, 'hover must work in the healthy part of a broken file')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_parser_recovery_flag():
+    # The recover_errors parser option must never regress the normal path: a
+    # broken file throws without it and yields recovered_errors with it.
+    code = 'def good():\n    return 1\n\ndef bad(:\n    pass\n\nx = 2\n'
+    threw = False
+    try:
+        await RapydScript.parse(code, {'filename': 'r.pyj', 'basedir': test_path, 'libdir': libdir, 'for_linting': True})
+    except:
+        threw = True
+    assrt.ok(threw, 'normal parse must still throw on syntax errors (no regression)')
+
+    top = await RapydScript.parse(code, {'filename': 'r.pyj', 'basedir': test_path, 'libdir': libdir, 'for_linting': True, 'recover_errors': True})
+    assrt.ok(top, 'recover_errors parse should return a toplevel')
+    assrt.ok(top.recovered_errors and top.recovered_errors.length >= 1, 'recovered_errors should be populated')
+
+async def test_configuration_change():
+    ctx = lsp.create_server_context({'line_length': 80, 'preferred_quote': 'single', 'import_dirs': []})
+
+    # Basic updates.
+    lsp.apply_configuration(ctx, {'lineLength': 120, 'preferredQuote': 'double', 'importPath': '/tmp/mylibs'})
+    assrt.equal(ctx.line_length, 120, 'lineLength should update line_length')
+    assrt.equal(ctx.preferred_quote, 'double', 'preferredQuote should update preferred_quote')
+    assrt.ok(ctx.import_dirs.length > 0, 'string importPath should populate import_dirs')
+
+    # Array-form importPath.
+    lsp.apply_configuration(ctx, {'importPath': ['/tmp/lib1', '/tmp/lib2']})
+    assrt.equal(ctx.import_dirs.length, 2, 'array importPath should yield 2 entries')
+
+    # Invalid values must be silently ignored.
+    lsp.apply_configuration(ctx, {'lineLength': 'bogus', 'preferredQuote': 'wrong'})
+    assrt.equal(ctx.line_length, 120, 'bogus lineLength must be ignored')
+    assrt.equal(ctx.preferred_quote, 'double', 'invalid preferredQuote must be ignored')
+
+    # Empty/absent settings must be a no-op.
+    lsp.apply_configuration(ctx, {})
+    assrt.equal(ctx.line_length, 120, 'empty settings must not reset line_length')
+
+    # Numeric lineLength (number type, not string).
+    lsp.apply_configuration(ctx, {'lineLength': 100})
+    assrt.equal(ctx.line_length, 100, 'numeric lineLength should be accepted')
+
+    # Empty importPath string clears the dirs.
+    lsp.apply_configuration(ctx, {'importPath': ''})
+    assrt.equal(ctx.import_dirs.length, 0, 'empty importPath string should clear import_dirs')
+
+async def test_organize_imports():
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'rs-lsp-org-'))
+    ctx = lsp.create_server_context({
+        'import_dirs': [tmp], 'libdir': libdir, 'workspace_roots': [tmp],
+        'line_length': 80, 'preferred_quote': 'single',
+    })
+    # Unorganized: stdlib after other -> edits are produced.
+    unorganized = 'import my_module\nimport math\n\nx = 1\n'
+    edits = lsp.organize_imports_document(ctx, unorganized)
+    assrt.ok(Array.isArray(edits) and edits.length > 0,
+             'organize_imports_document must return edits for unorganized imports')
+    assrt.ok(edits[0].newText.indexOf('import math') < edits[0].newText.indexOf('import my_module'),
+             'stdlib import (math) must come before other import in organized output')
+    assrt.ok(edits[0].newText.indexOf('\n\n') >= 0,
+             'organized output must have a blank line between stdlib and other groups')
+    # from __python__ import ... goes first, before stdlib.
+    with_python = 'import math\nfrom __python__ import os\n\nx = 1\n'
+    edits_py = lsp.organize_imports_document(ctx, with_python)
+    assrt.ok(Array.isArray(edits_py) and edits_py.length > 0,
+             'organize_imports_document must return edits when __python__ import is out of place')
+    assrt.ok(edits_py[0].newText.indexOf('from __python__') < edits_py[0].newText.indexOf('import math'),
+             '__python__ group must come before stdlib group in organized output')
+    # Already organized: no edits.
+    organized = 'import math\n\nimport my_module\n\nx = 1\n'
+    edits2 = lsp.organize_imports_document(ctx, organized)
+    assrt.equal(edits2.length, 0,
+                'organize_imports_document must return no edits for already-organized imports')
+    # No imports: no edits.
+    no_imports = 'x = 1\ny = 2\n'
+    edits3 = lsp.organize_imports_document(ctx, no_imports)
+    assrt.equal(edits3.length, 0,
+                'organize_imports_document must return no edits when there are no imports')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def run_tests():
+    await test_diagnostics()
+    await test_hover_and_definition()
+    await test_cross_file_references()
+    await test_cross_file_rename()
+    await test_invalid_rename()
+    await test_local_rename()
+    await test_completion()
+    await test_formatting()
+    await test_error_recovery_still_analyzes()
+    await test_parser_recovery_flag()
+    await test_configuration_change()
+    await test_organize_imports()
+
+__test_async_done__ = run_tests()