Refactoring and more tests

Author: erezsh

preql/autocomplete.py

@@ -3,6 +3,7 @@
 from lark import Token, UnexpectedCharacters, UnexpectedToken, Tree
 
 from .exceptions import ReturnSignal, pql_NameNotFound, PreqlError
+from .loggers import ac_log
 from . import pql_ast as ast
 from . import pql_objects as objects
 from .utils import bfs

preql/loggers.py

@@ -0,0 +1,22 @@
+from logging import getLogger, Formatter, StreamHandler, basicConfig
+from logging import DEBUG, INFO, WARN, ERROR, CRITICAL
+
+basicConfig(level=INFO, format="(%(levelname)s) %(name)s -- %(message)s")
+#             )#datefmt='%m-%d %H:%M')
+
+sh = StreamHandler()
+sh.setFormatter(Formatter('%(message)s'))
+
+def make_logger(name, level):
+    logger = getLogger(name)
+    logger.propagate = False
+    logger.setLevel(level)
+    logger.addHandler(sh)
+    return logger
+
+
+
+sql_log = make_logger('sql_output', DEBUG)
+ac_log = make_logger('autocomplete', CRITICAL)
+repl_log = make_logger('repl', INFO)
+test_log = make_logger('tests', ERROR)

tests/__main__.py

@@ -3,6 +3,7 @@
 logging.basicConfig(level=logging.INFO)
 
 from .test_basic import *
+from .test_autocomplete import AutocompleteTests
 
 
 if __name__ == '__main__':

tests/common.py

@@ -0,0 +1,21 @@
+from unittest import TestCase, skip
+from preql import sql, settings
+
+from preql import Preql
+
+SQLITE_URI = 'sqlite://:memory:'
+POSTGRES_URI = 'postgres://postgres:qweqwe123@localhost/postgres'
+
+class PreqlTests(TestCase):
+    def Preql(self):
+        settings.optimize = self.optimized
+        preql = Preql(self.uri)
+        self.preql = preql
+        return preql
+
+    def setUp(self):
+        self.preql = None
+
+    def tearDown(self):
+        if self.preql:
+            self.preql.engine.rollback()

tests/test_autocomplete.py

@@ -0,0 +1,103 @@
+import re
+import time
+import logging
+
+from preql import Preql
+from preql.autocomplete import autocomplete
+from preql.loggers import test_log
+
+from .common import PreqlTests, SQLITE_URI, POSTGRES_URI
+
+class AutocompleteTests(PreqlTests):
+    uri = SQLITE_URI
+    optimized = True
+
+    def test_basic(self):
+        p = self.Preql()
+        state = p.interp.state
+
+        assert "value" in autocomplete(state, "func d(){ [1]{")
+        assert "value" in autocomplete(state, "func d(){ [1][")
+        assert "value" not in autocomplete(state, "func d(){ [1]")
+
+        res = autocomplete(state, """
+        func x(param1) {
+            hello = "b"
+        """)
+        assert "hello" in res, res.keys()
+
+        res = autocomplete(state, """
+        func x(param1) {
+            hello = "b
+        """)
+
+        res = autocomplete(state, """
+        func x(param1) {
+            hello = [1] {value, value+2}
+        """)
+        assert "hello" in res, res.keys()
+
+    def test_progressive(self):
+        p = self.Preql()
+        state = p.interp.state
+
+        s0 = """
+        func hello() = 0
+
+        a = <<<hello>>>
+        """
+        progressive_test(state, s0)
+        progressive_test(state, s0, True)
+
+        s1 = """
+        func get_users(logins) {
+            const table matched_logins = <<<leftjoin>>>(l:logins.value, u:User.login)
+
+            existing_users = <<<matched_logins>>>[<<<u>>>!=null] {<<<u>>>.id}
+            new_users = new[] User(login: <<<matched_logins>>>[<<<u>>>==null] {<<<l>>>.value})
+
+            return <<<existing_users>>> + <<<new_users>>>
+        }
+
+        hello = <<<get_users>>>([1,2,3])
+        do_whatever = <<<hello>>>
+
+        """
+        progressive_test(state, s1*2)
+        progressive_test(state, s1, True)
+
+
+
+
+def _parse_autocomplete_requirements(s):
+    matches = {}
+    offset = 0
+    def g(m):
+        nonlocal offset
+        start = m.start() + offset
+        x ,= m.groups()
+        matches[start] = x
+        offset -= 6
+        return x
+
+    new_s = re.sub("<<<(\w+)>>>", g, s)
+    for k, v in matches.items():
+        assert new_s[k:k+len(v)] == v, (k, v)
+    return new_s, matches
+
+
+def progressive_test(state, s, test_partial=False):
+    total = 0
+    start = time.time()
+
+    s,d = _parse_autocomplete_requirements(s)
+    for i in range(1, len(s)):
+        ps = s[:i]
+        if i in d or test_partial:
+            names = autocomplete(state, ps)
+            total += 1
+            if i in d:
+                assert d[i] in names, (i, d[i])
+
+    duration = time.time() - start
+    test_log.info(f"Total {total} autocompletions in {duration:.2f} seconds, or {1000*duration/total:.2f} ms per autocomplete")

tests/test_basic.py

@@ -10,8 +10,8 @@
 from preql import sql, settings
 from preql.pql_types import T
 
-SQLITE_URI = 'sqlite://:memory:'
-POSTGRES_URI = 'postgres://postgres:qweqwe123@localhost/postgres'
+from .common import PreqlTests, SQLITE_URI, POSTGRES_URI
+
 
 
 def is_eq(a, b):
@@ -24,7 +24,7 @@ def is_eq(a, b):
     ("Unoptimized_Lt", SQLITE_URI, False),
     ("Unoptimized_Pg", POSTGRES_URI, False),
 ])
-class BasicTests(TestCase):
+class BasicTests(PreqlTests):
     def Preql(self):
         settings.optimize = self.optimized
         preql = Preql(self.uri)