Revert "Refactor current GAE abstraction library to be free of the SDK*"

go/src/infra/gae/libs/wrapper/brokenfeatures_test.go

 // Copyright 2015 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.
 
-package gae
+package wrapper
 
 import (
         "errors"
         "fmt"
         "sync"
         "testing"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
 type foo struct {
         BrokenFeatures
 }
 
-func (f *foo) RunIfNotBroken(fn func() error) error {
-        // can 'override' RunIfNotBroken
-        return f.BrokenFeatures.RunIfNotBroken(fn)
+func (f *foo) halp() error { // test the ability to call IsBroken from an internal helper
+        return f.IsBroken()
 }
 
-func (f *foo) Foo() (ret string, err error) {
-        err = f.RunIfNotBroken(func() error {
-                ret = "foo"
-                return nil
-        })
-        return
+func (f *foo) Foo() (string, error) {
+        err := f.halp()
+        if err != nil {
+                return "", err
+        }
+        return "foo", nil
 }
 
-func (f *foo) Bar() (ret string, err error) {
-        err = f.RunIfNotBroken(func() error {
-                ret = "bar"
-                return nil
-        })
-        return
+func (f *foo) Bar() (string, error) {
+        err := f.halp()
+        if err != nil {
+                return "", err
+        }
+        return "bar", nil
 }
 
 type override struct {
         BrokenFeatures
         totallyRekt bool
 }
 
-func (o *override) RunIfNotBroken(f func() error) error {
+func (o *override) IsBroken() error {
         if o.totallyRekt {
                 return fmt.Errorf("totallyRekt")
         }
-        return o.BrokenFeatures.RunIfNotBroken(f)
+        return o.BrokenFeatures.IsBroken()
 }
 
 func (o *override) Foo() error {
-        return o.RunIfNotBroken(func() error { return nil })
+        return o.IsBroken()
 }
 
 func TestBrokenFeatures(t *testing.T) {
         e := errors.New("sup")
         eCustom := fmt.Errorf("bad stuff happened")
         f := foo{BrokenFeatures{DefaultError: e}}
 
         Convey("BrokenFeatures", t, func() {
                 Convey("can break functions", func() {
                         s, err := f.Foo()
@@ skipping 47 matching lines @@
 
                 Convey("Can be broken if not embedded", func(c C) {
                         var wg sync.WaitGroup
                         wg.Add(1)
                         go func() {
                                 defer wg.Done()
                                 bf := BrokenFeatures{DefaultError: e}
                                 // break some feature so we're forced to crawl the stack.
                                 bf.BreakFeatures(nil, "Nerds")
                                 // should break because there's no exported functions on the stack.
-                                err := bf.RunIfNotBroken(func() error { return nil })
-                                c.So(err, ShouldEqual, ErrBrokenFeaturesBroken)
+                                c.So(bf.IsBroken(), ShouldEqual, ErrBrokenFeaturesBroken)
                         }()
                         wg.Wait()
                 })
         })
 }