fosslight-scanner 2.1.9__tar.gz → 2.1.11__tar.gz

{fosslight_scanner-2.1.9 → fosslight_scanner-2.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: fosslight_scanner
-Version: 2.1.9
+Version: 2.1.11
 Summary: FOSSLight Scanner
 Home-page: https://github.com/fosslight/fosslight_scanner
 Download-URL: https://github.com/fosslight/fosslight_scanner
@@ -14,6 +14,28 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10,<3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: future
+Requires-Dist: pandas
+Requires-Dist: openpyxl
+Requires-Dist: progress
+Requires-Dist: pyyaml
+Requires-Dist: beautifulsoup4
+Requires-Dist: fosslight_util<3.0.0,>=2.1.12
+Requires-Dist: fosslight_source<3.0.0,>=2.1.12
+Requires-Dist: fosslight_dependency<5.0.0,>=4.1.3
+Requires-Dist: fosslight_binary<6.0.0,>=5.1.9
+Requires-Dist: fosslight_prechecker<5.0.0,>=4.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 <!--
 Copyright (c) 2021 LG Electronics

{fosslight_scanner-2.1.9 → fosslight_scanner-2.1.11}/setup.py

@@ -15,7 +15,7 @@ with open('requirements.txt', 'r', 'utf-8') as f:
 if __name__ == "__main__":
     setup(
         name='fosslight_scanner',
-        version='2.1.9',
+        version='2.1.11',
         package_dir={"": "src"},
         packages=find_packages(where='src'),
         description='FOSSLight Scanner',

{fosslight_scanner-2.1.9 → fosslight_scanner-2.1.11}/src/fosslight_scanner/_help.py

@@ -3,8 +3,9 @@
 # Copyright (c) 2021 LG Electronics Inc.
 # SPDX-License-Identifier: Apache-2.0
 from fosslight_util.help import PrintHelpMsg
+from fosslight_util.output_format import SUPPORT_FORMAT
 
-_HELP_MESSAGE_SCANNER = """
+_HELP_MESSAGE_SCANNER = f"""
     FOSSLight Scanner performs open source analysis after downloading the source from URL that can be cloned by git or wget.
     Instead, open source analysis and checking copyright/license rules can be performed for the local source path.
     The output result is generated in OSS Report format.
@@ -21,14 +22,14 @@ _HELP_MESSAGE_SCANNER = """
 
         Options:
             -h\t\t\t    Print help message
-            -p <path>\t\t    Path to analyze (ex, -p {input_path})
+            -p <path>\t\t    Path to analyze (ex, -p [input_path])
                                      * Compare mode input file: Two FOSSLight reports (supports excel, yaml)
-                                       (ex, -p {before_name}.xlsx {after_name}.xlsx)
+                                       (ex, -p [before_name].xlsx [after_name].xlsx)
             -w <link>\t\t    Link to be analyzed can be downloaded by wget or git clone
-            -f <formats> [<format> ...]\t    FOSSLight Report file format (excel, csv, opossum, yaml, spdx-tag, spdx-yaml, spdx-json, spdx-xml)
+            -f <formats> [<format> ...]\t    FOSSLight Report file format ({', '.join(SUPPORT_FORMAT)})
                                      * Compare mode result file: supports excel, json, yaml, html
                                      * Multiple formats can be specified separated by space.
-            -e <path>\t\t    Path to exclude from analysis (ex, -e {dir} {file})
+            -e <path>\t\t    Path to exclude from analysis (ex, -e [dir] [file])
             -o <output>\t\t    Output directory or file
             -c <number>\t\t    Number of processes to analyze source
             -r\t\t\t    Keep raw data
@@ -40,13 +41,14 @@ _HELP_MESSAGE_SCANNER = """
             --no_correction\t    Enter if you don't want to correct OSS information with sbom-info.yaml
                                      * Correction mode only supported xlsx format.
             --correct_fpath <path>  Path to the sbom-info.yaml file
-            --ui\t\t\t  Generate UI mode result file
+            --ui\t\t    Generate UI mode result file
+            --recursive_dep\t    Recursively analyze dependencies
 
         Options for only 'all' or 'bin' mode
             -u <db_url>\t\t    DB Connection(format :'postgresql://username:password@host:port/database_name')
 
         Options for only 'all' or 'dependency' mode
-            -d <dependency_argument>\t    Additional arguments for running dependency analysis"""
+            -d <dependency_arg>\t    Additional arguments for running dependency analysis"""
 
 
 def print_help_msg():

{fosslight_scanner-2.1.9 → fosslight_scanner-2.1.11}/src/fosslight_scanner/_parse_setting.py

@@ -25,12 +25,13 @@ def parse_setting_json(data):
     source_print_matched_text = data.get('source_print_matched_text', False)
     source_time_out = data.get('source_time_out', 120)
     binary_simple = data.get('binary_simple', False)
+    recursive_dep = data.get('recursive_dep', False)
     str_lists = [mode, path, exclude_path]
     strings = [
         dep_argument, output, format, db_url,
         correct_fpath, link, selected_source_scanner
     ]
-    booleans = [timer, raw, no_correction, ui, source_write_json_file, source_print_matched_text, binary_simple]
+    booleans = [timer, raw, no_correction, ui, source_write_json_file, source_print_matched_text, binary_simple, recursive_dep]
 
     is_incorrect = False
 
@@ -65,4 +66,4 @@ def parse_setting_json(data):
     return mode, path, dep_argument, output, format, link, db_url, timer, \
         raw, core, no_correction, correct_fpath, ui, exclude_path, \
         selected_source_scanner, source_write_json_file, source_print_matched_text, source_time_out, \
-        binary_simple
+        binary_simple, recursive_dep

{fosslight_scanner-2.1.9 → fosslight_scanner-2.1.11}/src/fosslight_scanner/cli.py

@@ -15,7 +15,8 @@ from fosslight_util.help import print_package_version
 
 
 def set_args(mode, path, dep_argument, output, format, link, db_url, timer,
-             raw, core, no_correction, correct_fpath, ui, setting, exclude_path):
+             raw, core, no_correction, correct_fpath, ui, setting, exclude_path,
+             recursive_dep):
 
     selected_source_scanner = "all"
     source_write_json_file = False
@@ -30,7 +31,7 @@ def set_args(mode, path, dep_argument, output, format, link, db_url, timer,
             s_mode, s_path, s_dep_argument, s_output, s_format, s_link, s_db_url, s_timer, s_raw, s_core, \
                 s_no_correction, s_correct_fpath, s_ui, s_exclude_path, \
                 s_selected_source_scanner, s_source_write_json_file, s_source_print_matched_text, \
-                s_source_time_out, s_binary_simple = parse_setting_json(data)
+                s_source_time_out, s_binary_simple, s_recursive_dep = parse_setting_json(data)
 
             # direct cli arguments have higher priority than setting file
             mode = mode or s_mode
@@ -47,6 +48,7 @@ def set_args(mode, path, dep_argument, output, format, link, db_url, timer,
             correct_fpath = correct_fpath or s_correct_fpath
             ui = ui or s_ui
             exclude_path = exclude_path or s_exclude_path
+            recursive_dep = recursive_dep or s_recursive_dep
 
             # These options are only set from the setting file, not from CLI arguments
             selected_source_scanner = s_selected_source_scanner or selected_source_scanner
@@ -60,7 +62,7 @@ def set_args(mode, path, dep_argument, output, format, link, db_url, timer,
     return mode, path, dep_argument, output, format, link, db_url, timer, \
         raw, core, no_correction, correct_fpath, ui, exclude_path, \
         selected_source_scanner, source_write_json_file, source_print_matched_text, source_time_out, \
-        binary_simple
+        binary_simple, recursive_dep
 
 
 def main():
@@ -79,7 +81,7 @@ def main():
                         type=str, dest='format',nargs='*', default=[])
     parser.add_argument('--output', '-o', help='Output directory or file',
                         type=str, dest='output', default="")
-    parser.add_argument('--dependency', '-d', help='Dependency arguments',
+    parser.add_argument('--dependency', '-d', help='Dependency arguments (e.g. -d "-m pip" )',
                         type=str, dest='dep_argument', default="")
     parser.add_argument('--url', '-u', help="DB Url",
                         type=str, dest='db_url', default="")
@@ -105,6 +107,8 @@ def main():
                         type=str, required=False, default='')
     parser.add_argument('--ui', help='Generate UI mode result file',
                         action='store_true', required=False, default=False)
+    parser.add_argument('--recursive_dep', '-rd', help='Recursively analyze dependencies',
+                        action='store_true', dest='recursive_dep', default=False)
 
     try:
         args = parser.parse_args()
@@ -118,16 +122,16 @@ def main():
     else:
         mode, path, dep_argument, output, format, link, db_url, timer, raw, core, no_correction, correct_fpath, \
             ui, exclude_path, selected_source_scanner, source_write_json_file, source_print_matched_text, \
-            source_time_out, binary_simple, = set_args(
+            source_time_out, binary_simple, recursive_dep = set_args(
                 args.mode, args.path, args.dep_argument, args.output,
                 args.format, args.link, args.db_url, args.timer, args.raw,
                 args.core, args.no_correction, args.correct_fpath, args.ui,
-                args.setting, args.exclude_path)
+                args.setting, args.exclude_path, args.recursive_dep)
 
         run_main(mode, path, dep_argument, output, format, link, db_url, timer,
                  raw, core, not no_correction, correct_fpath, ui, exclude_path,
                  selected_source_scanner, source_write_json_file, source_print_matched_text,
-                 source_time_out, binary_simple)
+                 source_time_out, binary_simple, recursive_dep)
 
 
 if __name__ == "__main__":

{fosslight_scanner-2.1.9 → fosslight_scanner-2.1.11}/src/fosslight_scanner/fosslight_scanner.py

@@ -57,7 +57,8 @@ SCANNER_MODE = [
 ]
 
 
-def run_dependency(path_to_analyze, output_file_with_path, params="", path_to_exclude=[], formats=[]):
+def run_dependency(path_to_analyze, output_file_with_path, params="", path_to_exclude=[], formats=[],
+                   recursive_dep=False):
     result = []
 
     package_manager = ""
@@ -100,7 +101,9 @@ def run_dependency(path_to_analyze, output_file_with_path, params="", path_to_ex
             output_file_with_path,
             pip_activate_cmd, pip_deactivate_cmd,
             output_custom_dir, app_name,
-            github_token, formats, True, path_to_exclude=path_to_exclude
+            github_token, formats, True, path_to_exclude=path_to_exclude,
+            graph_path="", graph_size=(600,600),
+            recursive=recursive_dep
         )
         if success:
             result = scan_item
@@ -131,7 +134,7 @@ def run_scanner(src_path, dep_arguments, output_path, keep_raw_data=False,
                 default_oss_name="", default_oss_version="", url="",
                 correct_mode=True, correct_fpath="", ui_mode=False, path_to_exclude=[],
                 selected_source_scanner="all", source_write_json_file=False, source_print_matched_text=False,
-                source_time_out=120, binary_simple=False, formats=[]):
+                source_time_out=120, binary_simple=False, formats=[], recursive_dep=False):
     final_excel_dir = output_path
     success = True
     all_cover_items = []
@@ -232,7 +235,8 @@ def run_scanner(src_path, dep_arguments, output_path, keep_raw_data=False,
 
             if run_dep:
                 dep_scanitem = run_dependency(src_path, _output_dir,
-                                              dep_arguments, path_to_exclude, formats)
+                                              dep_arguments, path_to_exclude, formats,
+                                              recursive_dep)
                 all_scan_item.file_items.update(dep_scanitem.file_items)
                 all_cover_items.append(dep_scanitem.cover)
         else:
@@ -359,7 +363,7 @@ def run_main(mode_list, path_arg, dep_arguments, output_file_or_dir, file_format
              db_url, hide_progressbar=False, keep_raw_data=False, num_cores=-1,
              correct_mode=True, correct_fpath="", ui_mode=False, path_to_exclude=[],
              selected_source_scanner="all", source_write_json_file=False, source_print_matched_text=False,
-             source_time_out=120, binary_simple=False):
+             source_time_out=120, binary_simple=False, recursive_dep=False):
     global _executed_path, _start_time
 
     output_files = []
@@ -470,7 +474,7 @@ def run_main(mode_list, path_arg, dep_arguments, output_file_or_dir, file_format
                                 default_oss_name, default_oss_version, url_to_analyze,
                                 correct_mode, correct_fpath, ui_mode, path_to_exclude,
                                 selected_source_scanner, source_write_json_file, source_print_matched_text, source_time_out,
-                                binary_simple, formats)
+                                binary_simple, formats, recursive_dep)
 
                 if extract_folder:
                     shutil.rmtree(extract_folder)

{fosslight_scanner-2.1.9 → fosslight_scanner-2.1.11}/src/fosslight_scanner.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
-Name: fosslight-scanner
-Version: 2.1.9
+Metadata-Version: 2.4
+Name: fosslight_scanner
+Version: 2.1.11
 Summary: FOSSLight Scanner
 Home-page: https://github.com/fosslight/fosslight_scanner
 Download-URL: https://github.com/fosslight/fosslight_scanner
@@ -14,6 +14,28 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10,<3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: future
+Requires-Dist: pandas
+Requires-Dist: openpyxl
+Requires-Dist: progress
+Requires-Dist: pyyaml
+Requires-Dist: beautifulsoup4
+Requires-Dist: fosslight_util<3.0.0,>=2.1.12
+Requires-Dist: fosslight_source<3.0.0,>=2.1.12
+Requires-Dist: fosslight_dependency<5.0.0,>=4.1.3
+Requires-Dist: fosslight_binary<6.0.0,>=5.1.9
+Requires-Dist: fosslight_prechecker<5.0.0,>=4.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 <!--
 Copyright (c) 2021 LG Electronics

{fosslight_scanner-2.1.9 → fosslight_scanner-2.1.11}/src/fosslight_scanner.egg-info/SOURCES.txt

@@ -17,4 +17,11 @@ src/fosslight_scanner.egg-info/dependency_links.txt
 src/fosslight_scanner.egg-info/entry_points.txt
 src/fosslight_scanner.egg-info/requires.txt
 src/fosslight_scanner.egg-info/top_level.txt
-src/fosslight_scanner/resources/bom_compare.html
+src/fosslight_scanner/resources/bom_compare.html
+tests/test__get_input.py
+tests/test__help.py
+tests/test__parse_setting.py
+tests/test__run_compare.py
+tests/test_cli.py
+tests/test_common.py
+tests/test_fosslight_scanner.py

fosslight_scanner-2.1.11/tests/test__get_input.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2020 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+
+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"
+
+
+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
+    _, _, url_to_analyze = get_input_mode(executed_path, mode_list)
+
+    # then
+    assert url_to_analyze == "https://example.com"

fosslight_scanner-2.1.11/tests/test__help.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2020 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+
+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

fosslight_scanner-2.1.11/tests/test__parse_setting.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2020 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+from fosslight_scanner._parse_setting import parse_setting_json
+
+
+def test_parse_setting_json_valid_data():
+    data = {
+        'mode': ['test'],
+        'path': ['/some/path'],
+        'dep_argument': 'arg',
+        'output': 'output',
+        'format': 'json',
+        'link': 'http://example.com',
+        'db_url': 'sqlite:///:memory:',
+        'timer': True,
+        'raw': True,
+        'core': 4,
+        'no_correction': True,
+        'correct_fpath': '/correct/path',
+        'ui': True,
+        'exclude': ['/exclude/path'],
+        'selected_source_scanner': 'scanner',
+        'source_write_json_file': True,
+        'source_print_matched_text': True,
+        'source_time_out': 60,
+        'binary_simple': True
+    }
+    result = parse_setting_json(data)
+    assert result == (
+        ['test'], ['/some/path'], 'arg', 'output', 'json', 'http://example.com', 'sqlite:///:memory:', True,
+        True, 4, True, '/correct/path', True, ['/exclude/path'], 'scanner', True, True, 60, True, False
+    )

fosslight_scanner-2.1.11/tests/test__run_compare.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2020 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+
+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
+
+
+@pytest.mark.parametrize("ext, expected_content", [
+    # Test for JSON and YAML extensions
+    (".json", {"key": "value"}),
+    (".yaml", {"key": "value"}),
+
+    # Test for TXT extension (failure)
+    (".txt", {"key": "value"}),
+])
+def test_write_result_json_yaml(tmp_path, ext, expected_content):
+    # given
+    output_file = tmp_path / f"result{ext}"
+    compared_result = expected_content
+
+    # when
+    success = write_result_json_yaml(output_file, compared_result, ext)
+
+    # then
+    assert success is True, f"Failed to write file with extension {ext}"
+
+    # Verify content based on extension
+    if ext == ".json":
+        with open(output_file, 'r', encoding='utf-8') as f:
+            result_content = json.load(f)
+        assert result_content == compared_result, "The content of the JSON file does not match the expected content."
+
+    elif ext == ".yaml":
+        with open(output_file, 'r', encoding='utf-8') as f:
+            result_content = yaml.safe_load(f)
+        assert result_content == compared_result, "The content of the YAML file does not match the expected content."
+
+    elif ext == ".txt":
+        with open(output_file, 'r', encoding='utf-8') as f:
+            result_lines = f.readlines()
+        result_content = ''.join(result_lines)
+        assert result_content != compared_result, "The content of the TXT file does not match the expected string representation."
+
+
+def test_parse_result_for_table():
+    # given
+    add_expected = [ADD, '', '', 'test(1.0)', 'MIT']
+    oi = {"name": "test", "version": "1.0", "license": ["MIT"]}
+
+    # when
+    add_result = parse_result_for_table(oi, ADD)
+
+    # then
+    assert add_result == add_expected
+
+
+def test_get_sample_html():
+    # then
+    assert get_sample_html() != ''
+
+
+@pytest.mark.parametrize("compared_result, expected_before, expected_after", [
+    # Case with empty add, delete, change
+    ({ADD: [], DELETE: [], CHANGE: []}, "before.yaml", "after.yaml"),
+
+    # Case with one entry in add and no deletes or changes
+    ({ADD: [{"name": "test", "version": "1.0", "license": ["MIT"]}], DELETE: [], CHANGE: []},
+     "before.yaml", "after.yaml")
+])
+def test_write_result_html(tmp_path, compared_result, expected_before, expected_after):
+    # given
+    output_file = tmp_path / "result.html"
+
+    # when
+    success = write_result_html(output_file, compared_result, expected_before, expected_after)
+
+    # then
+    assert success is True, "Failed to write the HTML file."
+    assert output_file.exists(), "The HTML file was not created."
+    with open(output_file, 'r', encoding='utf-8') as f:
+        content = f.read()
+        assert content, "The HTML file is empty."
+
+
+@pytest.mark.parametrize("compared_result", [
+    # Case with empty add, delete, change
+    {ADD: [], DELETE: [], CHANGE: []},
+
+    # Case with one entry in add and no deletes or changes
+    {ADD: [{"name": "test", "version": "1.0", "license": ["MIT"]}], DELETE: [], CHANGE: []}
+])
+def test_write_result_xlsx(tmp_path, compared_result):
+    # given
+    output_file = tmp_path / "result.xlsx"
+
+    # when
+    success = write_result_xlsx(output_file, compared_result)
+
+    # then
+    assert success is True, "Failed to write the XLSX file."
+    assert output_file.exists(), "The XLSX file was not created."
+
+
+@pytest.mark.parametrize("ext, expected_output", [
+    (XLSX_EXT, "xlsx"),
+    (HTML_EXT, "html"),
+    (JSON_EXT, "json"),
+    (YAML_EXT, "yaml"),
+])
+def test_write_compared_result(tmp_path, ext, expected_output):
+    # given
+    output_file = tmp_path / "result"
+    compared_result = {ADD: [], DELETE: [], CHANGE: []}
+
+    # when
+    success, result_file = write_compared_result(output_file, compared_result, ext)
+
+    # then
+    assert success is True, f"Failed to write the compared result for extension {ext}"
+    if ext == XLSX_EXT:
+        assert str(result_file) == str(output_file), "The XLSX result file path does not match the expected output path."
+    elif ext == HTML_EXT:
+        expected_result_file = f"{str(output_file) + XLSX_EXT}, {str(output_file)}"
+        assert result_file == expected_result_file, "HTML file creation failed."
+    elif ext == JSON_EXT:
+        assert str(result_file) == str(output_file), "The JSON result file path does not match the expected output path."
+    else:
+        assert str(result_file) == str(output_file), "The YAML result file path does not match the expected output path."
+
+
+@pytest.mark.parametrize("path, file_name, ext, time_suffix, expected_output", [
+    # Case when file name is provided
+    ("/path", "file", XLSX_EXT, "time", "/path/file.xlsx"),
+
+    # Case when file name is empty, with different extensions
+    ("/path", "", XLSX_EXT, "time", "/path/fosslight_compare_time.xlsx"),
+    ("/path", "", HTML_EXT, "time", "/path/fosslight_compare_time.html"),
+    ("/path", "", YAML_EXT, "time", "/path/fosslight_compare_time.yaml"),
+    ("/path", "", JSON_EXT, "time", "/path/fosslight_compare_time.json"),
+])
+def test_get_comparison_result_filename(path, file_name, ext, time_suffix, expected_output):
+    # when
+    result = get_comparison_result_filename(path, file_name, ext, time_suffix)
+
+    # then
+    assert result == expected_output, f"Expected {expected_output} but got {result}"
+
+
+@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):
+    # when
+    with caplog.at_level(logging.INFO):
+        count_compared_result(compared_result)
+    # then
+    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

fosslight_scanner-2.1.11/tests/test_cli.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2020 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+import pytest
+import json
+import sys
+from fosslight_scanner.cli import main, set_args
+
+
+def test_set_args(monkeypatch):
+    # Mocking os.path.isfile to return True
+    monkeypatch.setattr("os.path.isfile", lambda x: True)
+
+    # Mocking the open function to return a mock file object
+    mock_file_data = json.dumps({
+        "mode": ["test_mode"],
+        "path": ["test_path"],
+        "dep_argument": "test_dep_argument",
+        "output": "test_output",
+        "format": ["test_format"],
+        "link": "test_link",
+        "db_url": "test_db_url",
+        "timer": True,
+        "raw": True,
+        "core": 4,
+        "no_correction": True,
+        "correct_fpath": "test_correct_fpath",
+        "ui": True,
+        "exclude": ["test_exclude_path"],
+        "selected_source_scanner": "test_scanner",
+        "source_write_json_file": True,
+        "source_print_matched_text": True,
+        "source_time_out": 100,
+        "binary_simple": True
+    })
+
+    def mock_open(*args, **kwargs):
+        from io import StringIO
+        return StringIO(mock_file_data)
+
+    monkeypatch.setattr("builtins.open", mock_open)
+
+    # Call the function with some arguments
+    result = set_args(
+        mode=None, path=None, dep_argument=None, output=None, format=None, link=None, db_url=None, timer=None,
+        raw=None, core=-1, no_correction=None, correct_fpath=None, ui=None, setting="dummy_path", exclude_path=None,
+        recursive_dep=False
+    )
+
+    # Expected result
+    expected = (
+        ["test_mode"], ["test_path"], "test_dep_argument", "test_output", ["test_format"], "test_link", "test_db_url", True,
+        True, 4, True, "test_correct_fpath", True, ["test_exclude_path"], "test_scanner", True, True, 100, True, False
+    )
+
+    assert result == expected
+
+
+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  # 인식되지 않은 인자에 대한 에러 메시지 확인

fosslight_scanner-2.1.11/tests/test_common.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2020 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+
+import os
+import pytest
+from fosslight_scanner.common import copy_file, run_analysis, call_analysis_api, check_package_dir, \
+    create_scancodejson, correct_scanner_result
+
+
+def test_copy_file_success(tmp_path):
+    # given
+    source = tmp_path / "source.txt"
+    destination = tmp_path / "destination"
+    source.write_text("Test content")
+
+    # when
+    success, copied_file = copy_file(str(source), str(destination))
+
+    # then
+    assert success is True
+    assert os.path.exists(copied_file)
+
+
+def test_copy_file_failure():
+    # given
+    source = "/nonexistent/path/source.txt"
+    destination = "/destination/path"
+
+    # when
+    success, _ = copy_file(source, destination)
+
+    # then
+    assert success is False
+
+
+@pytest.mark.parametrize("path_to_run, expected_result", [
+    ("/test/path", "Mocked result"),
+    ("", "")
+])
+def test_run_analysis(monkeypatch, path_to_run, expected_result):
+    # given
+    params = ["--param1", "value1"]
+    output = "/output/path"
+    exe_path = "/exe/path"
+
+    def mock_func():
+        return expected_result
+
+    # Mock os.chdir to prevent changing directories during test
+    monkeypatch.setattr(os, 'chdir', lambda x: None)
+    # Mock os.getcwd to return a default path
+    monkeypatch.setattr(os, 'getcwd', lambda: "/mocked/path")
+
+    # when
+    result = run_analysis(path_to_run, params, mock_func, "Test Run", output, exe_path)
+
+    # then
+    assert result == expected_result
+
+
+def test_call_analysis_api_with_path():
+    # given
+    path_to_run = "/test/path"
+    str_run_start = "Test Run"
+    return_idx = -1
+
+    def mock_func():
+        return ["Result"]
+
+    # when
+    success, result = call_analysis_api(path_to_run, str_run_start, return_idx, mock_func)
+
+    # then
+    assert success is True
+    assert result == ["Result"]
+
+
+def test_call_analysis_api_without_path():
+    # given
+    path_to_run = ""
+    str_run_start = "Test Run"
+    return_idx = -1
+
+    def mock_func():
+        return ["Result"]
+
+    # when
+    success, result = call_analysis_api(path_to_run, str_run_start, return_idx, mock_func)
+
+    # then
+    assert success is True
+    assert result == []
+
+
+def test_create_scancodejson(monkeypatch):
+    # Given
+
+    # Mocking os.walk
+    def mock_os_walk(path):
+        return [("/mocked/absolute/path", ["dir1"], ["file1", "file2"])]
+
+    # Mocking write_scancodejson
+    def mock_write_scancodejson(dirname, basename, all_scan_item):
+        pass
+
+    # Mocking copy.deepcopy
+    def mock_deepcopy(obj):
+        return obj
+
+    # Mocking os.path.abspath
+    monkeypatch.setattr("os.path.abspath", lambda x: "/mocked/absolute/path")
+
+    # Mocking os.path.basename
+    monkeypatch.setattr("os.path.basename", lambda x: "mocked_parent")
+    monkeypatch.setattr("os.walk", mock_os_walk)
+    monkeypatch.setattr("fosslight_scanner.common.write_scancodejson", mock_write_scancodejson)
+    monkeypatch.setattr("copy.deepcopy", mock_deepcopy)
+
+    # Mocking FOSSLIGHT_DEPENDENCY and FOSSLIGHT_SOURCE
+    global FOSSLIGHT_DEPENDENCY, FOSSLIGHT_SOURCE
+    FOSSLIGHT_DEPENDENCY = "fosslight_dependency"
+    FOSSLIGHT_SOURCE = "fosslight_source"
+
+    # Mocking all_scan_item_origin
+    class AllScanItem:
+        def __init__(self):
+            self.file_items = {
+                FOSSLIGHT_DEPENDENCY: [],
+                FOSSLIGHT_SOURCE: []
+            }
+
+    all_scan_item_origin = AllScanItem()
+    ui_mode_report = "/mocked/ui_mode_report"
+    src_path = "/mocked/src_path"
+
+    # When
+    success, err_msg = create_scancodejson(all_scan_item_origin, ui_mode_report, src_path)
+
+    # Then
+    assert success is True
+    assert err_msg == ''
+
+
+def test_correct_scanner_result(monkeypatch):
+    # Given
+    class MockOSSItem:
+        def __init__(self, license, exclude=False):
+            self.license = license
+            self.exclude = exclude
+
+    class MockFileItem:
+        def __init__(self, source_name_or_path, oss_items, exclude=False):
+            self.source_name_or_path = source_name_or_path
+            self.oss_items = oss_items
+            self.exclude = exclude
+
+    class MockAllScanItem:
+        def __init__(self, file_items):
+            self.file_items = file_items
+
+    src_oss_item = MockOSSItem(license="MIT")
+    bin_oss_item = MockOSSItem(license="")
+
+    src_file_item = MockFileItem("path/to/source", [src_oss_item])
+    bin_file_item = MockFileItem("path/to/source", [bin_oss_item])
+
+    all_scan_item = MockAllScanItem({
+        "FOSSLIGHT_SOURCE": [src_file_item],
+        "FOSSLIGHT_BINARY": [bin_file_item]
+    })
+
+    # When
+    result = correct_scanner_result(all_scan_item)
+    # Then
+    assert len(result.file_items["FOSSLIGHT_BINARY"][0].oss_items) == 1
+
+
+@pytest.mark.parametrize("source_name_or_path, expected", [
+    ("project/venv/file.py", True),
+    ("project/node_modules/file.js", True),
+    ("project/Pods/file.m", True),
+    ("project/Carthage/file.swift", True),
+    ("project/src/file.py", False),
+    ("project/venv/file.py", True),
+])
+def test_check_package_dir(source_name_or_path, expected):
+    result = check_package_dir(source_name_or_path)
+    # Then
+    assert result == expected

fosslight_scanner-2.1.11/tests/test_fosslight_scanner.py

@@ -0,0 +1,150 @@
+from fosslight_scanner.fosslight_scanner import run_scanner, download_source, init, run_main, run_dependency
+from fosslight_util.oss_item import ScannerItem
+
+
+def test_run_dependency(tmp_path):
+    # given
+    path_to_analyze = tmp_path / "test_project"
+    output_file_with_path = tmp_path / "output_file"
+    params = "-m 'npm' -a 'activate_cmd' -d 'deactivate_cmd' -c 'custom_dir' -n 'app_name' -t 'token_value'"
+    path_to_exclude = ["node_modules"]
+
+    # Create the directory to analyze
+    path_to_analyze.mkdir(parents=True, exist_ok=True)
+
+    # when
+    result = run_dependency(str(path_to_analyze), str(output_file_with_path), params, path_to_exclude)
+
+    # then
+    # Check that result is an instance of ScannerItem
+    assert isinstance(result, ScannerItem), "Result should be an instance of ScannerItem."
+
+    # Check that result is not None
+    assert result is not None, "Result should not be None."
+
+
+def test_run_scanner(tmp_path):
+    # given
+    src_path = tmp_path / "test_src"
+    output_path = tmp_path / "output"
+    dep_arguments = ""
+    output_file = ['test_output']
+    output_extension = [".yaml"]
+
+    # Create necessary directories and files for the test
+    src_path.mkdir(parents=True, exist_ok=True)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    # Create a dummy source file in `src_path` to be scanned
+    test_file = src_path / "test_file.py"
+    test_file.write_text("# This is a test file\nprint('Hello, World!')")
+
+    # when
+    run_scanner(
+        src_path=str(src_path),
+        dep_arguments=dep_arguments,
+        output_path=str(output_path),
+        keep_raw_data=True,
+        run_src=True,
+        run_bin=False,
+        run_dep=False,
+        run_prechecker=False,
+        remove_src_data=False,
+        result_log={},
+        output_files=output_file,
+        output_extensions=output_extension,
+        num_cores=1,
+        path_to_exclude=[]
+    )
+
+    # then
+    # Check if `src_path` and `output_path` still exist
+    assert src_path.is_dir(), "Source path should still exist."
+    assert output_path.is_dir(), "Output path should still exist."
+
+
+def test_download_source(tmp_path):
+    # given
+    link = "https://example.com/test_repo.git"
+    out_dir = tmp_path / "output"
+
+    # Create the necessary output directory
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # when
+    success, temp_src_dir, oss_name, oss_version = download_source(str(link), str(out_dir))
+
+    # then
+    # Ensure the function completes successfully
+    assert isinstance(success, bool), "Function should return a boolean for success."
+
+    # If the function fails, ensure temp_src_dir is empty
+    if not success:
+        assert temp_src_dir == "", "temp_src_dir should be an empty string if download fails."
+    else:
+        # If the function succeeds, check temp_src_dir is a valid path
+        assert isinstance(temp_src_dir, str), "Temporary source directory should be a string."
+        assert str(temp_src_dir).startswith(str(out_dir)), "Temporary source directory should be within the output directory."
+
+    # Ensure oss_name and oss_version are strings
+    assert isinstance(oss_name, str), "OSS name should be a string."
+    assert isinstance(oss_version, str), "OSS version should be a string."
+
+
+def test_init(tmp_path):
+    # given
+    output_path = tmp_path / "output"
+
+    # Initialize global variables if necessary
+    global _output_dir, _log_file
+    _output_dir = "test_output"  # Set to a default or test-specific value
+    _log_file = "test_log"       # Set the name of the log file
+
+    # when
+    dir_created, output_root_dir, result_log = init(str(output_path))
+
+    # then
+    # Ensure that the output directory was created
+    assert dir_created is True, "The output directory should be created."
+
+    # Check if the output_root_dir is correct
+    assert output_root_dir == str(output_path), "Output root directory should match the given path."
+
+    # Check that the result_log is not None and is a dictionary
+    assert result_log is not None, "Result log should not be None."
+    assert isinstance(result_log, dict), "Result log should be a dictionary."
+
+
+def test_run_main(tmp_path):
+    # given
+    mode_list = ["source"]
+    path_arg = [str(tmp_path / "test_src")]
+    dep_arguments = []
+    output_file_or_dir = str(tmp_path / "output")
+    file_format = ['yaml']
+    url_to_analyze = ""
+    db_url = ""
+
+    # Create necessary directories and files for the test
+    (tmp_path / "test_src").mkdir(parents=True, exist_ok=True)
+
+    # when
+    result = run_main(
+        mode_list=mode_list,
+        path_arg=path_arg,
+        dep_arguments=dep_arguments,
+        output_file_or_dir=output_file_or_dir,
+        file_format=file_format,
+        url_to_analyze=url_to_analyze,
+        db_url=db_url,
+        hide_progressbar=True,  # Disable progress bar for testing
+        keep_raw_data=True,     # Keep raw data to avoid cleanup during test
+        num_cores=1,
+        correct_mode=True,
+        correct_fpath="",
+        ui_mode=False,
+        path_to_exclude=[]
+    )
+
+    # then
+    assert result is True