Use unittest framework in the Automated Installer Testing Framework.

chrome/test/mini_installer/verifier.py

Index: chrome/test/mini_installer/verifier.py
diff --git a/chrome/test/mini_installer/verifier.py b/chrome/test/mini_installer/verifier.py
index 7b0fae6c46e0dc6dc16d204d4902e3edaa1cf2bd..558c7897f77826c7e2be77ef6c3ca68464b2122f 100644
--- a/chrome/test/mini_installer/verifier.py
+++ b/chrome/test/mini_installer/verifier.py
@@ -2,14 +2,30 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import registry_verifier
-
-def Verify(property):
-  """Verifies that the current machine states match the property object."""
-  for verifier_name, value in property.iteritems():
-    if verifier_name == 'RegistryEntries':
-      registry_verifier.VerifyRegistryEntries(value)
-    else:
-      # TODO(sukolsak): Implement other verifiers
-      # TODO(sukolsak): Use unittest framework instead of exceptions.
-      raise Exception('Unknown verifier')
+from registry_verifier import RegistryVerifier
+
+class Verifier:
+  """Verifies that the current machine state matches the expected machine
+  state."""
+
+  def __init__(self, testcase):
+    """Constructor.
+
+    Args:
+      testcase: A unittest.TestCase instance.
+    """
+    self.testcase = testcase
+    self.registry_verifier = RegistryVerifier(testcase)

[gab, 2013/08/08 02:07:08]

How about a single dictionary of verifiers, e.g.:

self.verifiers['RegistryEntries'] = RegistryVerifier(testcase)

Every individual verifier would subclass some AbstractVerifier which would do
two things:

1) Hold the testcase.
2) Have a Verify method to be overridden by the individual verifiers.

That then makes Verify() below extremely simple (even as we add more verifiers).

I'm happy to see this in a follow-up CL to keep this one down to introducing
unittest.

[robertshield, 2013/08/09 19:00:15]

I agree with the notion of having Verifiers derive from an interface of some
kind. IIRC Python either didn't have or had really ugly built in ways of
specifying abstract interfaces, but something like 

class Verifier(object):
  def Verify(self):
     raise NotImplementedError("Complain")

class RegistryVerifier(Verifier):
   def Verify(self):
      # Do stuff

accomplishes the same. 

+
+  def Verify(self, property):

[robertshield, 2013/08/09 19:00:15]

If the comment above is followed, this would then NOT be a method of Verifier,
but would instead be a standalone method that takes a given machine _state_,
conjures up the needed verifiers and runs them to check whether the state is
good.

[sukolsak, 2013/08/09 21:12:38]

Done.

+    """Verifies that the current machine states match the property dictionary.
+
+    Args:
+      property: A property dictionary.
+    """
+    for verifier_name, value in property.iteritems():
+      if verifier_name == 'RegistryEntries':
+        self.registry_verifier.VerifyRegistryEntries(value)
+      else:
+        # TODO(sukolsak): Implement other verifiers
+        self.testcase.fail('Unknown verifier %s' % verifier_name)