From da3b16024f005a4d1d4e10f73ae82afdd9cc4b04 Mon Sep 17 00:00:00 2001 From: Eduardo Enriquez Date: Wed, 19 Jun 2019 17:48:37 +0200 Subject: [PATCH 1/4] Working refactor test_parsing --- tests/conftest.py | 36 ++- tests/test_parsing/test_file.py | 499 ++++++++++++++++++++++++++++++++ tests/test_parsing/test_reqs.py | 139 +++++++++ 3 files changed, 673 insertions(+), 1 deletion(-) create mode 100644 tests/test_parsing/test_file.py create mode 100644 tests/test_parsing/test_reqs.py diff --git a/tests/conftest.py b/tests/conftest.py index 29ec3c7..1a8a3ae 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,11 +1,45 @@ import shutil +from logassert import logassert from pytest import fixture @fixture(scope="function") def tmp_file(tmpdir_factory): - """ Fixture for a unique tmpfile for each test.""" + """Fixture for a unique tmpfile for each test.""" dir_path = tmpdir_factory.mktemp("test") yield str(dir_path.join("testfile")) # Converted to str to support python <3.6 versions shutil.rmtree(str(dir_path)) + + +@fixture() +def logged(): + """Fixture to assert on loggings.""" + + class FixtureLogChecker(logassert.SetupLogChecker): + + _translation = [ + ('assertLogged', 'assert_logged'), + ('assertLoggedError', 'assert_error'), + ('assertLoggedWarning', 'assert_warning'), + ('assertLoggedInfo', 'assert_info'), + ('assertLoggedDebug', 'assert_debug'), + ('assertNotLogged', 'assert_not_logged'), + ('assertNotLoggedError', 'assert_not_error'), + ('assertNotLoggedWarning', 'assert_not_warning'), + ('assertNotLoggedInfo', 'assert_not_info'), + ('assertNotLoggedDebug', 'assert_not_debug'), + ] + + def __init__(self, logpath): + super().__init__(self, logpath) + + # old testing API translation + for old_name, new_name in self._translation: + setattr(self, new_name, getattr(self, old_name)) + + def fail(self, message): + """Called by logassert.SetupLogChecker on failure.""" + raise AssertionError(message) + + return FixtureLogChecker('fades.parsing') diff --git a/tests/test_parsing/test_file.py b/tests/test_parsing/test_file.py new file mode 100644 index 0000000..5a6fe61 --- /dev/null +++ b/tests/test_parsing/test_file.py @@ -0,0 +1,499 @@ +"""Check the imports parsing.""" +import io + +from fades import parsing, REPO_PYPI, REPO_VCS + +from tests.test_cache import get_req + + +def test_nocomment(): + # note that we're testing the import at the beginning of the line, and + # in also indented + parsed = parsing._parse_content(io.StringIO("""import time + import time + from time import foo + """)) + assert parsed == {} + + +def test_simple_default(): + parsed = parsing._parse_content(io.StringIO(""" + import time + import foo # fades + """)) + assert parsed == {REPO_PYPI: [get_req('foo')]} + + +def test_double(): + parsed = parsing._parse_content(io.StringIO(""" + import time # fades + import foo # fades + """)) + assert parsed == { + REPO_PYPI: [get_req('time'), get_req('foo')] + } + + +def test_version_same_default(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades == 3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo == 3.5')] + } + + +def test_version_different(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades !=3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo !=3.5')] + } + + +def test_version_same_no_spaces(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades==3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo ==3.5')] + } + + +def test_version_same_two_spaces(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades == 3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo == 3.5')] + } + + +def test_version_same_one_space_before(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades == 3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo == 3.5')] + } + + +def test_version_same_two_space_before(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades == 3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo == 3.5')] + } + + +def test_version_same_one_space_after(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades== 3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo == 3.5')] + } + + +def test_version_same_two_space_after(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades== 3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo == 3.5')] + } + + +def test_version_greater(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades > 2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo > 2')] + } + + +def test_version_greater_no_space(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades>2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo >2')] + } + + +def test_version_greater_no_space_default(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades>2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo >2')] + } + +def test_version_greater_two_spaces(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades > 2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo > 2')] + } + +def test_version_greater_one_space_after(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades> 2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo > 2')] + } + + +def test_version_greater_two_space_after(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades> 2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo > 2')] + } + + +def test_version_greater_one_space_before(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades> 2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo > 2')] + } + + +def test_version_greater_two_space_before(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades> 2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo > 2')] + } + + +def test_version_same_or_greater(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades >= 2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo >= 2')] + } + + +def test_version_same_or_greater_no_spaces(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades>=2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo >= 2')] + } + + +def test_version_same_or_greater_one_space_before(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades >=2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo >=2')] + } + + +def test_version_same_or_greater_two_space_before(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades >=2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo >=2')] + } + + +def test_version_same_or_greater_one_space_after(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades>= 2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo >= 2')] + } + + +def test_version_same_or_greater_two_space_after(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades>= 2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo >= 2')] + } + + +def test_continuation_line(): + parsed = parsing._parse_content(io.StringIO(""" + import bar + # fades > 2 + import foo + """)) + assert parsed == { + REPO_PYPI: [get_req('foo > 2')] + } + + +def test_from_import_simple(): + parsed = parsing._parse_content(io.StringIO(""" + from foo import bar # fades + """)) + assert parsed == { + REPO_PYPI: [get_req('foo')] + } + + +def test_import(): + parsed = parsing._parse_content(io.StringIO(""" + import foo.bar # fades + """)) + assert parsed == { + REPO_PYPI: [get_req('foo')] + } + + +def test_from_import_complex(): + parsed = parsing._parse_content(io.StringIO(""" + from baz.foo import bar # fades + """)) + assert parsed == { + REPO_PYPI: [get_req('baz')] + } + + +def test_allow_other_comments(): + parsed = parsing._parse_content(io.StringIO(""" + from foo import * # NOQA # fades + """)) + assert parsed == { + REPO_PYPI: [get_req('foo')] + } + + +def test_allow_other_comments_reverse_default(): + parsed = parsing._parse_content(io.StringIO(""" + from foo import * # fades # NOQA + """)) + assert parsed == { + REPO_PYPI: [get_req('foo')] + } + + +def test_strange_import(logged): + parsed = parsing._parse_content(io.StringIO(""" + from foo bar import :( # fades + """)) + logged.assert_debug( + "Not understood import info", + "['from', 'foo', 'bar', 'import', ':(']" + ) + assert parsed == {} + + +def test_strange_fadesinfo(logged): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades broken::whatever + """)) + logged.assert_warning("Not understood fades repository", "broken") + assert parsed == {} + + +def test_strange_fadesinfo2(logged): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fadesbroken + """)) + logged.assert_warning("Not understood fades info", "fadesbroken") + assert parsed == {} + + +def test_projectname_noversion_implicit(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades othername + """)) + assert parsed == { + REPO_PYPI: [get_req('othername')] + } + + +def test_projectname_noversion_explicit(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades pypi::othername + """)) + assert parsed == { + REPO_PYPI: [get_req('othername')] + } + + +def test_projectname_version_explicit(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades pypi::othername >= 3 + """)) + assert parsed == { + REPO_PYPI: [get_req('othername >= 3')] + } + + +def test_projectname_version_nospace(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades othername==5 + """)) + assert parsed == { + REPO_PYPI: [get_req('othername==5')] + } + + +def test_projectname_version_space(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades othername <5 + """)) + assert parsed == { + REPO_PYPI: [get_req('othername <5')] + } + + +def test_projectname_pkgnamedb(): + parsed = parsing._parse_content(io.StringIO(""" + import bs4 # fades + """)) + assert parsed == { + REPO_PYPI: [get_req('beautifulsoup4')] + } + + +def test_projectname_pkgnamedb_version(): + parsed = parsing._parse_content(io.StringIO(""" + import bs4 # fades >=5 + """)) + assert parsed == { + REPO_PYPI: [get_req('beautifulsoup4 >=5')] + } + + +def test_projectname_pkgnamedb_othername_default(): + parsed = parsing._parse_content(io.StringIO(""" + import bs4 # fades othername + """)) + assert parsed == { + REPO_PYPI: [get_req('othername')] + } + + +def test_projectname_pkgnamedb_version_othername(): + parsed = parsing._parse_content(io.StringIO(""" + import bs4 # fades othername >=5 + """)) + assert parsed == { + REPO_PYPI: [get_req('othername >=5')] + } + + +def test_comma_separated_import(): + parsed = parsing._parse_content(io.StringIO(""" + from foo import bar, baz, qux # fades + """)) + assert parsed == { + REPO_PYPI: [get_req('foo')] + } + + +def test_other_lines_with_fades_string(): + parsed = parsing._parse_content(io.StringIO(""" + import bar # fades + print("screen fades to black") + """)) + assert parsed == { + REPO_PYPI: [get_req('bar')] + } + + +def test_commented_line(logged): + parsed = parsing._parse_content(io.StringIO(""" + #import foo # fades + """)) + assert parsed == {} + logged.assert_not_warning("Not understood fades") + + +def test_with_fades_commented_line(logged): + parsed = parsing._parse_content(io.StringIO(""" + #import foo # fades + import bar # fades + """)) + assert parsed == { + REPO_PYPI: [get_req('bar')] + } + logged.assert_not_warning("Not understood fades") + + +def test_with_commented_line(logged): + parsed = parsing._parse_content(io.StringIO(""" + import bar # fades + # a commented line + """)) + assert parsed == { + REPO_PYPI: [get_req('bar')] + } + logged.assert_not_warning("Not understood fades") + + +def test_vcs_explicit(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades vcs::superurl + """)) + assert parsed == { + REPO_VCS: [parsing.VCSDependency('superurl')] + } + + +def test_vcs_implicit(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades http://www.whatever/project + """)) + assert parsed == { + REPO_VCS: [parsing.VCSDependency('http://www.whatever/project')] + } + + +def test_mixed(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades vcs::superurl + import bar # fades + """)) + assert parsed == { + REPO_VCS: [parsing.VCSDependency('superurl')], + REPO_PYPI: [get_req('bar')], + } + + +def test_fades_and_hashtag_mentioned_in_code(): + """Test the case where a string contains both: fades and hashtag (#) + but is not an import. + """ + parsed = parsing._parse_content(io.StringIO(""" + 'http://fades.readthedocs.io/en/release-7-0/readme.html#how-to-use-it' + """)) + assert parsed == {} + + +def test_fades_and_hashtag_mentioned_in_code_mixed_with_imports(): + parsed = parsing._parse_content(io.StringIO("""import requests # fades + + 'http://fades.readthedocs.io/en/release-7-0/readme.html#how-to-use-it' + """)) + assert parsed == { + REPO_PYPI: [get_req('requests')] + } + + +def test_fades_user_strange_comment_with_hashtag_ignored(): + parsed = parsing._parse_content(io.StringIO(""" + import foo # fades==2 # Some comment with #hashtash + """)) # noqa + assert parsed == {} diff --git a/tests/test_parsing/test_reqs.py b/tests/test_parsing/test_reqs.py new file mode 100644 index 0000000..facf599 --- /dev/null +++ b/tests/test_parsing/test_reqs.py @@ -0,0 +1,139 @@ +"""Check the requirements parsing.""" +import io + +from pkg_resources import parse_requirements +from fades import parsing, REPO_PYPI, REPO_VCS + + +def get_req(text): + """Transform a text requirement into the pkg_resources object.""" + return list(parse_requirements(text))[0] + + +def test_empty(): + parsed = parsing._parse_requirement(io.StringIO(""" + + """)) + assert parsed == {} + + +def test_simple(): + parsed = parsing._parse_requirement(io.StringIO(""" + pypi::foo + """)) + assert parsed == {REPO_PYPI: [get_req('foo')]} + + +def test_simple_default(): + parsed = parsing._parse_requirement(io.StringIO(""" + foo + """)) + assert parsed == {REPO_PYPI: [get_req('foo')]} + + +def test_double(): + parsed = parsing._parse_requirement(io.StringIO(""" + pypi::time + foo + """)) + assert parsed == { + REPO_PYPI: [get_req('time'), get_req('foo')] + } + + +def test_version_same(): + parsed = parsing._parse_requirement(io.StringIO(""" + pypi::foo == 3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo == 3.5')] + } + + +def test_version_same_default(): + parsed = parsing._parse_requirement(io.StringIO(""" + foo == 3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo == 3.5')] + } + + +def test_version_different(): + parsed = parsing._parse_requirement(io.StringIO(""" + foo !=3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo !=3.5')] + } + + +def test_version_same_no_spaces(): + parsed = parsing._parse_requirement(io.StringIO(""" + foo==3.5 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo ==3.5')] + } + + +def test_version_greater_two_spaces(): + parsed = parsing._parse_requirement(io.StringIO(""" + foo > 2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo > 2')] + } + + +def test_version_same_or_greater(): + parsed = parsing._parse_requirement(io.StringIO(""" + foo >=2 + """)) + assert parsed == { + REPO_PYPI: [get_req('foo >= 2')] + } + + +def test_comments(): + parsed = parsing._parse_requirement(io.StringIO(""" + pypi::foo # some text + # other text + bar + """)) + assert parsed == { + REPO_PYPI: [get_req('foo'), get_req('bar')] + } + + +def test_strange_repo(logged): + parsed = parsing._parse_requirement(io.StringIO(""" + unknown::foo + """)) + logged.assert_warning("Not understood fades repository", "unknown") + assert parsed == {} + + +def test_vcs_simple(): + parsed = parsing._parse_requirement(io.StringIO(""" + vcs::strangeurl + """)) + assert parsed == {REPO_VCS: [parsing.VCSDependency("strangeurl")]} + + +def test_vcs_simple_default(): + parsed = parsing._parse_requirement(io.StringIO(""" + bzrhttp://server/bleh + """)) + assert parsed == {REPO_VCS: [parsing.VCSDependency("bzrhttp://server/bleh")]} + + +def test_mixed(): + parsed = parsing._parse_requirement(io.StringIO(""" + vcs::strangeurl + pypi::foo + """)) + assert parsed == { + REPO_VCS: [parsing.VCSDependency("strangeurl")], + REPO_PYPI: [get_req('foo')], + } From cd6f1fac18c6cbe9d700760578169353942d53e5 Mon Sep 17 00:00:00 2001 From: "Eduardo Enriquez (eduzen)" Date: Thu, 20 Jun 2019 21:27:25 +0200 Subject: [PATCH 2/4] Fixes after merge with master --- tests/test_parsing/test_file.py | 96 +++++++++++++++++---------------- 1 file changed, 49 insertions(+), 47 deletions(-) diff --git a/tests/test_parsing/test_file.py b/tests/test_parsing/test_file.py index 5a6fe61..96a819e 100644 --- a/tests/test_parsing/test_file.py +++ b/tests/test_parsing/test_file.py @@ -3,7 +3,7 @@ from fades import parsing, REPO_PYPI, REPO_VCS -from tests.test_cache import get_req +from tests import get_reqs def test_nocomment(): @@ -21,16 +21,16 @@ def test_simple_default(): import time import foo # fades """)) - assert parsed == {REPO_PYPI: [get_req('foo')]} + assert parsed == {REPO_PYPI: get_reqs('foo')} def test_double(): parsed = parsing._parse_content(io.StringIO(""" import time # fades - import foo # fades + import foo # fades """)) assert parsed == { - REPO_PYPI: [get_req('time'), get_req('foo')] + REPO_PYPI: get_reqs('time') + get_reqs('foo') } @@ -39,7 +39,7 @@ def test_version_same_default(): import foo # fades == 3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo == 3.5')] + REPO_PYPI: get_reqs('foo == 3.5') } @@ -48,7 +48,7 @@ def test_version_different(): import foo # fades !=3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo !=3.5')] + REPO_PYPI: get_reqs('foo !=3.5') } @@ -57,7 +57,7 @@ def test_version_same_no_spaces(): import foo # fades==3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo ==3.5')] + REPO_PYPI: get_reqs('foo ==3.5') } @@ -66,7 +66,7 @@ def test_version_same_two_spaces(): import foo # fades == 3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo == 3.5')] + REPO_PYPI: get_reqs('foo == 3.5') } @@ -75,7 +75,7 @@ def test_version_same_one_space_before(): import foo # fades == 3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo == 3.5')] + REPO_PYPI: get_reqs('foo == 3.5') } @@ -84,7 +84,7 @@ def test_version_same_two_space_before(): import foo # fades == 3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo == 3.5')] + REPO_PYPI: get_reqs('foo == 3.5') } @@ -93,7 +93,7 @@ def test_version_same_one_space_after(): import foo # fades== 3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo == 3.5')] + REPO_PYPI: get_reqs('foo == 3.5') } @@ -102,7 +102,7 @@ def test_version_same_two_space_after(): import foo # fades== 3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo == 3.5')] + REPO_PYPI: get_reqs('foo == 3.5') } @@ -111,7 +111,7 @@ def test_version_greater(): import foo # fades > 2 """)) assert parsed == { - REPO_PYPI: [get_req('foo > 2')] + REPO_PYPI: get_reqs('foo > 2') } @@ -120,7 +120,7 @@ def test_version_greater_no_space(): import foo # fades>2 """)) assert parsed == { - REPO_PYPI: [get_req('foo >2')] + REPO_PYPI: get_reqs('foo >2') } @@ -129,23 +129,25 @@ def test_version_greater_no_space_default(): import foo # fades>2 """)) assert parsed == { - REPO_PYPI: [get_req('foo >2')] + REPO_PYPI: get_reqs('foo >2') } + def test_version_greater_two_spaces(): parsed = parsing._parse_content(io.StringIO(""" import foo # fades > 2 """)) assert parsed == { - REPO_PYPI: [get_req('foo > 2')] + REPO_PYPI: get_reqs('foo > 2') } + def test_version_greater_one_space_after(): parsed = parsing._parse_content(io.StringIO(""" import foo # fades> 2 """)) assert parsed == { - REPO_PYPI: [get_req('foo > 2')] + REPO_PYPI: get_reqs('foo > 2') } @@ -154,7 +156,7 @@ def test_version_greater_two_space_after(): import foo # fades> 2 """)) assert parsed == { - REPO_PYPI: [get_req('foo > 2')] + REPO_PYPI: get_reqs('foo > 2') } @@ -163,7 +165,7 @@ def test_version_greater_one_space_before(): import foo # fades> 2 """)) assert parsed == { - REPO_PYPI: [get_req('foo > 2')] + REPO_PYPI: get_reqs('foo > 2') } @@ -172,7 +174,7 @@ def test_version_greater_two_space_before(): import foo # fades> 2 """)) assert parsed == { - REPO_PYPI: [get_req('foo > 2')] + REPO_PYPI: get_reqs('foo > 2') } @@ -181,7 +183,7 @@ def test_version_same_or_greater(): import foo # fades >= 2 """)) assert parsed == { - REPO_PYPI: [get_req('foo >= 2')] + REPO_PYPI: get_reqs('foo >= 2') } @@ -190,7 +192,7 @@ def test_version_same_or_greater_no_spaces(): import foo # fades>=2 """)) assert parsed == { - REPO_PYPI: [get_req('foo >= 2')] + REPO_PYPI: get_reqs('foo >= 2') } @@ -199,7 +201,7 @@ def test_version_same_or_greater_one_space_before(): import foo # fades >=2 """)) assert parsed == { - REPO_PYPI: [get_req('foo >=2')] + REPO_PYPI: get_reqs('foo >=2') } @@ -208,7 +210,7 @@ def test_version_same_or_greater_two_space_before(): import foo # fades >=2 """)) assert parsed == { - REPO_PYPI: [get_req('foo >=2')] + REPO_PYPI: get_reqs('foo >=2') } @@ -217,7 +219,7 @@ def test_version_same_or_greater_one_space_after(): import foo # fades>= 2 """)) assert parsed == { - REPO_PYPI: [get_req('foo >= 2')] + REPO_PYPI: get_reqs('foo >= 2') } @@ -226,7 +228,7 @@ def test_version_same_or_greater_two_space_after(): import foo # fades>= 2 """)) assert parsed == { - REPO_PYPI: [get_req('foo >= 2')] + REPO_PYPI: get_reqs('foo >= 2') } @@ -237,7 +239,7 @@ def test_continuation_line(): import foo """)) assert parsed == { - REPO_PYPI: [get_req('foo > 2')] + REPO_PYPI: get_reqs('foo > 2') } @@ -246,7 +248,7 @@ def test_from_import_simple(): from foo import bar # fades """)) assert parsed == { - REPO_PYPI: [get_req('foo')] + REPO_PYPI: get_reqs('foo') } @@ -255,7 +257,7 @@ def test_import(): import foo.bar # fades """)) assert parsed == { - REPO_PYPI: [get_req('foo')] + REPO_PYPI: get_reqs('foo') } @@ -264,7 +266,7 @@ def test_from_import_complex(): from baz.foo import bar # fades """)) assert parsed == { - REPO_PYPI: [get_req('baz')] + REPO_PYPI: get_reqs('baz') } @@ -273,7 +275,7 @@ def test_allow_other_comments(): from foo import * # NOQA # fades """)) assert parsed == { - REPO_PYPI: [get_req('foo')] + REPO_PYPI: get_reqs('foo') } @@ -282,7 +284,7 @@ def test_allow_other_comments_reverse_default(): from foo import * # fades # NOQA """)) assert parsed == { - REPO_PYPI: [get_req('foo')] + REPO_PYPI: get_reqs('foo') } @@ -318,7 +320,7 @@ def test_projectname_noversion_implicit(): import foo # fades othername """)) assert parsed == { - REPO_PYPI: [get_req('othername')] + REPO_PYPI: get_reqs('othername') } @@ -327,7 +329,7 @@ def test_projectname_noversion_explicit(): import foo # fades pypi::othername """)) assert parsed == { - REPO_PYPI: [get_req('othername')] + REPO_PYPI: get_reqs('othername') } @@ -336,7 +338,7 @@ def test_projectname_version_explicit(): import foo # fades pypi::othername >= 3 """)) assert parsed == { - REPO_PYPI: [get_req('othername >= 3')] + REPO_PYPI: get_reqs('othername >= 3') } @@ -345,7 +347,7 @@ def test_projectname_version_nospace(): import foo # fades othername==5 """)) assert parsed == { - REPO_PYPI: [get_req('othername==5')] + REPO_PYPI: get_reqs('othername==5') } @@ -354,7 +356,7 @@ def test_projectname_version_space(): import foo # fades othername <5 """)) assert parsed == { - REPO_PYPI: [get_req('othername <5')] + REPO_PYPI: get_reqs('othername <5') } @@ -363,7 +365,7 @@ def test_projectname_pkgnamedb(): import bs4 # fades """)) assert parsed == { - REPO_PYPI: [get_req('beautifulsoup4')] + REPO_PYPI: get_reqs('beautifulsoup4') } @@ -372,7 +374,7 @@ def test_projectname_pkgnamedb_version(): import bs4 # fades >=5 """)) assert parsed == { - REPO_PYPI: [get_req('beautifulsoup4 >=5')] + REPO_PYPI: get_reqs('beautifulsoup4 >=5') } @@ -381,7 +383,7 @@ def test_projectname_pkgnamedb_othername_default(): import bs4 # fades othername """)) assert parsed == { - REPO_PYPI: [get_req('othername')] + REPO_PYPI: get_reqs('othername') } @@ -390,7 +392,7 @@ def test_projectname_pkgnamedb_version_othername(): import bs4 # fades othername >=5 """)) assert parsed == { - REPO_PYPI: [get_req('othername >=5')] + REPO_PYPI: get_reqs('othername >=5') } @@ -399,7 +401,7 @@ def test_comma_separated_import(): from foo import bar, baz, qux # fades """)) assert parsed == { - REPO_PYPI: [get_req('foo')] + REPO_PYPI: get_reqs('foo') } @@ -409,7 +411,7 @@ def test_other_lines_with_fades_string(): print("screen fades to black") """)) assert parsed == { - REPO_PYPI: [get_req('bar')] + REPO_PYPI: get_reqs('bar') } @@ -427,7 +429,7 @@ def test_with_fades_commented_line(logged): import bar # fades """)) assert parsed == { - REPO_PYPI: [get_req('bar')] + REPO_PYPI: get_reqs('bar') } logged.assert_not_warning("Not understood fades") @@ -438,7 +440,7 @@ def test_with_commented_line(logged): # a commented line """)) assert parsed == { - REPO_PYPI: [get_req('bar')] + REPO_PYPI: get_reqs('bar') } logged.assert_not_warning("Not understood fades") @@ -468,7 +470,7 @@ def test_mixed(): """)) assert parsed == { REPO_VCS: [parsing.VCSDependency('superurl')], - REPO_PYPI: [get_req('bar')], + REPO_PYPI: get_reqs('bar'), } @@ -488,7 +490,7 @@ def test_fades_and_hashtag_mentioned_in_code_mixed_with_imports(): 'http://fades.readthedocs.io/en/release-7-0/readme.html#how-to-use-it' """)) assert parsed == { - REPO_PYPI: [get_req('requests')] + REPO_PYPI: get_reqs('requests') } From 063c1a6d5bcf7257802c2fe77e980b945f25945d Mon Sep 17 00:00:00 2001 From: "Eduardo Enriqez (eduzen)" Date: Wed, 26 Jun 2019 01:26:12 +0200 Subject: [PATCH 3/4] Migrated to pytest all test in test_parsing.py --- tests/conftest.py | 46 +- tests/test_parsing.py | 806 ---------------------- tests/test_parsing/test_docstrings.py | 79 +++ tests/test_parsing/test_file_reqs.py | 59 ++ tests/test_parsing/test_manual.py | 58 ++ tests/test_parsing/test_vcs_dependency.py | 29 + 6 files changed, 259 insertions(+), 818 deletions(-) delete mode 100644 tests/test_parsing.py create mode 100644 tests/test_parsing/test_docstrings.py create mode 100644 tests/test_parsing/test_file_reqs.py create mode 100644 tests/test_parsing/test_manual.py create mode 100644 tests/test_parsing/test_vcs_dependency.py diff --git a/tests/conftest.py b/tests/conftest.py index 1a8a3ae..9a7c943 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,4 +1,5 @@ import shutil +import uuid from logassert import logassert from pytest import fixture @@ -8,7 +9,28 @@ def tmp_file(tmpdir_factory): """Fixture for a unique tmpfile for each test.""" dir_path = tmpdir_factory.mktemp("test") - yield str(dir_path.join("testfile")) # Converted to str to support python <3.6 versions + yield str( + dir_path.join("testfile") + ) # Converted to str to support python <3.6 versions + shutil.rmtree(str(dir_path)) + + +@fixture(scope="function") +def create_tmpfile(tmpdir_factory): + dir_path = tmpdir_factory.mktemp("test") + + def add_content(lines=None): + """Fixture for a unique tmpfile for each test.""" + namefile = str( + dir_path.join("testfile_{}".format(uuid.uuid4())) + ) # Converted to str to support python <3.6 versions + with open(namefile, "w", encoding="utf-8") as f: + for line in lines or []: + f.write(line + "\n") + + return namefile + + yield add_content shutil.rmtree(str(dir_path)) @@ -19,16 +41,16 @@ def logged(): class FixtureLogChecker(logassert.SetupLogChecker): _translation = [ - ('assertLogged', 'assert_logged'), - ('assertLoggedError', 'assert_error'), - ('assertLoggedWarning', 'assert_warning'), - ('assertLoggedInfo', 'assert_info'), - ('assertLoggedDebug', 'assert_debug'), - ('assertNotLogged', 'assert_not_logged'), - ('assertNotLoggedError', 'assert_not_error'), - ('assertNotLoggedWarning', 'assert_not_warning'), - ('assertNotLoggedInfo', 'assert_not_info'), - ('assertNotLoggedDebug', 'assert_not_debug'), + ("assertLogged", "assert_logged"), + ("assertLoggedError", "assert_error"), + ("assertLoggedWarning", "assert_warning"), + ("assertLoggedInfo", "assert_info"), + ("assertLoggedDebug", "assert_debug"), + ("assertNotLogged", "assert_not_logged"), + ("assertNotLoggedError", "assert_not_error"), + ("assertNotLoggedWarning", "assert_not_warning"), + ("assertNotLoggedInfo", "assert_not_info"), + ("assertNotLoggedDebug", "assert_not_debug"), ] def __init__(self, logpath): @@ -42,4 +64,4 @@ def fail(self, message): """Called by logassert.SetupLogChecker on failure.""" raise AssertionError(message) - return FixtureLogChecker('fades.parsing') + return FixtureLogChecker("fades.parsing") diff --git a/tests/test_parsing.py b/tests/test_parsing.py deleted file mode 100644 index f8a1a46..0000000 --- a/tests/test_parsing.py +++ /dev/null @@ -1,806 +0,0 @@ -# Copyright 2014-2019 Facundo Batista, Nicolás Demarchi -# -# This program is free software: you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 3, as published -# by the Free Software Foundation. -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranties of -# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR -# PURPOSE. See the GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program. If not, see . -# -# For further info, check https://github.com/PyAr/fades - -"""Tests for the parsing of module imports.""" - -import io -import unittest -import os - -import logassert - -from fades import parsing, REPO_PYPI, REPO_VCS -from tests import create_tempfile, get_reqs - - -class FileParsingTestCase(unittest.TestCase): - """Check the imports parsing.""" - - def setUp(self): - logassert.setup(self, 'fades.parsing') - - def test_nocomment(self): - # note that we're testing the import at the beginning of the line, and - # in also indented - parsed = parsing._parse_content(io.StringIO("""import time - import time - from time import foo - """)) - self.assertDictEqual(parsed, {}) - - def test_simple_default(self): - parsed = parsing._parse_content(io.StringIO(""" - import time - import foo # fades - """)) - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('foo')}) - - def test_double(self): - parsed = parsing._parse_content(io.StringIO(""" - import time # fades - import foo # fades - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('time', 'foo') - }) - - def test_version_same_default(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades == 3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo == 3.5') - }) - - def test_version_different(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades !=3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo !=3.5') - }) - - def test_version_same_no_spaces(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades==3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo ==3.5') - }) - - def test_version_same_two_spaces(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades == 3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo == 3.5') - }) - - def test_version_same_one_space_before(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades == 3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo == 3.5') - }) - - def test_version_same_two_space_before(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades == 3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo == 3.5') - }) - - def test_version_same_one_space_after(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades== 3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo == 3.5') - }) - - def test_version_same_two_space_after(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades== 3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo == 3.5') - }) - - def test_version_greater(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades > 2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo > 2') - }) - - def test_version_greater_no_space(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades>2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo >2') - }) - - def test_version_greater_no_space_default(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades>2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo >2') - }) - - def test_version_greater_two_spaces(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades > 2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo > 2') - }) - - def test_version_greater_one_space_after(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades> 2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo > 2') - }) - - def test_version_greater_two_space_after(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades> 2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo > 2') - }) - - def test_version_greater_one_space_before(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades> 2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo > 2') - }) - - def test_version_greater_two_space_before(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades> 2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo > 2') - }) - - def test_version_same_or_greater(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades >= 2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo >= 2') - }) - - def test_version_same_or_greater_no_spaces(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades>=2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo >= 2') - }) - - def test_version_same_or_greater_one_space_before(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades >=2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo >=2') - }) - - def test_version_same_or_greater_two_space_before(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades >=2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo >=2') - }) - - def test_version_same_or_greater_one_space_after(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades>= 2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo >= 2') - }) - - def test_version_same_or_greater_two_space_after(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades>= 2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo >= 2') - }) - - def test_continuation_line(self): - parsed = parsing._parse_content(io.StringIO(""" - import bar - # fades > 2 - import foo - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo > 2') - }) - - def test_from_import_simple(self): - parsed = parsing._parse_content(io.StringIO(""" - from foo import bar # fades - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo') - }) - - def test_import(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo.bar # fades - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo') - }) - - def test_from_import_complex(self): - parsed = parsing._parse_content(io.StringIO(""" - from baz.foo import bar # fades - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('baz') - }) - - def test_allow_other_comments(self): - parsed = parsing._parse_content(io.StringIO(""" - from foo import * # NOQA # fades - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo') - }) - - def test_allow_other_comments_reverse_default(self): - parsed = parsing._parse_content(io.StringIO(""" - from foo import * # fades # NOQA - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo') - }) - - def test_strange_import(self): - parsed = parsing._parse_content(io.StringIO(""" - from foo bar import :( # fades - """)) - self.assertLoggedDebug("Not understood import info", - "['from', 'foo', 'bar', 'import', ':(']") - self.assertDictEqual(parsed, {}) - - def test_strange_fadesinfo(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades broken::whatever - """)) - self.assertLoggedWarning("Not understood fades repository", "broken") - self.assertDictEqual(parsed, {}) - - def test_strange_fadesinfo2(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fadesbroken - """)) - self.assertLoggedWarning("Not understood fades info", "fadesbroken") - self.assertDictEqual(parsed, {}) - - def test_projectname_noversion_implicit(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades othername - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('othername') - }) - - def test_projectname_noversion_explicit(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades pypi::othername - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('othername') - }) - - def test_projectname_version_explicit(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades pypi::othername >= 3 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('othername >= 3') - }) - - def test_projectname_version_nospace(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades othername==5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('othername==5') - }) - - def test_projectname_version_space(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades othername <5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('othername <5') - }) - - def test_projectname_pkgnamedb(self): - parsed = parsing._parse_content(io.StringIO(""" - import bs4 # fades - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('beautifulsoup4') - }) - - def test_projectname_pkgnamedb_version(self): - parsed = parsing._parse_content(io.StringIO(""" - import bs4 # fades >=5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('beautifulsoup4 >=5') - }) - - def test_projectname_pkgnamedb_othername_default(self): - parsed = parsing._parse_content(io.StringIO(""" - import bs4 # fades othername - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('othername') - }) - - def test_projectname_pkgnamedb_version_othername(self): - parsed = parsing._parse_content(io.StringIO(""" - import bs4 # fades othername >=5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('othername >=5') - }) - - def test_comma_separated_import(self): - parsed = parsing._parse_content(io.StringIO(""" - from foo import bar, baz, qux # fades - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo') - }) - - def test_other_lines_with_fades_string(self): - parsed = parsing._parse_content(io.StringIO(""" - import bar # fades - print("screen fades to black") - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('bar') - }) - - def test_commented_line(self): - parsed = parsing._parse_content(io.StringIO(""" - #import foo # fades - """)) - self.assertDictEqual(parsed, {}) - self.assertNotLoggedWarning("Not understood fades") - - def test_with_fades_commented_line(self): - parsed = parsing._parse_content(io.StringIO(""" - #import foo # fades - import bar # fades - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('bar') - }) - self.assertNotLoggedWarning("Not understood fades") - - def test_with_commented_line(self): - parsed = parsing._parse_content(io.StringIO(""" - import bar # fades - # a commented line - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('bar') - }) - self.assertNotLoggedWarning("Not understood fades") - - def test_vcs_explicit(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades vcs::superurl - """)) - self.assertDictEqual(parsed, { - REPO_VCS: [parsing.VCSDependency('superurl')] - }) - - def test_vcs_implicit(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades http://www.whatever/project - """)) - self.assertDictEqual(parsed, { - REPO_VCS: [parsing.VCSDependency('http://www.whatever/project')] - }) - - def test_mixed(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades vcs::superurl - import bar # fades - """)) - self.assertDictEqual(parsed, { - REPO_VCS: [parsing.VCSDependency('superurl')], - REPO_PYPI: get_reqs('bar'), - }) - - def test_fades_and_hashtag_mentioned_in_code(self): - """Test the case where a string contains both: fades and hashtag (#) - but is not an import. - """ - parsed = parsing._parse_content(io.StringIO(""" - 'http://fades.readthedocs.io/en/release-7-0/readme.html#how-to-use-it' - """)) - self.assertDictEqual(parsed, {}) - - def test_fades_and_hashtag_mentioned_in_code_mixed_with_imports(self): - parsed = parsing._parse_content(io.StringIO("""import requests # fades - - 'http://fades.readthedocs.io/en/release-7-0/readme.html#how-to-use-it' - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('requests') - }) - - def test_fades_user_strange_comment_with_hashtag_ignored(self): - parsed = parsing._parse_content(io.StringIO(""" - import foo # fades==2 # Some comment with #hashtash - """)) # noqa - self.assertDictEqual(parsed, {}) - - -class ManualParsingTestCase(unittest.TestCase): - """Check the manual parsing.""" - - def test_none(self): - parsed = parsing.parse_manual(None) - self.assertDictEqual(parsed, {}) - - def test_nothing(self): - parsed = parsing.parse_manual([]) - self.assertDictEqual(parsed, {}) - - def test_simple(self): - parsed = parsing.parse_manual(["pypi::foo"]) - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('foo')}) - - def test_simple_default_pypi(self): - parsed = parsing.parse_manual(["foo"]) - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('foo')}) - - def test_double(self): - parsed = parsing.parse_manual(["pypi::foo", "pypi::bar"]) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo', 'bar') - }) - - def test_version(self): - parsed = parsing.parse_manual(["pypi::foo == 3.5"]) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo == 3.5') - - }) - - def test_version_default(self): - parsed = parsing.parse_manual(["foo == 3.5"]) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo == 3.5') - - }) - - def test_vcs_simple(self): - url = "git+git://server.com/etc" - parsed = parsing.parse_manual(["vcs::" + url]) - self.assertDictEqual(parsed, {REPO_VCS: [parsing.VCSDependency(url)]}) - - def test_vcs_simple_default(self): - url = "git+git://server.com/etc" - parsed = parsing.parse_manual([url]) - self.assertDictEqual(parsed, {REPO_VCS: [parsing.VCSDependency(url)]}) - - def test_mixed(self): - parsed = parsing.parse_manual(["pypi::foo", "vcs::git+git://server.com/etc"]) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo'), - REPO_VCS: [parsing.VCSDependency("git+git://server.com/etc")], - }) - - -class ReqsParsingTestCase(unittest.TestCase): - """Check the requirements parsing.""" - - def setUp(self): - logassert.setup(self, 'fades.parsing') - - def test_empty(self): - parsed = parsing._parse_requirement(io.StringIO(""" - - """)) - self.assertDictEqual(parsed, {}) - - def test_simple(self): - parsed = parsing._parse_requirement(io.StringIO(""" - pypi::foo - """)) - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('foo')}) - - def test_simple_default(self): - parsed = parsing._parse_requirement(io.StringIO(""" - foo - """)) - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('foo')}) - - def test_double(self): - parsed = parsing._parse_requirement(io.StringIO(""" - pypi::time - foo - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('time', 'foo') - }) - - def test_version_same(self): - parsed = parsing._parse_requirement(io.StringIO(""" - pypi::foo == 3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo == 3.5') - }) - - def test_version_same_default(self): - parsed = parsing._parse_requirement(io.StringIO(""" - foo == 3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo == 3.5') - }) - - def test_version_different(self): - parsed = parsing._parse_requirement(io.StringIO(""" - foo !=3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo !=3.5') - }) - - def test_version_same_no_spaces(self): - parsed = parsing._parse_requirement(io.StringIO(""" - foo==3.5 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo ==3.5') - }) - - def test_version_greater_two_spaces(self): - parsed = parsing._parse_requirement(io.StringIO(""" - foo > 2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo > 2') - }) - - def test_version_same_or_greater(self): - parsed = parsing._parse_requirement(io.StringIO(""" - foo >=2 - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo >= 2') - }) - - def test_comments(self): - parsed = parsing._parse_requirement(io.StringIO(""" - pypi::foo # some text - # other text - bar - """)) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo', 'bar') - }) - - def test_strange_repo(self): - parsed = parsing._parse_requirement(io.StringIO(""" - unknown::foo - """)) - self.assertLoggedWarning("Not understood fades repository", "unknown") - self.assertDictEqual(parsed, {}) - - def test_vcs_simple(self): - parsed = parsing._parse_requirement(io.StringIO(""" - vcs::strangeurl - """)) - self.assertDictEqual(parsed, {REPO_VCS: [parsing.VCSDependency("strangeurl")]}) - - def test_vcs_simple_default(self): - parsed = parsing._parse_requirement(io.StringIO(""" - bzr+http://server/bleh - """)) - self.assertDictEqual(parsed, {REPO_VCS: [parsing.VCSDependency("bzr+http://server/bleh")]}) - - def test_mixed(self): - parsed = parsing._parse_requirement(io.StringIO(""" - vcs::strangeurl - pypi::foo - """)) - self.assertDictEqual(parsed, { - REPO_VCS: [parsing.VCSDependency("strangeurl")], - REPO_PYPI: get_reqs('foo'), - }) - - -class DocstringParsingTestCase(unittest.TestCase): - """Check the docstring parsing.""" - - def setUp(self): - logassert.setup(self, 'fades.parsing') - - def test_empty(self): - parsed = parsing._parse_docstring(io.StringIO(""" - - """)) - self.assertDictEqual(parsed, {}) - - def test_only_comment(self): - with open("tests/test_files/no_req.py") as f: - parsed = parsing._parse_docstring(f) - self.assertDictEqual(parsed, {}) - - def test_req_in_module_docstring_triple_doublequoute(self): - with open("tests/test_files/req_module.py") as f: - parsed = parsing._parse_docstring(f) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo', 'bar') - }) - - def test_req_in_module_docstring_triple_singlequote(self): - with open("tests/test_files/req_module_2.py") as f: - parsed = parsing._parse_docstring(f) - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo', 'bar') - }) - - def test_req_in_module_docstring_one_doublequote(self): - with open("tests/test_files/req_module_3.py") as f: - parsed = parsing._parse_docstring(f) - self.assertDictEqual(parsed, {}) - - def test_req_in_class_docstring(self): - with open("tests/test_files/req_class.py") as f: - parsed = parsing._parse_docstring(f) - # no requirements found - self.assertDictEqual(parsed, {}) - - def test_req_in_def_docstring(self): - with open("tests/test_files/req_def.py") as f: - parsed = parsing._parse_docstring(f) - # no requirements found - self.assertDictEqual(parsed, {}) - - def test_req_in_multi_docstring(self): - with open("tests/test_files/req_all.py") as f: - parsed = parsing._parse_docstring(f) - # Only module requirements was found - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo==1.4') - }) - - def test_fades_word_as_part_of_text(self): - with open("tests/test_files/fades_as_part_of_other_word.py") as f: - parsed = parsing._parse_docstring(f) - self.assertDictEqual(parsed, {}) - - def test_mixed_backends(self): - with open("tests/test_files/req_mixed_backends.py") as f: - parsed = parsing._parse_docstring(f) - # Only module requirements was found - self.assertDictEqual(parsed, { - REPO_PYPI: get_reqs('foo', 'bar'), - REPO_VCS: [parsing.VCSDependency('git+http://whatever'), - parsing.VCSDependency('anotherurl')], - }) - - -class VCSDependencyTestCase(unittest.TestCase): - """Check the VCSDependency.""" - - def test_string_representation(self): - """This is particularly tested because it's the interface to be installed.""" - dep = parsing.VCSDependency("testurl") - self.assertEqual(str(dep), "testurl") - - def test_contains(self): - """This is particularly tested because it's how fulfilling is tested.""" - dep1 = parsing.VCSDependency("testurl") - dep2 = parsing.VCSDependency("testurl") - dep3 = parsing.VCSDependency("otherurl") - self.assertTrue(dep1 in dep2) - self.assertFalse(dep1 in dep3) - - def test_equality(self): - dep1 = parsing.VCSDependency("testurl") - dep2 = parsing.VCSDependency("testurl") - dep3 = parsing.VCSDependency("otherurl") - self.assertTrue(dep1 == dep2) - self.assertFalse(dep1 == dep3) - self.assertFalse(dep1 != dep2) - self.assertTrue(dep1 != dep3) - self.assertFalse(dep1 == 123) - self.assertFalse(dep1 == "testurl") - - -class FileReqsParsingTestCase(unittest.TestCase): - """Check the requirements parsing from a reqs.txt file.""" - - def setUp(self): - logassert.setup(self, 'fades.parsing') - - def test_requirement_files(self): - requirement_file = create_tempfile(self, ['foo']) - parsed = parsing.parse_reqfile(requirement_file) - - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('foo')}) - - def test_nested_requirement_files(self): - requirement_file = create_tempfile(self, ['foo']) - requirement_file_nested = create_tempfile( - self, ['bar\n-r {}'.format(requirement_file)]) - parsed = parsing.parse_reqfile(requirement_file_nested) - - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('bar', 'foo')}) - - def test_nested_requirement_files_invalid_format(self): - requirement_file_nested = create_tempfile(self, ['foo\n-r']) - parsed = parsing.parse_reqfile(requirement_file_nested) - - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('foo')}) - self.assertLoggedWarning( - "Invalid format to indicate a nested requirements file:") - - def test_nested_requirement_files_not_pwd(self): - requirement_file = create_tempfile(self, ['foo']) - fname = os.path.basename(requirement_file) - requirement_file_nested = create_tempfile( - self, ['bar\n-r {}'.format(fname)]) - parsed = parsing.parse_reqfile(requirement_file_nested) - - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('bar', 'foo')}) - - def test_nested_requirement_files_first_line(self): - requirement_file = create_tempfile(self, ['foo']) - requirement_file_nested = create_tempfile( - self, ['\n-r {}\nbar'.format(requirement_file)]) - parsed = parsing.parse_reqfile(requirement_file_nested) - - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('foo', 'bar')}) - - def test_two_nested_requirement_files(self): - requirement_file = create_tempfile(self, ['foo']) - requirement_file_nested1 = create_tempfile( - self, ['bar\n-r {}'.format(requirement_file)]) - requirement_file_nested2 = create_tempfile( - self, ['baz\n-r {}'.format(requirement_file_nested1)]) - parsed = parsing.parse_reqfile(requirement_file_nested2) - - self.assertDictEqual(parsed, {REPO_PYPI: get_reqs('baz', 'bar', 'foo')}) diff --git a/tests/test_parsing/test_docstrings.py b/tests/test_parsing/test_docstrings.py new file mode 100644 index 0000000..0bf29f9 --- /dev/null +++ b/tests/test_parsing/test_docstrings.py @@ -0,0 +1,79 @@ +"""Check the docstring parsing.""" +import io + +from fades import parsing, REPO_PYPI, REPO_VCS + +from tests import get_reqs + + +def test_empty(): + parsed = parsing._parse_docstring( + io.StringIO(""" + + """) + ) + assert parsed == {} + + +def test_only_comment(): + with open("tests/test_files/no_req.py") as f: + parsed = parsing._parse_docstring(f) + assert parsed == {} + + +def test_req_in_module_docstring_triple_doublequoute(): + with open("tests/test_files/req_module.py") as f: + parsed = parsing._parse_docstring(f) + assert parsed == {REPO_PYPI: get_reqs("foo", "bar")} + + +def test_req_in_module_docstring_triple_singlequote(): + with open("tests/test_files/req_module_2.py") as f: + parsed = parsing._parse_docstring(f) + assert parsed == {REPO_PYPI: get_reqs("foo", "bar")} + + +def test_req_in_module_docstring_one_doublequote(): + with open("tests/test_files/req_module_3.py") as f: + parsed = parsing._parse_docstring(f) + assert parsed == {} + + +def test_req_in_class_docstring(): + with open("tests/test_files/req_class.py") as f: + parsed = parsing._parse_docstring(f) + # no requirements found + assert parsed == {} + + +def test_req_in_def_docstring(): + with open("tests/test_files/req_def.py") as f: + parsed = parsing._parse_docstring(f) + # no requirements found + assert parsed == {} + + +def test_req_in_multi_docstring(): + with open("tests/test_files/req_all.py") as f: + parsed = parsing._parse_docstring(f) + # Only module requirements was found + assert parsed == {REPO_PYPI: get_reqs("foo==1.4")} + + +def test_fades_word_as_part_of_text(): + with open("tests/test_files/fades_as_part_of_other_word.py") as f: + parsed = parsing._parse_docstring(f) + assert parsed == {} + + +def test_mixed_backends(): + with open("tests/test_files/req_mixed_backends.py") as f: + parsed = parsing._parse_docstring(f) + # Only module requirements was found + assert parsed == { + REPO_PYPI: get_reqs("foo", "bar"), + REPO_VCS: [ + parsing.VCSDependency("git+http://whatever"), + parsing.VCSDependency("anotherurl"), + ], + } diff --git a/tests/test_parsing/test_file_reqs.py b/tests/test_parsing/test_file_reqs.py new file mode 100644 index 0000000..f4a566a --- /dev/null +++ b/tests/test_parsing/test_file_reqs.py @@ -0,0 +1,59 @@ +"""Check the requirements parsing from a reqs.txt file.""" +import os + +from fades import parsing, REPO_PYPI + +from tests import get_reqs + + +def test_requirement_files(create_tmpfile): + parsed = parsing.parse_reqfile(create_tmpfile(['foo'])) + assert parsed == {REPO_PYPI: get_reqs('foo')} + + +def test_nested_requirement_files(create_tmpfile): + requirement_file = create_tmpfile(['foo']) + requirement_file_nested = create_tmpfile( + ['bar\n-r {}'.format(requirement_file)] + ) + parsed = parsing.parse_reqfile(requirement_file_nested) + + assert parsed == {REPO_PYPI: get_reqs('bar', 'foo')} + + +def test_nested_requirement_files_invalid_format(logged, create_tmpfile): + requirement_file_nested = create_tmpfile(['foo\n-r']) + parsed = parsing.parse_reqfile(requirement_file_nested) + + assert parsed == {REPO_PYPI: get_reqs('foo')} + logged.assert_warning("Invalid format to indicate a nested requirements file:") + + +def test_nested_requirement_files_not_pwd(create_tmpfile): + requirement_file = create_tmpfile(['foo']) + fname = os.path.basename(requirement_file) + requirement_file_nested = create_tmpfile( + ['bar\n-r {}'.format(fname)]) + parsed = parsing.parse_reqfile(requirement_file_nested) + + assert parsed, {REPO_PYPI: get_reqs('bar', 'foo')} + + +def test_nested_requirement_files_first_line(create_tmpfile): + requirement_file = create_tmpfile(['foo']) + requirement_file_nested = create_tmpfile( + ['\n-r {}\nbar'.format(requirement_file)]) + parsed = parsing.parse_reqfile(requirement_file_nested) + + assert parsed == {REPO_PYPI: get_reqs('foo', 'bar')} + + +def test_two_nested_requirement_files(create_tmpfile): + requirement_file = create_tmpfile(['foo']) + requirement_file_nested1 = create_tmpfile( + ['bar\n-r {}'.format(requirement_file)]) + requirement_file_nested2 = create_tmpfile( + ['baz\n-r {}'.format(requirement_file_nested1)]) + parsed = parsing.parse_reqfile(requirement_file_nested2) + + assert parsed == {REPO_PYPI: get_reqs('baz', 'bar', 'foo')} diff --git a/tests/test_parsing/test_manual.py b/tests/test_parsing/test_manual.py new file mode 100644 index 0000000..6554021 --- /dev/null +++ b/tests/test_parsing/test_manual.py @@ -0,0 +1,58 @@ +"""Tests for the check of the manual parsing.""" +from fades import parsing, REPO_PYPI, REPO_VCS +from tests import get_reqs + + +def test_none(): + parsed = parsing.parse_manual(None) + assert parsed == {} + + +def test_nothing(): + parsed = parsing.parse_manual([]) + assert parsed == {} + + +def test_simple(): + parsed = parsing.parse_manual(["pypi::foo"]) + assert parsed == {REPO_PYPI: get_reqs("foo")} + + +def test_simple_default_pypi(): + parsed = parsing.parse_manual(["foo"]) + assert parsed == {REPO_PYPI: get_reqs("foo")} + + +def test_double(): + parsed = parsing.parse_manual(["pypi::foo", "pypi::bar"]) + assert parsed == {REPO_PYPI: get_reqs("foo", "bar")} + + +def test_version(): + parsed = parsing.parse_manual(["pypi::foo == 3.5"]) + assert parsed == {REPO_PYPI: get_reqs("foo == 3.5")} + + +def test_version_default(): + parsed = parsing.parse_manual(["foo == 3.5"]) + assert parsed == {REPO_PYPI: get_reqs("foo == 3.5")} + + +def test_vcs_simple(): + url = "git+git://server.com/etc" + parsed = parsing.parse_manual(["vcs::" + url]) + assert parsed == {REPO_VCS: [parsing.VCSDependency(url)]} + + +def test_vcs_simple_default(): + url = "git+git://server.com/etc" + parsed = parsing.parse_manual([url]) + assert parsed == {REPO_VCS: [parsing.VCSDependency(url)]} + + +def test_mixed(): + parsed = parsing.parse_manual(["pypi::foo", "vcs::git+git://server.com/etc"]) + assert parsed == { + REPO_PYPI: get_reqs("foo"), + REPO_VCS: [parsing.VCSDependency("git+git://server.com/etc")], + } diff --git a/tests/test_parsing/test_vcs_dependency.py b/tests/test_parsing/test_vcs_dependency.py new file mode 100644 index 0000000..1960bb3 --- /dev/null +++ b/tests/test_parsing/test_vcs_dependency.py @@ -0,0 +1,29 @@ +"""Check the VCSDependency.""" +from fades import parsing + + +def test_string_representation(): + """This is particularly tested because it's the interface to be installed.""" + dep = parsing.VCSDependency("testurl") + assert str(dep), "testurl" + + +def test_contains(): + """This is particularly tested because it's how fulfilling is tested.""" + dep1 = parsing.VCSDependency("testurl") + dep2 = parsing.VCSDependency("testurl") + dep3 = parsing.VCSDependency("otherurl") + assert dep1 in dep2 + assert dep1 not in dep3 + + +def test_equality(): + dep1 = parsing.VCSDependency("testurl") + dep2 = parsing.VCSDependency("testurl") + dep3 = parsing.VCSDependency("otherurl") + assert dep1 == dep2 + assert not (dep1 == dep3) + assert not (dep1 != dep2) + assert dep1 != dep3 + assert not (dep1 == 123) + assert not (dep1 == "testurl") From 7fd9aa0c710064e7e5cf63fdfb4edd2f14f8f140 Mon Sep 17 00:00:00 2001 From: "Eduardo Enriqez (eduzen)" Date: Wed, 26 Jun 2019 01:32:01 +0200 Subject: [PATCH 4/4] Some changes after code review --- tests/test_parsing/test_file.py | 2 +- tests/test_parsing/test_reqs.py | 28 ++++++++++++---------------- 2 files changed, 13 insertions(+), 17 deletions(-) diff --git a/tests/test_parsing/test_file.py b/tests/test_parsing/test_file.py index 96a819e..6e91c93 100644 --- a/tests/test_parsing/test_file.py +++ b/tests/test_parsing/test_file.py @@ -497,5 +497,5 @@ def test_fades_and_hashtag_mentioned_in_code_mixed_with_imports(): def test_fades_user_strange_comment_with_hashtag_ignored(): parsed = parsing._parse_content(io.StringIO(""" import foo # fades==2 # Some comment with #hashtash - """)) # noqa + """)) assert parsed == {} diff --git a/tests/test_parsing/test_reqs.py b/tests/test_parsing/test_reqs.py index facf599..2b86766 100644 --- a/tests/test_parsing/test_reqs.py +++ b/tests/test_parsing/test_reqs.py @@ -1,13 +1,9 @@ """Check the requirements parsing.""" import io -from pkg_resources import parse_requirements from fades import parsing, REPO_PYPI, REPO_VCS - -def get_req(text): - """Transform a text requirement into the pkg_resources object.""" - return list(parse_requirements(text))[0] +from tests import get_reqs def test_empty(): @@ -21,14 +17,14 @@ def test_simple(): parsed = parsing._parse_requirement(io.StringIO(""" pypi::foo """)) - assert parsed == {REPO_PYPI: [get_req('foo')]} + assert parsed == {REPO_PYPI: get_reqs('foo')} def test_simple_default(): parsed = parsing._parse_requirement(io.StringIO(""" foo """)) - assert parsed == {REPO_PYPI: [get_req('foo')]} + assert parsed == {REPO_PYPI: get_reqs('foo')} def test_double(): @@ -37,7 +33,7 @@ def test_double(): foo """)) assert parsed == { - REPO_PYPI: [get_req('time'), get_req('foo')] + REPO_PYPI: get_reqs('time') + get_reqs('foo') } @@ -46,7 +42,7 @@ def test_version_same(): pypi::foo == 3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo == 3.5')] + REPO_PYPI: get_reqs('foo == 3.5') } @@ -55,7 +51,7 @@ def test_version_same_default(): foo == 3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo == 3.5')] + REPO_PYPI: get_reqs('foo == 3.5') } @@ -64,7 +60,7 @@ def test_version_different(): foo !=3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo !=3.5')] + REPO_PYPI: get_reqs('foo !=3.5') } @@ -73,7 +69,7 @@ def test_version_same_no_spaces(): foo==3.5 """)) assert parsed == { - REPO_PYPI: [get_req('foo ==3.5')] + REPO_PYPI: get_reqs('foo ==3.5') } @@ -82,7 +78,7 @@ def test_version_greater_two_spaces(): foo > 2 """)) assert parsed == { - REPO_PYPI: [get_req('foo > 2')] + REPO_PYPI: get_reqs('foo > 2') } @@ -91,7 +87,7 @@ def test_version_same_or_greater(): foo >=2 """)) assert parsed == { - REPO_PYPI: [get_req('foo >= 2')] + REPO_PYPI: get_reqs('foo >= 2') } @@ -102,7 +98,7 @@ def test_comments(): bar """)) assert parsed == { - REPO_PYPI: [get_req('foo'), get_req('bar')] + REPO_PYPI: get_reqs('foo') + get_reqs('bar') } @@ -135,5 +131,5 @@ def test_mixed(): """)) assert parsed == { REPO_VCS: [parsing.VCSDependency("strangeurl")], - REPO_PYPI: [get_req('foo')], + REPO_PYPI: get_reqs('foo'), }