Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

78 files changed, 3765 insertions, 0 deletions

diff --git a/python/mozlint/.ruff.toml b/python/mozlint/.ruff.toml
new file mode 100644
index 0000000000..11e713da73
--- /dev/null
+++ b/python/mozlint/.ruff.toml
@@ -0,0 +1,4 @@
+extend = "../../pyproject.toml"
+
+[isort]
+known-first-party = ["mozlint"]
diff --git a/python/mozlint/mozlint/__init__.py b/python/mozlint/mozlint/__init__.py
new file mode 100644
index 0000000000..bcab4a48b1
--- /dev/null
+++ b/python/mozlint/mozlint/__init__.py
@@ -0,0 +1,7 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# flake8: noqa
+
+from .result import Issue
+from .roller import LintRoller
diff --git a/python/mozlint/mozlint/cli.py b/python/mozlint/mozlint/cli.py
new file mode 100644
index 0000000000..0262173367
--- /dev/null
+++ b/python/mozlint/mozlint/cli.py
@@ -0,0 +1,445 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+import sys
+from argparse import REMAINDER, SUPPRESS, ArgumentParser
+from pathlib import Path
+
+from mozlint.errors import NoValidLinter
+from mozlint.formatters import all_formatters
+
+
+class MozlintParser(ArgumentParser):
+    arguments = [
+        [
+            ["paths"],
+            {
+                "nargs": "*",
+                "default": None,
+                "help": "Paths to file or directories to lint, like "
+                "'browser/components/loop' or 'mobile/android'. "
+                "If not provided, defaults to the files changed according "
+                "to --outgoing and --workdir.",
+            },
+        ],
+        [
+            ["-l", "--linter"],
+            {
+                "dest": "linters",
+                "default": [],
+                "action": "append",
+                "help": "Linters to run, e.g 'eslint'. By default all linters "
+                "are run for all the appropriate files.",
+            },
+        ],
+        [
+            ["--list"],
+            {
+                "dest": "list_linters",
+                "default": False,
+                "action": "store_true",
+                "help": "List all available linters and exit.",
+            },
+        ],
+        [
+            ["-W", "--warnings"],
+            {
+                "const": True,
+                "nargs": "?",
+                "choices": ["soft"],
+                "dest": "show_warnings",
+                "help": "Display and fail on warnings in addition to errors. "
+                "--warnings=soft can be used to report warnings but only fail "
+                "on errors.",
+            },
+        ],
+        [
+            ["-v", "--verbose"],
+            {
+                "dest": "show_verbose",
+                "default": False,
+                "action": "store_true",
+                "help": "Enable verbose logging.",
+            },
+        ],
+        [
+            ["-f", "--format"],
+            {
+                "dest": "formats",
+                "action": "append",
+                "help": "Formatter to use. Defaults to 'stylish' on stdout. "
+                "You can specify an optional path as --format formatter:path "
+                "that will be used instead of stdout. "
+                "You can also use multiple formatters at the same time. "
+                "Formatters available: {}.".format(", ".join(all_formatters.keys())),
+            },
+        ],
+        [
+            ["-n", "--no-filter"],
+            {
+                "dest": "use_filters",
+                "default": True,
+                "action": "store_false",
+                "help": "Ignore all filtering. This is useful for quickly "
+                "testing a directory that otherwise wouldn't be run, "
+                "without needing to modify the config file.",
+            },
+        ],
+        [
+            ["--include-third-party"],
+            {
+                "dest": "include_third-party",
+                "default": False,
+                "action": "store_true",
+                "help": "Also run the linter(s) on third-party code",
+            },
+        ],
+        [
+            ["-o", "--outgoing"],
+            {
+                "const": True,
+                "nargs": "?",
+                "help": "Lint files touched by commits that are not on the remote repository. "
+                "Without arguments, finds the default remote that would be pushed to. "
+                "The remote branch can also be specified manually. Works with "
+                "mercurial or git.",
+            },
+        ],
+        [
+            ["-w", "--workdir"],
+            {
+                "const": "all",
+                "nargs": "?",
+                "choices": ["staged", "all"],
+                "help": "Lint files touched by changes in the working directory "
+                "(i.e haven't been committed yet). On git, --workdir=staged "
+                "can be used to only consider staged files. Works with "
+                "mercurial or git.",
+            },
+        ],
+        [
+            ["-r", "--rev"],
+            {
+                "default": None,
+                "type": str,
+                "help": "Lint files touched by changes in revisions described by REV. "
+                "For mercurial, it may be any revset. For git, it is a single tree-ish.",
+            },
+        ],
+        [
+            ["--fix"],
+            {
+                "action": "store_true",
+                "default": False,
+                "help": "Fix lint errors if possible. Any errors that could not be fixed "
+                "will be printed as normal.",
+            },
+        ],
+        [
+            ["--edit"],
+            {
+                "action": "store_true",
+                "default": False,
+                "help": "Each file containing lint errors will be opened in $EDITOR one after "
+                "the other.",
+            },
+        ],
+        [
+            ["--setup"],
+            {
+                "action": "store_true",
+                "default": False,
+                "help": "Bootstrap linter dependencies without running any of the linters.",
+            },
+        ],
+        [
+            ["-j", "--jobs"],
+            {
+                "default": None,
+                "dest": "num_procs",
+                "type": int,
+                "help": "Number of worker processes to spawn when running linters. "
+                "Defaults to the number of cores in your CPU.",
+            },
+        ],
+        # Paths to check for linter configurations.
+        # Default: tools/lint set in tools/lint/mach_commands.py
+        [
+            ["--config-path"],
+            {
+                "action": "append",
+                "default": [],
+                "dest": "config_paths",
+                "help": SUPPRESS,
+            },
+        ],
+        [
+            ["--check-exclude-list"],
+            {
+                "dest": "check_exclude_list",
+                "default": False,
+                "action": "store_true",
+                "help": "Run linters for all the paths in the exclude list.",
+            },
+        ],
+        [
+            ["extra_args"],
+            {
+                "nargs": REMAINDER,
+                "help": "Extra arguments that will be forwarded to the underlying linter.",
+            },
+        ],
+    ]
+
+    def __init__(self, **kwargs):
+        ArgumentParser.__init__(self, usage=self.__doc__, **kwargs)
+
+        for cli, args in self.arguments:
+            self.add_argument(*cli, **args)
+
+    def parse_known_args(self, *args, **kwargs):
+        # Allow '-wo' or '-ow' as shorthand for both --workdir and --outgoing.
+        for token in ("-wo", "-ow"):
+            if token in args[0]:
+                i = args[0].index(token)
+                args[0].pop(i)
+                args[0][i:i] = [token[:2], "-" + token[2]]
+
+        # This is here so the eslint mach command doesn't lose 'extra_args'
+        # when using mach's dispatch functionality.
+        args, extra = ArgumentParser.parse_known_args(self, *args, **kwargs)
+        args.extra_args = extra
+
+        self.validate(args)
+        return args, extra
+
+    def validate(self, args):
+        if args.edit and not os.environ.get("EDITOR"):
+            self.error("must set the $EDITOR environment variable to use --edit")
+
+        if args.paths:
+            invalid = [p for p in args.paths if not os.path.exists(p)]
+            if invalid:
+                self.error(
+                    "the following paths do not exist:\n{}".format("\n".join(invalid))
+                )
+
+        if args.formats:
+            formats = []
+            for fmt in args.formats:
+                if isinstance(fmt, tuple):  # format is already processed
+                    formats.append(fmt)
+                    continue
+
+                path = None
+                if ":" in fmt:
+                    # Detect optional formatter path
+                    pos = fmt.index(":")
+                    fmt, path = fmt[:pos], os.path.realpath(fmt[pos + 1 :])
+
+                    # Check path is writable
+                    fmt_dir = os.path.dirname(path)
+                    if not os.access(fmt_dir, os.W_OK | os.X_OK):
+                        self.error(
+                            "the following directory is not writable: {}".format(
+                                fmt_dir
+                            )
+                        )
+
+                if fmt not in all_formatters.keys():
+                    self.error(
+                        "the following formatter is not available: {}".format(fmt)
+                    )
+
+                formats.append((fmt, path))
+            args.formats = formats
+        else:
+            # Can't use argparse default or this choice will be always present
+            args.formats = [("stylish", None)]
+
+
+def find_linters(config_paths, linters=None):
+    lints = {}
+    for search_path in config_paths:
+        if not os.path.isdir(search_path):
+            continue
+
+        sys.path.insert(0, search_path)
+        files = os.listdir(search_path)
+        for f in files:
+            name = os.path.basename(f)
+
+            if not name.endswith(".yml"):
+                continue
+
+            name = name.rsplit(".", 1)[0]
+
+            if linters and name not in linters:
+                continue
+
+            lints[name] = os.path.join(search_path, f)
+
+    linters_not_found = list(set(linters).difference(set(lints.keys())))
+    return {"lint_paths": lints.values(), "linters_not_found": linters_not_found}
+
+
+def get_exclude_list_output(result, paths):
+    # Store the paths of all the subdirectories leading to the error files
+    error_file_paths = set()
+    for issues in result.issues.values():
+        error_file = issues[0].relpath
+        error_file_paths.add(error_file)
+        parent_dir = os.path.dirname(error_file)
+        while parent_dir:
+            error_file_paths.add(parent_dir)
+            parent_dir = os.path.dirname(parent_dir)
+
+    paths = [os.path.dirname(path) if path[-1] == "/" else path for path in paths]
+    # Remove all the error paths to get the list of green paths
+    green_paths = sorted(set(paths).difference(error_file_paths))
+
+    if green_paths:
+        out = (
+            "The following list of paths are now green "
+            "and can be removed from the exclude list:\n\n"
+        )
+        out += "\n".join(green_paths)
+
+    else:
+        out = "No path in the exclude list is green."
+
+    return out
+
+
+def run(
+    paths,
+    linters,
+    formats,
+    outgoing,
+    workdir,
+    rev,
+    edit,
+    check_exclude_list,
+    setup=False,
+    list_linters=False,
+    num_procs=None,
+    virtualenv_manager=None,
+    setupargs=None,
+    **lintargs
+):
+    from mozlint import LintRoller, formatters
+    from mozlint.editor import edit_issues
+
+    lintargs["config_paths"] = [
+        os.path.join(lintargs["root"], p) for p in lintargs["config_paths"]
+    ]
+
+    # Always perform exhaustive linting for exclude list paths
+    lintargs["use_filters"] = lintargs["use_filters"] and not check_exclude_list
+
+    if list_linters:
+        lint_paths = find_linters(lintargs["config_paths"], linters)
+        linters = [
+            os.path.splitext(os.path.basename(l))[0] for l in lint_paths["lint_paths"]
+        ]
+        print("\n".join(sorted(linters)))
+        print(
+            "\nNote that clang-tidy checks are not run as part of this "
+            "command, but using the static-analysis command."
+        )
+        return 0
+
+    lint = LintRoller(setupargs=setupargs or {}, **lintargs)
+    linters_info = find_linters(lintargs["config_paths"], linters)
+
+    result = None
+
+    try:
+
+        lint.read(linters_info["lint_paths"])
+
+        if check_exclude_list:
+            if len(lint.linters) > 1:
+                print("error: specify a single linter to check with `-l/--linter`")
+                return 1
+            paths = lint.linters[0]["local_exclude"]
+
+        if (
+            not paths
+            and Path.cwd() == Path(lint.root)
+            and not (outgoing or workdir or rev)
+        ):
+            print(
+                "warning: linting the entire repo takes a long time, using --outgoing and "
+                "--workdir instead. If you want to lint the entire repo, run `./mach lint .`"
+            )
+            # Setting the default values
+            outgoing = True
+            workdir = "all"
+
+        # Always run bootstrapping, but return early if --setup was passed in.
+        ret = lint.setup(virtualenv_manager=virtualenv_manager)
+        if setup:
+            return ret
+
+        if linters_info["linters_not_found"] != []:
+            raise NoValidLinter
+
+        # run all linters
+        result = lint.roll(
+            paths, outgoing=outgoing, workdir=workdir, rev=rev, num_procs=num_procs
+        )
+    except NoValidLinter as e:
+        result = lint.result
+        print(str(e))
+
+    if edit and result.issues:
+        edit_issues(result)
+        result = lint.roll(result.issues.keys(), num_procs=num_procs)
+
+    for every in linters_info["linters_not_found"]:
+        result.failed_setup.add(every)
+
+    if check_exclude_list:
+        # Get and display all those paths in the exclude list which are
+        # now green and can be safely removed from the list
+        out = get_exclude_list_output(result, paths)
+        print(out, file=sys.stdout)
+        return result.returncode
+
+    for formatter_name, path in formats:
+        formatter = formatters.get(formatter_name)
+
+        out = formatter(result)
+        # We do this only for `json` that is mostly used in automation
+        if not out and formatter_name == "json":
+            out = "{}"
+
+        if out:
+            fh = open(path, "w") if path else sys.stdout
+
+            if not path and fh.encoding == "ascii":
+                # If sys.stdout.encoding is ascii, printing output will fail
+                # due to the stylish formatter's use of unicode characters.
+                # Ideally the user should fix their environment by setting
+                # `LC_ALL=C.UTF-8` or similar. But this is a common enough
+                # problem that we help them out a little here by manually
+                # encoding and writing to the stdout buffer directly.
+                out += "\n"
+                fh.buffer.write(out.encode("utf-8", errors="replace"))
+                fh.buffer.flush()
+            else:
+                print(out, file=fh)
+
+            if path:
+                fh.close()
+
+    return result.returncode
+
+
+if __name__ == "__main__":
+    parser = MozlintParser()
+    args = vars(parser.parse_args())
+    sys.exit(run(**args))
diff --git a/python/mozlint/mozlint/editor.py b/python/mozlint/mozlint/editor.py
new file mode 100644
index 0000000000..1738892f93
--- /dev/null
+++ b/python/mozlint/mozlint/editor.py
@@ -0,0 +1,57 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+import subprocess
+import tempfile
+
+from mozlint import formatters
+
+
+def get_editor():
+    return os.environ.get("EDITOR")
+
+
+def edit_issues(result):
+    if not result.issues:
+        return
+
+    editor = get_editor()
+    if not editor:
+        print("warning: could not find a default editor")
+        return
+
+    name = os.path.basename(editor)
+    if name in ("vim", "nvim", "gvim"):
+        cmd = [
+            editor,
+            # need errorformat to match both Error and Warning, with or without a column
+            "--cmd",
+            "set errorformat+=%f:\\ line\\ %l\\\\,\\ col\\ %c\\\\,\\ %trror\\ -\\ %m",
+            "--cmd",
+            "set errorformat+=%f:\\ line\\ %l\\\\,\\ col\\ %c\\\\,\\ %tarning\\ -\\ %m",
+            "--cmd",
+            "set errorformat+=%f:\\ line\\ %l\\\\,\\ %trror\\ -\\ %m",
+            "--cmd",
+            "set errorformat+=%f:\\ line\\ %l\\\\,\\ %tarning\\ -\\ %m",
+            # start with quickfix window opened
+            "-c",
+            "copen",
+            # running with -q seems to open an empty buffer in addition to the
+            # first file, this removes that empty buffer
+            "-c",
+            "1bd",
+        ]
+
+        with tempfile.NamedTemporaryFile(mode="w") as fh:
+            s = formatters.get("compact", summary=False)(result)
+            fh.write(s)
+            fh.flush()
+
+            cmd.extend(["-q", fh.name])
+            subprocess.call(cmd)
+
+    else:
+        for path, errors in result.issues.items():
+            subprocess.call([editor, path])
diff --git a/python/mozlint/mozlint/errors.py b/python/mozlint/mozlint/errors.py
new file mode 100644
index 0000000000..4b36f00f69
--- /dev/null
+++ b/python/mozlint/mozlint/errors.py
@@ -0,0 +1,33 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+class LintException(Exception):
+    pass
+
+
+class LinterNotFound(LintException):
+    def __init__(self, path):
+        LintException.__init__(self, "Could not find lint file '{}'".format(path))
+
+
+class NoValidLinter(LintException):
+    def __init__(self):
+        LintException.__init__(
+            self,
+            "Invalid linters given, run again using valid linters or no linters",
+        )
+
+
+class LinterParseError(LintException):
+    def __init__(self, path, message):
+        LintException.__init__(self, "{}: {}".format(path, message))
+
+
+class LintersNotConfigured(LintException):
+    def __init__(self):
+        LintException.__init__(
+            self,
+            "No linters registered! Use `LintRoller.read` " "to register a linter.",
+        )
diff --git a/python/mozlint/mozlint/formatters/__init__.py b/python/mozlint/mozlint/formatters/__init__.py
new file mode 100644
index 0000000000..e50616216f
--- /dev/null
+++ b/python/mozlint/mozlint/formatters/__init__.py
@@ -0,0 +1,31 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import json
+
+from ..result import IssueEncoder
+from .compact import CompactFormatter
+from .stylish import StylishFormatter
+from .summary import SummaryFormatter
+from .treeherder import TreeherderFormatter
+from .unix import UnixFormatter
+
+
+class JSONFormatter(object):
+    def __call__(self, result):
+        return json.dumps(result.issues, cls=IssueEncoder)
+
+
+all_formatters = {
+    "compact": CompactFormatter,
+    "json": JSONFormatter,
+    "stylish": StylishFormatter,
+    "summary": SummaryFormatter,
+    "treeherder": TreeherderFormatter,
+    "unix": UnixFormatter,
+}
+
+
+def get(name, **fmtargs):
+    return all_formatters[name](**fmtargs)
diff --git a/python/mozlint/mozlint/formatters/compact.py b/python/mozlint/mozlint/formatters/compact.py
new file mode 100644
index 0000000000..54ee194215
--- /dev/null
+++ b/python/mozlint/mozlint/formatters/compact.py
@@ -0,0 +1,41 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import attr
+
+from ..result import Issue
+
+
+class CompactFormatter(object):
+    """Formatter for compact output.
+
+    This formatter prints one error per line, mimicking the
+    eslint 'compact' formatter.
+    """
+
+    # If modifying this format, please also update the vim errorformats in editor.py
+    fmt = "{path}: line {lineno}{column}, {level} - {message} ({rule})"
+
+    def __init__(self, summary=True):
+        self.summary = summary
+
+    def __call__(self, result):
+        message = []
+        num_problems = 0
+        for path, errors in sorted(result.issues.items()):
+            num_problems += len(errors)
+            for err in errors:
+                assert isinstance(err, Issue)
+
+                d = attr.asdict(err)
+                d["column"] = ", col %s" % d["column"] if d["column"] else ""
+                d["level"] = d["level"].capitalize()
+                d["rule"] = d["rule"] or d["linter"]
+                message.append(self.fmt.format(**d))
+
+        if self.summary and num_problems:
+            message.append(
+                "\n{} problem{}".format(num_problems, "" if num_problems == 1 else "s")
+            )
+        return "\n".join(message)
diff --git a/python/mozlint/mozlint/formatters/stylish.py b/python/mozlint/mozlint/formatters/stylish.py
new file mode 100644
index 0000000000..3f80bc7ad2
--- /dev/null
+++ b/python/mozlint/mozlint/formatters/stylish.py
@@ -0,0 +1,156 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+from mozterm import Terminal
+
+from ..result import Issue
+from ..util.string import pluralize
+
+
+class StylishFormatter(object):
+    """Formatter based on the eslint default."""
+
+    _indent_ = "  "
+
+    # Colors later on in the list are fallbacks in case the terminal
+    # doesn't support colors earlier in the list.
+    # See http://www.calmar.ws/vim/256-xterm-24bit-rgb-color-chart.html
+    _colors = {
+        "grey": [247, 8, 7],
+        "red": [1],
+        "green": [2],
+        "yellow": [3],
+        "brightred": [9, 1],
+        "brightyellow": [11, 3],
+    }
+
+    fmt = """
+  {c1}{lineno}{column}  {c2}{level}{normal}  {message}  {c1}{rule}({linter}){normal}
+{diff}""".lstrip(
+        "\n"
+    )
+    fmt_summary = (
+        "{t.bold}{c}\u2716 {problem} ({error}, {warning}{failure}, {fixed}){t.normal}"
+    )
+
+    def __init__(self, disable_colors=False):
+        self.term = Terminal(disable_styling=disable_colors)
+        self.num_colors = self.term.number_of_colors
+
+    def color(self, color):
+        for num in self._colors[color]:
+            if num < self.num_colors:
+                return self.term.color(num)
+        return ""
+
+    def _reset_max(self):
+        self.max_lineno = 0
+        self.max_column = 0
+        self.max_level = 0
+        self.max_message = 0
+
+    def _update_max(self, err):
+        """Calculates the longest length of each token for spacing."""
+        self.max_lineno = max(self.max_lineno, len(str(err.lineno)))
+        if err.column:
+            self.max_column = max(self.max_column, len(str(err.column)))
+        self.max_level = max(self.max_level, len(str(err.level)))
+        self.max_message = max(self.max_message, len(err.message))
+
+    def _get_colored_diff(self, diff):
+        if not diff:
+            return ""
+
+        new_diff = ""
+        for line in diff.split("\n"):
+            if line.startswith("+"):
+                new_diff += self.color("green")
+            elif line.startswith("-"):
+                new_diff += self.color("red")
+            else:
+                new_diff += self.term.normal
+            new_diff += self._indent_ + line + "\n"
+        return new_diff
+
+    def __call__(self, result):
+        message = []
+        failed = result.failed
+
+        num_errors = 0
+        num_warnings = 0
+        num_fixed = result.fixed
+        for path, errors in sorted(result.issues.items()):
+            self._reset_max()
+
+            message.append(self.term.underline(path))
+            # Do a first pass to calculate required padding
+            for err in errors:
+                assert isinstance(err, Issue)
+                self._update_max(err)
+                if err.level == "error":
+                    num_errors += 1
+                else:
+                    num_warnings += 1
+
+            for err in sorted(
+                errors, key=lambda e: (int(e.lineno), int(e.column or 0))
+            ):
+                if err.column:
+                    col = ":" + str(err.column).ljust(self.max_column)
+                else:
+                    col = "".ljust(self.max_column + 1)
+
+                args = {
+                    "normal": self.term.normal,
+                    "c1": self.color("grey"),
+                    "c2": self.color("red")
+                    if err.level == "error"
+                    else self.color("yellow"),
+                    "lineno": str(err.lineno).rjust(self.max_lineno),
+                    "column": col,
+                    "level": err.level.ljust(self.max_level),
+                    "rule": "{} ".format(err.rule) if err.rule else "",
+                    "linter": err.linter.lower(),
+                    "message": err.message.ljust(self.max_message),
+                    "diff": self._get_colored_diff(err.diff).ljust(self.max_message),
+                }
+                message.append(self.fmt.format(**args).rstrip().rstrip("\n"))
+
+            message.append("")  # newline
+
+        # If there were failures, make it clear which linters failed
+        for fail in failed:
+            message.append(
+                "{c}A failure occurred in the {name} linter.".format(
+                    c=self.color("brightred"), name=fail
+                )
+            )
+
+        # Print a summary
+        message.append(
+            self.fmt_summary.format(
+                t=self.term,
+                c=self.color("brightred")
+                if num_errors or failed
+                else self.color("brightyellow"),
+                problem=pluralize("problem", num_errors + num_warnings + len(failed)),
+                error=pluralize("error", num_errors),
+                warning=pluralize(
+                    "warning", num_warnings or result.total_suppressed_warnings
+                ),
+                failure=", {}".format(pluralize("failure", len(failed)))
+                if failed
+                else "",
+                fixed="{} fixed".format(num_fixed),
+            )
+        )
+
+        if result.total_suppressed_warnings > 0 and num_errors == 0:
+            message.append(
+                "(pass {c1}-W/--warnings{c2} to see warnings.)".format(
+                    c1=self.color("grey"), c2=self.term.normal
+                )
+            )
+
+        return "\n".join(message)
diff --git a/python/mozlint/mozlint/formatters/summary.py b/python/mozlint/mozlint/formatters/summary.py
new file mode 100644
index 0000000000..e6ecf37508
--- /dev/null
+++ b/python/mozlint/mozlint/formatters/summary.py
@@ -0,0 +1,50 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+from collections import defaultdict
+
+import mozpack.path as mozpath
+
+from ..util.string import pluralize
+
+
+class SummaryFormatter(object):
+    def __init__(self, depth=None):
+        self.depth = depth or int(os.environ.get("MOZLINT_SUMMARY_DEPTH", 1))
+
+    def __call__(self, result):
+        paths = set(
+            list(result.issues.keys()) + list(result.suppressed_warnings.keys())
+        )
+
+        commonprefix = mozpath.commonprefix([mozpath.abspath(p) for p in paths])
+        commonprefix = commonprefix.rsplit("/", 1)[0] + "/"
+
+        summary = defaultdict(lambda: [0, 0])
+        for path in paths:
+            abspath = mozpath.abspath(path)
+            assert abspath.startswith(commonprefix)
+
+            if abspath != commonprefix:
+                parts = mozpath.split(mozpath.relpath(abspath, commonprefix))[
+                    : self.depth
+                ]
+                abspath = mozpath.join(commonprefix, *parts)
+
+            summary[abspath][0] += len(
+                [r for r in result.issues[path] if r.level == "error"]
+            )
+            summary[abspath][1] += len(
+                [r for r in result.issues[path] if r.level == "warning"]
+            )
+            summary[abspath][1] += result.suppressed_warnings[path]
+
+        msg = []
+        for path, (errors, warnings) in sorted(summary.items()):
+            warning_str = (
+                ", {}".format(pluralize("warning", warnings)) if warnings else ""
+            )
+            msg.append("{}: {}{}".format(path, pluralize("error", errors), warning_str))
+        return "\n".join(msg)
diff --git a/python/mozlint/mozlint/formatters/treeherder.py b/python/mozlint/mozlint/formatters/treeherder.py
new file mode 100644
index 0000000000..66c7c59eee
--- /dev/null
+++ b/python/mozlint/mozlint/formatters/treeherder.py
@@ -0,0 +1,34 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import attr
+
+from ..result import Issue
+
+
+class TreeherderFormatter(object):
+    """Formatter for treeherder friendly output.
+
+    This formatter looks ugly, but prints output such that
+    treeherder is able to highlight the errors and warnings.
+    This is a stop-gap until bug 1276486 is fixed.
+    """
+
+    fmt = "TEST-UNEXPECTED-{level} | {path}:{lineno}{column} | {message} ({rule})"
+
+    def __call__(self, result):
+        message = []
+        for path, errors in sorted(result.issues.items()):
+            for err in errors:
+                assert isinstance(err, Issue)
+
+                d = attr.asdict(err)
+                d["column"] = ":%s" % d["column"] if d["column"] else ""
+                d["level"] = d["level"].upper()
+                d["rule"] = d["rule"] or d["linter"]
+                message.append(self.fmt.format(**d))
+
+        if not message:
+            message.append("No lint issues found.")
+        return "\n".join(message)
diff --git a/python/mozlint/mozlint/formatters/unix.py b/python/mozlint/mozlint/formatters/unix.py
new file mode 100644
index 0000000000..ae096f3e2e
--- /dev/null
+++ b/python/mozlint/mozlint/formatters/unix.py
@@ -0,0 +1,33 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import attr
+
+from ..result import Issue
+
+
+class UnixFormatter(object):
+    """Formatter that respects Unix output conventions frequently
+    employed by preprocessors and compilers.  The format is
+    `<FILENAME>:<LINE>[:<COL>]: <RULE> <LEVEL>: <MESSAGE>`.
+
+    """
+
+    fmt = "{path}:{lineno}:{column} {rule} {level}: {message}"
+
+    def __call__(self, result):
+        msg = []
+
+        for path, errors in sorted(result.issues.items()):
+            for err in errors:
+                assert isinstance(err, Issue)
+
+                slots = attr.asdict(err)
+                slots["path"] = slots["relpath"]
+                slots["column"] = "%d:" % slots["column"] if slots["column"] else ""
+                slots["rule"] = slots["rule"] or slots["linter"]
+
+                msg.append(self.fmt.format(**slots))
+
+        return "\n".join(msg)
diff --git a/python/mozlint/mozlint/parser.py b/python/mozlint/mozlint/parser.py
new file mode 100644
index 0000000000..eac502495b
--- /dev/null
+++ b/python/mozlint/mozlint/parser.py
@@ -0,0 +1,130 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+
+import yaml
+
+from .errors import LinterNotFound, LinterParseError
+from .types import supported_types
+
+GLOBAL_SUPPORT_FILES = []
+
+
+class Parser(object):
+    """Reads and validates lint configuration files."""
+
+    required_attributes = (
+        "name",
+        "description",
+        "type",
+        "payload",
+    )
+
+    def __init__(self, root):
+        self.root = root
+
+    def __call__(self, path):
+        return self.parse(path)
+
+    def _validate(self, linter):
+        relpath = os.path.relpath(linter["path"], self.root)
+
+        missing_attrs = []
+        for attr in self.required_attributes:
+            if attr not in linter:
+                missing_attrs.append(attr)
+
+        if missing_attrs:
+            raise LinterParseError(
+                relpath,
+                "Missing required attribute(s): " "{}".format(",".join(missing_attrs)),
+            )
+
+        if linter["type"] not in supported_types:
+            raise LinterParseError(relpath, "Invalid type '{}'".format(linter["type"]))
+
+        for attr in ("include", "exclude", "support-files"):
+            if attr not in linter:
+                continue
+
+            if not isinstance(linter[attr], list) or not all(
+                isinstance(a, str) for a in linter[attr]
+            ):
+                raise LinterParseError(
+                    relpath,
+                    "The {} directive must be a " "list of strings!".format(attr),
+                )
+            invalid_paths = set()
+            for path in linter[attr]:
+                if "*" in path:
+                    if attr == "include":
+                        raise LinterParseError(
+                            relpath,
+                            "Paths in the include directive cannot "
+                            "contain globs:\n  {}".format(path),
+                        )
+                    continue
+
+                abspath = path
+                if not os.path.isabs(abspath):
+                    abspath = os.path.join(self.root, path)
+
+                if not os.path.exists(abspath):
+                    invalid_paths.add("  " + path)
+
+            if invalid_paths:
+                raise LinterParseError(
+                    relpath,
+                    "The {} directive contains the following "
+                    "paths that don't exist:\n{}".format(
+                        attr, "\n".join(sorted(invalid_paths))
+                    ),
+                )
+
+        if "setup" in linter:
+            if linter["setup"].count(":") != 1:
+                raise LinterParseError(
+                    relpath,
+                    "The setup attribute '{!r}' must have the "
+                    "form 'module:object'".format(linter["setup"]),
+                )
+
+        if "extensions" in linter:
+            linter["extensions"] = [e.strip(".") for e in linter["extensions"]]
+
+    def parse(self, path):
+        """Read a linter and return its LINTER definition.
+
+        :param path: Path to the linter.
+        :returns: List of linter definitions ([dict])
+        :raises: LinterNotFound, LinterParseError
+        """
+        if not os.path.isfile(path):
+            raise LinterNotFound(path)
+
+        if not path.endswith(".yml"):
+            raise LinterParseError(
+                path, "Invalid filename, linters must end with '.yml'!"
+            )
+
+        with open(path) as fh:
+            configs = list(yaml.safe_load_all(fh))
+
+        if not configs:
+            raise LinterParseError(path, "No lint definitions found!")
+
+        linters = []
+        for config in configs:
+            for name, linter in config.items():
+                linter["name"] = name
+                linter["path"] = path
+                self._validate(linter)
+                linter.setdefault("support-files", []).extend(
+                    GLOBAL_SUPPORT_FILES + [path]
+                )
+                linter.setdefault("include", ["."])
+                linters.append(linter)
+
+        return linters
diff --git a/python/mozlint/mozlint/pathutils.py b/python/mozlint/mozlint/pathutils.py
new file mode 100644
index 0000000000..b1b4b644bc
--- /dev/null
+++ b/python/mozlint/mozlint/pathutils.py
@@ -0,0 +1,313 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+
+from mozpack import path as mozpath
+from mozpack.files import FileFinder
+
+
+class FilterPath(object):
+    """Helper class to make comparing and matching file paths easier."""
+
+    def __init__(self, path):
+        self.path = os.path.normpath(path)
+        self._finder = None
+
+    @property
+    def finder(self):
+        if self._finder:
+            return self._finder
+        self._finder = FileFinder(mozpath.normsep(self.path))
+        return self._finder
+
+    @property
+    def ext(self):
+        return os.path.splitext(self.path)[1].strip(".")
+
+    @property
+    def exists(self):
+        return os.path.exists(self.path)
+
+    @property
+    def isfile(self):
+        return os.path.isfile(self.path)
+
+    @property
+    def isdir(self):
+        return os.path.isdir(self.path)
+
+    def join(self, *args):
+        return FilterPath(os.path.join(self.path, *args))
+
+    def match(self, patterns):
+        a = mozpath.normsep(self.path)
+        for p in patterns:
+            if isinstance(p, FilterPath):
+                p = p.path
+            p = mozpath.normsep(p)
+            if mozpath.match(a, p):
+                return True
+        return False
+
+    def contains(self, other):
+        """Return True if other is a subdirectory of self or equals self."""
+        if isinstance(other, FilterPath):
+            other = other.path
+        a = os.path.abspath(self.path)
+        b = os.path.normpath(os.path.abspath(other))
+
+        parts_a = a.split(os.sep)
+        parts_b = b.split(os.sep)
+
+        if len(parts_a) > len(parts_b):
+            return False
+
+        for i, part in enumerate(parts_a):
+            if part != parts_b[i]:
+                return False
+        return True
+
+    def __repr__(self):
+        return repr(self.path)
+
+
+def collapse(paths, base=None, dotfiles=False):
+    """Given an iterable of paths, collapse them into the smallest possible set
+    of paths that contain the original set (without containing any extra paths).
+
+    For example, if directory 'a' contains two files b.txt and c.txt, calling:
+
+        collapse(['a/b.txt', 'a/c.txt'])
+
+    returns ['a']. But if a third file d.txt also exists, then it will return
+    ['a/b.txt', 'a/c.txt'] since ['a'] would also include that extra file.
+
+    :param paths: An iterable of paths (files and directories) to collapse.
+    :returns: The smallest set of paths (files and directories) that contain
+              the original set of paths and only the original set.
+    """
+    if not paths:
+        if not base:
+            return []
+
+        # Need to test whether directory chain is empty. If it is then bubble
+        # the base back up so that it counts as 'covered'.
+        for _, _, names in os.walk(base):
+            if names:
+                return []
+        return [base]
+
+    if not base:
+        paths = list(map(mozpath.abspath, paths))
+        base = mozpath.commonprefix(paths).rstrip("/")
+
+        # Make sure `commonprefix` factors in sibling directories that have the
+        # same prefix in their basenames.
+        parent = mozpath.dirname(base)
+        same_prefix = [
+            p for p in os.listdir(parent) if p.startswith(mozpath.basename(base))
+        ]
+        if not os.path.isdir(base) or len(same_prefix) > 1:
+            base = parent
+
+    if base in paths:
+        return [base]
+
+    covered = set()
+    full = set()
+    for name in os.listdir(base):
+        if not dotfiles and name[0] == ".":
+            continue
+
+        path = mozpath.join(base, name)
+        full.add(path)
+
+        if path in paths:
+            # This path was explicitly specified, so just bubble it back up
+            # without recursing down into it (if it was a directory).
+            covered.add(path)
+        elif os.path.isdir(path):
+            new_paths = [p for p in paths if p.startswith(path)]
+            covered.update(collapse(new_paths, base=path, dotfiles=dotfiles))
+
+    if full == covered:
+        # Every file under this base was covered, so we can collapse them all
+        # up into the base path.
+        return [base]
+    return list(covered)
+
+
+def filterpaths(root, paths, include, exclude=None, extensions=None):
+    """Filters a list of paths.
+
+    Given a list of paths and some filtering rules, return the set of paths
+    that should be linted.
+
+    :param paths: A starting list of paths to possibly lint.
+    :param include: A list of paths that should be included (required).
+    :param exclude: A list of paths that should be excluded (optional).
+    :param extensions: A list of file extensions which should be considered (optional).
+    :returns: A tuple containing a list of file paths to lint and a list of
+              paths to exclude.
+    """
+
+    def normalize(path):
+        if "*" not in path and not os.path.isabs(path):
+            path = os.path.join(root, path)
+        return FilterPath(path)
+
+    # Includes are always paths and should always exist.
+    include = list(map(normalize, include))
+
+    # Exclude paths with and without globs will be handled separately,
+    # pull them apart now.
+    exclude = list(map(normalize, exclude or []))
+    excludepaths = [p for p in exclude if p.exists]
+    excludeglobs = [p.path for p in exclude if not p.exists]
+
+    keep = set()
+    discard = set()
+    for path in list(map(normalize, paths)):
+        # Exclude bad file extensions
+        if extensions and path.isfile and path.ext not in extensions:
+            continue
+
+        if path.match(excludeglobs):
+            continue
+
+        # First handle include/exclude directives
+        # that exist (i.e don't have globs)
+        for inc in include:
+            # Only excludes that are subdirectories of the include
+            # path matter.
+            excs = [e for e in excludepaths if inc.contains(e)]
+
+            if path.contains(inc):
+                # If specified path is an ancestor of include path,
+                # then lint the include path.
+                keep.add(inc)
+
+                # We can't apply these exclude paths without explicitly
+                # including every sibling file. Rather than do that,
+                # just return them and hope the underlying linter will
+                # deal with them.
+                discard.update(excs)
+
+            elif inc.contains(path):
+                # If the include path is an ancestor of the specified
+                # path, then add the specified path only if there are
+                # no exclude paths in-between them.
+                if not any(e.contains(path) for e in excs):
+                    keep.add(path)
+                    discard.update([e for e in excs if path.contains(e)])
+
+        # Next expand excludes with globs in them so we can add them to
+        # the set of files to discard.
+        for pattern in excludeglobs:
+            for p, f in path.finder.find(pattern):
+                discard.add(path.join(p))
+
+    return (
+        [f.path for f in keep if f.exists],
+        collapse([f.path for f in discard if f.exists]),
+    )
+
+
+def findobject(path):
+    """
+    Find a Python object given a path of the form <modulepath>:<objectpath>.
+    Conceptually equivalent to
+
+        def find_object(modulepath, objectpath):
+            import <modulepath> as mod
+            return mod.<objectpath>
+    """
+    if path.count(":") != 1:
+        raise ValueError(
+            'python path {!r} does not have the form "module:object"'.format(path)
+        )
+
+    modulepath, objectpath = path.split(":")
+    obj = __import__(modulepath)
+    for a in modulepath.split(".")[1:]:
+        obj = getattr(obj, a)
+    for a in objectpath.split("."):
+        obj = getattr(obj, a)
+    return obj
+
+
+def ancestors(path):
+    while path:
+        yield path
+        (path, child) = os.path.split(path)
+        if child == "":
+            break
+
+
+def get_ancestors_by_name(name, path, root):
+    """Returns a list of files called `name` in `path`'s ancestors,
+    sorted from closest->furthest. This can be useful for finding
+    relevant configuration files.
+    """
+    configs = []
+    for path in ancestors(path):
+        config = os.path.join(path, name)
+        if os.path.isfile(config):
+            configs.append(config)
+        if path == root:
+            break
+    return configs
+
+
+def expand_exclusions(paths, config, root):
+    """Returns all files that match patterns and aren't excluded.
+
+    This is used by some external linters who receive 'batch' files (e.g dirs)
+    but aren't capable of applying their own exclusions. There is an argument
+    to be made that this step should just apply to all linters no matter what.
+
+    Args:
+        paths (list): List of candidate paths to lint.
+        config (dict): Linter's config object.
+        root (str): Root of the repository.
+
+    Returns:
+        Generator which generates list of paths that weren't excluded.
+    """
+    extensions = [e.lstrip(".") for e in config.get("extensions", [])]
+    find_dotfiles = config.get("find-dotfiles", False)
+
+    def normalize(path):
+        path = mozpath.normpath(path)
+        if os.path.isabs(path):
+            return path
+        return mozpath.join(root, path)
+
+    exclude = list(map(normalize, config.get("exclude", [])))
+    for path in paths:
+        path = mozpath.normsep(path)
+        if os.path.isfile(path):
+            if any(path.startswith(e) for e in exclude if "*" not in e):
+                continue
+
+            if any(mozpath.match(path, e) for e in exclude if "*" in e):
+                continue
+
+            yield path
+            continue
+
+        ignore = [
+            e[len(path) :].lstrip("/")
+            for e in exclude
+            if mozpath.commonprefix((path, e)) == path
+        ]
+        finder = FileFinder(path, ignore=ignore, find_dotfiles=find_dotfiles)
+
+        _, ext = os.path.splitext(path)
+        ext.lstrip(".")
+
+        for ext in extensions:
+            for p, f in finder.find("**/*.{}".format(ext)):
+                yield os.path.join(path, p)
diff --git a/python/mozlint/mozlint/result.py b/python/mozlint/mozlint/result.py
new file mode 100644
index 0000000000..01b04afee6
--- /dev/null
+++ b/python/mozlint/mozlint/result.py
@@ -0,0 +1,163 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+from collections import defaultdict
+from itertools import chain
+from json import JSONEncoder
+
+import attr
+import mozpack.path as mozpath
+
+
+class ResultSummary(object):
+    """Represents overall result state from an entire lint run."""
+
+    root = None
+
+    def __init__(self, root, fail_on_warnings=True):
+        self.fail_on_warnings = fail_on_warnings
+        self.reset()
+
+        # Store the repository root folder to be able to build
+        # Issues relative paths to that folder
+        if ResultSummary.root is None:
+            ResultSummary.root = mozpath.normpath(root)
+
+    def reset(self):
+        self.issues = defaultdict(list)
+        self.failed_run = set()
+        self.failed_setup = set()
+        self.suppressed_warnings = defaultdict(int)
+        self.fixed = 0
+
+    def has_issues_failure(self):
+        """Returns true in case issues were detected during the lint run. Do not
+        consider warning issues in case `self.fail_on_warnings` is set to False.
+        """
+        if self.fail_on_warnings is False:
+            return any(
+                result.level != "warning" for result in chain(*self.issues.values())
+            )
+        return len(self.issues) >= 1
+
+    @property
+    def returncode(self):
+        if self.has_issues_failure() or self.failed:
+            return 1
+        return 0
+
+    @property
+    def failed(self):
+        return self.failed_setup | self.failed_run
+
+    @property
+    def total_issues(self):
+        return sum([len(v) for v in self.issues.values()])
+
+    @property
+    def total_suppressed_warnings(self):
+        return sum(self.suppressed_warnings.values())
+
+    @property
+    def total_fixed(self):
+        return self.fixed
+
+    def update(self, other):
+        """Merge results from another ResultSummary into this one."""
+        for path, obj in other.issues.items():
+            self.issues[path].extend(obj)
+
+        self.failed_run |= other.failed_run
+        self.failed_setup |= other.failed_setup
+        self.fixed += other.fixed
+        for k, v in other.suppressed_warnings.items():
+            self.suppressed_warnings[k] += v
+
+
+@attr.s(slots=True, kw_only=True)
+class Issue(object):
+    """Represents a single lint issue and its related metadata.
+
+    :param linter: name of the linter that flagged this error
+    :param path: path to the file containing the error
+    :param message: text describing the error
+    :param lineno: line number that contains the error
+    :param column: column containing the error
+    :param level: severity of the error, either 'warning' or 'error' (default 'error')
+    :param hint: suggestion for fixing the error (optional)
+    :param source: source code context of the error (optional)
+    :param rule: name of the rule that was violated (optional)
+    :param lineoffset: denotes an error spans multiple lines, of the form
+                       (<lineno offset>, <num lines>) (optional)
+    :param diff: a diff describing the changes that need to be made to the code
+    """
+
+    linter = attr.ib()
+    path = attr.ib()
+    lineno = attr.ib(
+        default=None, converter=lambda lineno: int(lineno) if lineno else 0
+    )
+    column = attr.ib(
+        default=None, converter=lambda column: int(column) if column else column
+    )
+    message = attr.ib()
+    hint = attr.ib(default=None)
+    source = attr.ib(default=None)
+    level = attr.ib(default=None, converter=lambda level: level or "error")
+    rule = attr.ib(default=None)
+    lineoffset = attr.ib(default=None)
+    diff = attr.ib(default=None)
+    relpath = attr.ib(init=False, default=None)
+
+    def __attrs_post_init__(self):
+        root = ResultSummary.root
+        assert root is not None, "Missing ResultSummary.root"
+        if os.path.isabs(self.path):
+            self.path = mozpath.normpath(self.path)
+            self.relpath = mozpath.relpath(self.path, root)
+        else:
+            self.relpath = mozpath.normpath(self.path)
+            self.path = mozpath.join(root, self.path)
+
+
+class IssueEncoder(JSONEncoder):
+    """Class for encoding :class:`~result.Issue` to json.
+
+    Usage:
+
+    .. code-block:: python
+
+        json.dumps(results, cls=IssueEncoder)
+
+    """
+
+    def default(self, o):
+        if isinstance(o, Issue):
+            return attr.asdict(o)
+        return JSONEncoder.default(self, o)
+
+
+def from_config(config, **kwargs):
+    """Create a :class:`~result.Issue` from a linter config.
+
+    Convenience method that pulls defaults from a linter
+    config and forwards them.
+
+    :param config: linter config as defined in a .yml file
+    :param kwargs: same as :class:`~result.Issue`
+    :returns: :class:`~result.Issue` object
+    """
+    args = {}
+    for arg in attr.fields(Issue):
+        if arg.init:
+            args[arg.name] = kwargs.get(arg.name, config.get(arg.name))
+
+    if not args["linter"]:
+        args["linter"] = config.get("name")
+
+    if not args["message"]:
+        args["message"] = config.get("description")
+
+    return Issue(**args)
diff --git a/python/mozlint/mozlint/roller.py b/python/mozlint/mozlint/roller.py
new file mode 100644
index 0000000000..1425178114
--- /dev/null
+++ b/python/mozlint/mozlint/roller.py
@@ -0,0 +1,421 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import atexit
+import copy
+import logging
+import os
+import signal
+import sys
+import time
+import traceback
+from concurrent.futures import ProcessPoolExecutor
+from concurrent.futures.process import _python_exit as futures_atexit
+from itertools import chain
+from math import ceil
+from multiprocessing import cpu_count, get_context
+from multiprocessing.queues import Queue
+from subprocess import CalledProcessError
+from typing import Dict, Set
+
+import mozpack.path as mozpath
+from mozversioncontrol import (
+    InvalidRepoPath,
+    MissingUpstreamRepo,
+    get_repository_object,
+)
+
+from .errors import LintersNotConfigured, NoValidLinter
+from .parser import Parser
+from .pathutils import findobject
+from .result import ResultSummary
+from .types import supported_types
+
+SHUTDOWN = False
+orig_sigint = signal.getsignal(signal.SIGINT)
+
+logger = logging.getLogger("mozlint")
+handler = logging.StreamHandler()
+formatter = logging.Formatter(
+    "%(asctime)s.%(msecs)d %(lintname)s (%(pid)s) | %(message)s", "%H:%M:%S"
+)
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+
+def _run_worker(config, paths, **lintargs):
+    log = logging.LoggerAdapter(
+        logger, {"lintname": config.get("name"), "pid": os.getpid()}
+    )
+    lintargs["log"] = log
+    result = ResultSummary(lintargs["root"])
+
+    if SHUTDOWN:
+        return result
+
+    # Override warnings setup for code review
+    # Only disactivating when code_review_warnings is set to False on a linter.yml in use
+    if os.environ.get("CODE_REVIEW") == "1" and config.get(
+        "code_review_warnings", True
+    ):
+        lintargs["show_warnings"] = True
+
+    # Override ignore thirdparty
+    # Only deactivating include_thirdparty is set on a linter.yml in use
+    if config.get("include_thirdparty", False):
+        lintargs["include_thirdparty"] = True
+
+    func = supported_types[config["type"]]
+    start_time = time.monotonic()
+    try:
+        res = func(paths, config, **lintargs)
+        # Some linters support fixed operations
+        # dict returned - {"results":results,"fixed":fixed}
+        if isinstance(res, dict):
+            result.fixed += res["fixed"]
+            res = res["results"] or []
+        elif isinstance(res, list):
+            res = res or []
+        else:
+            print("Unexpected type received")
+            assert False
+    except Exception:
+        traceback.print_exc()
+        res = 1
+    except (KeyboardInterrupt, SystemExit):
+        return result
+    finally:
+        end_time = time.monotonic()
+        log.debug("Finished in {:.2f} seconds".format(end_time - start_time))
+        sys.stdout.flush()
+
+    if not isinstance(res, (list, tuple)):
+        if res:
+            result.failed_run.add(config["name"])
+    else:
+        for r in res:
+            if not lintargs.get("show_warnings") and r.level == "warning":
+                result.suppressed_warnings[r.path] += 1
+                continue
+
+            result.issues[r.path].append(r)
+
+    return result
+
+
+class InterruptableQueue(Queue):
+    """A multiprocessing.Queue that catches KeyboardInterrupt when a worker is
+    blocking on it and returns None.
+
+    This is needed to gracefully handle KeyboardInterrupts when a worker is
+    blocking on ProcessPoolExecutor's call queue.
+    """
+
+    def __init__(self, *args, **kwargs):
+        kwargs["ctx"] = get_context()
+        super(InterruptableQueue, self).__init__(*args, **kwargs)
+
+    def get(self, *args, **kwargs):
+        try:
+            return Queue.get(self, *args, **kwargs)
+        except KeyboardInterrupt:
+            return None
+
+
+def _worker_sigint_handler(signum, frame):
+    """Sigint handler for the worker subprocesses.
+
+    Tells workers not to process the extra jobs on the call queue that couldn't
+    be canceled by the parent process.
+    """
+    global SHUTDOWN
+    SHUTDOWN = True
+    orig_sigint(signum, frame)
+
+
+def wrap_futures_atexit():
+    """Sometimes futures' atexit handler can spew tracebacks. This wrapper
+    suppresses them."""
+    try:
+        futures_atexit()
+    except Exception:
+        # Generally `atexit` handlers aren't supposed to raise exceptions, but the
+        # futures' handler can sometimes raise when the user presses `CTRL-C`. We
+        # suppress all possible exceptions here so users have a nice experience
+        # when canceling their lint run. Any exceptions raised by this function
+        # won't be useful anyway.
+        pass
+
+
+atexit.unregister(futures_atexit)
+atexit.register(wrap_futures_atexit)
+
+
+class LintRoller(object):
+    """Registers and runs linters.
+
+    :param root: Path to which relative paths will be joined. If
+                 unspecified, root will either be determined from
+                 version control or cwd.
+    :param lintargs: Arguments to pass to the underlying linter(s).
+    """
+
+    MAX_PATHS_PER_JOB = (
+        50  # set a max size to prevent command lines that are too long on Windows
+    )
+
+    def __init__(self, root, exclude=None, setupargs=None, **lintargs):
+        self.parse = Parser(root)
+        try:
+            self.vcs = get_repository_object(root)
+        except InvalidRepoPath:
+            self.vcs = None
+
+        self.linters = []
+        self.lintargs = lintargs
+        self.lintargs["root"] = root
+        self._setupargs = setupargs or {}
+
+        # result state
+        self.result = ResultSummary(
+            root,
+            # Prevent failing on warnings when the --warnings parameter is set to "soft"
+            fail_on_warnings=lintargs.get("show_warnings") != "soft",
+        )
+
+        self.root = root
+        self.exclude = exclude or []
+
+        if lintargs.get("show_verbose"):
+            logger.setLevel(logging.DEBUG)
+        else:
+            logger.setLevel(logging.WARNING)
+
+        self.log = logging.LoggerAdapter(
+            logger, {"lintname": "mozlint", "pid": os.getpid()}
+        )
+
+    def read(self, paths):
+        """Parse one or more linters and add them to the registry.
+
+        :param paths: A path or iterable of paths to linter definitions.
+        """
+        if isinstance(paths, str):
+            paths = (paths,)
+
+        for linter in chain(*[self.parse(p) for p in paths]):
+            # Add only the excludes present in paths
+            linter["local_exclude"] = linter.get("exclude", [])[:]
+            # Add in our global excludes
+            linter.setdefault("exclude", []).extend(self.exclude)
+            self.linters.append(linter)
+
+    def setup(self, virtualenv_manager=None):
+        """Run setup for applicable linters"""
+        if not self.linters:
+            raise NoValidLinter
+
+        for linter in self.linters:
+            if "setup" not in linter:
+                continue
+
+            try:
+                setupargs = copy.deepcopy(self.lintargs)
+                setupargs.update(self._setupargs)
+                setupargs["name"] = linter["name"]
+                setupargs["log"] = logging.LoggerAdapter(
+                    self.log, {"lintname": linter["name"]}
+                )
+                if virtualenv_manager is not None:
+                    setupargs["virtualenv_manager"] = virtualenv_manager
+                start_time = time.monotonic()
+                res = findobject(linter["setup"])(
+                    **setupargs,
+                )
+                self.log.debug(
+                    f"setup for {linter['name']} finished in "
+                    f"{round(time.monotonic() - start_time, 2)} seconds"
+                )
+            except Exception:
+                traceback.print_exc()
+                res = 1
+
+            if res:
+                self.result.failed_setup.add(linter["name"])
+
+        if self.result.failed_setup:
+            print(
+                "error: problem with lint setup, skipping {}".format(
+                    ", ".join(sorted(self.result.failed_setup))
+                )
+            )
+            self.linters = [
+                l for l in self.linters if l["name"] not in self.result.failed_setup
+            ]
+            return 1
+        return 0
+
+    def should_lint_entire_tree(self, vcs_paths: Set[str], linter: Dict) -> bool:
+        """Return `True` if the linter should be run on the entire tree."""
+        # Don't lint the entire tree when `--fix` is passed to linters.
+        if "fix" in self.lintargs and self.lintargs["fix"]:
+            return False
+
+        # Lint the whole tree when a `support-file` is modified.
+        return any(
+            os.path.isfile(p) and mozpath.match(p, pattern)
+            for pattern in linter.get("support-files", [])
+            for p in vcs_paths
+        )
+
+    def _generate_jobs(self, paths, vcs_paths, num_procs):
+        def __get_current_paths(path=self.root):
+            return [os.path.join(path, p) for p in os.listdir(path)]
+
+        """A job is of the form (<linter:dict>, <paths:list>)."""
+        for linter in self.linters:
+            if self.should_lint_entire_tree(vcs_paths, linter):
+                lpaths = __get_current_paths()
+                print(
+                    "warning: {} support-file modified, linting entire tree "
+                    "(press ctrl-c to cancel)".format(linter["name"])
+                )
+            elif paths == {self.root}:
+                # If the command line is ".", the path will match with the root
+                # directory. In this case, get all the paths, so that we can
+                # benefit from chunking below.
+                lpaths = __get_current_paths()
+            else:
+                lpaths = paths.union(vcs_paths)
+
+            lpaths = list(lpaths) or __get_current_paths(os.getcwd())
+            chunk_size = (
+                min(self.MAX_PATHS_PER_JOB, int(ceil(len(lpaths) / num_procs))) or 1
+            )
+            if linter["type"] == "global":
+                # Global linters lint the entire tree in one job.
+                chunk_size = len(lpaths) or 1
+            assert chunk_size > 0
+
+            while lpaths:
+                yield linter, lpaths[:chunk_size]
+                lpaths = lpaths[chunk_size:]
+
+    def _collect_results(self, future):
+        if future.cancelled():
+            return
+
+        # Merge this job's results with our global ones.
+        self.result.update(future.result())
+
+    def roll(self, paths=None, outgoing=None, workdir=None, rev=None, num_procs=None):
+        """Run all of the registered linters against the specified file paths.
+
+        :param paths: An iterable of files and/or directories to lint.
+        :param outgoing: Lint files touched by commits that are not on the remote repository.
+        :param workdir: Lint all files touched in the working directory.
+        :param num_procs: The number of processes to use. Default: cpu count
+        :return: A :class:`~result.ResultSummary` instance.
+        """
+        if not self.linters:
+            raise LintersNotConfigured
+
+        self.result.reset()
+
+        # Need to use a set in case vcs operations specify the same file
+        # more than once.
+        paths = paths or set()
+        if isinstance(paths, str):
+            paths = set([paths])
+        elif isinstance(paths, (list, tuple)):
+            paths = set(paths)
+
+        if not self.vcs and (workdir or outgoing):
+            print(
+                "error: '{}' is not a known repository, can't use "
+                "--workdir or --outgoing".format(self.lintargs["root"])
+            )
+
+        # Calculate files from VCS
+        vcs_paths = set()
+        try:
+            if workdir:
+                vcs_paths.update(self.vcs.get_changed_files("AM", mode=workdir))
+            if rev:
+                vcs_paths.update(self.vcs.get_changed_files("AM", rev=rev))
+            if outgoing:
+                upstream = outgoing if isinstance(outgoing, str) else None
+                try:
+                    vcs_paths.update(
+                        self.vcs.get_outgoing_files("AM", upstream=upstream)
+                    )
+                except MissingUpstreamRepo:
+                    print(
+                        "warning: could not find default push, specify a remote for --outgoing"
+                    )
+        except CalledProcessError as e:
+            print("error running: {}".format(" ".join(e.cmd)))
+            if e.output:
+                print(e.output)
+
+        if not (paths or vcs_paths) and (workdir or outgoing):
+            if os.environ.get("MOZ_AUTOMATION") and not os.environ.get(
+                "PYTEST_CURRENT_TEST"
+            ):
+                raise Exception(
+                    "Despite being a CI lint job, no files were linted. Is the task "
+                    "missing explicit paths?"
+                )
+
+            print("warning: no files linted")
+            return self.result
+
+        # Make sure all paths are absolute. Join `paths` to cwd and `vcs_paths` to root.
+        paths = set(map(os.path.abspath, paths))
+        vcs_paths = set(
+            [
+                os.path.join(self.root, p) if not os.path.isabs(p) else p
+                for p in vcs_paths
+            ]
+        )
+
+        num_procs = num_procs or cpu_count()
+        jobs = list(self._generate_jobs(paths, vcs_paths, num_procs))
+
+        # Make sure we never spawn more processes than we have jobs.
+        num_procs = min(len(jobs), num_procs) or 1
+        if sys.platform == "win32":
+            # https://github.com/python/cpython/pull/13132
+            num_procs = min(num_procs, 61)
+
+        signal.signal(signal.SIGINT, _worker_sigint_handler)
+        executor = ProcessPoolExecutor(num_procs)
+        executor._call_queue = InterruptableQueue(executor._call_queue._maxsize)
+
+        # Submit jobs to the worker pool. The _collect_results method will be
+        # called when a job is finished. We store the futures so that they can
+        # be canceled in the event of a KeyboardInterrupt.
+        futures = []
+        for job in jobs:
+            future = executor.submit(_run_worker, *job, **self.lintargs)
+            future.add_done_callback(self._collect_results)
+            futures.append(future)
+
+        def _parent_sigint_handler(signum, frame):
+            """Sigint handler for the parent process.
+
+            Cancels all jobs that have not yet been placed on the call queue.
+            The parent process won't exit until all workers have terminated.
+            Assuming the linters are implemented properly, this shouldn't take
+            more than a couple seconds.
+            """
+            [f.cancel() for f in futures]
+            executor.shutdown(wait=True)
+            print("\nwarning: not all files were linted")
+            signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+        signal.signal(signal.SIGINT, _parent_sigint_handler)
+        executor.shutdown()
+        signal.signal(signal.SIGINT, orig_sigint)
+        return self.result
diff --git a/python/mozlint/mozlint/types.py b/python/mozlint/mozlint/types.py
new file mode 100644
index 0000000000..1a9a0bd473
--- /dev/null
+++ b/python/mozlint/mozlint/types.py
@@ -0,0 +1,214 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+import re
+import sys
+from abc import ABCMeta, abstractmethod
+
+from mozlog import commandline, get_default_logger, structuredlog
+from mozlog.reader import LogHandler
+from mozpack.files import FileFinder
+
+from . import result
+from .pathutils import expand_exclusions, filterpaths, findobject
+
+
+class BaseType(object):
+    """Abstract base class for all types of linters."""
+
+    __metaclass__ = ABCMeta
+    batch = False
+
+    def __call__(self, paths, config, **lintargs):
+        """Run linter defined by `config` against `paths` with `lintargs`.
+
+        :param paths: Paths to lint. Can be a file or directory.
+        :param config: Linter config the paths are being linted against.
+        :param lintargs: External arguments to the linter not defined in
+                         the definition, but passed in by a consumer.
+        :returns: A list of :class:`~result.Issue` objects.
+        """
+        log = lintargs["log"]
+
+        if lintargs.get("use_filters", True):
+            paths, exclude = filterpaths(
+                lintargs["root"],
+                paths,
+                config["include"],
+                config.get("exclude", []),
+                config.get("extensions", []),
+            )
+            config["exclude"] = exclude
+        elif config.get("exclude"):
+            del config["exclude"]
+
+        if not paths:
+            return {"results": [], "fixed": 0}
+
+        log.debug(
+            "Passing the following paths:\n{paths}".format(
+                paths="  \n".join(paths),
+            )
+        )
+
+        if self.batch:
+            return self._lint(paths, config, **lintargs)
+
+        errors = []
+
+        try:
+            for p in paths:
+                result = self._lint(p, config, **lintargs)
+                if result:
+                    errors.extend(result)
+        except KeyboardInterrupt:
+            pass
+        return errors
+
+    def _lint_dir(self, path, config, **lintargs):
+        if not config.get("extensions"):
+            patterns = ["**"]
+        else:
+            patterns = ["**/*.{}".format(e) for e in config["extensions"]]
+
+        exclude = [os.path.relpath(e, path) for e in config.get("exclude", [])]
+        finder = FileFinder(path, ignore=exclude)
+
+        errors = []
+        for pattern in patterns:
+            for p, f in finder.find(pattern):
+                errors.extend(self._lint(os.path.join(path, p), config, **lintargs))
+        return errors
+
+    @abstractmethod
+    def _lint(self, path, config, **lintargs):
+        pass
+
+
+class LineType(BaseType):
+    """Abstract base class for linter types that check each line individually.
+
+    Subclasses of this linter type will read each file and check the provided
+    payload against each line one by one.
+    """
+
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def condition(payload, line, config):
+        pass
+
+    def _lint(self, path, config, **lintargs):
+        if os.path.isdir(path):
+            return self._lint_dir(path, config, **lintargs)
+
+        payload = config["payload"]
+        with open(path, "r", errors="replace") as fh:
+            lines = fh.readlines()
+
+        errors = []
+        for i, line in enumerate(lines):
+            if self.condition(payload, line, config):
+                errors.append(result.from_config(config, path=path, lineno=i + 1))
+
+        return errors
+
+
+class StringType(LineType):
+    """Linter type that checks whether a substring is found."""
+
+    def condition(self, payload, line, config):
+        return payload in line
+
+
+class RegexType(LineType):
+    """Linter type that checks whether a regex match is found."""
+
+    def condition(self, payload, line, config):
+        flags = 0
+        if config.get("ignore-case"):
+            flags |= re.IGNORECASE
+
+        return re.search(payload, line, flags)
+
+
+class ExternalType(BaseType):
+    """Linter type that runs an external function.
+
+    The function is responsible for properly formatting the results
+    into a list of :class:`~result.Issue` objects.
+    """
+
+    batch = True
+
+    def _lint(self, files, config, **lintargs):
+        func = findobject(config["payload"])
+        return func(files, config, **lintargs)
+
+
+class ExternalFileType(ExternalType):
+    batch = False
+
+
+class GlobalType(ExternalType):
+    """Linter type that runs an external global linting function just once.
+
+    The function is responsible for properly formatting the results
+    into a list of :class:`~result.Issue` objects.
+    """
+
+    batch = True
+
+    def _lint(self, files, config, **lintargs):
+        # Global lints are expensive to invoke.  Try to avoid running
+        # them based on extensions and exclusions.
+        try:
+            next(expand_exclusions(files, config, lintargs["root"]))
+        except StopIteration:
+            return []
+
+        func = findobject(config["payload"])
+        return func(config, **lintargs)
+
+
+class LintHandler(LogHandler):
+    def __init__(self, config):
+        self.config = config
+        self.results = []
+
+    def lint(self, data):
+        self.results.append(result.from_config(self.config, **data))
+
+
+class StructuredLogType(BaseType):
+    batch = True
+
+    def _lint(self, files, config, **lintargs):
+        handler = LintHandler(config)
+        logger = config.get("logger")
+        if logger is None:
+            logger = get_default_logger()
+        if logger is None:
+            logger = structuredlog.StructuredLogger(config["name"])
+            commandline.setup_logging(logger, {}, {"mach": sys.stdout})
+        logger.add_handler(handler)
+
+        func = findobject(config["payload"])
+        try:
+            func(files, config, logger, **lintargs)
+        except KeyboardInterrupt:
+            pass
+        return handler.results
+
+
+supported_types = {
+    "string": StringType(),
+    "regex": RegexType(),
+    "external": ExternalType(),
+    "external-file": ExternalFileType(),
+    "global": GlobalType(),
+    "structured_log": StructuredLogType(),
+}
+"""Mapping of type string to an associated instance."""
diff --git a/python/mozlint/mozlint/util/__init__.py b/python/mozlint/mozlint/util/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/mozlint/util/__init__.py
diff --git a/python/mozlint/mozlint/util/implementation.py b/python/mozlint/mozlint/util/implementation.py
new file mode 100644
index 0000000000..9c72c0ea0f
--- /dev/null
+++ b/python/mozlint/mozlint/util/implementation.py
@@ -0,0 +1,35 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import signal
+from abc import ABC, abstractmethod
+
+from mozprocess import ProcessHandlerMixin
+
+
+class LintProcess(ProcessHandlerMixin, ABC):
+    def __init__(self, config, *args, **kwargs):
+        self.config = config
+        self.results = []
+
+        kwargs["universal_newlines"] = True
+        kwargs["processOutputLine"] = [self.process_line]
+        ProcessHandlerMixin.__init__(self, *args, **kwargs)
+
+    @abstractmethod
+    def process_line(self, line):
+        """Process a single line of output.
+
+        The implementation is responsible for creating one or more :class:`~mozlint.result.Issue`
+        and storing them somewhere accessible.
+
+        Args:
+            line (str): The line of output to process.
+        """
+        pass
+
+    def run(self, *args, **kwargs):
+        orig = signal.signal(signal.SIGINT, signal.SIG_IGN)
+        ProcessHandlerMixin.run(self, *args, **kwargs)
+        signal.signal(signal.SIGINT, orig)
diff --git a/python/mozlint/mozlint/util/string.py b/python/mozlint/mozlint/util/string.py
new file mode 100644
index 0000000000..9c1c7c99c2
--- /dev/null
+++ b/python/mozlint/mozlint/util/string.py
@@ -0,0 +1,9 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+def pluralize(s, num):
+    if num != 1:
+        s += "s"
+    return str(num) + " " + s
diff --git a/python/mozlint/setup.py b/python/mozlint/setup.py
new file mode 100644
index 0000000000..c16e15fd7f
--- /dev/null
+++ b/python/mozlint/setup.py
@@ -0,0 +1,26 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+from setuptools import setup
+
+VERSION = 0.1
+DEPS = ["mozlog >= 6.0"]
+
+setup(
+    name="mozlint",
+    description="Framework for registering and running micro lints",
+    license="MPL 2.0",
+    author="Andrew Halberstadt",
+    author_email="ahalberstadt@mozilla.com",
+    url="",
+    packages=["mozlint"],
+    version=VERSION,
+    classifiers=[
+        "Environment :: Console",
+        "Development Status :: 3 - Alpha",
+        "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
+        "Natural Language :: English",
+    ],
+    install_requires=DEPS,
+)
diff --git a/python/mozlint/test/__init__.py b/python/mozlint/test/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/__init__.py
diff --git a/python/mozlint/test/conftest.py b/python/mozlint/test/conftest.py
new file mode 100644
index 0000000000..9683c23b13
--- /dev/null
+++ b/python/mozlint/test/conftest.py
@@ -0,0 +1,66 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+import sys
+from argparse import Namespace
+
+import pytest
+
+from mozlint import LintRoller
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+
+@pytest.fixture
+def lint(request):
+    lintargs = getattr(request.module, "lintargs", {})
+    lint = LintRoller(root=here, **lintargs)
+
+    # Add a few super powers to our lint instance
+    def mock_vcs(files):
+        def _fake_vcs_files(*args, **kwargs):
+            return files
+
+        setattr(lint.vcs, "get_changed_files", _fake_vcs_files)
+        setattr(lint.vcs, "get_outgoing_files", _fake_vcs_files)
+
+    setattr(lint, "vcs", Namespace())
+    setattr(lint, "mock_vcs", mock_vcs)
+    return lint
+
+
+@pytest.fixture(scope="session")
+def filedir():
+    return os.path.join(here, "files")
+
+
+@pytest.fixture(scope="module")
+def files(filedir, request):
+    suffix_filter = getattr(request.module, "files", [""])
+    return [
+        os.path.join(filedir, p)
+        for p in os.listdir(filedir)
+        if any(p.endswith(suffix) for suffix in suffix_filter)
+    ]
+
+
+@pytest.fixture(scope="session")
+def lintdir():
+    lintdir = os.path.join(here, "linters")
+    sys.path.insert(0, lintdir)
+    return lintdir
+
+
+@pytest.fixture(scope="module")
+def linters(lintdir):
+    def inner(*names):
+        return [
+            os.path.join(lintdir, p)
+            for p in os.listdir(lintdir)
+            if any(os.path.splitext(p)[0] == name for name in names)
+            if os.path.splitext(p)[1] == ".yml"
+        ]
+
+    return inner
diff --git a/python/mozlint/test/files/foobar.js b/python/mozlint/test/files/foobar.js
new file mode 100644
index 0000000000..d9754d0a2f
--- /dev/null
+++ b/python/mozlint/test/files/foobar.js
@@ -0,0 +1,2 @@
+// Oh no.. we called this variable foobar, bad!
+var foobar = "a string";
diff --git a/python/mozlint/test/files/foobar.py b/python/mozlint/test/files/foobar.py
new file mode 100644
index 0000000000..3b6416d211
--- /dev/null
+++ b/python/mozlint/test/files/foobar.py
@@ -0,0 +1,3 @@
+# Oh no.. we called this variable foobar, bad!
+
+foobar = "a string"
diff --git a/python/mozlint/test/files/irrelevant/file.txt b/python/mozlint/test/files/irrelevant/file.txt
new file mode 100644
index 0000000000..323fae03f4
--- /dev/null
+++ b/python/mozlint/test/files/irrelevant/file.txt
@@ -0,0 +1 @@
+foobar
diff --git a/python/mozlint/test/files/no_foobar.js b/python/mozlint/test/files/no_foobar.js
new file mode 100644
index 0000000000..6b95d646c0
--- /dev/null
+++ b/python/mozlint/test/files/no_foobar.js
@@ -0,0 +1,2 @@
+// What a relief
+var properlyNamed = "a string";
diff --git a/python/mozlint/test/filter/a.js b/python/mozlint/test/filter/a.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/filter/a.js
diff --git a/python/mozlint/test/filter/a.py b/python/mozlint/test/filter/a.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/filter/a.py
diff --git a/python/mozlint/test/filter/foo/empty.txt b/python/mozlint/test/filter/foo/empty.txt
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/filter/foo/empty.txt
diff --git a/python/mozlint/test/filter/foobar/empty.txt b/python/mozlint/test/filter/foobar/empty.txt
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/filter/foobar/empty.txt
diff --git a/python/mozlint/test/filter/subdir1/b.js b/python/mozlint/test/filter/subdir1/b.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/filter/subdir1/b.js
diff --git a/python/mozlint/test/filter/subdir1/b.py b/python/mozlint/test/filter/subdir1/b.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/filter/subdir1/b.py
diff --git a/python/mozlint/test/filter/subdir1/subdir3/d.js b/python/mozlint/test/filter/subdir1/subdir3/d.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/filter/subdir1/subdir3/d.js
diff --git a/python/mozlint/test/filter/subdir1/subdir3/d.py b/python/mozlint/test/filter/subdir1/subdir3/d.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/filter/subdir1/subdir3/d.py
diff --git a/python/mozlint/test/filter/subdir2/c.js b/python/mozlint/test/filter/subdir2/c.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/filter/subdir2/c.js
diff --git a/python/mozlint/test/filter/subdir2/c.py b/python/mozlint/test/filter/subdir2/c.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozlint/test/filter/subdir2/c.py
diff --git a/python/mozlint/test/linters/badreturncode.yml b/python/mozlint/test/linters/badreturncode.yml
new file mode 100644
index 0000000000..72abf83cc7
--- /dev/null
+++ b/python/mozlint/test/linters/badreturncode.yml
@@ -0,0 +1,8 @@
+---
+BadReturnCodeLinter:
+    description: Returns an error code no matter what
+    include:
+        - files
+    type: external
+    extensions: ['.js', '.jsm']
+    payload: external:badreturncode
diff --git a/python/mozlint/test/linters/excludes.yml b/python/mozlint/test/linters/excludes.yml
new file mode 100644
index 0000000000..1fc1068735
--- /dev/null
+++ b/python/mozlint/test/linters/excludes.yml
@@ -0,0 +1,10 @@
+---
+ExcludesLinter:
+    description: >-
+        Make sure the string foobar never appears in browser js
+        files because it is bad
+    rule: no-foobar
+    exclude: ['**/foobar.js']
+    extensions: ['.js', 'jsm']
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/excludes_empty.yml b/python/mozlint/test/linters/excludes_empty.yml
new file mode 100644
index 0000000000..03cd1aecab
--- /dev/null
+++ b/python/mozlint/test/linters/excludes_empty.yml
@@ -0,0 +1,8 @@
+---
+ExcludesEmptyLinter:
+    description: It's bad to have the string foobar in js files.
+    include:
+        - files
+    type: external
+    extensions: ['.js', '.jsm']
+    payload: foobar
diff --git a/python/mozlint/test/linters/explicit_path.yml b/python/mozlint/test/linters/explicit_path.yml
new file mode 100644
index 0000000000..1e7e8f4bf1
--- /dev/null
+++ b/python/mozlint/test/linters/explicit_path.yml
@@ -0,0 +1,8 @@
+---
+ExplicitPathLinter:
+    description: Only lint a specific file name
+    rule: no-foobar
+    include:
+        - files/no_foobar.js
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/external.py b/python/mozlint/test/linters/external.py
new file mode 100644
index 0000000000..9c2e58909d
--- /dev/null
+++ b/python/mozlint/test/linters/external.py
@@ -0,0 +1,74 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+import time
+
+from mozlint import result
+from mozlint.errors import LintException
+
+
+def badreturncode(files, config, **lintargs):
+    return 1
+
+
+def external(files, config, **lintargs):
+    if lintargs.get("fix"):
+        # mimics no results because they got fixed
+        return []
+
+    results = []
+    for path in files:
+        if os.path.isdir(path):
+            continue
+
+        with open(path, "r") as fh:
+            for i, line in enumerate(fh.readlines()):
+                if "foobar" in line:
+                    results.append(
+                        result.from_config(
+                            config, path=path, lineno=i + 1, column=1, rule="no-foobar"
+                        )
+                    )
+    return results
+
+
+def raises(files, config, **lintargs):
+    raise LintException("Oh no something bad happened!")
+
+
+def slow(files, config, **lintargs):
+    time.sleep(2)
+    return []
+
+
+def structured(files, config, logger, **kwargs):
+    for path in files:
+        if os.path.isdir(path):
+            continue
+
+        with open(path, "r") as fh:
+            for i, line in enumerate(fh.readlines()):
+                if "foobar" in line:
+                    logger.lint_error(
+                        path=path, lineno=i + 1, column=1, rule="no-foobar"
+                    )
+
+
+def passes(files, config, **lintargs):
+    return []
+
+
+def setup(**lintargs):
+    print("setup passed")
+
+
+def setupfailed(**lintargs):
+    print("setup failed")
+    return 1
+
+
+def setupraised(**lintargs):
+    print("setup raised")
+    raise LintException("oh no setup failed")
diff --git a/python/mozlint/test/linters/external.yml b/python/mozlint/test/linters/external.yml
new file mode 100644
index 0000000000..574b8df4cb
--- /dev/null
+++ b/python/mozlint/test/linters/external.yml
@@ -0,0 +1,8 @@
+---
+ExternalLinter:
+    description: It's bad to have the string foobar in js files.
+    include:
+        - files
+    type: external
+    extensions: ['.js', '.jsm']
+    payload: external:external
diff --git a/python/mozlint/test/linters/global.yml b/python/mozlint/test/linters/global.yml
new file mode 100644
index 0000000000..47d5ce81e4
--- /dev/null
+++ b/python/mozlint/test/linters/global.yml
@@ -0,0 +1,8 @@
+---
+GlobalLinter:
+    description: It's bad to have the string foobar in js files.
+    include:
+        - files
+    type: global
+    extensions: ['.js', '.jsm']
+    payload: global_payload:global_payload
diff --git a/python/mozlint/test/linters/global_payload.py b/python/mozlint/test/linters/global_payload.py
new file mode 100644
index 0000000000..ec620b6af1
--- /dev/null
+++ b/python/mozlint/test/linters/global_payload.py
@@ -0,0 +1,38 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import mozpack.path as mozpath
+from external import external
+from mozpack.files import FileFinder
+
+from mozlint import result
+
+
+def global_payload(config, **lintargs):
+    # A global linter that runs the external linter to actually lint.
+    finder = FileFinder(lintargs["root"])
+    files = [mozpath.join(lintargs["root"], p) for p, _ in finder.find("files/**")]
+    issues = external(files, config, **lintargs)
+    for issue in issues:
+        # Make issue look like it comes from this linter.
+        issue.linter = "global_payload"
+    return issues
+
+
+def global_skipped(config, **lintargs):
+    # A global linter that always registers a lint error.  Absence of
+    # this error shows that the path exclusion mechanism can cause
+    # global lint payloads to not be invoked at all.  In particular,
+    # the `extensions` field means that nothing under `files/**` will
+    # match.
+
+    finder = FileFinder(lintargs["root"])
+    files = [mozpath.join(lintargs["root"], p) for p, _ in finder.find("files/**")]
+
+    issues = []
+    issues.append(
+        result.from_config(
+            config, path=files[0], lineno=1, column=1, rule="not-skipped"
+        )
+    )
diff --git a/python/mozlint/test/linters/global_skipped.yml b/python/mozlint/test/linters/global_skipped.yml
new file mode 100644
index 0000000000..99b784e8be
--- /dev/null
+++ b/python/mozlint/test/linters/global_skipped.yml
@@ -0,0 +1,8 @@
+---
+GlobalSkippedLinter:
+    description: It's bad to run global linters when nothing matches.
+    include:
+        - files
+    type: global
+    extensions: ['.non.existent.extension']
+    payload: global_payload:global_skipped
diff --git a/python/mozlint/test/linters/invalid_exclude.yml b/python/mozlint/test/linters/invalid_exclude.yml
new file mode 100644
index 0000000000..7231d2c146
--- /dev/null
+++ b/python/mozlint/test/linters/invalid_exclude.yml
@@ -0,0 +1,6 @@
+---
+BadExcludeLinter:
+    description: Has an invalid exclude directive.
+    exclude: [0, 1]  # should be a list of strings
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/invalid_extension.ym b/python/mozlint/test/linters/invalid_extension.ym
new file mode 100644
index 0000000000..435fa10320
--- /dev/null
+++ b/python/mozlint/test/linters/invalid_extension.ym
@@ -0,0 +1,5 @@
+---
+BadExtensionLinter:
+    description: Has an invalid file extension.
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/invalid_include.yml b/python/mozlint/test/linters/invalid_include.yml
new file mode 100644
index 0000000000..b76b3e6a61
--- /dev/null
+++ b/python/mozlint/test/linters/invalid_include.yml
@@ -0,0 +1,6 @@
+---
+BadIncludeLinter:
+    description: Has an invalid include directive.
+    include: should be a list
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/invalid_include_with_glob.yml b/python/mozlint/test/linters/invalid_include_with_glob.yml
new file mode 100644
index 0000000000..857bb1376b
--- /dev/null
+++ b/python/mozlint/test/linters/invalid_include_with_glob.yml
@@ -0,0 +1,6 @@
+---
+BadIncludeLinterWithGlob:
+    description: Has an invalid include directive.
+    include: ['**/*.js']
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/invalid_support_files.yml b/python/mozlint/test/linters/invalid_support_files.yml
new file mode 100644
index 0000000000..db39597d68
--- /dev/null
+++ b/python/mozlint/test/linters/invalid_support_files.yml
@@ -0,0 +1,6 @@
+---
+BadSupportFilesLinter:
+    description: Has an invalid support files directive.
+    support-files: should be a list
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/invalid_type.yml b/python/mozlint/test/linters/invalid_type.yml
new file mode 100644
index 0000000000..29d82e541e
--- /dev/null
+++ b/python/mozlint/test/linters/invalid_type.yml
@@ -0,0 +1,5 @@
+---
+BadTypeLinter:
+    description: Has an invalid type.
+    type: invalid
+    payload: foobar
diff --git a/python/mozlint/test/linters/missing_attrs.yml b/python/mozlint/test/linters/missing_attrs.yml
new file mode 100644
index 0000000000..5abe15fcfc
--- /dev/null
+++ b/python/mozlint/test/linters/missing_attrs.yml
@@ -0,0 +1,3 @@
+---
+MissingAttrsLinter:
+    description: Missing type and payload
diff --git a/python/mozlint/test/linters/missing_definition.yml b/python/mozlint/test/linters/missing_definition.yml
new file mode 100644
index 0000000000..d66b2cb781
--- /dev/null
+++ b/python/mozlint/test/linters/missing_definition.yml
@@ -0,0 +1 @@
+# No definition
diff --git a/python/mozlint/test/linters/multiple.yml b/python/mozlint/test/linters/multiple.yml
new file mode 100644
index 0000000000..5b880b3691
--- /dev/null
+++ b/python/mozlint/test/linters/multiple.yml
@@ -0,0 +1,19 @@
+---
+StringLinter:
+    description: >-
+        Make sure the string foobar never appears in browser js
+        files because it is bad
+    rule: no-foobar
+    extensions: ['.js', 'jsm']
+    type: string
+    payload: foobar
+
+---
+RegexLinter:
+    description: >-
+        Make sure the string foobar never appears in browser js
+        files because it is bad
+    rule: no-foobar
+    extensions: ['.js', 'jsm']
+    type: regex
+    payload: foobar
diff --git a/python/mozlint/test/linters/non_existing_exclude.yml b/python/mozlint/test/linters/non_existing_exclude.yml
new file mode 100644
index 0000000000..8190123027
--- /dev/null
+++ b/python/mozlint/test/linters/non_existing_exclude.yml
@@ -0,0 +1,7 @@
+---
+BadExcludeLinter:
+    description: Has an invalid exclude directive.
+    exclude:
+        - files/does_not_exist
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/non_existing_include.yml b/python/mozlint/test/linters/non_existing_include.yml
new file mode 100644
index 0000000000..5443d751ed
--- /dev/null
+++ b/python/mozlint/test/linters/non_existing_include.yml
@@ -0,0 +1,7 @@
+---
+BadIncludeLinter:
+    description: Has an invalid include directive.
+    include:
+        - files/does_not_exist
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/non_existing_support_files.yml b/python/mozlint/test/linters/non_existing_support_files.yml
new file mode 100644
index 0000000000..e636fadf93
--- /dev/null
+++ b/python/mozlint/test/linters/non_existing_support_files.yml
@@ -0,0 +1,7 @@
+---
+BadSupportFilesLinter:
+    description: Has an invalid support-files directive.
+    support-files:
+        - files/does_not_exist
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/raises.yml b/python/mozlint/test/linters/raises.yml
new file mode 100644
index 0000000000..9c0b234779
--- /dev/null
+++ b/python/mozlint/test/linters/raises.yml
@@ -0,0 +1,6 @@
+---
+RaisesLinter:
+    description: Raises an exception
+    include: ['.']
+    type: external
+    payload: external:raises
diff --git a/python/mozlint/test/linters/regex.yml b/python/mozlint/test/linters/regex.yml
new file mode 100644
index 0000000000..2c9c812428
--- /dev/null
+++ b/python/mozlint/test/linters/regex.yml
@@ -0,0 +1,10 @@
+---
+RegexLinter:
+    description: >-
+        Make sure the string foobar never appears in a js variable
+        file because it is bad.
+    rule: no-foobar
+    include: ['.']
+    extensions: ['js', '.jsm']
+    type: regex
+    payload: foobar
diff --git a/python/mozlint/test/linters/setup.yml b/python/mozlint/test/linters/setup.yml
new file mode 100644
index 0000000000..ac75d72c70
--- /dev/null
+++ b/python/mozlint/test/linters/setup.yml
@@ -0,0 +1,9 @@
+---
+SetupLinter:
+    description: It's bad to have the string foobar in js files.
+    include:
+        - files
+    type: external
+    extensions: ['.js', '.jsm']
+    payload: external:external
+    setup: external:setup
diff --git a/python/mozlint/test/linters/setupfailed.yml b/python/mozlint/test/linters/setupfailed.yml
new file mode 100644
index 0000000000..1e3543286f
--- /dev/null
+++ b/python/mozlint/test/linters/setupfailed.yml
@@ -0,0 +1,9 @@
+---
+SetupFailedLinter:
+    description: It's bad to have the string foobar in js files.
+    include:
+        - files
+    type: external
+    extensions: ['.js', '.jsm']
+    payload: external:external
+    setup: external:setupfailed
diff --git a/python/mozlint/test/linters/setupraised.yml b/python/mozlint/test/linters/setupraised.yml
new file mode 100644
index 0000000000..8c987f2d3c
--- /dev/null
+++ b/python/mozlint/test/linters/setupraised.yml
@@ -0,0 +1,9 @@
+---
+SetupRaisedLinter:
+    description: It's bad to have the string foobar in js files.
+    include:
+        - files
+    type: external
+    extensions: ['.js', '.jsm']
+    payload: external:external
+    setup: external:setupraised
diff --git a/python/mozlint/test/linters/slow.yml b/python/mozlint/test/linters/slow.yml
new file mode 100644
index 0000000000..2c47679010
--- /dev/null
+++ b/python/mozlint/test/linters/slow.yml
@@ -0,0 +1,8 @@
+---
+SlowLinter:
+    description: A linter that takes awhile to run
+    include:
+        - files
+    type: external
+    extensions: ['.js', '.jsm']
+    payload: external:slow
diff --git a/python/mozlint/test/linters/string.yml b/python/mozlint/test/linters/string.yml
new file mode 100644
index 0000000000..836d866ae2
--- /dev/null
+++ b/python/mozlint/test/linters/string.yml
@@ -0,0 +1,9 @@
+---
+StringLinter:
+    description: >-
+        Make sure the string foobar never appears in browser js
+        files because it is bad
+    rule: no-foobar
+    extensions: ['.js', 'jsm']
+    type: string
+    payload: foobar
diff --git a/python/mozlint/test/linters/structured.yml b/python/mozlint/test/linters/structured.yml
new file mode 100644
index 0000000000..01ef447ee3
--- /dev/null
+++ b/python/mozlint/test/linters/structured.yml
@@ -0,0 +1,8 @@
+---
+StructuredLinter:
+    description: "It's bad to have the string foobar in js files."
+    include:
+        - files
+    type: structured_log
+    extensions: ['.js', '.jsm']
+    payload: external:structured
diff --git a/python/mozlint/test/linters/support_files.yml b/python/mozlint/test/linters/support_files.yml
new file mode 100644
index 0000000000..0c278d51fa
--- /dev/null
+++ b/python/mozlint/test/linters/support_files.yml
@@ -0,0 +1,10 @@
+---
+SupportFilesLinter:
+    description: Linter that has a few support files
+    include:
+        - files
+    support-files:
+        - '**/*.py'
+    type: external
+    extensions: ['.js', '.jsm']
+    payload: external:passes
diff --git a/python/mozlint/test/linters/warning.yml b/python/mozlint/test/linters/warning.yml
new file mode 100644
index 0000000000..b86bfd07c7
--- /dev/null
+++ b/python/mozlint/test/linters/warning.yml
@@ -0,0 +1,11 @@
+---
+WarningLinter:
+    description: >-
+        Make sure the string foobar never appears in browser js
+        files because it is bad, but not too bad (just a warning)
+    rule: no-foobar
+    level: warning
+    include: ['.']
+    type: string
+    extensions: ['.js', 'jsm']
+    payload: foobar
diff --git a/python/mozlint/test/linters/warning_no_code_review.yml b/python/mozlint/test/linters/warning_no_code_review.yml
new file mode 100644
index 0000000000..20bfc0503b
--- /dev/null
+++ b/python/mozlint/test/linters/warning_no_code_review.yml
@@ -0,0 +1,12 @@
+---
+WarningNoCodeReviewLinter:
+    description: >-
+        Make sure the string foobar never appears in browser js
+        files because it is bad, but not too bad (just a warning)
+    rule: no-foobar-no-code-review
+    level: warning
+    include: ['.']
+    type: string
+    extensions: ['.js', 'jsm']
+    payload: foobar
+    code_review_warnings: false
diff --git a/python/mozlint/test/python.ini b/python/mozlint/test/python.ini
new file mode 100644
index 0000000000..5c2c11d73f
--- /dev/null
+++ b/python/mozlint/test/python.ini
@@ -0,0 +1,11 @@
+[DEFAULT]
+subsuite = mozlint
+
+[test_cli.py]
+[test_editor.py]
+[test_formatters.py]
+[test_parser.py]
+[test_pathutils.py]
+[test_result.py]
+[test_roller.py]
+[test_types.py]
diff --git a/python/mozlint/test/runcli.py b/python/mozlint/test/runcli.py
new file mode 100644
index 0000000000..be60a1da19
--- /dev/null
+++ b/python/mozlint/test/runcli.py
@@ -0,0 +1,17 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+import sys
+
+from mozlint import cli
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+if __name__ == "__main__":
+    parser = cli.MozlintParser()
+    args = vars(parser.parse_args(sys.argv[1:]))
+    args["root"] = here
+    args["config_paths"] = [os.path.join(here, "linters")]
+    sys.exit(cli.run(**args))
diff --git a/python/mozlint/test/test_cli.py b/python/mozlint/test/test_cli.py
new file mode 100644
index 0000000000..01aeaa74b4
--- /dev/null
+++ b/python/mozlint/test/test_cli.py
@@ -0,0 +1,127 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+import subprocess
+import sys
+from distutils.spawn import find_executable
+
+import mozunit
+import pytest
+
+from mozlint import cli
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+
+@pytest.fixture
+def parser():
+    return cli.MozlintParser()
+
+
+@pytest.fixture
+def run(parser, lintdir, files):
+    def inner(args=None):
+        args = args or []
+        args.extend(files)
+        lintargs = vars(parser.parse_args(args))
+        lintargs["root"] = here
+        lintargs["config_paths"] = [os.path.join(here, "linters")]
+        return cli.run(**lintargs)
+
+    return inner
+
+
+def test_cli_with_ascii_encoding(run, monkeypatch, capfd):
+    cmd = [sys.executable, "runcli.py", "-l=string", "-f=stylish", "files/foobar.js"]
+    env = os.environ.copy()
+    env["PYTHONPATH"] = os.pathsep.join(sys.path)
+    env["PYTHONIOENCODING"] = "ascii"
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        cwd=here,
+        env=env,
+        universal_newlines=True,
+    )
+    out = proc.communicate()[0]
+    assert "Traceback" not in out
+
+
+def test_cli_run_with_fix(run, capfd):
+    ret = run(["-f", "json", "--fix", "--linter", "external"])
+    out, err = capfd.readouterr()
+    assert ret == 0
+    assert out.endswith("{}\n")
+
+
+@pytest.mark.skipif(not find_executable("echo"), reason="No `echo` executable found.")
+def test_cli_run_with_edit(run, parser, capfd):
+    os.environ["EDITOR"] = "echo"
+
+    ret = run(["-f", "compact", "--edit", "--linter", "external"])
+    out, err = capfd.readouterr()
+    out = out.splitlines()
+    assert ret == 1
+    assert out[0].endswith("foobar.js")  # from the `echo` editor
+    assert "foobar.js: line 1, col 1, Error" in out[1]
+    assert "foobar.js: line 2, col 1, Error" in out[2]
+    assert "2 problems" in out[-1]
+    assert len(out) == 5
+
+    del os.environ["EDITOR"]
+    with pytest.raises(SystemExit):
+        parser.parse_args(["--edit"])
+
+
+def test_cli_run_with_setup(run, capfd):
+    # implicitly call setup
+    ret = run(["-l", "setup", "-l", "setupfailed", "-l", "setupraised"])
+    out, err = capfd.readouterr()
+    assert "setup passed" in out
+    assert "setup failed" in out
+    assert "setup raised" in out
+    assert ret == 1
+
+    # explicitly call setup
+    ret = run(["-l", "setup", "-l", "setupfailed", "-l", "setupraised", "--setup"])
+    out, err = capfd.readouterr()
+    assert "setup passed" in out
+    assert "setup failed" in out
+    assert "setup raised" in out
+    assert ret == 1
+
+
+def test_cli_for_exclude_list(run, monkeypatch, capfd):
+    ret = run(["-l", "excludes", "--check-exclude-list"])
+    out, err = capfd.readouterr()
+
+    assert "**/foobar.js" in out
+    assert (
+        "The following list of paths are now green and can be removed from the exclude list:"
+        in out
+    )
+
+    ret = run(["-l", "excludes_empty", "--check-exclude-list"])
+    out, err = capfd.readouterr()
+
+    assert "No path in the exclude list is green." in out
+    assert ret == 1
+
+
+def test_cli_run_with_wrong_linters(run, capfd):
+
+    run(["-l", "external", "-l", "foobar"])
+    out, err = capfd.readouterr()
+
+    # Check if it identifes foobar as invalid linter
+    assert "A failure occurred in the foobar linter." in out
+
+    # Check for exception message
+    assert "Invalid linters given, run again using valid linters or no linters" in out
+
+
+if __name__ == "__main__":
+    mozunit.main()
diff --git a/python/mozlint/test/test_editor.py b/python/mozlint/test/test_editor.py
new file mode 100644
index 0000000000..7a15a613a6
--- /dev/null
+++ b/python/mozlint/test/test_editor.py
@@ -0,0 +1,92 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+import subprocess
+
+import mozunit
+import pytest
+
+from mozlint import editor
+from mozlint.result import Issue, ResultSummary
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+
+@pytest.fixture
+def capture_commands(monkeypatch):
+    def inner(commands):
+        def fake_subprocess_call(*args, **kwargs):
+            commands.append(args[0])
+
+        monkeypatch.setattr(subprocess, "call", fake_subprocess_call)
+
+    return inner
+
+
+@pytest.fixture
+def result():
+    result = ResultSummary("/fake/root")
+    result.issues["foo.py"].extend(
+        [
+            Issue(
+                linter="no-foobar",
+                path="foo.py",
+                lineno=1,
+                message="Oh no!",
+            ),
+            Issue(
+                linter="no-foobar",
+                path="foo.py",
+                lineno=3,
+                column=10,
+                message="To Yuma!",
+            ),
+        ]
+    )
+    return result
+
+
+def test_no_editor(monkeypatch, capture_commands, result):
+    commands = []
+    capture_commands(commands)
+
+    monkeypatch.delenv("EDITOR", raising=False)
+    editor.edit_issues(result)
+    assert commands == []
+
+
+def test_no_issues(monkeypatch, capture_commands, result):
+    commands = []
+    capture_commands(commands)
+
+    monkeypatch.setenv("EDITOR", "generic")
+    result.issues = {}
+    editor.edit_issues(result)
+    assert commands == []
+
+
+def test_vim(monkeypatch, capture_commands, result):
+    commands = []
+    capture_commands(commands)
+
+    monkeypatch.setenv("EDITOR", "vim")
+    editor.edit_issues(result)
+    assert len(commands) == 1
+    assert commands[0][0] == "vim"
+
+
+def test_generic(monkeypatch, capture_commands, result):
+    commands = []
+    capture_commands(commands)
+
+    monkeypatch.setenv("EDITOR", "generic")
+    editor.edit_issues(result)
+    assert len(commands) == len(result.issues)
+    assert all(c[0] == "generic" for c in commands)
+    assert all("foo.py" in c for c in commands)
+
+
+if __name__ == "__main__":
+    mozunit.main()
diff --git a/python/mozlint/test/test_formatters.py b/python/mozlint/test/test_formatters.py
new file mode 100644
index 0000000000..5a276a1c23
--- /dev/null
+++ b/python/mozlint/test/test_formatters.py
@@ -0,0 +1,141 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import json
+
+import attr
+import mozpack.path as mozpath
+import mozunit
+import pytest
+
+from mozlint import formatters
+from mozlint.result import Issue, ResultSummary
+
+NORMALISED_PATHS = {
+    "abc": mozpath.normpath("a/b/c.txt"),
+    "def": mozpath.normpath("d/e/f.txt"),
+    "root": mozpath.abspath("/fake/root"),
+}
+
+EXPECTED = {
+    "compact": {
+        "kwargs": {},
+        "format": """
+/fake/root/a/b/c.txt: line 1, Error - oh no foo (foo)
+/fake/root/a/b/c.txt: line 4, col 10, Error - oh no baz (baz)
+/fake/root/a/b/c.txt: line 5, Error - oh no foo-diff (foo-diff)
+/fake/root/d/e/f.txt: line 4, col 2, Warning - oh no bar (bar-not-allowed)
+
+4 problems
+""".strip(),
+    },
+    "stylish": {
+        "kwargs": {"disable_colors": True},
+        "format": """
+/fake/root/a/b/c.txt
+  1     error  oh no foo       (foo)
+  4:10  error  oh no baz       (baz)
+  5     error  oh no foo-diff  (foo-diff)
+  diff 1
+  - hello
+  + hello2
+
+/fake/root/d/e/f.txt
+  4:2  warning  oh no bar  bar-not-allowed (bar)
+
+\u2716 4 problems (3 errors, 1 warning, 0 fixed)
+""".strip(),
+    },
+    "treeherder": {
+        "kwargs": {},
+        "format": """
+TEST-UNEXPECTED-ERROR | /fake/root/a/b/c.txt:1 | oh no foo (foo)
+TEST-UNEXPECTED-ERROR | /fake/root/a/b/c.txt:4:10 | oh no baz (baz)
+TEST-UNEXPECTED-ERROR | /fake/root/a/b/c.txt:5 | oh no foo-diff (foo-diff)
+TEST-UNEXPECTED-WARNING | /fake/root/d/e/f.txt:4:2 | oh no bar (bar-not-allowed)
+""".strip(),
+    },
+    "unix": {
+        "kwargs": {},
+        "format": """
+{abc}:1: foo error: oh no foo
+{abc}:4:10: baz error: oh no baz
+{abc}:5: foo-diff error: oh no foo-diff
+{def}:4:2: bar-not-allowed warning: oh no bar
+""".format(
+            **NORMALISED_PATHS
+        ).strip(),
+    },
+    "summary": {
+        "kwargs": {},
+        "format": """
+{root}/a: 3 errors
+{root}/d: 0 errors, 1 warning
+""".format(
+            **NORMALISED_PATHS
+        ).strip(),
+    },
+}
+
+
+@pytest.fixture
+def result(scope="module"):
+    result = ResultSummary("/fake/root")
+    containers = (
+        Issue(linter="foo", path="a/b/c.txt", message="oh no foo", lineno=1),
+        Issue(
+            linter="bar",
+            path="d/e/f.txt",
+            message="oh no bar",
+            hint="try baz instead",
+            level="warning",
+            lineno="4",
+            column="2",
+            rule="bar-not-allowed",
+        ),
+        Issue(
+            linter="baz",
+            path="a/b/c.txt",
+            message="oh no baz",
+            lineno=4,
+            column=10,
+            source="if baz:",
+        ),
+        Issue(
+            linter="foo-diff",
+            path="a/b/c.txt",
+            message="oh no foo-diff",
+            lineno=5,
+            source="if baz:",
+            diff="diff 1\n- hello\n+ hello2",
+        ),
+    )
+    result = ResultSummary("/fake/root")
+    for c in containers:
+        result.issues[c.path].append(c)
+    return result
+
+
+@pytest.mark.parametrize("name", EXPECTED.keys())
+def test_formatters(result, name):
+    opts = EXPECTED[name]
+    fmt = formatters.get(name, **opts["kwargs"])
+    # encoding to str bypasses a UnicodeEncodeError in pytest
+    assert fmt(result) == opts["format"]
+
+
+def test_json_formatter(result):
+    fmt = formatters.get("json")
+    formatted = json.loads(fmt(result))
+
+    assert set(formatted.keys()) == set(result.issues.keys())
+
+    attrs = attr.fields(Issue)
+    for errors in formatted.values():
+        for err in errors:
+            assert all(a.name in err for a in attrs)
+
+
+if __name__ == "__main__":
+    mozunit.main()
diff --git a/python/mozlint/test/test_parser.py b/python/mozlint/test/test_parser.py
new file mode 100644
index 0000000000..2fbf26c8e5
--- /dev/null
+++ b/python/mozlint/test/test_parser.py
@@ -0,0 +1,80 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+
+import mozunit
+import pytest
+
+from mozlint.errors import LinterNotFound, LinterParseError
+from mozlint.parser import Parser
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+
+@pytest.fixture(scope="module")
+def parse(lintdir):
+    parser = Parser(here)
+
+    def _parse(name):
+        path = os.path.join(lintdir, name)
+        return parser(path)
+
+    return _parse
+
+
+def test_parse_valid_linter(parse):
+    lintobj = parse("string.yml")
+    assert isinstance(lintobj, list)
+    assert len(lintobj) == 1
+
+    lintobj = lintobj[0]
+    assert isinstance(lintobj, dict)
+    assert "name" in lintobj
+    assert "description" in lintobj
+    assert "type" in lintobj
+    assert "payload" in lintobj
+    assert "extensions" in lintobj
+    assert "include" in lintobj
+    assert lintobj["include"] == ["."]
+    assert set(lintobj["extensions"]) == set(["js", "jsm"])
+
+
+def test_parser_valid_multiple(parse):
+    lintobj = parse("multiple.yml")
+    assert isinstance(lintobj, list)
+    assert len(lintobj) == 2
+
+    assert lintobj[0]["name"] == "StringLinter"
+    assert lintobj[1]["name"] == "RegexLinter"
+
+
+@pytest.mark.parametrize(
+    "linter",
+    [
+        "invalid_type.yml",
+        "invalid_extension.ym",
+        "invalid_include.yml",
+        "invalid_include_with_glob.yml",
+        "invalid_exclude.yml",
+        "invalid_support_files.yml",
+        "missing_attrs.yml",
+        "missing_definition.yml",
+        "non_existing_include.yml",
+        "non_existing_exclude.yml",
+        "non_existing_support_files.yml",
+    ],
+)
+def test_parse_invalid_linter(parse, linter):
+    with pytest.raises(LinterParseError):
+        parse(linter)
+
+
+def test_parse_non_existent_linter(parse):
+    with pytest.raises(LinterNotFound):
+        parse("missing_file.lint")
+
+
+if __name__ == "__main__":
+    mozunit.main()
diff --git a/python/mozlint/test/test_pathutils.py b/python/mozlint/test/test_pathutils.py
new file mode 100644
index 0000000000..78f7883e88
--- /dev/null
+++ b/python/mozlint/test/test_pathutils.py
@@ -0,0 +1,166 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+from fnmatch import fnmatch
+
+import mozunit
+import pytest
+
+from mozlint import pathutils
+
+here = os.path.abspath(os.path.dirname(__file__))
+root = os.path.join(here, "filter")
+
+
+def assert_paths(a, b):
+    def normalize(p):
+        if not os.path.isabs(p):
+            p = os.path.join(root, p)
+        return os.path.normpath(p)
+
+    assert set(map(normalize, a)) == set(map(normalize, b))
+
+
+@pytest.mark.parametrize(
+    "test",
+    (
+        {
+            "paths": ["a.js", "subdir1/subdir3/d.js"],
+            "include": ["."],
+            "exclude": ["subdir1"],
+            "expected": ["a.js"],
+        },
+        {
+            "paths": ["a.js", "subdir1/subdir3/d.js"],
+            "include": ["subdir1/subdir3"],
+            "exclude": ["subdir1"],
+            "expected": ["subdir1/subdir3/d.js"],
+        },
+        {
+            "paths": ["."],
+            "include": ["."],
+            "exclude": ["**/c.py", "subdir1/subdir3"],
+            "extensions": ["py"],
+            "expected": ["."],
+            "expected_exclude": ["subdir2/c.py", "subdir1/subdir3"],
+        },
+        {
+            "paths": [
+                "a.py",
+                "a.js",
+                "subdir1/b.py",
+                "subdir2/c.py",
+                "subdir1/subdir3/d.py",
+            ],
+            "include": ["."],
+            "exclude": ["**/c.py", "subdir1/subdir3"],
+            "extensions": ["py"],
+            "expected": ["a.py", "subdir1/b.py"],
+        },
+        {
+            "paths": ["a.py", "a.js", "subdir2"],
+            "include": ["."],
+            "exclude": [],
+            "extensions": ["py"],
+            "expected": ["a.py", "subdir2"],
+        },
+        {
+            "paths": ["subdir1"],
+            "include": ["."],
+            "exclude": ["subdir1/subdir3"],
+            "extensions": ["py"],
+            "expected": ["subdir1"],
+            "expected_exclude": ["subdir1/subdir3"],
+        },
+        {
+            "paths": ["docshell"],
+            "include": ["docs"],
+            "exclude": [],
+            "expected": [],
+        },
+        {
+            "paths": ["does/not/exist"],
+            "include": ["."],
+            "exclude": [],
+            "expected": [],
+        },
+    ),
+)
+def test_filterpaths(test):
+    expected = test.pop("expected")
+    expected_exclude = test.pop("expected_exclude", [])
+
+    paths, exclude = pathutils.filterpaths(root, **test)
+    assert_paths(paths, expected)
+    assert_paths(exclude, expected_exclude)
+
+
+@pytest.mark.parametrize(
+    "test",
+    (
+        {
+            "paths": ["subdir1/b.js"],
+            "config": {
+                "exclude": ["subdir1"],
+                "extensions": "js",
+            },
+            "expected": [],
+        },
+        {
+            "paths": ["subdir1/subdir3"],
+            "config": {
+                "exclude": ["subdir1"],
+                "extensions": "js",
+            },
+            "expected": [],
+        },
+    ),
+)
+def test_expand_exclusions(test):
+    expected = test.pop("expected", [])
+
+    paths = list(pathutils.expand_exclusions(test["paths"], test["config"], root))
+    assert_paths(paths, expected)
+
+
+@pytest.mark.parametrize(
+    "paths,expected",
+    [
+        (["subdir1/*"], ["subdir1"]),
+        (["subdir2/*"], ["subdir2"]),
+        (["subdir1/*.*", "subdir1/subdir3/*", "subdir2/*"], ["subdir1", "subdir2"]),
+        ([root + "/*", "subdir1/*.*", "subdir1/subdir3/*", "subdir2/*"], [root]),
+        (["subdir1/b.py", "subdir1/subdir3"], ["subdir1/b.py", "subdir1/subdir3"]),
+        (["subdir1/b.py", "subdir1/b.js"], ["subdir1/b.py", "subdir1/b.js"]),
+        (["subdir1/subdir3"], ["subdir1/subdir3"]),
+        (
+            [
+                "foo",
+                "foobar",
+            ],
+            ["foo", "foobar"],
+        ),
+    ],
+)
+def test_collapse(paths, expected):
+    os.chdir(root)
+
+    inputs = []
+    for path in paths:
+        base, name = os.path.split(path)
+        if "*" in name:
+            for n in os.listdir(base):
+                if not fnmatch(n, name):
+                    continue
+                inputs.append(os.path.join(base, n))
+        else:
+            inputs.append(path)
+
+    print("inputs: {}".format(inputs))
+    assert_paths(pathutils.collapse(inputs), expected)
+
+
+if __name__ == "__main__":
+    mozunit.main()
diff --git a/python/mozlint/test/test_result.py b/python/mozlint/test/test_result.py
new file mode 100644
index 0000000000..02e8156b3c
--- /dev/null
+++ b/python/mozlint/test/test_result.py
@@ -0,0 +1,26 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import mozunit
+
+from mozlint.result import Issue, ResultSummary
+
+
+def test_issue_defaults():
+    ResultSummary.root = "/fake/root"
+
+    issue = Issue(linter="linter", path="path", message="message", lineno=None)
+    assert issue.lineno == 0
+    assert issue.column is None
+    assert issue.level == "error"
+
+    issue = Issue(
+        linter="linter", path="path", message="message", lineno="1", column="2"
+    )
+    assert issue.lineno == 1
+    assert issue.column == 2
+
+
+if __name__ == "__main__":
+    mozunit.main()
diff --git a/python/mozlint/test/test_roller.py b/python/mozlint/test/test_roller.py
new file mode 100644
index 0000000000..2918047cd2
--- /dev/null
+++ b/python/mozlint/test/test_roller.py
@@ -0,0 +1,396 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+import platform
+import signal
+import subprocess
+import sys
+import time
+from itertools import chain
+
+import mozunit
+import pytest
+
+from mozlint.errors import LintersNotConfigured, NoValidLinter
+from mozlint.result import Issue, ResultSummary
+from mozlint.roller import LintRoller
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+
+def test_roll_no_linters_configured(lint, files):
+    with pytest.raises(LintersNotConfigured):
+        lint.roll(files)
+
+
+def test_roll_successful(lint, linters, files):
+    lint.read(linters("string", "regex", "external"))
+
+    result = lint.roll(files)
+    assert len(result.issues) == 1
+    assert result.failed == set([])
+
+    path = list(result.issues.keys())[0]
+    assert os.path.basename(path) == "foobar.js"
+
+    errors = result.issues[path]
+    assert isinstance(errors, list)
+    assert len(errors) == 6
+
+    container = errors[0]
+    assert isinstance(container, Issue)
+    assert container.rule == "no-foobar"
+
+
+def test_roll_from_subdir(lint, linters):
+    lint.read(linters("string", "regex", "external"))
+
+    oldcwd = os.getcwd()
+    try:
+        os.chdir(os.path.join(lint.root, "files"))
+
+        # Path relative to cwd works
+        result = lint.roll("foobar.js")
+        assert len(result.issues) == 1
+        assert len(result.failed) == 0
+        assert result.returncode == 1
+
+        # Path relative to root doesn't work
+        result = lint.roll(os.path.join("files", "foobar.js"))
+        assert len(result.issues) == 0
+        assert len(result.failed) == 0
+        assert result.returncode == 0
+
+        # Paths from vcs are always joined to root instead of cwd
+        lint.mock_vcs([os.path.join("files", "foobar.js")])
+        result = lint.roll(outgoing=True)
+        assert len(result.issues) == 1
+        assert len(result.failed) == 0
+        assert result.returncode == 1
+
+        result = lint.roll(workdir=True)
+        assert len(result.issues) == 1
+        assert len(result.failed) == 0
+        assert result.returncode == 1
+
+        result = lint.roll(rev='not public() and keyword("dummy revset expression")')
+        assert len(result.issues) == 1
+        assert len(result.failed) == 0
+        assert result.returncode == 1
+    finally:
+        os.chdir(oldcwd)
+
+
+def test_roll_catch_exception(lint, linters, files, capfd):
+    lint.read(linters("raises"))
+
+    lint.roll(files)  # assert not raises
+    out, err = capfd.readouterr()
+    assert "LintException" in err
+
+
+def test_roll_with_global_excluded_path(lint, linters, files):
+    lint.exclude = ["**/foobar.js"]
+    lint.read(linters("string", "regex", "external"))
+    result = lint.roll(files)
+
+    assert len(result.issues) == 0
+    assert result.failed == set([])
+
+
+def test_roll_with_local_excluded_path(lint, linters, files):
+    lint.read(linters("excludes"))
+    result = lint.roll(files)
+
+    assert "**/foobar.js" in lint.linters[0]["local_exclude"]
+    assert len(result.issues) == 0
+    assert result.failed == set([])
+
+
+def test_roll_with_no_files_to_lint(lint, linters, capfd):
+    lint.read(linters("string", "regex", "external"))
+    lint.mock_vcs([])
+    result = lint.roll([], workdir=True)
+    assert isinstance(result, ResultSummary)
+    assert len(result.issues) == 0
+    assert len(result.failed) == 0
+
+    out, err = capfd.readouterr()
+    assert "warning: no files linted" in out
+
+
+def test_roll_with_invalid_extension(lint, linters, filedir):
+    lint.read(linters("external"))
+    result = lint.roll(os.path.join(filedir, "foobar.py"))
+    assert len(result.issues) == 0
+    assert result.failed == set([])
+
+
+def test_roll_with_failure_code(lint, linters, files):
+    lint.read(linters("badreturncode"))
+
+    result = lint.roll(files, num_procs=1)
+    assert len(result.issues) == 0
+    assert result.failed == set(["BadReturnCodeLinter"])
+
+
+def test_roll_warnings(lint, linters, files):
+    lint.read(linters("warning"))
+    result = lint.roll(files)
+    assert len(result.issues) == 0
+    assert result.total_issues == 0
+    assert len(result.suppressed_warnings) == 1
+    assert result.total_suppressed_warnings == 2
+
+    lint.lintargs["show_warnings"] = True
+    result = lint.roll(files)
+    assert len(result.issues) == 1
+    assert result.total_issues == 2
+    assert len(result.suppressed_warnings) == 0
+    assert result.total_suppressed_warnings == 0
+
+
+def test_roll_code_review(monkeypatch, linters, files):
+    monkeypatch.setenv("CODE_REVIEW", "1")
+    lint = LintRoller(root=here, show_warnings=False)
+    lint.read(linters("warning"))
+    result = lint.roll(files)
+    assert len(result.issues) == 1
+    assert result.total_issues == 2
+    assert len(result.suppressed_warnings) == 0
+    assert result.total_suppressed_warnings == 0
+    assert result.returncode == 1
+
+
+def test_roll_code_review_warnings_disabled(monkeypatch, linters, files):
+    monkeypatch.setenv("CODE_REVIEW", "1")
+    lint = LintRoller(root=here, show_warnings=False)
+    lint.read(linters("warning_no_code_review"))
+    result = lint.roll(files)
+    assert len(result.issues) == 0
+    assert result.total_issues == 0
+    assert lint.result.fail_on_warnings is True
+    assert len(result.suppressed_warnings) == 1
+    assert result.total_suppressed_warnings == 2
+    assert result.returncode == 0
+
+
+def test_roll_code_review_warnings_soft(linters, files):
+    lint = LintRoller(root=here, show_warnings="soft")
+    lint.read(linters("warning_no_code_review"))
+    result = lint.roll(files)
+    assert len(result.issues) == 1
+    assert result.total_issues == 2
+    assert lint.result.fail_on_warnings is False
+    assert len(result.suppressed_warnings) == 0
+    assert result.total_suppressed_warnings == 0
+    assert result.returncode == 0
+
+
+def fake_run_worker(config, paths, **lintargs):
+    result = ResultSummary(lintargs["root"])
+    result.issues["count"].append(1)
+    return result
+
+
+@pytest.mark.skipif(
+    platform.system() == "Windows",
+    reason="monkeypatch issues with multiprocessing on Windows",
+)
+@pytest.mark.parametrize("num_procs", [1, 4, 8, 16])
+def test_number_of_jobs(monkeypatch, lint, linters, files, num_procs):
+    monkeypatch.setattr(sys.modules[lint.__module__], "_run_worker", fake_run_worker)
+
+    linters = linters("string", "regex", "external")
+    lint.read(linters)
+    num_jobs = len(lint.roll(files, num_procs=num_procs).issues["count"])
+
+    if len(files) >= num_procs:
+        assert num_jobs == num_procs * len(linters)
+    else:
+        assert num_jobs == len(files) * len(linters)
+
+
+@pytest.mark.skipif(
+    platform.system() == "Windows",
+    reason="monkeypatch issues with multiprocessing on Windows",
+)
+@pytest.mark.parametrize("max_paths,expected_jobs", [(1, 12), (4, 6), (16, 6)])
+def test_max_paths_per_job(monkeypatch, lint, linters, files, max_paths, expected_jobs):
+    monkeypatch.setattr(sys.modules[lint.__module__], "_run_worker", fake_run_worker)
+
+    files = files[:4]
+    assert len(files) == 4
+
+    linters = linters("string", "regex", "external")[:3]
+    assert len(linters) == 3
+
+    lint.MAX_PATHS_PER_JOB = max_paths
+    lint.read(linters)
+    num_jobs = len(lint.roll(files, num_procs=2).issues["count"])
+    assert num_jobs == expected_jobs
+
+
+@pytest.mark.skipif(
+    platform.system() == "Windows",
+    reason="monkeypatch issues with multiprocessing on Windows",
+)
+@pytest.mark.parametrize("num_procs", [1, 4, 8, 16])
+def test_number_of_jobs_global(monkeypatch, lint, linters, files, num_procs):
+    monkeypatch.setattr(sys.modules[lint.__module__], "_run_worker", fake_run_worker)
+
+    linters = linters("global")
+    lint.read(linters)
+    num_jobs = len(lint.roll(files, num_procs=num_procs).issues["count"])
+
+    assert num_jobs == 1
+
+
+@pytest.mark.skipif(
+    platform.system() == "Windows",
+    reason="monkeypatch issues with multiprocessing on Windows",
+)
+@pytest.mark.parametrize("max_paths", [1, 4, 16])
+def test_max_paths_per_job_global(monkeypatch, lint, linters, files, max_paths):
+    monkeypatch.setattr(sys.modules[lint.__module__], "_run_worker", fake_run_worker)
+
+    files = files[:4]
+    assert len(files) == 4
+
+    linters = linters("global")[:1]
+    assert len(linters) == 1
+
+    lint.MAX_PATHS_PER_JOB = max_paths
+    lint.read(linters)
+    num_jobs = len(lint.roll(files, num_procs=2).issues["count"])
+    assert num_jobs == 1
+
+
+@pytest.mark.skipif(
+    platform.system() == "Windows",
+    reason="signal.CTRL_C_EVENT isn't causing a KeyboardInterrupt on Windows",
+)
+def test_keyboard_interrupt():
+    # We use two linters so we'll have two jobs. One (string.yml) will complete
+    # quickly. The other (slow.yml) will run slowly.  This way the first worker
+    # will be be stuck blocking on the ProcessPoolExecutor._call_queue when the
+    # signal arrives and the other still be doing work.
+    cmd = [sys.executable, "runcli.py", "-l=string", "-l=slow", "files/foobar.js"]
+    env = os.environ.copy()
+    env["PYTHONPATH"] = os.pathsep.join(sys.path)
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        cwd=here,
+        env=env,
+        universal_newlines=True,
+    )
+    time.sleep(1)
+    proc.send_signal(signal.SIGINT)
+
+    out = proc.communicate()[0]
+    print(out)
+    assert "warning: not all files were linted" in out
+    assert "2 problems" in out
+    assert "Traceback" not in out
+
+
+def test_support_files(lint, linters, filedir, monkeypatch, files):
+    jobs = []
+
+    # Replace the original _generate_jobs with a new one that simply
+    # adds jobs to a list (and then doesn't return anything).
+    orig_generate_jobs = lint._generate_jobs
+
+    def fake_generate_jobs(*args, **kwargs):
+        jobs.extend([job[1] for job in orig_generate_jobs(*args, **kwargs)])
+        return []
+
+    monkeypatch.setattr(lint, "_generate_jobs", fake_generate_jobs)
+
+    linter_path = linters("support_files")[0]
+    lint.read(linter_path)
+    lint.root = filedir
+
+    # Modified support files only lint entire root if --outgoing or --workdir
+    # are used.
+    path = os.path.join(filedir, "foobar.js")
+    vcs_path = os.path.join(filedir, "foobar.py")
+
+    lint.mock_vcs([vcs_path])
+    lint.roll(path)
+    actual_files = sorted(chain(*jobs))
+    assert actual_files == [path]
+
+    expected_files = sorted(files)
+
+    jobs = []
+    lint.roll(path, workdir=True)
+    actual_files = sorted(chain(*jobs))
+    assert actual_files == expected_files
+
+    jobs = []
+    lint.roll(path, outgoing=True)
+    actual_files = sorted(chain(*jobs))
+    assert actual_files == expected_files
+
+    jobs = []
+    lint.roll(path, rev='draft() and keyword("dummy revset expression")')
+    actual_files = sorted(chain(*jobs))
+    assert actual_files == expected_files
+
+    # Lint config file is implicitly added as a support file
+    lint.mock_vcs([linter_path])
+    jobs = []
+    lint.roll(path, outgoing=True, workdir=True)
+    actual_files = sorted(chain(*jobs))
+    assert actual_files == expected_files
+
+    # Avoid linting the entire root when `--fix` is passed.
+    lint.mock_vcs([vcs_path])
+    lint.lintargs["fix"] = True
+
+    jobs = []
+    lint.roll(path, outgoing=True)
+    actual_files = sorted(chain(*jobs))
+    assert actual_files == sorted([path, vcs_path]), (
+        "`--fix` with `--outgoing` on a `support-files` change should "
+        "avoid linting the entire root."
+    )
+
+    jobs = []
+    lint.roll(path, workdir=True)
+    actual_files = sorted(chain(*jobs))
+    assert actual_files == sorted([path, vcs_path]), (
+        "`--fix` with `--workdir` on a `support-files` change should "
+        "avoid linting the entire root."
+    )
+
+    jobs = []
+    lint.roll(path, rev='draft() and keyword("dummy revset expression")')
+    actual_files = sorted(chain(*jobs))
+    assert actual_files == sorted([path, vcs_path]), (
+        "`--fix` with `--rev` on a `support-files` change should "
+        "avoid linting the entire root."
+    )
+
+
+def test_setup(lint, linters, filedir, capfd):
+    with pytest.raises(NoValidLinter):
+        lint.setup()
+
+    lint.read(linters("setup", "setupfailed", "setupraised"))
+    lint.setup()
+    out, err = capfd.readouterr()
+    assert "setup passed" in out
+    assert "setup failed" in out
+    assert "setup raised" in out
+    assert "error: problem with lint setup, skipping" in out
+    assert lint.result.failed_setup == set(["SetupFailedLinter", "SetupRaisedLinter"])
+
+
+if __name__ == "__main__":
+    mozunit.main()
diff --git a/python/mozlint/test/test_types.py b/python/mozlint/test/test_types.py
new file mode 100644
index 0000000000..6ed78747b7
--- /dev/null
+++ b/python/mozlint/test/test_types.py
@@ -0,0 +1,84 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import os
+
+import mozpack.path as mozpath
+import mozunit
+import pytest
+
+from mozlint.result import Issue, ResultSummary
+
+
+@pytest.fixture
+def path(filedir):
+    def _path(name):
+        return mozpath.join(filedir, name)
+
+    return _path
+
+
+@pytest.fixture(
+    params=[
+        "external.yml",
+        "global.yml",
+        "regex.yml",
+        "string.yml",
+        "structured.yml",
+    ]
+)
+def linter(lintdir, request):
+    return os.path.join(lintdir, request.param)
+
+
+def test_linter_types(lint, linter, files, path):
+    lint.read(linter)
+    result = lint.roll(files)
+    assert isinstance(result, ResultSummary)
+    assert isinstance(result.issues, dict)
+    assert path("foobar.js") in result.issues
+    assert path("no_foobar.js") not in result.issues
+
+    issue = result.issues[path("foobar.js")][0]
+    assert isinstance(issue, Issue)
+
+    name = os.path.basename(linter).split(".")[0]
+    assert issue.linter.lower().startswith(name)
+
+
+def test_linter_missing_files(lint, linter, filedir):
+    # Missing files should be caught by `mozlint.cli`, so the only way they
+    # could theoretically happen is if they show up from versioncontrol. So
+    # let's just make sure they get ignored.
+    lint.read(linter)
+    files = [
+        os.path.join(filedir, "missing.js"),
+        os.path.join(filedir, "missing.py"),
+    ]
+    result = lint.roll(files)
+    assert result.returncode == 0
+
+    lint.mock_vcs(files)
+    result = lint.roll(outgoing=True)
+    assert result.returncode == 0
+
+
+def test_no_filter(lint, lintdir, files):
+    lint.read(os.path.join(lintdir, "explicit_path.yml"))
+    result = lint.roll(files)
+    assert len(result.issues) == 0
+
+    lint.lintargs["use_filters"] = False
+    result = lint.roll(files)
+    assert len(result.issues) == 3
+
+
+def test_global_skipped(lint, lintdir, files):
+    lint.read(os.path.join(lintdir, "global_skipped.yml"))
+    result = lint.roll(files)
+    assert len(result.issues) == 0
+
+
+if __name__ == "__main__":
+    mozunit.main()