Python FromImport Beispiele

Beispiel #1

Datei: sort_test.py Projekt: mxr/aspy.refactor_imports

def test_not_separate_not_import_before_from():
    ret = sort(IMPORTS, separate=False, import_before_from=False)
    assert ret == ((
        FromImport.from_str('from aspy import refactor_imports'),
        FromImport.from_str('from os import path'),
        ImportImport.from_str('import pyramid'),
        ImportImport.from_str('import sys'),
    ), )

Beispiel #2

Datei: sort_test.py Projekt: pombreda/aspy.refactor_imports

def test_not_separate_not_import_before_from():
    ret = sort(IMPORTS, separate=False, import_before_from=False)
    assert ret == (
        (
            FromImport.from_str('from aspy import refactor_imports'),
            FromImport.from_str('from os import path'),
            ImportImport.from_str('import pyramid'),
            ImportImport.from_str('import sys'),
        ),
    )

Beispiel #3

Datei: sort_test.py Projekt: mxr/aspy.refactor_imports

def test_future_separate_block_non_separate():
    ret = sort(
        (
            FromImport.from_str('from __future__ import absolute_import'),
            ImportImport.from_str('import pyramid'),
        ),
        separate=False,
        import_before_from=True,
    )
    assert ret == (
        (FromImport.from_str('from __future__ import absolute_import'), ),
        (ImportImport.from_str('import pyramid'), ),
    )

Beispiel #4

Datei: sort_test.py Projekt: pombreda/aspy.refactor_imports

def test_future_separate_block_non_separate():
    ret = sort(
        (
            FromImport.from_str('from __future__ import absolute_import'),
            ImportImport.from_str('import pyramid'),
        ),
        separate=False,
        import_before_from=True,
    )
    assert ret == (
        (FromImport.from_str('from __future__ import absolute_import'),),
        (ImportImport.from_str('import pyramid'),),
    )

Beispiel #5

Datei: import_obj_test.py Projekt: asottile/aspy.refactor_imports

def test_from_import_cmp():
    not_sorted = [
        FromImport.from_str('from foo import bar as baz'),
        FromImport.from_str('from foo import bar'),
        FromImport.from_str('from herp import derp'),
        FromImport.from_str('from foo import bar as buz'),
        FromImport.from_str('from foo.bar import womp'),
    ]
    assert sorted(not_sorted) == [
        FromImport.from_str('from foo import bar'),
        FromImport.from_str('from foo import bar as baz'),
        FromImport.from_str('from foo import bar as buz'),
        FromImport.from_str('from foo.bar import womp'),
        FromImport.from_str('from herp import derp'),
    ]

Beispiel #6

def test_from_import_cmp():
    not_sorted = [
        FromImport.from_str('from foo import bar as baz'),
        FromImport.from_str('from foo import bar'),
        FromImport.from_str('from herp import derp'),
        FromImport.from_str('from foo import bar as buz'),
        FromImport.from_str('from foo.bar import womp'),
    ]
    assert sorted(not_sorted) == [
        FromImport.from_str('from foo import bar'),
        FromImport.from_str('from foo import bar as baz'),
        FromImport.from_str('from foo import bar as buz'),
        FromImport.from_str('from foo.bar import womp'),
        FromImport.from_str('from herp import derp'),
    ]

Beispiel #7

Datei: sort_test.py Projekt: coldnight/aspy.refactor_imports

def test_separate_relative():
    ret = sort(RELATIVE_IMPORTS)
    assert ret == (
        (
            ImportImport.from_str('import sys'),
            FromImport.from_str('from os import path'),
        ),
        (ImportImport.from_str('import pyramid'), ),
        (
            FromImport.from_str('from .sort import sort'),
            FromImport.from_str('from aspy import refactor_imports'),
        ),
    )

    ret = sort(RELATIVE_IMPORTS, separate_relative=True)
    assert ret == ((
        ImportImport.from_str('import sys'),
        FromImport.from_str('from os import path'),
    ), (ImportImport.from_str('import pyramid'), ), (
        FromImport.from_str('from aspy import refactor_imports'), ),
                   (FromImport.from_str('from .sort import sort'), ))

Beispiel #8

Datei: sort_test.py Projekt: pombreda/aspy.refactor_imports

from __future__ import absolute_import
from __future__ import unicode_literals

from aspy.refactor_imports.import_obj import FromImport
from aspy.refactor_imports.import_obj import ImportImport
from aspy.refactor_imports.sort import sort


IMPORTS = (
    FromImport.from_str('from os import path'),
    FromImport.from_str('from aspy import refactor_imports'),
    ImportImport.from_str('import sys'),
    ImportImport.from_str('import pyramid'),
)


def test_separate_import_before_from():
    ret = sort(IMPORTS, separate=True, import_before_from=True)
    assert ret == (
        (
            ImportImport.from_str('import sys'),
            FromImport.from_str('from os import path'),
        ),
        (
            ImportImport.from_str('import pyramid'),
        ),
        (
            FromImport.from_str('from aspy import refactor_imports'),
        ),
    )

Beispiel #9

def test_from_import_hashable():
    my_set = set()
    my_set.add(FromImport.from_str('from foo import bar'))
    my_set.add(FromImport.from_str('from foo import bar'))
    assert len(my_set) == 1

Beispiel #10

def test_from_import_to_text(import_str):
    assert FromImport.from_str(import_str).to_text() == import_str

Beispiel #11

def test_from_import_has_multiple_imports(input_str, expected):
    assert FromImport.from_str(input_str).has_multiple_imports is expected

Beispiel #12

def from_import():
    yield FromImport.from_str('from Foo import bar as baz')

Beispiel #13

Datei: import_obj_test.py Projekt: asottile/aspy.refactor_imports

def test_from_import_has_multiple_imports(input_str, expected):
    assert FromImport.from_str(input_str).has_multiple_imports is expected

Beispiel #14

Datei: import_obj_test.py Projekt: asottile/aspy.refactor_imports

def from_import():
    yield FromImport.from_str('from Foo import bar as baz')

Beispiel #15

Datei: import_obj_test.py Projekt: asottile/aspy.refactor_imports

@pytest.mark.parametrize(
    ('input_str', 'expected'),
    (
        ('from foo import bar', False),
        ('from foo import bar, baz', True),
    ),
)
def test_from_import_has_multiple_imports(input_str, expected):
    assert FromImport.from_str(input_str).has_multiple_imports is expected


@pytest.mark.parametrize(
    ('input_str', 'expected'),
    (
        ('from foo import bar', [FromImport.from_str('from foo import bar')]),
        (
            'from foo import bar, baz',
            [
                FromImport.from_str('from foo import bar'),
                FromImport.from_str('from foo import baz'),
            ],
        ),
        (
            'from .foo import bar, baz',
            [
                FromImport.from_str('from .foo import bar'),
                FromImport.from_str('from .foo import baz'),
            ],
        ),
    ),

Beispiel #16

Datei: sort_test.py Projekt: mxr/aspy.refactor_imports

from __future__ import absolute_import
from __future__ import unicode_literals

from aspy.refactor_imports.import_obj import FromImport
from aspy.refactor_imports.import_obj import ImportImport
from aspy.refactor_imports.sort import sort

IMPORTS = (
    FromImport.from_str('from os import path'),
    FromImport.from_str('from aspy import refactor_imports'),
    ImportImport.from_str('import sys'),
    ImportImport.from_str('import pyramid'),
)


def test_separate_import_before_from():
    ret = sort(IMPORTS, separate=True, import_before_from=True)
    assert ret == (
        (
            ImportImport.from_str('import sys'),
            FromImport.from_str('from os import path'),
        ),
        (ImportImport.from_str('import pyramid'), ),
        (FromImport.from_str('from aspy import refactor_imports'), ),
    )


def test_separate_not_import_before_from():
    ret = sort(IMPORTS, separate=True, import_before_from=False)
    assert ret == (
        (

Beispiel #17

@pytest.mark.parametrize(
    ('input_str', 'expected'),
    (
        ('from foo import bar', False),
        ('from foo import bar, baz', True),
    ),
)
def test_from_import_has_multiple_imports(input_str, expected):
    assert FromImport.from_str(input_str).has_multiple_imports is expected


@pytest.mark.parametrize(
    ('input_str', 'expected'),
    (
        ('from foo import bar', [FromImport.from_str('from foo import bar')]),
        (
            'from foo import bar, baz',
            [
                FromImport.from_str('from foo import bar'),
                FromImport.from_str('from foo import baz'),
            ],
        ),
        (
            'from .foo import bar, baz',
            [
                FromImport.from_str('from .foo import bar'),
                FromImport.from_str('from .foo import baz'),
            ],
        ),
    ),

Beispiel #18

Datei: import_obj_test.py Projekt: asottile/aspy.refactor_imports

def test_from_import_split_imports(input_str, expected):
    assert FromImport.from_str(input_str).split_imports() == expected

Beispiel #19

Datei: import_obj_test.py Projekt: asottile/aspy.refactor_imports

def test_from_import_to_text(import_str):
    assert FromImport.from_str(import_str).to_text() == import_str

Beispiel #20

Datei: import_obj_test.py Projekt: asottile/aspy.refactor_imports

def test_from_import_to_text_normalizes_whitespace(import_str, expected):
    assert FromImport.from_str(import_str).to_text() == expected

Beispiel #21

def test_from_import_split_imports(input_str, expected):
    assert FromImport.from_str(input_str).split_imports() == expected

Beispiel #22

Datei: import_obj_test.py Projekt: asottile/aspy.refactor_imports

def test_hashable():
    my_set = set()
    my_set.add(FromImport.from_str('from foo import bar'))
    my_set.add(FromImport.from_str('from foo import bar'))
    assert len(my_set) == 1

Beispiel #23

def test_from_import_to_text_normalizes_whitespace(import_str, expected):
    assert FromImport.from_str(import_str).to_text() == expected

Beispiel #24

Datei: import_obj_test.py Projekt: asottile/aspy.refactor_imports

def test_local_imports(input_str):
    assert FromImport.from_str(input_str).to_text() == input_str

Beispiel #25

def test_local_imports(input_str):
    assert FromImport.from_str(input_str).to_text() == input_str

Beispiel #26

Datei: sort_test.py Projekt: coldnight/aspy.refactor_imports

from __future__ import absolute_import
from __future__ import unicode_literals

from aspy.refactor_imports.import_obj import FromImport
from aspy.refactor_imports.import_obj import ImportImport
from aspy.refactor_imports.sort import sort

IMPORTS = (
    FromImport.from_str('from os import path'),
    FromImport.from_str('from aspy import refactor_imports'),
    ImportImport.from_str('import sys'),
    ImportImport.from_str('import pyramid'),
)

RELATIVE_IMPORTS = IMPORTS + (FromImport.from_str("from .sort import sort"), )


def test_separate_import_before_from():
    ret = sort(IMPORTS, separate=True, import_before_from=True)
    assert ret == (
        (
            ImportImport.from_str('import sys'),
            FromImport.from_str('from os import path'),
        ),
        (ImportImport.from_str('import pyramid'), ),
        (FromImport.from_str('from aspy import refactor_imports'), ),
    )


def test_separate_not_import_before_from():
    ret = sort(IMPORTS, separate=True, import_before_from=False)