diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 354c761..cce4c7b 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -23,7 +23,7 @@ repos:
     -   id: pylint
         name: pylint (library code)
         types: [python]
-        exclude: "^(docs/|examples/|setup.py$)"
+        exclude: "^(docs/|tests/|examples/|setup.py$)"
 -   repo: local
     hooks:
     -   id: pylint_examples
@@ -32,3 +32,11 @@ repos:
         entry: /usr/bin/env bash -c
         args: ['([[ ! -d "examples" ]] || for example in $(find . -path "./examples/*.py"); do pylint --disable=missing-docstring,invalid-name $example; done)']
         language: system
+-   repo: local
+    hooks:
+    -   id: pylint_tests
+        name: pylint (tests code)
+        description: Run pylint rules on "tests/*.py" files
+        entry: /usr/bin/env bash -c
+        args: ['([[ ! -d "tests" ]] || for test in $(find . -path "./tests/*.py"); do pylint --disable=missing-docstring $test; done)']
+        language: system
diff --git a/tests/tests.py b/tests/tests.py
index 8fba0d5..50ddb38 100644
--- a/tests/tests.py
+++ b/tests/tests.py
@@ -24,100 +24,102 @@ def _false():
     return False
 
 
-def assertEqual(a, b):
-    assert a == b, "Want %r, got %r" % (a, b)
+def assertEqual(var_a, var_b):  # pylint: disable=invalid-name
+    assert var_a == var_b, "Want %r, got %r" % (var_a, var_b)
 
 
 def test_back_and_forth():
     # Start false
-    db = adafruit_debouncer.Debouncer(_false)
-    assertEqual(db.value, False)
+    debouncer = adafruit_debouncer.Debouncer(_false)
+    assertEqual(debouncer.value, False)
 
     # Set the raw state to true, update, and make sure the debounced
     # state has not changed yet:
-    db.function = _true
-    db.update()
-    assertEqual(db.value, False)
-    assert not db.last_duration, "There was no previous interval??"
+    debouncer.function = _true
+    debouncer.update()
+    assertEqual(debouncer.value, False)
+    assert not debouncer.last_duration, "There was no previous interval??"
 
     # Sleep longer than the debounce interval, so state can change:
     time.sleep(0.02)
-    db.update()
-    assert db.last_duration  # is actually duration between powerup and now
-    assertEqual(db.value, True)
-    assertEqual(db.rose, True)
-    assertEqual(db.fell, False)
+    debouncer.update()
+    assert debouncer.last_duration  # is actually duration between powerup and now
+    assertEqual(debouncer.value, True)
+    assertEqual(debouncer.rose, True)
+    assertEqual(debouncer.fell, False)
     # Duration since last change has only been long enough to run these
     # asserts, which should be well under 1/10 second
-    assert db.current_duration < 0.1, "Unit error? %d" % db.current_duration
+    assert debouncer.current_duration < 0.1, (
+        "Unit error? %d" % debouncer.current_duration
+    )
 
     # Set raw state back to false, make sure it's not instantly reflected,
     # then wait and make sure it IS reflected after the interval has passed.
-    db.function = _false
-    db.update()
-    assertEqual(db.value, True)
-    assertEqual(db.fell, False)
-    assertEqual(db.rose, False)
+    debouncer.function = _false
+    debouncer.update()
+    assertEqual(debouncer.value, True)
+    assertEqual(debouncer.fell, False)
+    assertEqual(debouncer.rose, False)
     time.sleep(0.02)
-    assert 0.019 < db.current_duration <= 1, (
-        "Unit error? sleep .02 -> duration %d" % db.current_duration
+    assert 0.019 < debouncer.current_duration <= 1, (
+        "Unit error? sleep .02 -> duration %d" % debouncer.current_duration
     )
-    db.update()
-    assertEqual(db.value, False)
-    assertEqual(db.rose, False)
-    assertEqual(db.fell, True)
+    debouncer.update()
+    assertEqual(debouncer.value, False)
+    assertEqual(debouncer.rose, False)
+    assertEqual(debouncer.fell, True)
 
-    assert 0 < db.current_duration <= 0.1, (
-        "Unit error? time to run asserts %d" % db.current_duration
+    assert 0 < debouncer.current_duration <= 0.1, (
+        "Unit error? time to run asserts %d" % debouncer.current_duration
     )
-    assert 0 < db.last_duration < 0.1, (
-        "Unit error? Last dur should be ~.02, is %d" % db.last_duration
+    assert 0 < debouncer.last_duration < 0.1, (
+        "Unit error? Last dur should be ~.02, is %d" % debouncer.last_duration
     )
 
 
 def test_interval_is_the_same():
-    db = adafruit_debouncer.Debouncer(_false, interval=0.25)
-    assertEqual(db.value, False)
-    db.update()
-    db.function = _true
-    db.update()
+    debouncer = adafruit_debouncer.Debouncer(_false, interval=0.25)
+    assertEqual(debouncer.value, False)
+    debouncer.update()
+    debouncer.function = _true
+    debouncer.update()
 
     time.sleep(0.1)  # longer than default interval
-    db.update()
-    assertEqual(db.value, False)
+    debouncer.update()
+    assertEqual(debouncer.value, False)
 
     time.sleep(0.2)  # 0.1 + 0.2 > 0.25
-    db.update()
-    assertEqual(db.value, True)
-    assertEqual(db.rose, True)
-    assertEqual(db.interval, 0.25)
+    debouncer.update()
+    assertEqual(debouncer.value, True)
+    assertEqual(debouncer.rose, True)
+    assertEqual(debouncer.interval, 0.25)
 
 
 def test_setting_interval():
     # Check that setting the interval does change the time the debouncer waits
-    db = adafruit_debouncer.Debouncer(_false, interval=0.01)
-    db.update()
+    debouncer = adafruit_debouncer.Debouncer(_false, interval=0.01)
+    debouncer.update()
 
     # set the interval to a longer time, sleep for a time between
     # the two interval settings, and assert that the value hasn't changed.
 
-    db.function = _true
-    db.interval = 0.2
-    db.update()
-    assert db.interval - 0.2 < 0.00001, "interval is not consistent"
+    debouncer.function = _true
+    debouncer.interval = 0.2
+    debouncer.update()
+    assert debouncer.interval - 0.2 < 0.00001, "interval is not consistent"
     time.sleep(0.11)
-    db.update()
+    debouncer.update()
 
-    assertEqual(db.value, False)
-    assertEqual(db.rose, False)
-    assertEqual(db.fell, False)
+    assertEqual(debouncer.value, False)
+    assertEqual(debouncer.rose, False)
+    assertEqual(debouncer.fell, False)
 
     # and then once the whole time has passed make sure it did change
     time.sleep(0.11)
-    db.update()
-    assertEqual(db.value, True)
-    assertEqual(db.rose, True)
-    assertEqual(db.fell, False)
+    debouncer.update()
+    assertEqual(debouncer.value, True)
+    assertEqual(debouncer.rose, True)
+    assertEqual(debouncer.fell, False)
 
 
 def run():
@@ -131,8 +133,8 @@ def run():
                 test()
                 print("PASS")
                 passes += 1
-            except Exception as e:
-                sys.print_exception(e)
+            except Exception as err:  # pylint: disable=broad-except
+                sys.print_exception(err)  # pylint: disable=no-member
                 print("FAIL")
                 fails += 1