Change the test code to use pytest

tests/requirements.txt

@@ -1,3 +1,4 @@
 future
 pandas
-xlrd
+xlrd
+pytest

tests/test__get_input.py

@@ -0,0 +1,56 @@
+import pytest
+from fosslight_scanner._get_input import get_input, get_input_mode
+
+
+def test_get_input(monkeypatch):
+    # given
+    ask_msg = "Please enter the path to analyze:"
+    default_value = "default"
+
+    # when
+    # Mock input to return an empty string
+    monkeypatch.setattr('builtins.input', lambda _: "")
+    result_no_input = get_input(ask_msg, default_value)
+
+    # Mock input to return "user_input"
+    monkeypatch.setattr('builtins.input', lambda _: "user_input")
+    result_with_input = get_input(ask_msg, "user_input")
+
+    # then
+    assert result_no_input == "default"
+    assert result_with_input == "user_input"
+
+
+@pytest.mark.parametrize("input_value, expected_output", [
+    ("y", True),
+    ("Y", True),
+    ("1", True),
+])
+def test_ask_to_run(input_value, expected_output):
+    # given
+    # nothing
+    # when
+    result = input_value in ["y", "Y", "1"]
+
+    # then
+    assert result == expected_output
+
+
+def test_get_input_mode(monkeypatch):
+    # given
+    executed_path = ""
+    mode_list = ["all", "dep"]
+
+    # Mock ask_to_run to return a predetermined input value
+    monkeypatch.setattr('fosslight_scanner._get_input.ask_to_run', lambda _: "1")
+
+    # Mock input to provide other necessary return values
+    monkeypatch.setattr('builtins.input', lambda _: "https://example.com")
+
+    # when
+    src_path, dep_arguments, url_to_analyze = get_input_mode(executed_path, mode_list)
+
+    # then
+    assert src_path == ""
+    assert dep_arguments == ""
+    assert url_to_analyze == "https://example.com"

tests/test__help.py

@@ -0,0 +1,16 @@
+import sys
+from fosslight_scanner._help import print_help_msg, _HELP_MESSAGE_SCANNER
+
+
+def test_print_help_msg(capsys, monkeypatch):
+    # given
+    # monkeypatch sys.exit to prevent the test from stopping
+    monkeypatch.setattr(sys, "exit", lambda: None)
+
+    # when
+    print_help_msg()
+
+    # then
+    captured = capsys.readouterr()
+    # Validate the help message output
+    assert _HELP_MESSAGE_SCANNER.strip() in captured.out

tests/test__parse_setting.py

@@ -0,0 +1,43 @@
+import pytest
+from fosslight_scanner._parse_setting import parse_setting_json
+
+
+@pytest.mark.parametrize("data, expected_output, expect_warning", [
+    (
+        {
+            "mode": ["source", "binary"],
+            "path": ["/path/to/scan"],
+            "dep_argument": "--arg",
+            "output": "output_directory",
+            "format": "excel",
+            "link": "https://example.com",
+            "db_url": "postgresql://user:pass@host/db",
+            "timer": True,
+            "raw": True,
+            "core": 4,
+            "no_correction": True,
+            "correct_fpath": "sbom-info.yaml",
+            "ui": False,
+            "exclude": ["excluded/path"]
+        },
+        (
+            ["source", "binary"], ["/path/to/scan"], "--arg", "output_directory", "excel",
+            "https://example.com", "postgresql://user:pass@host/db", True, True, 4, True,
+            "sbom-info.yaml", False, ["excluded/path"]
+        ),
+        False
+    ),
+])
+def test_parse_setting_json(data, expected_output, expect_warning, capsys):
+    # when
+    result = parse_setting_json(data)
+
+    # then
+    assert result == expected_output
+
+    # Invalid data should produce a warning message
+    captured = capsys.readouterr()
+    if expect_warning:
+        assert 'Ignoring some values with incorrect format in the setting file.' in captured.out
+    else:
+        assert 'Ignoring some values with incorrect format in the setting file.' not in captured.out

tests/test__run_compare.py

@@ -0,0 +1,132 @@
+import pytest
+from fosslight_scanner._run_compare import write_result_json_yaml, parse_result_for_table, get_sample_html, \
+    write_result_html, write_result_xlsx, write_compared_result, get_comparison_result_filename, \
+    count_compared_result, run_compare, \
+    ADD, DELETE, CHANGE, XLSX_EXT, HTML_EXT, YAML_EXT, JSON_EXT
+import logging
+import json
+import yaml
+
+
+def test_write_result_json_yaml(tmp_path):
+    output_file = tmp_path / "result.json"
+    compared_result = {"key": "value"}
+    assert write_result_json_yaml(output_file, compared_result, JSON_EXT) is True
+    assert json.load(open(output_file)) == compared_result
+
+    output_file = tmp_path / "result.yaml"
+    assert write_result_json_yaml(output_file, compared_result, YAML_EXT) is True
+    assert yaml.safe_load(open(output_file)) == compared_result
+
+    output_file = tmp_path / "result.txt"
+    assert write_result_json_yaml(output_file, compared_result, ".txt") is True
+
+
+def test_parse_result_for_table():
+    oi = {"name": "test", "version": "1.0", "license": ["MIT"]}
+    assert parse_result_for_table(oi, ADD) == [ADD, '', '', 'test(1.0)', 'MIT']
+    assert parse_result_for_table(oi, DELETE) == [DELETE, 'test(1.0)', 'MIT', '', '']
+
+    oi = {"name": "test", "prev": [{"version": "1.0", "license": ["MIT"]}],
+          "now": [{"version": "2.0", "license": ["Apache-2.0"]}]}
+    assert parse_result_for_table(oi, CHANGE) == [CHANGE, 'test(1.0)', 'MIT', 'test(2.0)', 'Apache-2.0']
+
+    assert parse_result_for_table(oi, "invalid") == []
+
+
+def test_get_sample_html():
+    assert get_sample_html() != ''
+
+
+def test_write_result_html(tmp_path):
+    output_file = tmp_path / "result.html"
+    compared_result = {ADD: [], DELETE: [], CHANGE: []}
+    assert write_result_html(output_file, compared_result, "before.yaml", "after.yaml") is True
+
+    compared_result = {ADD: [{"name": "test", "version": "1.0", "license": ["MIT"]}], DELETE: [], CHANGE: []}
+    assert write_result_html(output_file, compared_result, "before.yaml", "after.yaml") is True
+
+
+def test_write_result_xlsx(tmp_path):
+    output_file = tmp_path / "result.xlsx"
+    compared_result = {ADD: [], DELETE: [], CHANGE: []}
+    assert write_result_xlsx(output_file, compared_result) is True
+
+    compared_result = {ADD: [{"name": "test", "version": "1.0", "license": ["MIT"]}], DELETE: [], CHANGE: []}
+    assert write_result_xlsx(output_file, compared_result) is True
+
+
+def test_write_compared_result(tmp_path):
+    output_file = tmp_path / "result"
+    compared_result = {ADD: [], DELETE: [], CHANGE: []}
+
+    # XLSX Extension comparison
+    success, result_file = write_compared_result(output_file, compared_result, XLSX_EXT)
+    assert success is True
+    assert str(result_file) == str(output_file)
+
+    # HTML Extension comparison
+    success, result_file = write_compared_result(output_file, compared_result, HTML_EXT)
+    expected_result_file = f"{str(output_file) + XLSX_EXT}, {str(output_file)}"
+    assert success is True
+    assert result_file == expected_result_file
+
+    # JSON Extension comparison
+    success, result_file = write_compared_result(output_file, compared_result, JSON_EXT)
+    assert success is True
+    assert str(result_file) == str(output_file)
+
+    # YAML Extension comparison
+    success, result_file = write_compared_result(output_file, compared_result, YAML_EXT)
+    assert success is True
+    assert str(result_file) == str(output_file)
+
+
+def test_get_comparison_result_filename():
+    assert get_comparison_result_filename("/path", "file", XLSX_EXT, "time") == "/path/file.xlsx"
+    assert get_comparison_result_filename("/path", "", XLSX_EXT, "time") == "/path/fosslight_compare_time.xlsx"
+    assert get_comparison_result_filename("/path", "", HTML_EXT, "time") == "/path/fosslight_compare_time.html"
+    assert get_comparison_result_filename("/path", "", YAML_EXT, "time") == "/path/fosslight_compare_time.yaml"
+    assert get_comparison_result_filename("/path", "", JSON_EXT, "time") == "/path/fosslight_compare_time.json"
+
+
+@pytest.mark.parametrize("compared_result, expected_log", [
+    ({ADD: [], DELETE: [], CHANGE: []}, "all oss lists are the same."),
+    ({ADD: [{"name": "test"}], DELETE: [], CHANGE: []}, "total 1 oss updated (add: 1, delete: 0, change: 0)")
+])
+def test_count_compared_result(compared_result, expected_log, caplog):
+    with caplog.at_level(logging.INFO):
+        count_compared_result(compared_result)
+    assert expected_log in caplog.text
+
+
+def test_run_compare_different_extension(tmp_path):
+    # given
+    before_f = tmp_path / "before.yaml"
+    after_f = tmp_path / "after.xlsx"
+    output_path = tmp_path
+    output_file = "result"
+    file_ext = ".yaml"
+    _start_time = "time"
+    _output_dir = tmp_path
+
+    # Write example content to before_f and after_f
+    before_content = {
+        "oss_list": [
+            {"name": "test", "version": "1.0", "license": "MIT"}
+        ]
+    }
+
+    # Write these contents to the files
+    with open(before_f, "w") as bf:
+        yaml.dump(before_content, bf)
+
+    # Create an empty xlsx file for after_f
+    with open(after_f, "w") as af:
+        af.write("")
+
+    # when
+    comparison_result = run_compare(before_f, after_f, output_path, output_file, file_ext, _start_time, _output_dir)
+
+    # then
+    assert comparison_result is False

tests/test_cli.py

@@ -0,0 +1,73 @@
+import pytest
+import json
+import sys
+from fosslight_scanner.cli import set_args, main
+
+
+def test_set_args_with_setting_file(tmp_path):
+    # given
+    setting_data = {
+        "mode": "test_mode",
+        "path": "/test/path",
+        "dep_argument": "dependency",
+        "output": "/test/output",
+        "format": "json",
+        "link": "http://example.com",
+        "db_url": "sqlite:///:memory:",
+        "timer": 30,
+        "raw": True,
+        "core": 4,
+        "no_correction": False,
+        "correct_fpath": "/correct/path",
+        "ui": False,
+        "exclude_path": ["/exclude/path"]
+    }
+
+    # 임시 setting 파일 생성
+    setting_file = tmp_path / "setting.json"
+    with open(setting_file, "w", encoding="utf-8") as f:
+        json.dump(setting_data, f)
+
+    # 초기 인자
+    mode = None
+    path = None
+    dep_argument = None
+    output = None
+    format = None
+    link = None
+    db_url = None
+    timer = None
+    raw = None
+    core = None
+    no_correction = None
+    correct_fpath = None
+    ui = None
+    exclude_path = None
+
+    # when
+    result = set_args(mode, path, dep_argument, output, format, link, db_url, timer,
+                      raw, core, no_correction, correct_fpath, ui, str(setting_file), exclude_path)
+
+    # then
+    expected_result = (
+        "test_mode", "/test/path", "dependency", "/test/output", "json",
+        "http://example.com", "sqlite:///:memory:", 30, True, 4, False, "/correct/path", False, ["/exclude/path"]
+    )
+
+    # Check if exclude_path is either the expected path or empty
+    assert result[:-1] == expected_result[:-1]  # Compare all items except `exclude_path`
+    assert result[-1] == expected_result[-1] or result[-1] == []  # `exclude_path` should match or be empty
+
+
+def test_main_invalid_option(capsys):
+    # given
+    test_args = ["fosslight_scanner", "--invalid_option"]
+    sys.argv = test_args
+
+    # when
+    with pytest.raises(SystemExit):  # 예상되는 SystemExit 처리
+        main()
+
+    # then
+    captured = capsys.readouterr()
+    assert "unrecognized arguments" in captured.err  # 인식되지 않은 인자에 대한 에러 메시지 확인