Use unittest framework in the Automated Installer Testing Framework.

chrome/test/mini_installer/verifier.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import registry_verifier
+from registry_verifier import RegistryVerifier
 
-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')
+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)