def test_addheader_force_dot_license_identical_to_explicit_license(
fake_repository, stringio, mock_date_today):
"""For backwards compatibility, --force-dot-license should have identical
results as --explicit-license.
"""
files = [
fake_repository / "foo.py",
fake_repository / "bar.py",
]
for path in files:
path.write_text("pass")
expected = cleandoc("""
spdx-FileCopyrightText: 2018 Jane Doe
spdx-License-Identifier: GPL-3.0-or-later
""").replace("spdx", "SPDX")
for arg, path in zip(("--force-dot-license", "--explicit-license"), files):
main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Jane Doe",
arg,
str(path),
],
out=stringio,
)
for path in files:
assert (path.with_name(f"{path.name}.license").read_text().strip() ==
expected)
assert path.read_text() == "pass"
def test_addheader_no_copyright_or_license(fake_repository):
"""Add a header, but supply no copyright or license."""
simple_file = fake_repository / "foo.py"
simple_file.write_text("pass")
with pytest.raises(SystemExit):
main(["addheader", "foo.py"])
def test_download_custom_output_too_many(empty_directory, stringio,
mock_put_license_in_file):
"""Providing more than one license with a custom output results in an
error.
"""
with pytest.raises(SystemExit):
main(["download", "-o", "foo", "0BSD", "GPL-3.0-or-later"],
out=stringio)
def test_addheader_merge_copyrights_simple(fake_repository, stringio):
"""Add multiple headers to a file with merge copyrights."""
simple_file = fake_repository / "foo.py"
simple_file.write_text("pass")
result = main(
[
"addheader",
"--year",
"2016",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--merge-copyrights",
"foo.py",
],
out=stringio,
)
assert result == 0
assert (simple_file.read_text() == cleandoc("""
# spdx-FileCopyrightText: 2016 Mary Sue
#
# spdx-License-Identifier: GPL-3.0-or-later
pass
""").replace("spdx", "SPDX"))
result = main(
[
"addheader",
"--year",
"2018",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--merge-copyrights",
"foo.py",
],
out=stringio,
)
assert result == 0
assert (simple_file.read_text() == cleandoc("""
# spdx-FileCopyrightText: 2016 - 2018 Mary Sue
#
# spdx-License-Identifier: GPL-3.0-or-later
pass
""").replace("spdx", "SPDX"))
def test_addheader_single_line_not_supported(fake_repository, skip_option):
"""Expect a fail if --single-line is not supported for a file type."""
with pytest.raises(SystemExit):
main([
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--single-line",
skip_option,
"src/source_code.html",
])
def test_addheader_single_multi_line_mutually_exclusive(fake_repository):
"""--single-line and --multi-line are mutually exclusive."""
with pytest.raises(SystemExit):
main([
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--single-line",
"--multi-line",
"src/source_code.c",
])
def test_addheader_unrecognised_style(fake_repository):
"""Add a header to a file that has an unrecognised extension."""
simple_file = fake_repository / "foo.foo"
simple_file.write_text("pass")
with pytest.raises(SystemExit):
main([
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"foo.foo",
])
def test_addheader_year_mutually_exclusive(fake_repository):
"""--exclude-year and --year are mutually exclusive."""
with pytest.raises(SystemExit):
main([
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--exclude-year",
"--year",
"2020",
"src/source_code.py",
])
def test_addheader_explicit_license_double(fake_repository, stringio,
mock_date_today):
"""When path.license already exists, don't create path.license.license."""
simple_file = fake_repository / "foo.txt"
simple_file_license = fake_repository / "foo.txt.license"
simple_file_license_license = fake_repository / "foo.txt.license.license"
simple_file.write_text("foo")
simple_file_license.write_text("foo")
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--explicit-license",
"foo.txt",
],
out=stringio,
)
assert result == 0
assert not simple_file_license_license.exists()
assert (simple_file_license.read_text().strip() == cleandoc("""
spdx-FileCopyrightText: 2018 Mary Sue
spdx-License-Identifier: GPL-3.0-or-later
""").replace("spdx", "SPDX"))
def test_addheader_uncommentable_json(fake_repository, stringio,
mock_date_today):
"""Add a header to a .license file if the file is uncommentable, e.g., JSON."""
json_file = fake_repository / "foo.json"
json_file.write_text('{"foo": 23, "bar": 42}')
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"foo.json",
],
out=stringio,
)
assert result == 0
assert (json_file.with_name(
f"{json_file.name}.license").read_text().strip() == cleandoc("""
spdx-FileCopyrightText: 2018 Mary Sue
spdx-License-Identifier: GPL-3.0-or-later
""").replace("spdx", "SPDX"))
def test_addheader_binary(fake_repository, stringio, mock_date_today,
binary_string):
"""Add a header to a .license file if the file is a binary."""
binary_file = fake_repository / "foo.png"
binary_file.write_bytes(binary_string)
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"foo.png",
],
out=stringio,
)
assert result == 0
assert (binary_file.with_name(
f"{binary_file.name}.license").read_text().strip() == cleandoc("""
spdx-FileCopyrightText: 2018 Mary Sue
spdx-License-Identifier: GPL-3.0-or-later
""").replace("spdx", "SPDX"))
def test_addheader_template_without_extension(fake_repository, stringio,
mock_date_today,
template_simple_source):
"""Find the correct header even when not using an extension."""
simple_file = fake_repository / "foo.py"
simple_file.write_text("pass")
template_file = fake_repository / ".reuse/templates/mytemplate.jinja2"
template_file.parent.mkdir(parents=True, exist_ok=True)
template_file.write_text(template_simple_source)
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--template",
"mytemplate",
"foo.py",
],
out=stringio,
)
assert result == 0
assert (simple_file.read_text() == cleandoc("""
# Hello, world!
#
# spdx-FileCopyrightText: 2018 Mary Sue
#
# spdx-License-Identifier: GPL-3.0-or-later
pass
""").replace("spdx", "SPDX"))
def test_addheader_explicit_license(fake_repository, stringio,
mock_date_today):
"""Add a header to a .license file if --explicit-license is given."""
# pylint: disable=unused-argument
simple_file = fake_repository / "foo.py"
simple_file.write_text("pass")
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--explicit-license",
"foo.py",
],
out=stringio,
)
assert result == 0
assert (simple_file.with_name(
f"{simple_file.name}.license").read_text().strip() == cleandoc("""
spdx-FileCopyrightText: 2018 Mary Sue
spdx-License-Identifier: GPL-3.0-or-later
""").replace("spdx", "SPDX"))
assert simple_file.read_text() == "pass"
def test_addheader_line_endings(empty_directory, stringio, mock_date_today,
line_ending):
"""Given a file with a certain type of line ending, preserve it."""
simple_file = empty_directory / "foo.py"
simple_file.write_bytes(
line_ending.encode("utf-8").join([b"hello", b"world"]))
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"foo.py",
],
out=stringio,
)
assert result == 0
with open(simple_file, newline="") as fp:
contents = fp.read()
assert (contents == cleandoc("""
# spdx-FileCopyrightText: 2018 Mary Sue
#
# spdx-License-Identifier: GPL-3.0-or-later
hello
world
""").replace("spdx", "SPDX").replace("\n", line_ending))
def test_lint_custom_root_different_cwd(fake_repository, stringio):
"""Use a custom root while CWD is different."""
os.chdir("/")
result = main(["--root", str(fake_repository), "lint"], out=stringio)
assert result == 0
assert ":-)" in stringio.getvalue()
def test_addheader_implicit_style(fake_repository, stringio, mock_date_today):
"""Add a header to a file that has a recognised extension."""
simple_file = fake_repository / "foo.js"
simple_file.write_text("pass")
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"foo.js",
],
out=stringio,
)
assert result == 0
assert (simple_file.read_text() == cleandoc("""
// spdx-FileCopyrightText: 2018 Mary Sue
//
// spdx-License-Identifier: GPL-3.0-or-later
pass
""").replace("spdx", "SPDX"))
def test_addheader_simple(fake_repository, stringio, mock_date_today):
"""Add a header to a file that does not have one."""
simple_file = fake_repository / "foo.py"
simple_file.write_text("pass")
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"foo.py",
],
out=stringio,
)
assert result == 0
assert (simple_file.read_text() == cleandoc("""
# spdx-FileCopyrightText: 2018 Mary Sue
#
# spdx-License-Identifier: GPL-3.0-or-later
pass
""").replace("spdx", "SPDX"))
def test_lint_submodule_included_fail(submodule_repository, stringio):
"""Run a failed lint."""
(submodule_repository / "submodule/foo.c").touch()
result = main(["--include-submodules", "lint"], out=stringio)
assert result == 1
assert ":-(" in stringio.getvalue()
def test_lint_submodule(submodule_repository, stringio):
"""Run a successful lint."""
(submodule_repository / "submodule/foo.c").touch()
result = main(["lint"], out=stringio)
assert result == 0
assert ":-)" in stringio.getvalue()
def test_addheader_specify_style(fake_repository, stringio, mock_date_today):
"""Add a header to a file that does not have one, using a custom style."""
# pylint: disable=unused-argument
simple_file = fake_repository / "foo.py"
simple_file.write_text("pass")
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--style",
"c",
"foo.py",
],
out=stringio,
)
assert result == 0
assert (simple_file.read_text() == cleandoc("""
// spdx-FileCopyrightText: 2018 Mary Sue
//
// spdx-License-Identifier: GPL-3.0-or-later
pass
""").replace("spdx", "SPDX"))
def test_addheader_explicit_license_unsupported_filetype(
fake_repository, stringio, mock_date_today):
"""Add a header to a .license file if --explicit-license is given, with the
base file being an otherwise unsupported filetype.
"""
simple_file = fake_repository / "foo.txt"
simple_file.write_text("Preserve this")
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--explicit-license",
"foo.txt",
],
out=stringio,
)
assert result == 0
assert (simple_file.with_name(
f"{simple_file.name}.license").read_text().strip() == cleandoc("""
spdx-FileCopyrightText: 2018 Mary Sue
spdx-License-Identifier: GPL-3.0-or-later
""").replace("spdx", "SPDX"))
assert simple_file.read_text() == "Preserve this"
def test_lint_fail_quiet(fake_repository, stringio):
"""Run a failed lint."""
(fake_repository / "foo.py").write_text("foo")
result = main(["lint", "--quiet"], out=stringio)
assert result > 0
assert stringio.getvalue() == ""
def test_addheader_license_file(fake_repository, stringio, mock_date_today):
"""Add a header to a .license file if it exists."""
simple_file = fake_repository / "foo.py"
simple_file.write_text("foo")
license_file = fake_repository / "foo.py.license"
license_file.write_text(
cleandoc("""
spdx-FileCopyrightText: 2016 Jane Doe
Hello
""").replace("spdx", "SPDX"))
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"foo.py",
],
out=stringio,
)
assert result == 0
assert (license_file.read_text() == cleandoc("""
spdx-FileCopyrightText: 2016 Jane Doe
spdx-FileCopyrightText: 2018 Mary Sue
spdx-License-Identifier: GPL-3.0-or-later
""").replace("spdx", "SPDX"))
assert simple_file.read_text() == "foo"
def test_lint_custom_root_git(git_repository, stringio):
"""Use a custom root location in a git repo."""
result = main(["--root", "doc", "lint"], out=stringio)
assert result > 0
assert "index.rst" in stringio.getvalue()
assert ":-(" in stringio.getvalue()
def test_addheader_year(fake_repository, stringio):
"""Add a header to a file with a custom year."""
# pylint: disable=unused-argument
simple_file = fake_repository / "foo.py"
simple_file.write_text("pass")
result = main(
[
"addheader",
"--year",
"2016",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"foo.py",
],
out=stringio,
)
assert result == 0
assert (simple_file.read_text() == cleandoc("""
# spdx-FileCopyrightText: 2016 Mary Sue
#
# spdx-License-Identifier: GPL-3.0-or-later
pass
""").replace("spdx", "SPDX"))
def test_addheader_template_simple_multiple(fake_repository, stringio,
mock_date_today,
template_simple_source):
"""Add a header with a custom template to multiple files."""
simple_files = [fake_repository / f"foo{i}.py" for i in range(10)]
for simple_file in simple_files:
simple_file.write_text("pass")
template_file = fake_repository / ".reuse/templates/mytemplate.jinja2"
template_file.parent.mkdir(parents=True, exist_ok=True)
template_file.write_text(template_simple_source)
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--template",
"mytemplate.jinja2",
] + list(map(str, simple_files)),
out=stringio,
)
assert result == 0
for simple_file in simple_files:
assert (simple_file.read_text() == cleandoc("""
# Hello, world!
#
# spdx-FileCopyrightText: 2018 Mary Sue
#
# spdx-License-Identifier: GPL-3.0-or-later
pass
""").replace("spdx", "SPDX"))
def test_addheader_force_multi_line_for_c(fake_repository, stringio,
mock_date_today):
"""--multi-line forces a multi-line comment for C."""
simple_file = fake_repository / "foo.c"
simple_file.write_text("foo")
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--multi-line",
"foo.c",
],
out=stringio,
)
assert result == 0
assert (simple_file.read_text() == cleandoc("""
/*
* spdx-FileCopyrightText: 2018 Mary Sue
*
* spdx-License-Identifier: GPL-3.0-or-later
*/
foo
""").replace("spdx", "SPDX"))
def test_addheader_template_commented(fake_repository, stringio,
mock_date_today,
template_commented_source):
"""Add a header with a custom template that is already commented."""
simple_file = fake_repository / "foo.c"
simple_file.write_text("pass")
template_file = (fake_repository /
".reuse/templates/mytemplate.commented.jinja2")
template_file.parent.mkdir(parents=True, exist_ok=True)
template_file.write_text(template_commented_source)
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--template",
"mytemplate.commented.jinja2",
"foo.c",
],
out=stringio,
)
assert result == 0
assert (simple_file.read_text() == cleandoc("""
# Hello, world!
#
# spdx-FileCopyrightText: 2018 Mary Sue
#
# spdx-License-Identifier: GPL-3.0-or-later
pass
""").replace("spdx", "SPDX"))
def test_addheader_no_year(fake_repository, stringio):
"""Add a header to a file without a year."""
simple_file = fake_repository / "foo.py"
simple_file.write_text("pass")
result = main(
[
"addheader",
"--exclude-year",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"foo.py",
],
out=stringio,
)
assert result == 0
assert (simple_file.read_text() == cleandoc("""
# spdx-FileCopyrightText: Mary Sue
#
# spdx-License-Identifier: GPL-3.0-or-later
pass
""").replace("spdx", "SPDX"))
def test_addheader_template_no_spdx(fake_repository, stringio,
template_no_spdx_source):
"""Add a header with a template that lacks SPDX info."""
# pylint: disable=unused-argument
simple_file = fake_repository / "foo.py"
simple_file.write_text("pass")
template_file = fake_repository / ".reuse/templates/mytemplate.jinja2"
template_file.parent.mkdir(parents=True, exist_ok=True)
template_file.write_text(template_no_spdx_source)
result = main(
[
"addheader",
"--license",
"GPL-3.0-or-later",
"--copyright",
"Mary Sue",
"--template",
"mytemplate.jinja2",
"foo.py",
],
out=stringio,
)
assert result == 1
