Re-add WithinTolerance validator with tests (#920)

openhtf/util/validators.py

@@ -339,3 +339,41 @@ def __str__(self):
 @register
 def consistent_end_dimension_pivot_validate(sub_validator):
   return ConsistentEndDimensionPivot(sub_validator)
+
+
+class WithinTolerance(RangeValidatorBase):
+  """Validates that a number is within a given tolerance of a value."""
+
+  def __init__(self, expected, tolerance):
+    if tolerance < 0:
+      raise ValueError(
+        'tolerance argument is {}, must be >0'.format(tolerance))
+    self.expected = expected
+    self.tolerance = tolerance
+
+  @property
+  def minimum(self):
+    return self.expected - self.tolerance
+
+  @property
+  def maximum(self):
+    return self.expected + self.tolerance
+
+  def __call__(self, value):
+    return self.minimum <= value <= self.maximum
+
+  def __str__(self):
+    return "'x' is within {} of {}".format(self.tolerance, self.expected)
+
+  def __eq__(self, other):
+    return (isinstance(other, type(self)) and
+            self.expected == other.expected and
+            self.tolerance == other.tolerance)
+
+  def __ne__(self, other):
+    return not self == other
+
+
+@register
+def within_tolerance(expected, tolerance):
+  return WithinTolerance(expected, tolerance)

test/util/validators_test.py

@@ -250,3 +250,73 @@ def phase(test):
 
     phase_record = yield phase
     self.assertMeasurementFail(phase_record, 'pivot')
+
+
+class TestWithinTolerance(unittest.TestCase):
+
+  def test_raises_for_negative_tolerance(self):
+    with six.assertRaisesRegex(self, ValueError, 'tolerance argument is'):
+      validators.WithinTolerance(expected=5.0, tolerance=-0.1)
+
+  def test_within_tolerance_small(self):
+    validator = validators.WithinTolerance(expected=5.0, tolerance=0.1)
+    for valid_value in [5.0, 5.01, 5.09, 5.0999, 4.9, 4.91]:
+      self.assertTrue(
+          validator(valid_value),
+          msg='{} should validate, but did not'.format(valid_value))
+    for invalid_value in [0, 0.01, -10.0, 10.0, 5.2, 5.11, 4.89]:
+      self.assertFalse(
+          validator(invalid_value),
+          msg='{} should not validate, but did'.format(invalid_value))
+
+  def test_within_tolerance_large(self):
+    validator = validators.WithinTolerance(expected=0.0, tolerance=100.0)
+    for valid_value in [0.0, -90.5, 100.0, -100.0, -1.3, -99.9]:
+      self.assertTrue(
+          validator(valid_value),
+          msg='{} should validate, but did not'.format(valid_value))
+    for invalid_value in [100.001, 1000.0, -200.0, -100.1, 1e6]:
+      self.assertFalse(
+          validator(invalid_value),
+          msg='{} should not validate, but did'.format(invalid_value))
+
+  def test_within_tolerance_negative(self):
+    validator = validators.WithinTolerance(expected=5.0, tolerance=0.1)
+    for valid_value in [5.0, 5.01, 5.09, 5.0999, 4.9, 4.91]:
+      self.assertTrue(
+          validator(valid_value),
+          msg='{} should validate, but did not'.format(valid_value))
+    for invalid_value in [0, 0.01, -10.0, 10.0, 5.2, 5.11, 4.89]:
+      self.assertFalse(
+          validator(invalid_value),
+          msg='{} should not validate, but did'.format(invalid_value))
+
+  def test_equals_equivalent_within_tolerance_validator(self):
+    validator_a = validators.WithinTolerance(expected=5.0, tolerance=0.1)
+    validator_b = validators.WithinTolerance(expected=5.0, tolerance=0.1)
+    self.assertEqual(validator_a, validator_b,
+                     msg='Validators should compare equal, but did not.')
+
+  def test_not_equals_when_not_equivalent(self):
+    validator_a = validators.WithinTolerance(expected=5.0, tolerance=0.1)
+    validator_b = validators.WithinTolerance(expected=5.0, tolerance=0.2)
+    validator_c = validators.WithinTolerance(expected=4.0, tolerance=0.1)
+    for validator in [validator_b, validator_c]:
+      self.assertNotEqual(validator_a, validator)
+
+  def test_string_representation_does_not_raise(self):
+    validator_a = validators.WithinTolerance(expected=5.0, tolerance=0.1)
+    str(validator_a)
+    # Check that we constructed a usable validator.
+    self.assertTrue(validator_a(5.0))
+
+  def test_is_deep_copyable(self):
+    validator_a = validators.WithinTolerance(expected=5.0, tolerance=0.1)
+    # Call implemented functions, try catch the cases where they might change
+    # state in a non-deepcopyable manner.
+    validator_a(1)
+    str(validator_a)
+    validator_a == 'a'
+    validator_b = copy.deepcopy(validator_a)
+    self.assertEqual(validator_a.expected, validator_b.expected)
+    self.assertEqual(validator_a.tolerance, validator_b.tolerance)