supplier-meesho.webflow 1.0.0

package/GitRepos/isort/tests/unit/profiles/test_plone.py

@@ -0,0 +1,75 @@
+from functools import partial
+
+from ..utils import isort_test
+
+plone_isort_test = partial(isort_test, profile="plone")
+
+
+def test_plone_code_snippet_one():
+    plone_isort_test(
+        """# -*- coding: utf-8 -*-
+from plone.app.multilingual.testing import PLONE_APP_MULTILINGUAL_PRESET_FIXTURE  # noqa
+from plone.app.robotframework.testing import REMOTE_LIBRARY_BUNDLE_FIXTURE
+from plone.app.testing import FunctionalTesting
+from plone.app.testing import IntegrationTesting
+from plone.app.testing import PloneWithPackageLayer
+from plone.testing import z2
+
+import plone.app.multilingualindexes
+
+
+PAMI_FIXTURE = PloneWithPackageLayer(
+    bases=(PLONE_APP_MULTILINGUAL_PRESET_FIXTURE,),
+    name="PAMILayer:Fixture",
+    gs_profile_id="plone.app.multilingualindexes:default",
+    zcml_package=plone.app.multilingualindexes,
+    zcml_filename="configure.zcml",
+    additional_z2_products=["plone.app.multilingualindexes"],
+)
+"""
+    )
+
+
+def test_plone_code_snippet_two():
+    plone_isort_test(
+        """# -*- coding: utf-8 -*-
+from Acquisition import aq_base
+from App.class_init import InitializeClass
+from App.special_dtml import DTMLFile
+from BTrees.OOBTree import OOTreeSet
+from logging import getLogger
+from plone import api
+from plone.app.multilingual.events import ITranslationRegisteredEvent
+from plone.app.multilingual.interfaces import ITG
+from plone.app.multilingual.interfaces import ITranslatable
+from plone.app.multilingual.interfaces import ITranslationManager
+from plone.app.multilingualindexes.utils import get_configuration
+from plone.indexer.interfaces import IIndexableObject
+from Products.CMFPlone.utils import safe_hasattr
+from Products.DateRecurringIndex.index import DateRecurringIndex
+from Products.PluginIndexes.common.UnIndex import UnIndex
+from Products.ZCatalog.Catalog import Catalog
+from ZODB.POSException import ConflictError
+from zope.component import getMultiAdapter
+from zope.component import queryAdapter
+from zope.globalrequest import getRequest
+
+
+logger = getLogger(__name__)
+"""
+    )
+
+
+def test_plone_code_snippet_three():
+    plone_isort_test(
+        """# -*- coding: utf-8 -*-
+from plone.app.querystring.interfaces import IQueryModifier
+from zope.interface import provider
+
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+"""
+    )

package/GitRepos/isort/tests/unit/profiles/test_pycharm.py

@@ -0,0 +1,55 @@
+from functools import partial
+
+from ..utils import isort_test
+
+pycharm_isort_test = partial(isort_test, profile="pycharm")
+
+
+def test_pycharm_snippet_one():
+    pycharm_isort_test(
+        """import shutil
+import sys
+from io import StringIO
+from pathlib import Path
+from typing import (
+    Optional,
+    TextIO,
+    Union,
+    cast
+)
+from warnings import warn
+
+from isort import core
+
+from . import io
+from .exceptions import (
+    ExistingSyntaxErrors,
+    FileSkipComment,
+    FileSkipSetting,
+    IntroducedSyntaxErrors
+)
+from .format import (
+    ask_whether_to_apply_changes_to_file,
+    create_terminal_printer,
+    show_unified_diff
+)
+from .io import Empty
+from .place import module as place_module  # noqa: F401
+from .place import module_with_reason as place_module_with_reason  # noqa: F401
+from .settings import (
+    DEFAULT_CONFIG,
+    Config
+)
+
+
+def sort_code_string(
+    code: str,
+    extension: Optional[str] = None,
+    config: Config = DEFAULT_CONFIG,
+    file_path: Optional[Path] = None,
+    disregard_skip: bool = False,
+    show_diff: Union[bool, TextIO] = False,
+    **config_kwargs,
+):
+"""
+    )

package/GitRepos/isort/tests/unit/profiles/test_wemake.py

@@ -0,0 +1,87 @@
+"""A set of test cases for the wemake isort profile.
+
+Snippets are taken directly from the wemake-python-styleguide project here:
+https://github.com/wemake-services/wemake-python-styleguide
+"""
+from functools import partial
+
+from ..utils import isort_test
+
+wemake_isort_test = partial(
+    isort_test, profile="wemake", known_first_party=["wemake_python_styleguide"]
+)
+
+
+def test_wemake_snippet_one():
+    wemake_isort_test(
+        """
+import ast
+import tokenize
+import traceback
+from typing import ClassVar, Iterator, Sequence, Type
+
+from flake8.options.manager import OptionManager
+from typing_extensions import final
+
+from wemake_python_styleguide import constants, types
+from wemake_python_styleguide import version as pkg_version
+from wemake_python_styleguide.options.config import Configuration
+from wemake_python_styleguide.options.validation import validate_options
+from wemake_python_styleguide.presets.types import file_tokens as tokens_preset
+from wemake_python_styleguide.presets.types import filename as filename_preset
+from wemake_python_styleguide.presets.types import tree as tree_preset
+from wemake_python_styleguide.transformations.ast_tree import transform
+from wemake_python_styleguide.violations import system
+from wemake_python_styleguide.visitors import base
+
+VisitorClass = Type[base.BaseVisitor]
+"""
+    )
+
+
+def test_wemake_snippet_two():
+    wemake_isort_test(
+        """
+from collections import defaultdict
+from typing import ClassVar, DefaultDict, List
+
+from flake8.formatting.base import BaseFormatter
+from flake8.statistics import Statistics
+from flake8.style_guide import Violation
+from pygments import highlight
+from pygments.formatters import TerminalFormatter
+from pygments.lexers import PythonLexer
+from typing_extensions import Final
+
+from wemake_python_styleguide.version import pkg_version
+
+#: That url is generated and hosted by Sphinx.
+DOCS_URL_TEMPLATE: Final = (
+    'https://wemake-python-stylegui.de/en/{0}/pages/usage/violations/'
+)
+"""
+    )
+
+
+def test_wemake_snippet_three():
+    wemake_isort_test(
+        """
+import ast
+
+from pep8ext_naming import NamingChecker
+from typing_extensions import final
+
+from wemake_python_styleguide.transformations.ast.bugfixes import (
+    fix_async_offset,
+    fix_line_number,
+)
+from wemake_python_styleguide.transformations.ast.enhancements import (
+    set_if_chain,
+    set_node_context,
+)
+
+
+@final
+class _ClassVisitor(ast.NodeVisitor): ...
+"""
+    )

package/GitRepos/isort/tests/unit/test_action_comments.py

@@ -0,0 +1,47 @@
+"""Tests for isort action comments, such as isort: skip"""
+import isort
+
+
+def test_isort_off_and_on():
+    """Test so ensure isort: off action comment and associated on action comment work together"""
+
+    # as top of file comment
+    assert (
+        isort.code(
+            """# isort: off
+import a
+import a
+
+# isort: on
+import a
+import a
+"""
+        )
+        == """# isort: off
+import a
+import a
+
+# isort: on
+import a
+"""
+    )
+    # as middle comment
+    assert (
+        isort.code(
+            """
+import a
+import a
+
+# isort: off
+import a
+import a
+"""
+        )
+        == """
+import a
+
+# isort: off
+import a
+import a
+"""
+    )

package/GitRepos/isort/tests/unit/test_api.py

@@ -0,0 +1,108 @@
+"""Tests the isort API module"""
+import os
+from io import StringIO
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from isort import ImportKey, api
+from isort.settings import Config
+
+imperfect_content = "import b\nimport a\n"
+fixed_content = "import a\nimport b\n"
+fixed_diff = "+import a\n import b\n-import a\n"
+
+
+@pytest.fixture
+def imperfect(tmpdir) -> None:
+    imperfect_file = tmpdir.join("test_needs_changes.py")
+    imperfect_file.write_text(imperfect_content, "utf8")
+    return imperfect_file
+
+
+def test_sort_file_with_bad_syntax(tmpdir) -> None:
+    tmp_file = tmpdir.join("test_bad_syntax.py")
+    tmp_file.write_text("""print('mismatching quotes")""", "utf8")
+    with pytest.warns(UserWarning):
+        api.sort_file(tmp_file, atomic=True)
+    with pytest.warns(UserWarning):
+        api.sort_file(tmp_file, atomic=True, write_to_stdout=True)
+
+
+def test_sort_file(imperfect) -> None:
+    assert api.sort_file(imperfect)
+    assert imperfect.read() == fixed_content
+
+
+def test_sort_file_in_place(imperfect) -> None:
+    assert api.sort_file(imperfect, overwrite_in_place=True)
+    assert imperfect.read() == fixed_content
+
+
+def test_sort_file_to_stdout(capsys, imperfect) -> None:
+    assert api.sort_file(imperfect, write_to_stdout=True)
+    out, _ = capsys.readouterr()
+    assert out == fixed_content.replace("\n", os.linesep)
+
+
+def test_other_ask_to_apply(imperfect) -> None:
+    # First show diff, but ensure change wont get written by asking to apply
+    # and ensuring answer is no.
+    with patch("isort.format.input", MagicMock(return_value="n")):
+        assert not api.sort_file(imperfect, ask_to_apply=True)
+        assert imperfect.read() == imperfect_content
+
+    # Then run again, but apply the change (answer is yes)
+    with patch("isort.format.input", MagicMock(return_value="y")):
+        assert api.sort_file(imperfect, ask_to_apply=True)
+        assert imperfect.read() == fixed_content
+
+
+def test_check_file_no_changes(capsys, tmpdir) -> None:
+    perfect = tmpdir.join("test_no_changes.py")
+    perfect.write_text("import a\nimport b\n", "utf8")
+    assert api.check_file(perfect, show_diff=True)
+    out, _ = capsys.readouterr()
+    assert not out
+
+
+def test_check_file_with_changes(capsys, imperfect) -> None:
+    assert not api.check_file(imperfect, show_diff=True)
+    out, _ = capsys.readouterr()
+    assert fixed_diff.replace("\n", os.linesep) in out
+
+
+def test_sorted_imports_multiple_configs() -> None:
+    with pytest.raises(ValueError):
+        api.sort_code_string("import os", config=Config(line_length=80), line_length=80)
+
+
+def test_diff_stream() -> None:
+    output = StringIO()
+    assert api.sort_stream(StringIO("import b\nimport a\n"), output, show_diff=True)
+    output.seek(0)
+    assert fixed_diff in output.read()
+
+
+def test_sort_code_string_mixed_newlines():
+    assert api.sort_code_string("import A\n\r\nimportA\n\n") == "import A\r\n\r\nimportA\r\n\n"
+
+
+def test_find_imports_in_file(imperfect):
+    found_imports = list(api.find_imports_in_file(imperfect))
+    assert "b" in [found_import.module for found_import in found_imports]
+
+
+def test_find_imports_in_code():
+    code = """
+from x.y import z as a
+from x.y import z as a
+from x.y import z
+import x.y
+import x
+"""
+    assert len(list(api.find_imports_in_code(code))) == 5
+    assert len(list(api.find_imports_in_code(code, unique=True))) == 4
+    assert len(list(api.find_imports_in_code(code, unique=ImportKey.ATTRIBUTE))) == 3
+    assert len(list(api.find_imports_in_code(code, unique=ImportKey.MODULE))) == 2
+    assert len(list(api.find_imports_in_code(code, unique=ImportKey.PACKAGE))) == 1

package/GitRepos/isort/tests/unit/test_comments.py

@@ -0,0 +1,34 @@
+from hypothesis import given
+from hypothesis import strategies as st
+
+import isort.comments
+
+
+def test_add_to_line():
+    assert (
+        isort.comments.add_to_line([], "import os  # comment", removed=True).strip() == "import os"
+    )
+
+
+# These tests were written by the `hypothesis.extra.ghostwriter` module
+# and is provided under the Creative Commons Zero public domain dedication.
+
+
+@given(
+    comments=st.one_of(st.none(), st.lists(st.text())),
+    original_string=st.text(),
+    removed=st.booleans(),
+    comment_prefix=st.text(),
+)
+def test_fuzz_add_to_line(comments, original_string, removed, comment_prefix):
+    isort.comments.add_to_line(
+        comments=comments,
+        original_string=original_string,
+        removed=removed,
+        comment_prefix=comment_prefix,
+    )
+
+
+@given(line=st.text())
+def test_fuzz_parse(line):
+    isort.comments.parse(line=line)

package/GitRepos/isort/tests/unit/test_deprecated_finders.py

@@ -0,0 +1,210 @@
+import importlib.machinery
+import os
+import posixpath
+from pathlib import Path
+from unittest.mock import patch
+
+from isort import sections, settings
+from isort.deprecated import finders
+from isort.deprecated.finders import FindersManager
+from isort.settings import Config
+
+PIPFILE = """
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[requires]
+python_version = "3.5"
+
+[packages]
+Django = "~=1.11"
+deal = {editable = true, git = "https://github.com/orsinium/deal.git"}
+
+[dev-packages]
+"""
+
+
+class TestFindersManager:
+    def test_init(self):
+        assert FindersManager(settings.DEFAULT_CONFIG)
+
+        class ExceptionOnInit(finders.BaseFinder):
+            def __init__(*args, **kwargs):
+                super().__init__(*args, **kwargs)
+                raise ValueError("test")
+
+        with patch(
+            "isort.deprecated.finders.FindersManager._default_finders_classes",
+            FindersManager._default_finders_classes + (ExceptionOnInit,),
+        ):
+            assert FindersManager(settings.Config(verbose=True))
+
+    def test_no_finders(self):
+        assert FindersManager(settings.DEFAULT_CONFIG, []).find("isort") is None
+
+    def test_find_broken_finder(self):
+        class ExceptionOnFind(finders.BaseFinder):
+            def find(*args, **kwargs):
+                raise ValueError("test")
+
+        assert (
+            FindersManager(settings.Config(verbose=True), [ExceptionOnFind]).find("isort") is None
+        )
+
+
+class AbstractTestFinder:
+    kind = finders.BaseFinder
+
+    @classmethod
+    def setup_class(cls):
+        cls.instance = cls.kind(settings.DEFAULT_CONFIG)
+
+    def test_create(self):
+        assert self.kind(settings.DEFAULT_CONFIG)
+
+    def test_find(self):
+        self.instance.find("isort")
+        self.instance.find("")
+
+
+class TestForcedSeparateFinder(AbstractTestFinder):
+    kind = finders.ForcedSeparateFinder
+
+
+class TestDefaultFinder(AbstractTestFinder):
+    kind = finders.DefaultFinder
+
+
+class TestKnownPatternFinder(AbstractTestFinder):
+    kind = finders.KnownPatternFinder
+
+
+class TestLocalFinder(AbstractTestFinder):
+    kind = finders.LocalFinder
+
+
+class TestPathFinder(AbstractTestFinder):
+    kind = finders.PathFinder
+
+    def test_conda_and_virtual_env(self, tmpdir):
+        python3lib = tmpdir.mkdir("lib").mkdir("python3")
+        python3lib.mkdir("site-packages").mkdir("y")
+        python3lib.mkdir("n").mkdir("site-packages").mkdir("x")
+        tmpdir.mkdir("z").join("__init__.py").write("__version__ = '1.0.0'")
+        tmpdir.chdir()
+
+        conda = self.kind(settings.Config(conda_env=str(tmpdir)), str(tmpdir))
+        venv = self.kind(settings.Config(virtual_env=str(tmpdir)), str(tmpdir))
+        assert conda.find("y") == venv.find("y") == "THIRDPARTY"
+        assert conda.find("x") == venv.find("x") == "THIRDPARTY"
+        assert conda.find("z") == "THIRDPARTY"
+        assert conda.find("os") == venv.find("os") == "STDLIB"
+
+    def test_default_section(self, tmpdir):
+        tmpdir.join("file.py").write("import b\nimport a\n")
+        assert self.kind(settings.Config(default_section="CUSTOM"), tmpdir).find("file") == "CUSTOM"
+
+    def test_src_paths(self, tmpdir):
+        tmpdir.join("file.py").write("import b\nimport a\n")
+        assert (
+            self.kind(settings.Config(src_paths=[Path(str(tmpdir))]), tmpdir).find("file")
+            == settings.DEFAULT_CONFIG.default_section
+        )
+
+
+class TestPipfileFinder(AbstractTestFinder):
+    kind = finders.PipfileFinder
+
+
+class TestRequirementsFinder(AbstractTestFinder):
+    kind = finders.RequirementsFinder
+
+    def test_no_pipreqs(self):
+        with patch("isort.deprecated.finders.pipreqs", None):
+            assert not self.kind(settings.DEFAULT_CONFIG).find("isort")
+
+    def test_not_enabled(self):
+        test_finder = self.kind(settings.DEFAULT_CONFIG)
+        test_finder.enabled = False
+        assert not test_finder.find("isort")
+
+    def test_requirements_dir(self, tmpdir):
+        tmpdir.mkdir("requirements").join("development.txt").write("x==1.00")
+        test_finder = self.kind(settings.DEFAULT_CONFIG, str(tmpdir))
+        assert test_finder.find("x")
+
+
+def test_requirements_finder(tmpdir) -> None:
+    subdir = tmpdir.mkdir("subdir").join("lol.txt")
+    subdir.write("flask")
+    req_file = tmpdir.join("requirements.txt")
+    req_file.write("Django==1.11\n-e git+https://github.com/orsinium/deal.git#egg=deal\n")
+    for path in (str(tmpdir), str(subdir)):
+
+        finder = finders.RequirementsFinder(config=Config(), path=path)
+
+        files = list(finder._get_files())
+        assert len(files) == 1  # file finding
+        assert files[0].endswith("requirements.txt")  # file finding
+        assert set(finder._get_names(str(req_file))) == {"Django", "deal"}  # file parsing
+
+        assert finder.find("django") == sections.THIRDPARTY  # package in reqs
+        assert finder.find("flask") is None  # package not in reqs
+        assert finder.find("deal") == sections.THIRDPARTY  # vcs
+
+        assert len(finder.mapping) > 100
+        assert finder._normalize_name("deal") == "deal"
+        assert finder._normalize_name("Django") == "django"  # lowercase
+        assert finder._normalize_name("django_haystack") == "haystack"  # mapping
+        assert finder._normalize_name("Flask-RESTful") == "flask_restful"  # conver `-`to `_`
+
+    req_file.remove()
+
+
+def test_pipfile_finder(tmpdir) -> None:
+    pipfile = tmpdir.join("Pipfile")
+    pipfile.write(PIPFILE)
+    finder = finders.PipfileFinder(config=Config(), path=str(tmpdir))
+
+    assert set(finder._get_names(str(tmpdir))) == {"Django", "deal"}  # file parsing
+
+    assert finder.find("django") == sections.THIRDPARTY  # package in reqs
+    assert finder.find("flask") is None  # package not in reqs
+    assert finder.find("deal") == sections.THIRDPARTY  # vcs
+
+    assert len(finder.mapping) > 100
+    assert finder._normalize_name("deal") == "deal"
+    assert finder._normalize_name("Django") == "django"  # lowercase
+    assert finder._normalize_name("django_haystack") == "haystack"  # mapping
+    assert finder._normalize_name("Flask-RESTful") == "flask_restful"  # conver `-`to `_`
+
+    pipfile.remove()
+
+
+def test_path_finder(monkeypatch) -> None:
+    config = config = Config()
+    finder = finders.PathFinder(config=config)
+    third_party_prefix = next(path for path in finder.paths if "site-packages" in path)
+    ext_suffixes = importlib.machinery.EXTENSION_SUFFIXES
+    imaginary_paths = {
+        posixpath.join(finder.stdlib_lib_prefix, "example_1.py"),
+        posixpath.join(third_party_prefix, "example_2.py"),
+        posixpath.join(os.getcwd(), "example_3.py"),
+    }
+    imaginary_paths.update(
+        {
+            posixpath.join(third_party_prefix, "example_" + str(i) + ext_suffix)
+            for i, ext_suffix in enumerate(ext_suffixes, 4)
+        }
+    )
+
+    monkeypatch.setattr(
+        "isort.deprecated.finders.exists_case_sensitive", lambda p: p in imaginary_paths
+    )
+    assert finder.find("example_1") == sections.STDLIB
+    assert finder.find("example_2") == sections.THIRDPARTY
+    assert finder.find("example_3") == settings.DEFAULT_CONFIG.default_section
+    for i, _ in enumerate(ext_suffixes, 4):
+        assert finder.find("example_" + str(i)) == sections.THIRDPARTY