diff --git a/tools/eclipse/.gitignore b/tools/eclipse/.gitignore
new file mode 100644
index 0000000..1bc5aa1
--- /dev/null
+++ b/tools/eclipse/.gitignore
@@ -0,0 +1 @@
+/.coverage
diff --git a/tools/eclipse/BUILD b/tools/eclipse/BUILD
index 789a607..451f22d 100644
--- a/tools/eclipse/BUILD
+++ b/tools/eclipse/BUILD
@@ -1,4 +1,4 @@
-load("@rules_python//python:defs.bzl", "py_binary")
+load("@rules_python//python:defs.bzl", "py_binary", "py_test")
 
 package(
     default_visibility = ["//visibility:public"],
@@ -9,3 +9,16 @@
     srcs = ["project.py"],
     main = "project.py",
 )
+
+py_test(
+    name = "test_project",
+    srcs = ["test_project.py"],
+    deps = [":project"],
+)
+
+test_suite(
+    name = "test",
+    tests = [
+        "test_project",
+    ]
+)
diff --git a/tools/eclipse/project.py b/tools/eclipse/project.py
index a24266f..93eeb3a 100755
--- a/tools/eclipse/project.py
+++ b/tools/eclipse/project.py
@@ -28,77 +28,98 @@
   'JavaSE-11',
 ])
 
-opts = argparse.ArgumentParser("Create Eclipse Project")
-opts.add_argument('-r', '--root', help='Root directory entry', required=True)
-opts.add_argument('-n', '--name', help='Project name')
-opts.add_argument('-x', '--exclude', action='append', help='Exclude paths')
-opts.add_argument('-b', '--batch', action='store_true',
-                  dest='batch', help='Bazel batch option')
-opts.add_argument('--bazel',
-                  help=('name of the bazel executable. Defaults to using'
-                        ' bazelisk if found, or bazel if bazelisk is not'
-                        ' found.'),
-                  action='store', default=None, dest='bazel_exe')
-args = opts.parse_args()
+class EclipseProject():
 
-root = args.root
-ROOT = os.path.abspath(root)
-while not os.path.exists(os.path.join(ROOT, 'WORKSPACE')):
-  if ROOT == '/':
-    print('Could not find root of project: no WORKSPACE file found',
-          file=sys.stderr)
-    sys.exit(1)
-  ROOT = os.path.dirname(ROOT)
+  # Path to the Bazel/Bazelisk binary
+  bazel_exe = None
+  # Root of the Bazel project (holding WORKSPACE file)
+  ROOT = None
 
-batch_option = '--batch' if args.batch else None
+  def main(self):
+    self.bazel_exe = self.find_bazel(self.args.bazel_exe)
 
-def find_bazel():
-  if args.bazel_exe:
+    self.ROOT = self.find_root(self.args.root)
+
+    project_name = (self.args.name if self.args.name
+                    else os.path.basename(self.ROOT))
+
+    self.gen_project(project_name, root=self.ROOT)
+    self.gen_classpath(self.retrieve_ext_location().decode('utf-8'))
+
+  def _get_argument_parser(self):
+    opts = argparse.ArgumentParser("Create Eclipse Project")
+    opts.add_argument('-r', '--root', help='Root directory entry',
+                      required=True)
+    opts.add_argument('-n', '--name', help='Project name')
+    opts.add_argument('-x', '--exclude', action='append', help='Exclude paths')
+    opts.add_argument('-b', '--batch', action='store_true',
+                      dest='batch', help='Bazel batch option')
+    opts.add_argument('--bazel',
+                      help=('name of the bazel executable. Defaults to using'
+                            ' bazelisk if found, or bazel if bazelisk is not'
+                            ' found.'),
+                      action='store', default=None, dest='bazel_exe')
+    return opts
+
+  def parse_args(self, args):
+    self.args = self._get_argument_parser().parse_args(args)
+    return self.args
+
+  def find_root(self, root):
+    ROOT = os.path.abspath(root)
+    while not os.path.exists(os.path.join(ROOT, 'WORKSPACE')):
+      if ROOT == '/':
+        raise Exception(
+          'Could not find root of project: no WORKSPACE file found')
+      ROOT = os.path.dirname(ROOT)
+    return ROOT
+
+  def find_bazel(self, bazel_exe=None):
+    if bazel_exe:
+      try:
+        return subprocess.check_output(
+          ['which', bazel_exe]).strip().decode('UTF-8')
+      except subprocess.CalledProcessError:
+        raise Exception('Bazel command: %s not found' % bazel_exe)
     try:
       return subprocess.check_output(
-        ['which', args.bazel_exe]).strip().decode('UTF-8')
+        ['which', 'bazelisk']).strip().decode('UTF-8')
     except subprocess.CalledProcessError:
-      print('Bazel command: %s not found' % args.bazel_exe, file=sys.stderr)
-      sys.exit(1)
-  try:
+      try:
+        return subprocess.check_output(
+          ['which', 'bazel']).strip().decode('UTF-8')
+      except subprocess.CalledProcessError:
+        raise Exception(
+          "Neither bazelisk nor bazel found. Please see"
+          " Documentation/dev-bazel for instructions on installing"
+          " one of them.")
+
+  def _build_bazel_cmd(self, *args):
+    cmd = [self.bazel_exe]
+    if self.args.batch:
+      cmd.append('--batch')
+    for arg in args:
+      cmd.append(arg)
+    return cmd
+
+  def retrieve_ext_location(self):
     return subprocess.check_output(
-      ['which', 'bazelisk']).strip().decode('UTF-8')
-  except subprocess.CalledProcessError:
+      self._build_bazel_cmd('info', 'output_base')).strip()
+
+  def _query_classpath(self):
+    t = '//tools/eclipse:main_classpath_collect'
     try:
-      return subprocess.check_output(
-        ['which', 'bazel']).strip().decode('UTF-8')
+      cmd = self._build_bazel_cmd('build', t)
+      subprocess.check_call(cmd)
     except subprocess.CalledProcessError:
-      print("Neither bazelisk nor bazel found. Please see"
-            " Documentation/dev-bazel for instructions on installing"
-            " one of them.")
-      sys.exit(1)
+      raise Exception("Could not query classpath with:" % cmd)
+    name = 'bazel-bin/tools/eclipse/' + t.split(':')[1] + '.runtime_classpath'
+    return [line.rstrip('\n') for line in open(name)]
 
-bazel_exe = find_bazel()
-
-def _build_bazel_cmd(*args):
-  cmd = [bazel_exe]
-  if batch_option:
-    cmd.append('--batch')
-  for arg in args:
-    cmd.append(arg)
-  return cmd
-
-def retrieve_ext_location():
-  return subprocess.check_output(_build_bazel_cmd('info', 'output_base')).strip()
-
-def _query_classpath():
-  t = '//tools/eclipse:main_classpath_collect'
-  try:
-    subprocess.check_call(_build_bazel_cmd('build', t))
-  except subprocess.CalledProcessError:
-    exit(1)
-  name = 'bazel-bin/tools/eclipse/' + t.split(':')[1] + '.runtime_classpath'
-  return [line.rstrip('\n') for line in open(name)]
-
-def gen_project(name, root=ROOT):
-  p = os.path.join(root, '.project')
-  with open(p, 'w') as fd:
-    print("""\
+  def gen_project(name, root):
+    p = os.path.join(root, '.project')
+    with open(p, 'w') as fd:
+      print("""\
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
   <name>%(name)s</name>
@@ -113,107 +134,111 @@
 </projectDescription>\
     """ % {"name": name}, file=fd)
 
-def gen_classpath(ext):
-  def make_classpath():
-    impl = xml.dom.minidom.getDOMImplementation()
-    return impl.createDocument(None, 'classpath', None)
+  def gen_classpath(self, ext):
+    def make_classpath():
+      impl = xml.dom.minidom.getDOMImplementation()
+      return impl.createDocument(None, 'classpath', None)
 
-  def classpathentry(kind, path, src=None, out=None, exported=None):
-    e = doc.createElement('classpathentry')
-    e.setAttribute('kind', kind)
-    # TODO(davido): Remove this and other exclude BUILD files hack
-    # when this Bazel bug is fixed:
-    # https://github.com/bazelbuild/bazel/issues/1083
-    if kind == 'src':
-      e.setAttribute('excluding', '**/BUILD')
-    e.setAttribute('path', path)
-    if src:
-      e.setAttribute('sourcepath', src)
-    if out:
-      e.setAttribute('output', out)
-    if exported:
-      e.setAttribute('exported', 'true')
-    doc.documentElement.appendChild(e)
-
-  doc = make_classpath()
-  src = set()
-  lib = set()
-
-  java_library = re.compile('bazel-out/(?:.*)-fastbuild/bin(.*)/[^/]+[.]jar$')
-  srcs = re.compile('(.*/external/[^/]+)/jar/(.*)[.]jar')
-  for p in _query_classpath():
-    m = java_library.match(p)
-    if m:
-      src.add(m.group(1).lstrip('/'))
-    else:
-      if ext is not None and p.startswith("external"):
-        p = os.path.join(ext, p)
-        lib.add(p)
-
-  src_paths = {}
-  for s in sorted(src):
-    out = None
-
-    if s.startswith('lib/'):
-      out = 'eclipse-out/lib'
-
-    p = os.path.join(s, 'java')
-    if os.path.exists(p):
-      classpathentry('src', p, out=out)
-      continue
-
-    for env in ['main', 'test', 'java', 'javatests']:
-      o = None
+    def classpathentry(kind, path, src=None, out=None, exported=None):
+      e = doc.createElement('classpathentry')
+      e.setAttribute('kind', kind)
+      # TODO(davido): Remove this and other exclude BUILD files hack
+      # when this Bazel bug is fixed:
+      # https://github.com/bazelbuild/bazel/issues/1083
+      if kind == 'src':
+        e.setAttribute('excluding', '**/BUILD')
+      e.setAttribute('path', path)
+      if src:
+        e.setAttribute('sourcepath', src)
       if out:
-        o = out + '/' + env
-      elif env == 'test' or env == 'javatests':
-        o = 'eclipse-out/test'
+        e.setAttribute('output', out)
+      if exported:
+        e.setAttribute('exported', 'true')
+      doc.documentElement.appendChild(e)
 
-      if s.startswith(env + '/'):
-        src_paths[env] = o
-        continue
+    doc = make_classpath()
+    src = set()
+    lib = set()
 
-      for srctype in ['java', 'resources']:
-        p = os.path.join(s, 'src', env, srctype)
-        if os.path.exists(p):
-          src_paths[p] = o
-
-  for s in src_paths:
-    classpathentry('src', s, out=src_paths[s])
-
-  for libs in [lib]:
-    for j in sorted(libs):
-      if excluded(j):
-        continue
-      s = None
-      m = srcs.match(j)
+    java_library = re.compile('bazel-out/(?:.*)-fastbuild/bin(.*)/[^/]+[.]jar$')
+    srcs = re.compile('(.*/external/[^/]+)/jar/(.*)[.]jar')
+    for p in self._query_classpath():
+      m = java_library.match(p)
       if m:
-        prefix = m.group(1)
-        suffix = m.group(2)
-        p = os.path.join(prefix, "src", "%s-src.jar" % suffix)
-        if os.path.exists(p):
-          s = p
-      classpathentry('lib', j, s)
+        src.add(m.group(1).lstrip('/'))
+      else:
+        if ext is not None and p.startswith("external"):
+          p = os.path.join(ext, p)
+          lib.add(p)
 
-  classpathentry('con', JRE)
-  classpathentry('output', 'eclipse-out/classes')
+    src_paths = {}
+    for s in sorted(src):
+      out = None
 
-  p = os.path.join(ROOT, '.classpath')
-  with open(p, 'w') as fd:
-    doc.writexml(fd, addindent='\t', newl='\n', encoding='UTF-8')
+      if s.startswith('lib/'):
+        out = 'eclipse-out/lib'
 
-def excluded(lib):
-  if args.exclude:
-    for x in args.exclude:
-      if x in lib:
-        return True
-  return False
+      p = os.path.join(s, 'java')
+      if os.path.exists(p):
+        classpathentry('src', p, out=out)
+        continue
 
-try:
-  name = args.name if args.name else os.path.basename(ROOT)
-  gen_project(name)
-  gen_classpath(retrieve_ext_location().decode('utf-8'))
+      for env in ['main', 'test', 'java', 'javatests']:
+        o = None
+        if out:
+          o = out + '/' + env
+        elif env == 'test' or env == 'javatests':
+          o = 'eclipse-out/test'
 
-except KeyboardInterrupt:
-  print('Interrupted by user', file=sys.stderr)
-  exit(1)
+        if s.startswith(env + '/'):
+          src_paths[env] = o
+          continue
+
+        for srctype in ['java', 'resources']:
+          p = os.path.join(s, 'src', env, srctype)
+          if os.path.exists(p):
+            src_paths[p] = o
+
+    for s in src_paths:
+      classpathentry('src', s, out=src_paths[s])
+
+    for libs in [lib]:
+      for j in sorted(libs):
+        if self.excluded(j):
+          continue
+        s = None
+        m = srcs.match(j)
+        if m:
+          prefix = m.group(1)
+          suffix = m.group(2)
+          p = os.path.join(prefix, "src", "%s-src.jar" % suffix)
+          if os.path.exists(p):
+            s = p
+        classpathentry('lib', j, s)
+
+    classpathentry('con', JRE)
+    classpathentry('output', 'eclipse-out/classes')
+
+    p = os.path.join(self.ROOT, '.classpath')
+    with open(p, 'w') as fd:
+      doc.writexml(fd, addindent='\t', newl='\n', encoding='UTF-8')
+
+  def excluded(self, lib):
+    if self.args.exclude:
+      for x in self.args.exclude:
+        if x in lib:
+          return True
+    return False
+
+def main():
+  try:
+    ec = EclipseProject()
+    ec.parse_args(args=sys.argv[1:])
+    ec.main()
+  except KeyboardInterrupt:
+    print('Interrupted by user', file=sys.stderr)
+    exit(1)
+
+
+if __name__ == '__main__':
+  main()
diff --git a/tools/eclipse/test_project.py b/tools/eclipse/test_project.py
new file mode 100755
index 0000000..be73474
--- /dev/null
+++ b/tools/eclipse/test_project.py
@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+#
+# You can run tests using:
+#
+#   bazel test --test_output=streamed //tools/eclipse:test
+#
+# Or directly:
+#
+# ./tools/eclipse/test_project.py
+#
+
+from io import StringIO
+import unittest
+from unittest.mock import call, patch
+from subprocess import CalledProcessError
+
+import project
+from project import EclipseProject
+
+class EclipseProjectTestCase(unittest.TestCase):
+
+  @patch.object(project, 'EclipseProject')
+  def test_script_entrypoint(self, ep):
+    with patch.object(project.sys, 'argv', ['project.py', '-r', '/dev/null']):
+      project.main()
+      ep.assert_has_calls([
+          call(),
+          call().parse_args(args=['-r', '/dev/null']),
+          call().main(),
+      ])
+
+  @patch('sys.stderr', new_callable=StringIO)
+  def test_script_entrypoint_handles_control_c(self, stderr):
+
+    with self.assertRaises(SystemExit) as c:
+      with patch.object(project.EclipseProject, 'parse_args',
+                        side_effect=KeyboardInterrupt):
+        project.main()
+
+    self.assertIn('Interrupted by user\n', stderr.getvalue())
+    self.assertEquals(c.exception.code, 1)
+
+  @patch('sys.stderr', new_callable=StringIO)
+  def test_requires_root_option(self, stderr):
+    with self.assertRaises(SystemExit) as c:
+      ep = EclipseProject()
+      ep.parse_args([])
+    self.assertEqual(c.exception.code, 2)
+    self.assertIn(
+      'the following arguments are required: -r/--root',
+      stderr.getvalue()
+    )
+
+  def test_batch_option_is_passed_to_bazel(self):
+      ep = EclipseProject()
+      ep.parse_args(['-r', '/dev/null'])
+      ep.bazel_exe = 'my_bazel'
+      self.assertEquals(ep._build_bazel_cmd(), ['my_bazel'])
+
+      ep.parse_args(['-r', '/dev/null', '--batch'])
+      self.assertEquals(ep._build_bazel_cmd(), ['my_bazel', '--batch'])
+
+  def test_find_root_raises_when_no_WORKSPACE_found(self):
+    with patch('os.path.exists') as exists:
+      exists.return_value = False
+      with self.assertRaises(Exception):
+        EclipseProject().find_root('/tmp/path/to')
+      exists.assert_has_calls([
+        call('/tmp/path/to/WORKSPACE'),
+        call('/tmp/path/WORKSPACE'),
+        call('/tmp/WORKSPACE'),
+      ])
+
+  def test_find_root_in_grandparent_directory(self):
+    with patch('os.path.exists') as exists:
+      exists.side_effect = [False, False, True, False]
+      root = EclipseProject().find_root('/tmp/path/to/foo')
+      exists.assert_has_calls([
+        call('/tmp/path/to/foo/WORKSPACE'),
+        call('/tmp/path/to/WORKSPACE'),
+        call('/tmp/path/WORKSPACE'),
+      ])
+      self.assertEqual('/tmp/path', root)
+
+  @patch('subprocess.check_output')
+  def test_find_bazel_finds_bazelisk_first(self, check_output):
+    check_output.return_value = b'/path/to/bazelisk'
+    self.assertEqual(EclipseProject().find_bazel(), '/path/to/bazelisk')
+
+  @patch('subprocess.check_output')
+  def test_find_bazel_fallback_to_bazel(self, check_output):
+    check_output.side_effect = [
+        CalledProcessError(1, 'which bazelisk',
+                           '', '[TEST] bazelisk not found'),
+        b'/path/to/bazel',
+    ]
+    self.assertEqual(EclipseProject().find_bazel(), '/path/to/bazel')
+
+  @patch('subprocess.check_output')
+  def test_find_bazel_raise_without_bazel_and_bazelisk(self, check_output):
+    check_output.side_effect = [
+        CalledProcessError(1, 'which bazelisk',
+                           '', '[TEST] bazelisk not found'),
+        CalledProcessError(1, 'which bazel',
+                           '', '[TEST] bazel not found'),
+    ]
+    with self.assertRaisesRegex(Exception, "Neither bazelisk nor bazel found"):
+      EclipseProject().find_bazel()
+
+  @patch('subprocess.check_output')
+  def test_find_given_existing_bazel_exe(self, check_output):
+    check_output.return_value = b'/path/to/bin/mybazel'
+    self.assertEqual(EclipseProject().find_bazel('my_bazel'),
+                     '/path/to/bin/mybazel')
+
+  @patch('subprocess.check_output')
+  def test_find_given_not_existing_bazel_exe(self, check_output):
+    check_output.side_effect = CalledProcessError(
+      1, 'which mybazel', '', '[TEST] mybazel not found')
+    with self.assertRaisesRegex(Exception, 'Bazel command: mybazel not found'):
+      EclipseProject().find_bazel('mybazel')
+
+  @patch('subprocess.check_output')
+  def test_retrieve_ext_location_strips_newline(self, check_output):
+    check_output.return_value = '/path/to/.cache/bazel/xxxx\n'
+    ep = EclipseProject()
+    ep.parse_args(['-r' '/dev/null', '--bazel', 'my_bazel'])
+    assert not ep.retrieve_ext_location().endswith('\n')
+
+
+if __name__ == "__main__":
+  unittest.main(verbosity=2)
diff --git a/tools/eclipse/test_project_coverage b/tools/eclipse/test_project_coverage
new file mode 100755
index 0000000..fa3e819
--- /dev/null
+++ b/tools/eclipse/test_project_coverage
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+COVERAGE="python3 -m coverage"
+
+$COVERAGE run --branch --include=project.py test_project.py
+$COVERAGE html