Esempio n. 1
0
def test_main_passes_default_arguments_with_no_command_line_options(mocker):
    p = mocker.patch("natsort.__main__.sort_and_print_entries")
    main("num-2", "num-6", "num-1")
    args = p.call_args[0][1]
    assert not args.paths
    assert args.filter is None
    assert args.reverse_filter is None
    assert args.exclude is None
    assert not args.reverse
    assert args.number_type == "int"
    assert not args.signed
    assert args.exp
    assert not args.locale
Esempio n. 2
0
def test_main_passes_default_arguments_with_no_command_line_options(mocker):
    p = mocker.patch("natsort.__main__.sort_and_print_entries")
    main("num-2", "num-6", "num-1")
    args = p.call_args[0][1]
    assert not args.paths
    assert args.filter is None
    assert args.reverse_filter is None
    assert args.exclude is None
    assert not args.reverse
    assert args.number_type == "int"
    assert not args.signed
    assert args.exp
    assert not args.locale
Esempio n. 3
0
def test_main_passes_default_arguments_with_no_command_line_options():
    with patch('natsort.__main__.sort_and_print_entries') as p:
        sys.argv[1:] = ['num-2', 'num-6', 'num-1']
        main()
        args = p.call_args[0][1]
        assert not args.paths
        assert args.filter is None
        assert args.reverse_filter is None
        assert args.exclude is None
        assert not args.reverse
        assert args.number_type == 'int'
        assert not args.signed
        assert args.exp
        assert not args.locale
Esempio n. 4
0
def test_main_passes_default_arguments_with_no_command_line_options():
    with patch('natsort.__main__.sort_and_print_entries') as p:
        sys.argv[1:] = ['num-2', 'num-6', 'num-1']
        main()
        args = p.call_args[0][1]
        assert not args.paths
        assert args.filter is None
        assert args.reverse_filter is None
        assert args.exclude is None
        assert not args.reverse
        assert args.number_type == 'int'
        assert not args.signed
        assert args.exp
        assert not args.locale
Esempio n. 5
0
def test_main_passes_arguments_with_all_command_line_options():
    with patch('natsort.__main__.sort_and_print_entries') as p:
        sys.argv[1:] = ['--paths', '--reverse', '--locale',
                        '--filter', '4', '10',
                        '--reverse-filter', '100', '110',
                        '--number-type', 'float', '--noexp', '--sign',
                        '--exclude', '34', '--exclude', '35',
                        'num-2', 'num-6', 'num-1']
        main()
        args = p.call_args[0][1]
        assert args.paths
        assert args.filter == [(4.0, 10.0)]
        assert args.reverse_filter == [(100.0, 110.0)]
        assert args.exclude == [34, 35]
        assert args.reverse
        assert args.number_type == 'float'
        assert args.signed
        assert not args.exp
        assert args.locale
Esempio n. 6
0
def test_main_passes_arguments_with_all_command_line_options():
    with patch('natsort.__main__.sort_and_print_entries') as p:
        sys.argv[1:] = [
            '--paths', '--reverse', '--locale', '--filter', '4', '10',
            '--reverse-filter', '100', '110', '--number-type', 'float',
            '--noexp', '--sign', '--exclude', '34', '--exclude', '35', 'num-2',
            'num-6', 'num-1'
        ]
        main()
        args = p.call_args[0][1]
        assert args.paths
        assert args.filter == [(4.0, 10.0)]
        assert args.reverse_filter == [(100.0, 110.0)]
        assert args.exclude == [34, 35]
        assert args.reverse
        assert args.number_type == 'float'
        assert args.signed
        assert not args.exp
        assert args.locale
Esempio n. 7
0
def test_main_passes_arguments_with_all_command_line_options(mocker):
    arguments = ["--paths", "--reverse", "--locale"]
    arguments.extend(["--filter", "4", "10"])
    arguments.extend(["--reverse-filter", "100", "110"])
    arguments.extend(["--number-type", "float"])
    arguments.extend(["--noexp", "--sign"])
    arguments.extend(["--exclude", "34"])
    arguments.extend(["--exclude", "35"])
    arguments.extend(["num-2", "num-6", "num-1"])
    p = mocker.patch("natsort.__main__.sort_and_print_entries")
    main(*arguments)
    args = p.call_args[0][1]
    assert args.paths
    assert args.filter == [(4.0, 10.0)]
    assert args.reverse_filter == [(100.0, 110.0)]
    assert args.exclude == [34, 35]
    assert args.reverse
    assert args.number_type == "float"
    assert args.signed
    assert not args.exp
    assert args.locale
Esempio n. 8
0
def test_main_passes_arguments_with_all_command_line_options(mocker):
    arguments = ["--paths", "--reverse", "--locale"]
    arguments.extend(["--filter", "4", "10"])
    arguments.extend(["--reverse-filter", "100", "110"])
    arguments.extend(["--number-type", "float"])
    arguments.extend(["--noexp", "--sign"])
    arguments.extend(["--exclude", "34"])
    arguments.extend(["--exclude", "35"])
    arguments.extend(["num-2", "num-6", "num-1"])
    p = mocker.patch("natsort.__main__.sort_and_print_entries")
    main(*arguments)
    args = p.call_args[0][1]
    assert args.paths
    assert args.filter == [(4.0, 10.0)]
    assert args.reverse_filter == [(100.0, 110.0)]
    assert args.exclude == [34, 35]
    assert args.reverse
    assert args.number_type == "float"
    assert args.signed
    assert not args.exp
    assert args.locale
Esempio n. 9
0
def test_main(capsys):

    # Simple sorting
    sys.argv[1:] = ['num-2', 'num-6', 'num-1']
    main()
    out, __ = capsys.readouterr()
    assert out == """\
num-6
num-2
num-1
"""

    # Reverse order
    sys.argv[1:] = ['-r', 'num-2', 'num-6', 'num-1']
    main()
    out, __ = capsys.readouterr()
    assert out == """\
num-1
num-2
num-6
"""

    # Neglect '-' or '+'
    sys.argv[1:] = ['--nosign', 'num-2', 'num-6', 'num-1']
    main()
    out, __ = capsys.readouterr()
    assert out == """\
num-1
num-2
num-6
"""

    # Sort as digits
    sys.argv[1:] = ['-t', 'digit', 'num-2', 'num-6', 'num-1']
    main()
    out, __ = capsys.readouterr()
    assert out == """\
num-1
num-2
num-6
"""

    # Sort as versions (synonym for digits)
    sys.argv[1:] = ['-t', 'version', 'num-2', 'num-6', 'num-1']
    main()
    out, __ = capsys.readouterr()
    assert out == """\
num-1
num-2
num-6
"""

    # Exclude the number -1 and 6.  Only -1 is present.
    sys.argv[1:] = [
        '-t', 'int', '-e', '-1', '-e', '6', 'num-2', 'num-6', 'num-1'
    ]
    main()
    out, __ = capsys.readouterr()
    assert out == """\
num-6
num-2
"""

    # Exclude the number 1 and 6.
    # Both are present because we use digits/versions.
    sys.argv[1:] = [
        '-t', 'ver', '-e', '1', '-e', '6', 'num-2', 'num-6', 'num-1'
    ]
    main()
    out, __ = capsys.readouterr()
    assert out == """\
num-2
"""

    # Floats work too.
    sys.argv[1:] = ['a1.0e3', 'a5.3', 'a453.6']
    main()
    out, __ = capsys.readouterr()
    assert out == """\
a5.3
a453.6
a1.0e3
"""

    # Only include in the range of 1-10.
    sys.argv[1:] = ['-f', '1', '10', 'a1.0e3', 'a5.3', 'a453.6']
    main()
    out, __ = capsys.readouterr()
    assert out == """\
a5.3
"""

    # Don't include in the range of 1-10.
    sys.argv[1:] = ['-F', '1', '10', 'a1.0e3', 'a5.3', 'a453.6']
    main()
    out, __ = capsys.readouterr()
    assert out == """\
a453.6
a1.0e3
"""

    # Include two ranges.
    sys.argv[1:] = [
        '-f', '1', '10', '-f', '400', '500', 'a1.0e3', 'a5.3', 'a453.6'
    ]
    main()
    out, __ = capsys.readouterr()
    assert out == """\
a5.3
a453.6
"""

    # Don't account for exponential notation.
    sys.argv[1:] = ['--noexp', 'a1.0e3', 'a5.3', 'a453.6']
    main()
    out, __ = capsys.readouterr()
    assert out == """\
a1.0e3
a5.3
a453.6
"""

    # To sort complicated filenames you need --paths
    sys.argv[1:] = ['/Folder (1)/', '/Folder/', '/Folder (10)/']
    main()
    out, __ = capsys.readouterr()
    assert out == """\
/Folder (1)/
/Folder (10)/
/Folder/
"""
    sys.argv[1:] = ['--paths', '/Folder (1)/', '/Folder/', '/Folder (10)/']
    main()
    out, __ = capsys.readouterr()
    assert out == """\