From b09f3b0af2167e2da39a66344b3c1750b14c4355 Mon Sep 17 00:00:00 2001
From: pombredanne <pombredanne@nexb.com>
Date: Mon, 7 Dec 2015 13:44:09 +0100
Subject: [PATCH] Revert "Added --package scan option for #44, removed
 --extract option for #52"

This reverts commit 47329fc103f477d375bdb705e04e25ef14306afd.
---
 src/scancode/cli.py        | 286 +++++++++++++++++-------------
 tests/scancode/test_cli.py | 350 ++++++++++++++++++++-----------------
 2 files changed, 357 insertions(+), 279 deletions(-)

diff --git a/src/scancode/cli.py b/src/scancode/cli.py
index fffc882d289..ede8d89844b 100644
--- a/src/scancode/cli.py
+++ b/src/scancode/cli.py
@@ -28,28 +28,22 @@
 from functools import partial
 import json
 import os
-from types import GeneratorType
 
 import click
-from click.termui import style
 
-from commoncode import ignore
+from commoncode import ignore, fileutils
 from commoncode.fileutils import resource_iter
-from commoncode import fileutils
 
 from scancode import __version__ as version
-from scancode import utils
-
-from scancode.format import as_html
-from scancode.format import as_html_app
-from scancode.format import create_html_app_assets
-from scancode.format import HtmlAppAssetCopyWarning
-from scancode.format import HtmlAppAssetCopyError
-
+from scancode.api import as_html
+from scancode.api import as_html_app
+from scancode.api import create_html_app_assets
+from scancode.api import extract_archives
 from scancode.api import get_copyrights
 from scancode.api import get_licenses
+from scancode.api import HtmlAppAssetCopyWarning
+from scancode.api import HtmlAppAssetCopyError
 from scancode.api import get_file_infos
-from scancode.api import get_package_infos
 
 
 info_text = '''
@@ -162,7 +156,20 @@ def print_about(ctx, param, value):
 
     scancode -f json -l -c samples/zlib/ > scan.json
 
-To extract archives, see the 'extractcode' command instead.
+Extract all archives found in the 'samples' directory tree:
+
+    scancode --extract samples
+
+Note: If an archive contains other archives, all contained archives will be
+extracted recursively. Extraction is done directly in the 'samples' directory,
+side-by-side with each archive. Files are extracted in a directory named after
+the archive with an '-extract' suffix added to its name, created side-by-side
+with the corresponding archive file.
+
+Extract a single archive. Files are extracted in the directory
+'samples/arch/zlib.tar.gz-extract/':
+
+    scancode --extract samples/arch/zlib.tar.gz
 '''
 
 
@@ -200,146 +207,179 @@ def print_version(ctx, param, value):
 '''
 
 
-class ScanCommand(utils.BaseCommand):
-    short_usage_help = '''
+short_help = '''
 Try 'scancode --help' for help on options and arguments.'''
 
 
 formats = ['json', 'html', 'html-app']
 
 
+class ScanCommand(click.Command):
+    def get_usage(self, ctx):
+        """
+        Ensure that usage points to the --help option explicitly.
+        Workaround click issue https://github.com/mitsuhiko/click/issues/393
+        """
+        return click.Command.get_usage(self, ctx) + short_help
+
+    def main(self, args=None, prog_name=None, complete_var=None,
+             standalone_mode=True, **extra):
+        """
+        Workaround click 4.0 bug https://github.com/mitsuhiko/click/issues/365
+        """
+        return click.Command.main(self, args=args, prog_name=self.name,
+                                  complete_var=complete_var,
+                                  standalone_mode=standalone_mode, **extra)
+
+
 @click.command(name='scancode', epilog=epilog_text, cls=ScanCommand)
 @click.pass_context
-
 @click.argument('input', metavar='<input>', type=click.Path(exists=True, readable=True))
 @click.argument('output_file', default='-', metavar='<output_file>', type=click.File('wb'))
-
 @click.option('-c', '--copyright', is_flag=True, default=False, help='Scan <input> for copyrights. [default]')
 @click.option('-l', '--license', is_flag=True, default=False, help='Scan <input> for licenses. [default]')
-@click.option('-p', '--package', is_flag=True, default=False, help='Scan <input> for packages. [default]')
-@click.option('-i', '--info', is_flag=True, default=False, help='Scan <input> for files information.')
-
-@click.option('-f', '--format', is_flag=False, default='json', show_default=True, metavar='<style>', type=click.Choice(formats),
-              help='Set <output_file> format <style> to one of: %s' % ' or '.join(formats),)
+@click.option('-i', '--info', is_flag=True, default=False, help='Collect files information from  <input>.')
+@click.option('-f', '--format', metavar='<style>', type=click.Choice(formats),
+              default='json', show_default=True,
+              help='Set <output_file> format <style> to one of: %s' % ' or '.join(formats),
+              )
+@click.option('-e', '--extract', is_flag=True, default=False, is_eager=True,
+              help=('Extract any archives and compressed files found in <input> recursively, in-place, ignoring other scan options. Use this before scanning proper, as an <input> preparation step.'))
 @click.option('--verbose', is_flag=True, default=False, help='Print verbose file-by-file progress messages.')
-
 @click.help_option('-h', '--help')
-@click.option('--examples', is_flag=True, is_eager=True, callback=print_examples, help=('Show command examples and exit.'))
-@click.option('--about', is_flag=True, is_eager=True, callback=print_about, help='Show information about ScanCode and licensing and exit.')
-@click.option('--version', is_flag=True, is_eager=True, callback=print_version, help='Show the version and exit.')
-
-def scancode(ctx, input, output_file, copyright, license, package,  # @ReservedAssignment
-             info, format, verbose, *args, **kwargs):  # @ReservedAssignment
+@click.option('--examples', is_flag=True, is_eager=True, callback=print_examples,
+              help=('Show command examples and exit.'))
+@click.option('--about', is_flag=True, is_eager=True, callback=print_about,
+              help=('Show information about ScanCode and licensing and exit.'))
+@click.option('--version', is_flag=True, is_eager=True, callback=print_version,
+              help=('Show the version and exit.'))
+def scancode(ctx, input, output_file, extract, copyright, license, info, format, verbose, *args, **kwargs):  # @ReservedAssignment
     """scan the <input> file or directory for origin and license and save results to the <output_file>.
 
     The scan results are printed on terminal if <output_file> is not provided.
     """
-
     abs_input = os.path.abspath(os.path.expanduser(input))
-    scans = [copyright, license, package, info]
+    scans = [copyright, license, info]
+    if extract:
+        if any(scans):
+            # exclusive, ignoring other options.
+            # FIXME: this should turned into  a sub-command
+            ctx.fail('''The '--extract' option cannot be combined with other scanning options.
+Use the '--extract' option alone to extract archives found in  <input>.
+then run scancode again to scan the extracted files.''')
+            ctx.exit(1)
+
+        click.secho('Extracting archives...', fg='green')
+        extract_with_progress(abs_input, verbose)
+        click.secho('Extracting done.', fg='green')
+        return
 
     # Default scan when no options is provided
     if not any(scans):
         copyright = True  # @ReservedAssignment
         license = True  # @ReservedAssignment
-        package = True
-
-    # note: "flag and function" expressions return the function if flag is True
-    scans = {
-        'copyrights': copyright and get_copyrights,
-        'licenses': license and get_licenses,
-        'packages': package and get_package_infos,
-        'infos': info and get_file_infos,
-    }
-
-    results = []
-
-    # note: we inline progress display functions to close on some args
-
-    def scan_start():
-        """Progress event displayed at start of scan"""
-        return style('Scanning files...', fg='green')
-
-
-    def scan_event(item):
-        """Progress event displayed each time a file is scanned"""
-        if item:
-            line = verbose and item or fileutils.file_name(item) or ''
-            return 'Scanning: %(line)s' % locals()
-
-
-    def scan_end():
-        """Progress event displayed at end of scan"""
-        has_warnings = False
-        has_errors = False
-        summary = []
-        summary_color = 'green'
-        summary_color = has_warnings and 'yellow' or summary_color
-        summary_color = has_errors and 'red' or summary_color
-        summary.append(style('Scanning done.', fg=summary_color, reset=True))
-        return '\n'.join(summary)
-
-
-    ignored = partial(ignore.is_ignored, ignores=ignore.ignores_VCS, unignores={})
-    resources = resource_iter(abs_input, ignored=ignored)
-
-    with utils.progressmanager(resources,
-                               item_show_func=scan_event,
-                               start_show_func=scan_start,
-                               finish_show_func=scan_end,
-                               verbose=verbose,
-                               show_pos=True,
-                               ) as progressive_resources:
-
-        for resource in progressive_resources:
-            res = fileutils.as_posixpath(resource)
-            results.append(scan_one(res, scans))
-
-    # TODO: eventually merge scans for the same resource location...
-    # TODO: fix absolute paths as relative to original input argument...
-
-    save_results(results, format, input, output_file)
-
 
-def scan_one(input_file, scans):
+    if copyright or license or info:
+        click.secho('Scanning files...', fg='green')
+        results = []
+
+        ignored = partial(ignore.is_ignored, ignores=ignore.ignores_VCS, unignores={})
+        files = resource_iter(abs_input, ignored=ignored)
+
+        if not verbose:
+            # only display a progress bar
+            with click.progressbar(files, show_pos=True) as files:
+                for input_file in files:
+                    input_file = fileutils.as_posixpath(input_file)
+                    results.append(scan_one(input_file, copyright, license, info, verbose))
+        else:
+            for input_file in files:
+                input_file = fileutils.as_posixpath(input_file)
+                results.append(scan_one(input_file, copyright, license, info, verbose))
+
+        if format == 'html':
+            output_file.write(as_html(results))
+
+        elif format == 'html-app':
+            output_file.write(as_html_app(results, input, output_file))
+            try:
+                create_html_app_assets(output_file)
+            except HtmlAppAssetCopyWarning:
+                click.secho('\nHTML app creation skipped when printing to terminal.',
+                            fg='yellow')
+            except HtmlAppAssetCopyError:
+                click.secho('\nFailed to create HTML app.', fg='red')
+
+        elif format == 'json':
+            meta = OrderedDict()
+            meta['scancode_notice'] = acknowledgment_text_json
+            meta['scancode_version'] = version
+            meta['resource_count'] = len(results)
+            meta['results'] = results
+            output_file.write(json.dumps(meta, indent=2))
+        else:
+            # This should never happen by construction
+            raise Exception('Unknown format: ' + repr(format))
+        click.secho('Scanning done.', fg='green')
+
+
+def scan_one(input_file, copyright, license, info, verbose=False):  # @ReservedAssignment
     """
-    Scan one file or directory and return scanned data, calling every scan in
-    the scans mapping of (scan name -> scan function).
+    Scan one file and return scanned data.
     """
+    if verbose:
+        click.secho('Scanning: %(input_file)s: ' % locals(), nl=False, fg='blue')
     data = OrderedDict()
     data['location'] = input_file
-    for scan_name, scan_func in scans.items():
-        if scan_func:
-            scan = scan_func(input_file)
-            if isinstance(scan, GeneratorType):
-                scan = list(scan)
-            data[scan_name] = scan
+    if copyright:
+        if verbose:
+            click.secho('copyrights. ', nl=False, fg='green')
+        data['copyrights'] = list(get_copyrights(input_file))
+    if license:
+        if verbose:
+            click.secho('licenses. ', nl=False, fg='green')
+        data['licenses'] = list(get_licenses(input_file))
+    if info:
+        if verbose:
+            click.secho('infos. ', nl=False, fg='green')
+        data['infos'] = get_file_infos(input_file)
+
+    if verbose:
+        click.secho('', nl=True)
     return data
 
 
-def save_results(results, format, input, output_file):  # @ReservedAssignment
+def extract_with_progress(input, verbose=False):  # @ReservedAssignment
     """
-    Save results to file or screen.
+    Extract archives and display progress.
     """
-    assert format in formats
-    if format == 'html':
-        output_file.write(as_html(results))
-
-    elif format == 'html-app':
-        output_file.write(as_html_app(results, input, output_file))
-        try:
-            create_html_app_assets(output_file)
-        except HtmlAppAssetCopyWarning:
-            click.secho('\nHTML app creation skipped when printing to terminal.',
-                       err=True, fg='yellow')
-        except HtmlAppAssetCopyError:
-            click.secho('\nFailed to create HTML app.', err=True, fg='red')
-
-    elif format == 'json':
-        meta = OrderedDict()
-        meta['scancode_notice'] = acknowledgment_text_json
-        meta['scancode_version'] = version
-        meta['resource_count'] = len(results)
-        # TODO: add scanning options to meta
-        meta['results'] = results
-        output_file.write(json.dumps(meta, indent=2))
+    if verbose:
+        for xev in extract_archives(input, verbose=verbose):
+            if not xev.done:
+                click.secho('Extracting: ' + xev.source + ': ', nl=False, fg='green')
+            else:
+                if xev.warnings or xev.errors:
+                    click.secho('done.', fg='red' if xev.errors else 'yellow')
+                    display_extract_event(xev)
+                else:
+                    click.secho('done.', fg='green')
+    else:
+        extract_results = []
+        # only display a progress bar
+        with click.progressbar(extract_archives(input, verbose=verbose), show_pos=True) as extractions:
+            for xevent in extractions:
+                extract_results.append(xevent)
+        # display warnings/errors at the end
+        for xev in extract_results:
+            if xev.warnings or xev.errors:
+                if xev.warnings or xev.errors:
+                    click.secho('Extracting: ' + xev.source + ': ', nl=False, fg='green')
+                    click.secho('done.', fg='red' if xev.errors else 'yellow')
+                    display_extract_event(xev)
+
+
+def display_extract_event(xev):
+    for e in xev.errors:
+        click.secho('  ERROR: ' + e, fg='red')
+    for warn in xev.warnings:
+        click.secho('  WARNING: ' + warn, fg='yellow')
diff --git a/tests/scancode/test_cli.py b/tests/scancode/test_cli.py
index 91ae968c4ee..7c98ed120a5 100644
--- a/tests/scancode/test_cli.py
+++ b/tests/scancode/test_cli.py
@@ -24,168 +24,206 @@
 
 from __future__ import absolute_import, print_function
 
-import codecs
-import json
 import os
+import json
 
-import click
 from click.testing import CliRunner
 
+from commoncode.testcase import FileBasedTesting
 from commoncode.fileutils import as_posixpath
-from commoncode.testcase import FileDrivenTesting
 
 from scancode import cli
+import codecs
 
 
-test_env = FileDrivenTesting()
-test_env.test_data_dir = os.path.join(os.path.dirname(__file__), 'data')
-
-
-"""
-These CLI tests are dependent on py.test monkeypatch to  ensure we are testing
-the actual command outputs as if using a TTY or not.
-"""
-
-def load_json_result(result_file, test_dir):
-    """
-    Load the result file as utf-8 JSON and strip test_dir prefix from
-    locations.
-    Sort the results by location.
-    """
-    test_dir = as_posixpath(test_dir)
-    with codecs.open(result_file, encoding='utf-8') as res:
-        scan_result = json.load(res)
-        for result in scan_result['results']:
-            loc = result['location']
-            loc = as_posixpath(loc).replace(test_dir, '').strip('/')
-            result['location'] = loc
-    scan_result['results'].sort(key=lambda x: x['location'])
-    return scan_result
-
-
-def test_copyright_option_detects_copyrights(monkeypatch):
-    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
-    test_dir = test_env.get_test_loc('copyright', copy=True)
-    runner = CliRunner()
-    result_file = test_env.get_temp_file('json')
-    result = runner.invoke(cli.scancode, ['--copyright', test_dir, result_file])
-    assert result.exit_code == 0
-    assert 'Scanning done' in result.output
-    assert os.path.exists(result_file)
-    assert len(open(result_file).read()) > 10
-
-
-def test_verbose_option_with_copyrights(monkeypatch):
-    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
-    test_dir = test_env.get_test_loc('copyright', copy=True)
-    runner = CliRunner()
-    result_file = test_env.get_temp_file('json')
-    result = runner.invoke(cli.scancode, ['--copyright', '--verbose', test_dir, result_file])
-    assert result.exit_code == 0
-    assert 'Scanning done' in result.output
-    assert 'copyright_acme_c-c.c' in result.output
-    assert os.path.exists(result_file)
-    assert len(open(result_file).read()) > 10
-
-
-def test_license_option_detects_licenses(monkeypatch):
-    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
-    test_dir = test_env.get_test_loc('license', copy=True)
-    runner = CliRunner()
-    result_file = test_env.get_temp_file('json')
-    result = runner.invoke(cli.scancode, ['--license', test_dir, result_file])
-    assert result.exit_code == 0
-    assert 'Scanning done' in result.output
-    assert os.path.exists(result_file)
-    assert len(open(result_file).read()) > 10
-
-
-def test_scancode_skip_vcs_files_and_dirs_by_default(monkeypatch):
-    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
-    test_dir = test_env.extract_test_tar('ignore/vcs.tgz')
-    runner = CliRunner()
-    result_file = test_env.get_temp_file('json')
-    result = runner.invoke(cli.scancode, ['--copyright', test_dir, result_file])
-    assert result.exit_code == 0
-    scan_result = load_json_result(result_file, test_dir)
-    # a single test.tst file and its directory that is not a VCS file should be listed
-    assert 2 == scan_result['resource_count']
-    scan_locs = [x['location'] for x in scan_result['results']]
-    assert [u'vcs', u'vcs/test.txt'] == scan_locs
-
-
-def test_usage_and_help_return_a_correct_script_name_on_all_platforms(monkeypatch):
-    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
-    runner = CliRunner()
-    result = runner.invoke(cli.scancode, ['--help'])
-    assert 'Usage: scancode [OPTIONS]' in result.output
-    # this was showing up on Windows
-    assert 'scancode-script.py' not in result.output
-
-    result = runner.invoke(cli.scancode, [])
-    assert 'Usage: scancode [OPTIONS]' in result.output
-    # this was showing up on Windows
-    assert 'scancode-script.py' not in result.output
-
-    result = runner.invoke(cli.scancode, ['-xyz'])
-    # this was showing up on Windows
-    assert 'scancode-script.py' not in result.output
-
-
-def test_info_collect_infos(monkeypatch):
-    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
-    test_dir = test_env.extract_test_tar('info/basic.tgz')
-    runner = CliRunner()
-    result_file = test_env.get_temp_file('json')
-    result = runner.invoke(cli.scancode, ['--info', test_dir, result_file])
-    assert result.exit_code == 0
-    assert 'Scanning done' in result.output
-    expected = load_json_result(test_env.get_test_loc('info/basic.expected.json'), test_dir)
-    loaded_result = load_json_result(result_file, test_dir)
-    assert expected == loaded_result
-
-
-def test_info_license_copyrights(monkeypatch):
-    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
-    test_dir = test_env.extract_test_tar('info/basic.tgz')
-    runner = CliRunner()
-    result_file = test_env.get_temp_file('json')
-    result = runner.invoke(cli.scancode, ['--info', '--license', '--copyright', test_dir, result_file])
-    assert result.exit_code == 0
-    assert 'Scanning done' in result.output
-    expected = load_json_result(test_env.get_test_loc('info/all.expected.json'), test_dir)
-    loaded_result = load_json_result(result_file, test_dir)
-    assert expected == loaded_result
-
-
-def test_paths_are_posix_in_html_app_format_output(monkeypatch):
-    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
-    test_dir = test_env.get_test_loc('posix_path', copy=True)
-    runner = CliRunner()
-    result_file = test_env.get_temp_file('html')
-    result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'html-app', test_dir, result_file])
-    assert result.exit_code == 0
-    assert 'Scanning done' in result.output
-    assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()
-
-
-def test_paths_are_posix_in_html_format_output(monkeypatch):
-    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
-    test_dir = test_env.get_test_loc('posix_path', copy=True)
-    runner = CliRunner()
-    result_file = test_env.get_temp_file('html')
-    result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'html', test_dir, result_file])
-    assert result.exit_code == 0
-    assert 'Scanning done' in result.output
-    assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()
-
-
-def test_paths_are_posix_in_json_format_output(monkeypatch):
-    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
-    test_dir = test_env.get_test_loc('posix_path', copy=True)
-    runner = CliRunner()
-    result_file = test_env.get_temp_file('json')
-    result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'json', test_dir, result_file])
-    assert result.exit_code == 0
-    assert 'Scanning done' in result.output
-    assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()
+class TestCommandLine(FileBasedTesting):
+    test_data_dir = os.path.join(os.path.dirname(__file__), 'data')
+
+    def test_extract_option_is_exclusive_of_other_options(self):
+        test_dir = self.get_temp_dir()
+        runner = CliRunner()
+        result = runner.invoke(cli.scancode, ['--extract', '--copyright', test_dir])
+        assert result.exit_code == 2
+        assert 'option cannot be combined with other scanning options' in result.output
+
+        result = runner.invoke(cli.scancode, ['--copyright', '--extract', test_dir])
+        assert result.exit_code == 2
+        assert 'option cannot be combined with other scanning options' in result.output
+
+        result = runner.invoke(cli.scancode, ['--extract', '--license', test_dir])
+        assert result.exit_code == 2
+        assert 'option cannot be combined with other scanning options' in result.output
+
+        result = runner.invoke(cli.scancode, ['--extract', '--license', '--copyright', test_dir])
+        assert result.exit_code == 2
+        assert 'option cannot be combined with other scanning options' in result.output
+
+    def test_extract_option_can_take_an_empty_directory(self):
+        test_dir = self.get_temp_dir()
+        runner = CliRunner()
+        result = runner.invoke(cli.scancode, ['--extract', test_dir])
+        assert result.exit_code == 0
+        assert 'Extracting done' in result.output
+
+    def test_extract_option_does_extract(self):
+        test_dir = self.get_test_loc('extract', copy=True)
+        runner = CliRunner()
+        result = runner.invoke(cli.scancode, ['--extract', test_dir])
+        assert result.exit_code == 0
+        assert 'Extracting done' in result.output
+        assert 'ERROR: Unrecognized archive format' in result.output
+        assert os.path.exists(os.path.join(test_dir, 'some.tar.gz-extract'))
+
+    def test_extract_option_works_with_relative_paths(self):
+        # The setup is a tad complex because we want to have a relative dir
+        # to the base dir where we run tests from, ie the scancode-toolkit/ dir
+        # To use relative paths, we use our tmp dir at the root of the code
+        from os.path import dirname, join, abspath
+        from  commoncode import fileutils
+        import extractcode
+        import tempfile
+        import shutil
+
+        scancode_root = dirname(dirname(dirname(__file__)))
+        scancode_tmp = join(scancode_root, 'tmp')
+        fileutils.create_dir(scancode_tmp)
+        scancode_root_abs = abspath(scancode_root)
+        test_src_dir = tempfile.mkdtemp(dir=scancode_tmp).replace(scancode_root_abs, '').strip('\\/')
+        test_file = self.get_test_loc('extract_relative_path/basic.zip')
+        shutil.copy(test_file, test_src_dir)
+        test_src_file = join(test_src_dir, 'basic.zip')
+        test_tgt_dir = join(scancode_root, test_src_file) + extractcode.EXTRACT_SUFFIX
+
+        runner = CliRunner()
+        result = runner.invoke(cli.scancode, ['--extract', test_src_file])
+        assert result.exit_code == 0
+        assert 'Extracting done' in result.output
+        assert not 'WARNING' in result.output
+        assert not 'ERROR' in result.output
+        expected = ['/c/a/a.txt', '/c/b/a.txt', '/c/c/a.txt']
+        file_result = [as_posixpath(f.replace(test_tgt_dir, '')) for f in fileutils.file_iter(test_tgt_dir)]
+        assert sorted(expected) == sorted(file_result)
+
+    def test_copyright_option_detects_copyrights(self):
+        test_dir = self.get_test_loc('copyright', copy=True)
+        runner = CliRunner()
+        result_file = self.get_temp_file('json')
+        result = runner.invoke(cli.scancode, ['--copyright', test_dir, result_file])
+        assert result.exit_code == 0
+        assert 'Scanning done' in result.output
+        assert os.path.exists(result_file)
+        assert len(open(result_file).read()) > 10
+
+    def test_verbose_copyrights(self):
+        test_dir = self.get_test_loc('copyright', copy=True)
+        runner = CliRunner()
+        result_file = self.get_temp_file('json')
+        result = runner.invoke(cli.scancode, ['--copyright', '--verbose', test_dir, result_file])
+        assert result.exit_code == 0
+        assert 'Scanning done' in result.output
+        assert 'copyright_acme_c-c.c' in result.output
+        assert os.path.exists(result_file)
+        assert len(open(result_file).read()) > 10
+
+    def test_license_option_detects_licenses(self):
+        test_dir = self.get_test_loc('license', copy=True)
+        runner = CliRunner()
+        result_file = self.get_temp_file('json')
+        result = runner.invoke(cli.scancode, ['--license', test_dir, result_file])
+        assert result.exit_code == 0
+        assert 'Scanning done' in result.output
+        assert os.path.exists(result_file)
+        assert len(open(result_file).read()) > 10
+
+    def test_scancode_skip_vcs_files_and_dirs_by_default(self):
+        test_dir = self.extract_test_tar('ignore/vcs.tgz')
+        runner = CliRunner()
+        result_file = self.get_temp_file('json')
+        result = runner.invoke(cli.scancode, ['--copyright', test_dir, result_file])
+        assert result.exit_code == 0
+        scan_result = self.load_json_result(result_file, test_dir)
+        # a single test.tst file and its directory that is not a VCS file should be listed
+        assert 2 == scan_result['resource_count']
+        scan_locs = [x['location'] for x in scan_result['results']]
+        assert [u'vcs', u'vcs/test.txt'] == scan_locs
+
+    def load_json_result(self, result_file, test_dir):
+        """
+        Load the result file as utf-8 JSON and strip test_dir prefix from
+        locations.
+        Sort the results by location.
+        """
+        test_dir = as_posixpath(test_dir)
+        with codecs.open(result_file, encoding='utf-8') as res:
+            scan_result = json.load(res)
+            for result in scan_result['results']:
+                loc = result['location']
+                loc = as_posixpath(loc).replace(test_dir, '').strip('/')
+                result['location'] = loc
+        scan_result['results'].sort(key=lambda x: x['location'])
+        return scan_result
+
+    def test_usage_and_help_return_a_correct_script_name_on_all_platforms(self):
+        runner = CliRunner()
+        result = runner.invoke(cli.scancode, ['--help'])
+        assert 'Usage: scancode [OPTIONS]' in result.output
+        # this was showing up on Windows
+        assert 'scancode-script.py' not in result.output
+
+        result = runner.invoke(cli.scancode, [])
+        assert 'Usage: scancode [OPTIONS]' in result.output
+        # this was showing up on Windows
+        assert 'scancode-script.py' not in result.output
+
+        result = runner.invoke(cli.scancode, ['-xyz'])
+        # this was showing up on Windows
+        assert 'scancode-script.py' not in result.output
+
+    def test_info_collect_infos(self):
+        test_dir = self.extract_test_tar('info/basic.tgz')
+        runner = CliRunner()
+        result_file = self.get_temp_file('json')
+        result = runner.invoke(cli.scancode, ['--info', test_dir, result_file])
+        assert result.exit_code == 0
+        assert 'Scanning done' in result.output
+        expected = self.load_json_result(self.get_test_loc('info/basic.expected.json'), test_dir)
+        loaded_result = self.load_json_result(result_file, test_dir)
+        assert expected == loaded_result
+
+    def test_info_license_copyrights(self):
+        test_dir = self.extract_test_tar('info/basic.tgz')
+        runner = CliRunner()
+        result_file = self.get_temp_file('json')
+        result = runner.invoke(cli.scancode, ['--info', '--license', '--copyright', test_dir, result_file])
+        assert result.exit_code == 0
+        assert 'Scanning done' in result.output
+        expected = self.load_json_result(self.get_test_loc('info/all.expected.json'), test_dir)
+        loaded_result = self.load_json_result(result_file, test_dir)
+        assert expected == loaded_result
+
+    def test_paths_are_posix_in_html_app_format_output(self):
+        test_dir = self.get_test_loc('posix_path', copy=True)
+        runner = CliRunner()
+        result_file = self.get_temp_file('html')
+        result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'html-app', test_dir, result_file])
+        assert result.exit_code == 0
+        assert 'Scanning done' in result.output
+        assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()
+
+    def test_paths_are_posix_in_html_format_output(self):
+        test_dir = self.get_test_loc('posix_path', copy=True)
+        runner = CliRunner()
+        result_file = self.get_temp_file('html')
+        result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'html', test_dir, result_file])
+        assert result.exit_code == 0
+        assert 'Scanning done' in result.output
+        assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()
+
+    def test_paths_are_posix_in_json_format_output(self):
+        test_dir = self.get_test_loc('posix_path', copy=True)
+        runner = CliRunner()
+        result_file = self.get_temp_file('json')
+        result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'json', test_dir, result_file])
+        assert result.exit_code == 0
+        assert 'Scanning done' in result.output
+        assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()