Implement config service cache on top of datastore

common/testing/assertions/error_tests.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package assertions
 
 import (
         "fmt"
 
+        "github.com/luci/luci-go/common/errors"
+
         "github.com/smartystreets/assertions"
 )
 
 // ShouldErrLike compares an `error` or `string` on the left side, to an `error`
 // or `string` on the right side.
 //
 // If the righthand side is omitted, this expects `actual` to be nil.
 //
 // If a singular righthand side is provided, this expects the stringified
 // `actual` to contain the stringified `expected[0]` to be a substring of it.
@@ skipping 40 matching lines @@
         f, ok := function.(func())
         if !ok {
                 return fmt.Sprintf("unknown argument type %T, expected `func()`", function)
         }
         defer func() {
                 ret = ShouldErrLike(recover(), expected...)
         }()
         f()
         return ShouldErrLike(nil, expected...)
 }
+
+// ShouldUnwrapTo asserts that an error, when unwrapped, equals another error.
+//
+// The actual field will be unwrapped using errors.Unwrap and then compared to
+// the error in expected.
+func ShouldUnwrapTo(actual interface{}, expected ...interface{}) string {
+        act, ok := actual.(error)
+        if !ok {
+                return fmt.Sprintf("ShouldUnwrapTo requires an error actual type, got %T", act)
+        }
+
+        if len(expected) != 1 {
+                return fmt.Sprintf("ShouldUnwrapTo requires exactly one expected value, got %d", len(expected))
+        }
+        exp, ok := expected[0].(error)
+        if !ok {
+                return fmt.Sprintf("ShouldUnwrapTo requires an error expected type, got %T", expected[0])
+        }
+
+        return assertions.ShouldEqual(errors.Unwrap(act), exp)
+}