panic for MustRegister

Author: KaylaNguyen

v2/delay/delay.go

@@ -10,15 +10,15 @@ To use a deferred function, you must register the function to be
 deferred as a top-level var. For example,
 
     ```
-    var laterFunc = delay.Register("key", myFunc)
+    var laterFunc = delay.MustRegister("key", myFunc)
 
     func myFunc(ctx context.Context, a, b string) {...}
     ```
 
 You can also inline with a function literal:
 
     ```
-    var laterFunc = delay.Register("key", func(ctx context.Context, a, b string) {...})
+    var laterFunc = delay.MustRegister("key", func(ctx context.Context, a, b string) {...})
     ```
 
 In the above example, "key" is a logical name for the function.
@@ -150,7 +150,7 @@ func fileKey(file string) (string, error) {
 // This function Func must be called in a global scope to properly
 // register the function with the framework.
 //
-// Deprecated: Use Register instead.
+// Deprecated: Use MustRegister instead.
 func Func(key string, i interface{}) *Function {
 	// Derive unique, somewhat stable key for this func.
 	_, file, _, _ := runtime.Caller(1)
@@ -171,24 +171,22 @@ func Func(key string, i interface{}) *Function {
 	return f
 }
 
-// Register declares a new function that can be called in a deferred fashion.
+// MustRegister declares a new function that can be called in a deferred fashion.
 // The second argument i must be a function with the first argument of
 // type context.Context.
-// Register requires the key to be globally unique.
+// MustRegister requires the key to be globally unique.
 //
-// This function Register must be called in a global scope to properly
+// This function MustRegister must be called in a global scope to properly
 // register the function with the framework.
 // See the package notes above for more details.
-func Register(key string, i interface{}) *Function {
+func MustRegister(key string, i interface{}) *Function {
 	f, err := registerFunction(key, i)
 	if err != nil {
 		return f
 	}
 
 	if old := funcs[f.key]; old != nil {
-		old.err = fmt.Errorf("multiple functions registered for %s", key)
-		f.err = fmt.Errorf("multiple functions registered for %s", key)
-		return f
+		panic(fmt.Sprintf("multiple functions registered for %s", key))
 	}
 	funcs[f.key] = f
 	return f
@@ -208,9 +206,9 @@ func registerFunction(key string, i interface{}) (*Function, error) {
 		return f, errFirstArg
 	}
 
-	// Register the function's arguments with the gob package.
+	// MustRegister the function's arguments with the gob package.
 	// This is required because they are marshaled inside a []interface{}.
-	// gob.Register only expects to be called during initialization;
+	// gob.MustRegister only expects to be called during initialization;
 	// that's fine because this function expects the same.
 	for i := 0; i < t.NumIn(); i++ {
 		// Only concrete types may be registered. If the argument has

v2/delay/delay_test.go

@@ -43,7 +43,7 @@ func init() {
 
 var (
 	invalidFunc     = Func("invalid", func() {})
-	invalidRegister = Register("invalid", func() {})
+	invalidRegister = MustRegister("invalid", func() {})
 
 	regFRuns = 0
 	regFMsg  = ""
@@ -52,7 +52,7 @@ var (
 		regFMsg = arg
 	}
 	regFunc     = Func("regFunc", regF)
-	regRegister = Register("regRegister", regF)
+	regRegister = MustRegister("regRegister", regF)
 
 	custFTally = 0
 	custF      = func(c context.Context, ct *CustomType, ci CustomInterface) {
@@ -66,7 +66,7 @@ var (
 		custFTally += a + b
 	}
 	custFunc     = Func("custFunc", custF)
-	custRegister = Register("custRegister", custF)
+	custRegister = MustRegister("custRegister", custF)
 
 	anotherCustFunc = Func("custFunc2", func(c context.Context, n int, ct *CustomType, ci CustomInterface) {
 	})
@@ -81,7 +81,7 @@ var (
 		varFMsg = fmt.Sprintf(format, as...)
 	}
 	varFunc     = Func("variadicFunc", varF)
-	varRegister = Register("variadicRegister", varF)
+	varRegister = MustRegister("variadicRegister", varF)
 
 	errFRuns = 0
 	errFErr  = errors.New("error!")
@@ -93,7 +93,7 @@ var (
 		return errFErr
 	}
 	errFunc     = Func("errFunc", errF)
-	errRegister = Register("errRegister", errF)
+	errRegister = MustRegister("errRegister", errF)
 
 	dupeWhich = 0
 	dupe1F    = func(c context.Context) {
@@ -102,14 +102,12 @@ var (
 		}
 	}
 	dupe1Func     = Func("dupe", dupe1F)
-	dupe1Register = Register("dupe", dupe1F)
 	dupe2F        = func(c context.Context) {
 		if dupeWhich == 0 {
 			dupeWhich = 2
 		}
 	}
 	dupe2Func     = Func("dupe", dupe2F)
-	dupe2Register = Register("dupe", dupe2F)
 
 	requestFuncRuns    = 0
 	requestFuncHeaders *taskqueue.RequestHeaders
@@ -119,14 +117,14 @@ var (
 		requestFuncHeaders, requestFuncErr = RequestHeaders(c)
 	}
 	requestFunc     = Func("requestFunc", requestF)
-	requestRegister = Register("requestRegister", requestF)
+	requestRegister = MustRegister("requestRegister", requestF)
 
 	stdCtxRuns = 0
 	stdCtxF    = func(c stdctx.Context) {
 		stdCtxRuns++
 	}
 	stdCtxFunc     = Func("stdctxFunc", stdCtxF)
-	stdCtxRegister = Register("stdctxRegister", stdCtxF)
+	stdCtxRegister = MustRegister("stdctxRegister", stdCtxF)
 )
 
 type fakeContext struct {
@@ -424,31 +422,14 @@ func TestFuncDuplicateFunction(t *testing.T) {
 	}
 }
 
-func TestRegisterDuplicateFunction(t *testing.T) {
-	c := newFakeContext()
-
-	// Fake out the adding of a task.
-	var task *taskqueue.Task
-	taskqueueAdder = func(_ context.Context, tk *taskqueue.Task, queue string) (*taskqueue.Task, error) {
-		if queue != "" {
-			t.Errorf(`Got queue %q, expected ""`, queue)
+func TestMustRegisterDuplicateFunction(t *testing.T) {
+	MustRegister("dupe", dupe1F)
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("MustRegister did not panic")
 		}
-		task = tk
-		return tk, nil
-	}
-
-	if err := dupe1Register.Call(c.ctx); err == nil {
-		t.Error("dupe1Register.Call did not return error")
-	}
-	if task != nil {
-		t.Error("dupe1Register.Call posted a task")
-	}
-	if err := dupe2Register.Call(c.ctx); err == nil {
-		t.Error("dupe2Register.Call did not return error")
-	}
-	if task != nil {
-		t.Fatalf("dupe2Register.Call did not post a task")
-	}
+	}()
+	MustRegister("dupe", dupe2F)
 }
 
 func TestGetRequestHeadersFromContext(t *testing.T) {