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..8d3e7a47664595aed543a8a3da628cddc929510b 100644
--- a/chrome/test/mini_installer/verifier.py
+++ b/chrome/test/mini_installer/verifier.py
@@ -4,12 +4,16 @@
 
 import registry_verifier
 
-def Verify(property):
-  """Verifies that the current machine states match the property object."""
+def Verify(property, testcase):

[gab, 2013/08/07 13:03:34]

Instead of having this method take a testcase (and a bunch of methods in
registry_verifier doing so as well), how about making this a Verifier class and
all other verifiers classes as well.

A Verifier would be owned by each TestCase which would pass it a reference to
itself.

Each Verifier would own an instance of every verifiers and would also pass down
a reference to the TestCase to these at construction time.
I prefer that to having to modify a bunch of methods to take a |testcase|
parameter.

I don't like the cyclic dependency (TestCase -> Verifier; Verifier -> TestCase),
but I don't see how to avoid it if we need the TestCase to be able to do fine
grain asserts/fails in the verifiers. At least the ownership model is clear
(TestCase -> Verifier -> SpecificVerifier) and the interaction model is
synchronous so it's not really a dangerous cyclic dependency per se.

[sukolsak, 2013/08/07 21:23:29]

I like to think of verifiers as a collection of static methods that don't have
any state, so we don't have to worry about reference cycles and other things.
But, like you said, it also comes at a cost of having to pass down |testcase| to
every method. So, your suggestion works too.

[gab, 2013/08/08 02:09:29]

And yes, I agree, that's also how I saw them at first, but having to pass
testcase around only in methods that need them (and potentially having to change
methods signatures if we later want to assert in existing methods that don't
take a testcase object is just plain ugly imo). A class is designed to hold this
type of data and is a better fit here I think.

+  """Verifies that the current machine states match the property object.
+
+  Args:
+    property: A property dictionary.
+    testcase: A TestCase instance.
+  """
   for verifier_name, value in property.iteritems():
     if verifier_name == 'RegistryEntries':
-      registry_verifier.VerifyRegistryEntries(value)
+      registry_verifier.VerifyRegistryEntries(value, testcase)
     else:
       # TODO(sukolsak): Implement other verifiers
-      # TODO(sukolsak): Use unittest framework instead of exceptions.
-      raise Exception('Unknown verifier')
+      testcase.fail('Unknown verifier %s' % verifier_name)