Implemented service.EnsureMinUnits().

state/export_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package state
 
 import (
         "fmt"
         "io/ioutil"
         "net/url"
         "path/filepath"
@@ skipping 38 matching lines @@
         st.transactionHooks <- converted
         c.Assert(original, HasLen, 0)
         return func() {
                 remaining := <-st.transactionHooks
                 st.transactionHooks <- nil
                 c.Assert(remaining, HasLen, 0)
         }
 }
 
 // SetBeforeHooks uses SetTransactionHooks to queue N functions to be run
-// immediately before the next N transactions. Nil values are accepted, and
-// useful, in that they can be used to ensure that a transaction is run at
-// the expected time, without having to make any changes or assert any state.
+// immediately before the next N transactions. The first function is executed
+// before the first transaction, the second function before the second
+// transaction and so on. Nil values are accepted, and useful, in that they can
+// be used to ensure that a transaction is run at the expected time, without
+// having to make any changes or assert any state.
 func SetBeforeHooks(c *C, st *State, fs ...func()) TransactionChecker {
         transactionHooks := make([]TransactionHook, len(fs))
         for i, f := range fs {
                 transactionHooks[i] = TransactionHook{Before: f}
+        }
+        return SetTransactionHooks(c, st, transactionHooks...)
+}
+
+// SetAfterHooks uses SetTransactionHooks to queue N functions to be run
+// immediately after the next N transactions. The first function is executed
+// after the first transaction, the second function after the second
+// transaction and so on.
+func SetAfterHooks(c *C, st *State, fs ...func()) TransactionChecker {
+        transactionHooks := make([]TransactionHook, len(fs))
+        for i, f := range fs {
+                transactionHooks[i] = TransactionHook{After: f}
         }
         return SetTransactionHooks(c, st, transactionHooks...)
 }
 
 // SetRetryHooks uses SetTransactionHooks to inject a block function designed
 // to disrupt a transaction built against recent state, and a check function
 // designed to verify that the replacement transaction against the new state
 // has been applied as expected.
 func SetRetryHooks(c *C, st *State, block, check func()) TransactionChecker {
         return SetTransactionHooks(c, st, TransactionHook{
@@ skipping 82 matching lines @@
 
 // MinUnitsRevno returns the Revno of the minUnits document
 // associated with the given service name.
 func MinUnitsRevno(st *State, serviceName string) (int, error) {
         var doc minUnitsDoc
         if err := st.minUnits.FindId(serviceName).One(&doc); err != nil {
                 return 0, err
         }
         return doc.Revno, nil
 }