src/foundation/api/revel/intercept_test.go

   1 // Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
   2 // Revel Framework source code and usage is governed by a MIT style
   3 // license that can be found in the LICENSE file.
   4
   5 package revel
   6
   7 import (
   8         "reflect"
   9         "testing"
  10 )
  11
  12 var funcP = func(c *Controller) Result { return nil }
  13 var funcP2 = func(c *Controller) Result { return nil }
  14
  15 type InterceptController struct{ *Controller }
  16 type InterceptControllerN struct{ InterceptController }
  17 type InterceptControllerP struct{ *InterceptController }
  18 type InterceptControllerNP struct {
  19         *Controller
  20         InterceptControllerN
  21         InterceptControllerP
  22 }
  23
  24 func (c InterceptController) methN() Result  { return nil }
  25 func (c *InterceptController) methP() Result { return nil }
  26
  27 func (c InterceptControllerN) methNN() Result  { return nil }
  28 func (c *InterceptControllerN) methNP() Result { return nil }
  29 func (c InterceptControllerP) methPN() Result  { return nil }
  30 func (c *InterceptControllerP) methPP() Result { return nil }
  31
  32 // Methods accessible from InterceptControllerN
  33 var MethodN = []interface{}{
  34         InterceptController.methN,
  35         (*InterceptController).methP,
  36         InterceptControllerN.methNN,
  37         (*InterceptControllerN).methNP,
  38 }
  39
  40 // Methods accessible from InterceptControllerP
  41 var MethodP = []interface{}{
  42         InterceptController.methN,
  43         (*InterceptController).methP,
  44         InterceptControllerP.methPN,
  45         (*InterceptControllerP).methPP,
  46 }
  47
  48 // This checks that all the various kinds of interceptor functions/methods are
  49 // properly invoked.
  50 func TestInvokeArgType(t *testing.T) {
  51         n := InterceptControllerN{InterceptController{&Controller{}}}
  52         p := InterceptControllerP{&InterceptController{&Controller{}}}
  53         np := InterceptControllerNP{&Controller{}, n, p}
  54         testInterceptorController(t, reflect.ValueOf(&n), MethodN)
  55         testInterceptorController(t, reflect.ValueOf(&p), MethodP)
  56         testInterceptorController(t, reflect.ValueOf(&np), MethodN)
  57         testInterceptorController(t, reflect.ValueOf(&np), MethodP)
  58 }
  59
  60 func testInterceptorController(t *testing.T, appControllerPtr reflect.Value, methods []interface{}) {
  61         interceptors = []*Interception{}
  62         InterceptFunc(funcP, BEFORE, appControllerPtr.Elem().Interface())
  63         InterceptFunc(funcP2, BEFORE, AllControllers)
  64         for _, m := range methods {
  65                 InterceptMethod(m, BEFORE)
  66         }
  67         ints := getInterceptors(BEFORE, appControllerPtr)
  68
  69         if len(ints) != 6 {
  70                 t.Fatalf("N: Expected 6 interceptors, got %d.", len(ints))
  71         }
  72
  73         testInterception(t, ints[0], reflect.ValueOf(&Controller{}))
  74         testInterception(t, ints[1], reflect.ValueOf(&Controller{}))
  75         for i := range methods {
  76                 testInterception(t, ints[i+2], appControllerPtr)
  77         }
  78 }
  79
  80 func testInterception(t *testing.T, intc *interceptorItem, arg reflect.Value) {
  81         val := intc.Interceptor.Invoke(arg, &intc.Target)
  82         if !val.IsNil() {
  83                 t.Errorf("Failed (%v): Expected nil got %v", intc, val)
  84         }
  85 }