def test_set_schema(completer):
    text = ('SET SCHEMA ')
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set([
        schema(u"'blog'"),
        schema(u"'Custom'"),
        schema(u"'custom'"),
        schema(u"'public'")])
Esempio n. 2
0
def test_set_schema(completer):
    text = ('SET SCHEMA ')
    result = result_set(completer, text)
    assert result == set([
        schema(u"'blog'"),
        schema(u"'Custom'"),
        schema(u"'custom'"),
        schema(u"'public'")])
Esempio n. 3
0
def test_set_schema(completer):
    text = "SET SCHEMA "
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set([
        schema("'blog'"),
        schema("'Custom'"),
        schema("'custom'"),
        schema("'public'")
    ])
def test_table_casing(completer_with_casing, complete_event, text):
    result = completer_with_casing.get_completions(
        Document(text=text), complete_event)
    assert set(result) == set([
        schema('public'),
        schema('CUSTOM'),
        schema('"Custom"'),
        table('users'),
        table('Orders'),
        table('"select"'),
        function('Func1()'),
        function('func2()')])
def test_aliases_with_casing(completer_aliases_casing, complete_event, text):
    result = completer_aliases_casing.get_completions(
        Document(text=text), complete_event)
    assert set(result) == set([
        schema('public'),
        schema('CUSTOM'),
        schema('"Custom"'),
        table('users u'),
        table('Orders O' if text == 'SELECT * FROM ' else 'Orders O2'),
        table('"select" s'),
        function('Func1() F'),
        function('func2() f')])
def test_table_casing(completer_with_casing, complete_event, text):
    result = completer_with_casing.get_completions(Document(text=text),
                                                   complete_event)
    assert set(result) == set([
        schema('public'),
        schema('CUSTOM'),
        schema('"Custom"'),
        table('users'),
        table('Orders'),
        table('"select"'),
        function('Func1()'),
        function('func2()')
    ])
def test_aliases_with_casing(completer_aliases_casing, complete_event, text):
    result = completer_aliases_casing.get_completions(Document(text=text),
                                                      complete_event)
    assert set(result) == set([
        schema('public'),
        schema('CUSTOM'),
        schema('"Custom"'),
        table('users u'),
        table('Orders O' if text == 'SELECT * FROM ' else 'Orders O2'),
        table('"select" s'),
        function('Func1() F'),
        function('func2() f')
    ])
def test_cased_joins(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_rels + [
        join('"Users" ON "Users".UserID = Users.ID'),
        join('Users Users2 ON Users2.ID = Users.PARENTID'),
        join('Users Users2 ON Users2.PARENTID = Users.ID'),
    ])
def test_cased_joins(completer, text):
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set([schema('PUBLIC')] + cased_rels + [
        join('"Users" ON "Users".UserID = Users.ID'),
        join('Users Users2 ON Users2.ID = Users.PARENTID'),
        join('Users Users2 ON Users2.PARENTID = Users.ID'),
    ])
def test_cased_joins(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_rels + [
        join('"Users" ON "Users".UserID = Users.ID'),
        join('Users Users2 ON Users2.ID = Users.PARENTID'),
        join('Users Users2 ON Users2.PARENTID = Users.ID'),
    ])
def test_cased_joins(cased_completer, complete_event, text):
    result = set(cased_completer.get_completions(
        Document(text=text), complete_event))
    assert set(result) == set([schema('PUBLIC')] + cased_rels + [
        join('"Users" ON "Users".UserID = Users.ID'),
        join('Users Users2 ON Users2.ID = Users.PARENTID'),
        join('Users Users2 ON Users2.PARENTID = Users.ID'),
        ])
def test_cased_joins(cased_completer, complete_event, text):
    result = set(
        cased_completer.get_completions(Document(text=text), complete_event))
    assert set(result) == set([schema('PUBLIC')] + cased_rels + [
        join('"Users" ON "Users".UserID = Users.ID'),
        join('Users Users2 ON Users2.ID = Users.PARENTID'),
        join('Users Users2 ON Users2.PARENTID = Users.ID'),
    ])
def test_duplicate_aliases_with_casing(completer, text):
    result = result_set(completer, text)
    assert result == set([
        schema('PUBLIC'),
        table('Orders O2'),
        table('Users U'),
        table('"Users" U'),
        table('"select" s'),
        view('User_Emails UE'),
        function('_custom_fun() cf'),
        function('Custom_Fun() CF'),
        function('Custom_Func1() CF'),
        function('custom_func2() cf'),
        function('set_returning_func() srf')])
def test_duplicate_aliases_with_casing(cased_aliased_completer,
                                        complete_event, text):
    result = cased_aliased_completer.get_completions(
        Document(text=text), complete_event)
    assert set(result) == set([
        schema('PUBLIC'),
        table('Orders O2'),
        table('Users U'),
        table('"Users" U'),
        table('"select" s'),
        view('User_Emails UE'),
        function('_custom_fun() cf'),
        function('Custom_Fun() CF'),
        function('Custom_Func1() CF'),
        function('custom_func2() cf'),
        function('set_returning_func() srf')])
Esempio n. 15
0
def test_duplicate_aliases_with_casing(completer, text):
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set([
        schema("PUBLIC"),
        table("Orders O2"),
        table("Users U"),
        table('"Users" U'),
        table('"select" s'),
        view("User_Emails UE"),
        view("Functions F"),
        function("_custom_fun() cf"),
        function("Custom_Fun() CF"),
        function("Custom_Func1() CF"),
        function("custom_func2() cf"),
        function(
            "set_returning_func(x := , y := ) srf",
            display="set_returning_func(x, y) srf",
        ),
    ])
def test_duplicate_aliases_with_casing(completer, text):
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set([
        schema('PUBLIC'),
        table('Orders O2'),
        table('Users U'),
        table('"Users" U'),
        table('"select" s'),
        view('User_Emails UE'),
        view('Functions F'),
        function('_custom_fun() cf'),
        function('Custom_Fun() CF'),
        function('Custom_Func1() CF'),
        function('custom_func2() cf'),
        function(
            'set_returning_func(x := , y := ) srf',
            display='set_returning_func(x, y) srf'
        ),
    ])
def test_list_functions_for_special(completer):
    result = result_set(completer, r'\df ')
    assert result == set(
        [schema('PUBLIC')] + [function(f) for f in cased_func_names]
    )
def test_list_functions_for_special(completer):
    result = get_result(completer, r'\df ')
    assert completions_to_set(result) == completions_to_set(
        [schema('PUBLIC')] + [function(f) for f in cased_func_names]
    )
def test_table_casing(cased_completer, complete_event, text):
    result = cased_completer.get_completions(Document(text=text),
                                             complete_event)
    assert set(result) == set([schema('PUBLIC')] + cased_rels)
def test_aliases_with_casing(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_aliased_rels)
Esempio n. 21
0
def test_aliases_with_casing(completer, text):
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set(
        [schema("PUBLIC")] + cased_aliased_rels)
Esempio n. 22
0
def test_list_functions_for_special(completer):
    result = result_set(completer, r'\df ')
    assert result == set([schema('PUBLIC')] +
                         [function(f) for f in cased_func_names])
def test_table_casing(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_rels)
def test_set_schema(completer):
    text = ('SET SCHEMA ')
    result = result_set(completer, text)
    expected = set([schema(u"'public'")])
    assert result == expected
Esempio n. 25
0
            ("blog", "entries", "entryid", "blog", "entacclog", "entryid"),
            ("blog", "entries", "entryid", "blog", "entrytags", "entryid"),
            ("blog", "tags", "tagid", "blog", "entrytags", "tagid"),
        ],
    },
    "defaults": {
        "public": {
            ("orders", "id"): "nextval('orders_id_seq'::regclass)",
            ("orders", "datestamp"): "now()",
            ("orders", "status"): "'PENDING'::text",
        }
    },
}

testdata = MetaData(metadata)
cased_schemas = [schema(x) for x in ("public", "blog", "CUSTOM", '"Custom"')]
casing = (
    "SELECT",
    "Orders",
    "User_Emails",
    "CUSTOM",
    "Func1",
    "Entries",
    "Tags",
    "EntryTags",
    "EntAccLog",
    "EntryID",
    "EntryTitle",
    "EntryText",
)
completers = testdata.get_completers(casing)
def test_table_casing(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_rels)
            ('blog', 'entries', 'entryid', 'blog', 'entacclog', 'entryid'),
            ('blog', 'entries', 'entryid', 'blog', 'entrytags', 'entryid'),
            ('blog', 'tags', 'tagid', 'blog', 'entrytags', 'tagid'),
        ],
    },
    'defaults': {
        'public': {
            ('orders', 'id'): "nextval('orders_id_seq'::regclass)",
            ('orders', 'datestamp'): "now()",
            ('orders', 'status'): "'PENDING'::text",
        }
    },
}

testdata = MetaData(metadata)
cased_schemas = [schema(x) for x in ('public', 'blog', 'CUSTOM', '"Custom"')]
casing = ('SELECT', 'Orders', 'User_Emails', 'CUSTOM', 'Func1', 'Entries',
          'Tags', 'EntryTags', 'EntAccLog',
          'EntryID', 'EntryTitle', 'EntryText')
completers = testdata.get_completers(casing)


@parametrize('completer', completers(filtr=True, casing=False, qualify=no_qual))
@parametrize('table', ['users', '"users"'])
def test_suggested_column_names_from_shadowed_visible_table(completer, table) :
    result = get_result(completer, 'SELECT  FROM ' + table, len('SELECT '))
    assert completions_to_set(result) == completions_to_set(
        testdata.columns_functions_and_keywords('users'))


@parametrize('completer', completers(filtr=True, casing=False, qualify=no_qual))
def test_set_schema(completer):
    text = ('SET SCHEMA ')
    result = get_result(completer, text)
    expected = completions_to_set([schema(u"'public'")])
    assert completions_to_set(result) == expected
def test_table_casing(cased_completer, complete_event, text):
    result = cased_completer.get_completions(
        Document(text=text), complete_event)
    assert set(result) == set([schema('PUBLIC')] + cased_rels)
def test_table_casing(completer, text):
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set(
        [schema('PUBLIC')] + cased_rels)
Esempio n. 31
0
def test_set_schema(completer):
    text = ('SET SCHEMA ')
    result = result_set(completer, text)
    expected = set([schema(u"'public'")])
    assert result == expected
        'custom': ['typ3', 'typ4'],
     },
    'foreignkeys': {
        'custom': [
            ('public', 'users', 'id', 'custom', 'shipments', 'user_id')
        ],
        'blog': [
            ('blog', 'entries', 'entryid', 'blog', 'entacclog', 'entryid'),
            ('blog', 'entries', 'entryid', 'blog', 'entrytags', 'entryid'),
            ('blog', 'tags', 'tagid', 'blog', 'entrytags', 'tagid'),
        ],
    },
}

testdata = MetaData(metadata)
cased_schemas = [schema(x) for x in ('public', 'blog', 'CUSTOM', '"Custom"')]

@pytest.fixture
def completer():
    return testdata.completer

casing = ('SELECT', 'Orders', 'User_Emails', 'CUSTOM', 'Func1', 'Entries',
          'Tags', 'EntryTags', 'EntAccLog',
          'EntryID', 'EntryTitle', 'EntryText')

@pytest.fixture
def completer_with_casing():
    return testdata.get_completer(casing=casing)

@pytest.fixture
def completer_with_aliases():
def test_aliases_with_casing(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_aliased_rels)