File: invoker_test.go

package info (click to toggle)
golang-github-revel-revel 0.12.0+dfsg-4
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 828 kB
  • sloc: xml: 7; makefile: 4
file content (133 lines) | stat: -rw-r--r-- 3,318 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
package revel

import (
	"net/url"
	"reflect"
	"testing"
)

// These tests verify that Controllers are initialized properly, given the range
// of embedding possibilities..

type P struct{ *Controller }

type PN struct{ P }

type PNN struct{ PN }

// Embedded via two paths
type P2 struct{ *Controller }
type PP2 struct {
	*Controller // Need to embed this explicitly to avoid duplicate selector.
	P
	P2
	PNN
}

var GENERATIONS = []interface{}{P{}, PN{}, PNN{}}

func TestFindControllers(t *testing.T) {
	controllers = make(map[string]*ControllerType)
	RegisterController((*P)(nil), nil)
	RegisterController((*PN)(nil), nil)
	RegisterController((*PNN)(nil), nil)
	RegisterController((*PP2)(nil), nil)

	// Test construction of indexes to each *Controller
	checkSearchResults(t, P{}, [][]int{{0}})
	checkSearchResults(t, PN{}, [][]int{{0, 0}})
	checkSearchResults(t, PNN{}, [][]int{{0, 0, 0}})
	checkSearchResults(t, PP2{}, [][]int{{0}, {1, 0}, {2, 0}, {3, 0, 0, 0}})
}

func checkSearchResults(t *testing.T, obj interface{}, expected [][]int) {
	actual := findControllers(reflect.TypeOf(obj))
	if !reflect.DeepEqual(expected, actual) {
		t.Errorf("Indexes do not match.  expected %v actual %v", expected, actual)
	}
}

func TestSetAction(t *testing.T) {
	controllers = make(map[string]*ControllerType)
	RegisterController((*P)(nil), []*MethodType{{Name: "Method"}})
	RegisterController((*PNN)(nil), []*MethodType{{Name: "Method"}})
	RegisterController((*PP2)(nil), []*MethodType{{Name: "Method"}})

	// Test that all *revel.Controllers are initialized.
	c := &Controller{Name: "Test"}
	if err := c.SetAction("P", "Method"); err != nil {
		t.Error(err)
	} else if c.AppController.(*P).Controller != c {
		t.Errorf("P not initialized")
	}

	if err := c.SetAction("PNN", "Method"); err != nil {
		t.Error(err)
	} else if c.AppController.(*PNN).Controller != c {
		t.Errorf("PNN not initialized")
	}

	// PP2 has 4 different slots for *Controller.
	if err := c.SetAction("PP2", "Method"); err != nil {
		t.Error(err)
	} else if pp2 := c.AppController.(*PP2); pp2.Controller != c ||
		pp2.P.Controller != c ||
		pp2.P2.Controller != c ||
		pp2.PNN.Controller != c {
		t.Errorf("PP2 not initialized")
	}
}

func BenchmarkSetAction(b *testing.B) {
	type Mixin1 struct {
		*Controller
		x, y int
		foo  string
	}
	type Mixin2 struct {
		*Controller
		a, b float64
		bar  string
	}

	type Benchmark struct {
		*Controller
		Mixin1
		Mixin2
		user interface{}
		guy  string
	}

	RegisterController((*Mixin1)(nil), []*MethodType{{Name: "Method"}})
	RegisterController((*Mixin2)(nil), []*MethodType{{Name: "Method"}})
	RegisterController((*Benchmark)(nil), []*MethodType{{Name: "Method"}})
	c := Controller{
		RenderArgs: make(map[string]interface{}),
	}

	for i := 0; i < b.N; i++ {
		if err := c.SetAction("Benchmark", "Method"); err != nil {
			b.Errorf("Failed to set action: %s", err)
			return
		}
	}
}

func BenchmarkInvoker(b *testing.B) {
	startFakeBookingApp()
	c := Controller{
		RenderArgs: make(map[string]interface{}),
	}
	if err := c.SetAction("Hotels", "Show"); err != nil {
		b.Errorf("Failed to set action: %s", err)
		return
	}
	c.Request = NewRequest(showRequest)
	c.Params = &Params{Values: make(url.Values)}
	c.Params.Set("id", "3")

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ActionInvoker(&c, nil)
	}
}