~rogpeppe/juju-core/438-local-instance-Addresses

« back to all changes in this revision

Viewing changes to rpc/rpc_test.go

  • Committer: Roger Peppe
  • Date: 2012-12-03 18:42:13 UTC
  • mto: (841.1.2 197-api-passwords)
  • mto: This revision was merged to the branch mainline in revision 883.
  • Revision ID: roger.peppe@canonical.com-20121203184213-9getgnjiipl2u2hm
rpc: initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
package rpc_test
 
2
import (
 
3
        . "launchpad.net/gocheck"
 
4
        "testing"
 
5
        "fmt"
 
6
        "launchpad.net/juju-core/rpc"
 
7
        "reflect"
 
8
        "strings"
 
9
)
 
10
 
 
11
type suite struct{}
 
12
var _ = Suite(suite{})
 
13
 
 
14
func TestAll(t *testing.T) {
 
15
        TestingT(t)
 
16
}
 
17
 
 
18
type TRoot struct {
 
19
        A string
 
20
        B int
 
21
        C TStruct
 
22
        //      D TIntWithMethods TODO
 
23
}
 
24
 
 
25
type TContext struct {
 
26
        S string
 
27
}
 
28
 
 
29
func (ctxt *TContext) String() string {
 
30
        if ctxt == nil {
 
31
                return "nil"
 
32
        }
 
33
        return ctxt.S
 
34
}
 
35
 
 
36
func (TRoot) CheckContext(ctxt *TContext) error {
 
37
        called(ctxt, "TRoot.CheckContext ")
 
38
        return nil
 
39
}
 
40
 
 
41
type TStruct struct {
 
42
        X string
 
43
}
 
44
 
 
45
func (TStruct) Method_0r0() {
 
46
        called(nil, "TStruct.Method_0r0")
 
47
}
 
48
func (TStruct) Method_c0r0(ctxt *TContext) {
 
49
        called(ctxt, "TStruct.Method_c0r0", ctxt)
 
50
}
 
51
func (TStruct) Method_1r0(x string) {
 
52
        called(nil, "TStruct.Method1r0", x)
 
53
}
 
54
func (TStruct) Method_c1r0(ctxt *TContext, x string) {
 
55
        called(ctxt, "TStruct.Method_c1r0", ctxt, x)
 
56
}
 
57
func (TStruct) Method_c2r0(ctxt *TContext, x, bogus string) {
 
58
        called(ctxt, "TStruct.Method_c2r0", ctxt, x, bogus)
 
59
}
 
60
func (TStruct) Method_0r0e() error {
 
61
        called(nil, "TStruct.Method_0r0e")
 
62
        return methodError("TStruct.Method_0r0e")
 
63
}
 
64
func (TStruct) Method_0r1() string {
 
65
        called(nil, "TStruct.Method_0r1")
 
66
        return "TStruct.Method_0r0e"
 
67
}
 
68
func (TStruct) Method_0r1e() (string, error) {
 
69
        called(nil, "TStruct.Method_0r1e")
 
70
        return "TStruct.Method_0r1e", nil
 
71
}
 
72
// TODO fill in other permutations
 
73
func (TStruct) Method_c1r1e(ctxt *TContext, x string) (int, error) {
 
74
        called(ctxt, "TStruct.Method_c1r1e", x)
 
75
        return 0, methodError("TStruct.Method_c1r1e")
 
76
}
 
77
 
 
78
func methodError(name string) error {
 
79
        return fmt.Errorf("method %s", name)
 
80
}
 
81
 
 
82
var root = &TRoot{
 
83
        A: "A",
 
84
        B: 99,
 
85
        C: TStruct{
 
86
                X: "X",
 
87
        },
 
88
}
 
89
 
 
90
var calls []string
 
91
func called(ctxt *TContext, args ...interface{}) {
 
92
        calls = append(calls, fmt.Sprintf("%v: %s", ctxt, fmt.Sprint(args)))
 
93
}
 
94
 
 
95
var tests = []struct{
 
96
        path string
 
97
        calls string
 
98
        arg interface{}
 
99
        ret interface{}
 
100
        err string
 
101
}{{
 
102
        path: "/A",
 
103
        ret: "A",
 
104
}, {
 
105
        path: "/B",
 
106
        ret: 99,
 
107
}, {
 
108
        path: "/C",
 
109
        ret: TStruct{X: "X"},
 
110
},  {
 
111
        path: "/C/X",
 
112
        ret: "X",
 
113
}, {
 
114
        path: "/C/Method_0r0",
 
115
        calls: "nil: TStruct.Method_0r0",
 
116
}, {
 
117
        path: "/C/Method_c1r1e",
 
118
        arg: "hello",
 
119
        calls: "ctxt: TStruct.Method_c1r1e hello",
 
120
        err: "method TStruct.Method_c1r1e",
 
121
}, {
 
122
        path: "/C/Method_c1r1e-hello",
 
123
        calls: "ctxt: TStruct.Method_c1r1e hello",
 
124
        err: "method TStruct.Method_c1r1e",
 
125
},
 
126
}
 
127
 
 
128
func (suite) TestCall(c *C) {
 
129
        ctxt := &TContext{"ctxt"}
 
130
        srv, err := rpc.NewServer(root)
 
131
        c.Assert(err, IsNil)
 
132
        for i, test := range tests {
 
133
                c.Logf("test %d: %s", i, test.path)
 
134
                calls = nil
 
135
                v, err := srv.Call(test.path, ctxt, reflect.ValueOf(test.arg))
 
136
                if test.err != "" {
 
137
                        c.Assert(err, ErrorMatches, test.err)
 
138
                } else {
 
139
                        c.Assert(err, IsNil)
 
140
                        c.Assert(strings.Join(calls, "; "), Equals, "TRoot.CheckContext; " + test.calls)
 
141
                        if test.ret == nil {
 
142
                                c.Assert(v.IsValid(), Equals, false)
 
143
                        } else {
 
144
                                c.Assert(v.Interface(), DeepEquals, test.ret)
 
145
                        }
 
146
                }
 
147
        }
 
148
}
 
 
b'\\ No newline at end of file'