1
2
3
4
5
6
7 package logger
8
9 import (
10 "testing"
11
12 "go.mongodb.org/mongo-driver/bson/primitive"
13 "go.mongodb.org/mongo-driver/internal/assert"
14 )
15
16 func verifySerialization(t *testing.T, got, want KeyValues) {
17 t.Helper()
18
19 for i := 0; i < len(got); i += 2 {
20 assert.Equal(t, want[i], got[i], "key position mismatch")
21 assert.Equal(t, want[i+1], got[i+1], "value position mismatch for %q", want[i])
22 }
23 }
24
25 func TestSerializeCommand(t *testing.T) {
26 t.Parallel()
27
28 serverConnectionID := int64(100)
29 serviceID := primitive.NewObjectID()
30
31 tests := []struct {
32 name string
33 cmd Command
34 extraKeysAndValues []interface{}
35 want KeyValues
36 }{
37 {
38 name: "empty",
39 want: KeyValues{
40 KeyCommandName, "",
41 KeyDatabaseName, "",
42 KeyDriverConnectionID, uint64(0),
43 KeyMessage, "",
44 KeyOperationID, int32(0),
45 KeyRequestID, int64(0),
46 KeyServerHost, "",
47 },
48 },
49 {
50 name: "complete Command object",
51 cmd: Command{
52 DriverConnectionID: 1,
53 Name: "foo",
54 DatabaseName: "db",
55 Message: "bar",
56 OperationID: 2,
57 RequestID: 3,
58 ServerHost: "localhost",
59 ServerPort: "27017",
60 ServerConnectionID: &serverConnectionID,
61 ServiceID: &serviceID,
62 },
63 want: KeyValues{
64 KeyCommandName, "foo",
65 KeyDatabaseName, "db",
66 KeyDriverConnectionID, uint64(1),
67 KeyMessage, "bar",
68 KeyOperationID, int32(2),
69 KeyRequestID, int64(3),
70 KeyServerHost, "localhost",
71 KeyServerPort, int64(27017),
72 KeyServerConnectionID, serverConnectionID,
73 KeyServiceID, serviceID.Hex(),
74 },
75 },
76 }
77
78 for _, test := range tests {
79 test := test
80
81 t.Run(test.name, func(t *testing.T) {
82 t.Parallel()
83
84 got := SerializeCommand(test.cmd, test.extraKeysAndValues...)
85 verifySerialization(t, got, test.want)
86 })
87 }
88 }
89
90 func TestSerializeConnection(t *testing.T) {
91 t.Parallel()
92
93 tests := []struct {
94 name string
95 conn Connection
96 extraKeysAndValues []interface{}
97 want KeyValues
98 }{
99 {
100 name: "empty",
101 want: KeyValues{
102 KeyMessage, "",
103 KeyServerHost, "",
104 },
105 },
106 {
107 name: "complete Connection object",
108 conn: Connection{
109 Message: "foo",
110 ServerHost: "localhost",
111 ServerPort: "27017",
112 },
113 want: KeyValues{
114 "message", "foo",
115 "serverHost", "localhost",
116 "serverPort", int64(27017),
117 },
118 },
119 }
120
121 for _, test := range tests {
122 test := test
123
124 t.Run(test.name, func(t *testing.T) {
125 t.Parallel()
126
127 got := SerializeConnection(test.conn, test.extraKeysAndValues...)
128 verifySerialization(t, got, test.want)
129 })
130 }
131 }
132
133 func TestSerializeServer(t *testing.T) {
134 t.Parallel()
135
136 topologyID := primitive.NewObjectID()
137 serverConnectionID := int64(100)
138
139 tests := []struct {
140 name string
141 srv Server
142 extraKeysAndValues []interface{}
143 want KeyValues
144 }{
145 {
146 name: "empty",
147 want: KeyValues{
148 KeyDriverConnectionID, uint64(0),
149 KeyMessage, "",
150 KeyServerHost, "",
151 KeyTopologyID, primitive.ObjectID{}.Hex(),
152 },
153 },
154 {
155 name: "complete Server object",
156 srv: Server{
157 DriverConnectionID: 1,
158 TopologyID: topologyID,
159 Message: "foo",
160 ServerConnectionID: &serverConnectionID,
161 ServerHost: "localhost",
162 ServerPort: "27017",
163 },
164 want: KeyValues{
165 KeyDriverConnectionID, uint64(1),
166 KeyMessage, "foo",
167 KeyServerHost, "localhost",
168 KeyTopologyID, topologyID.Hex(),
169 KeyServerConnectionID, serverConnectionID,
170 KeyServerPort, int64(27017),
171 },
172 },
173 }
174
175 for _, test := range tests {
176 test := test
177
178 t.Run(test.name, func(t *testing.T) {
179 t.Parallel()
180
181 got := SerializeServer(test.srv, test.extraKeysAndValues...)
182 verifySerialization(t, got, test.want)
183 })
184 }
185
186 }
187
188 func TestSerializeTopology(t *testing.T) {
189 t.Parallel()
190
191 topologyID := primitive.NewObjectID()
192
193 tests := []struct {
194 name string
195 topo Topology
196 extraKeysAndValues []interface{}
197 want KeyValues
198 }{
199 {
200 name: "empty",
201 want: KeyValues{
202 KeyTopologyID, primitive.ObjectID{}.Hex(),
203 },
204 },
205 {
206 name: "complete Server object",
207 topo: Topology{
208 ID: topologyID,
209 Message: "foo",
210 },
211 want: KeyValues{
212 KeyTopologyID, topologyID.Hex(),
213 KeyMessage, "foo",
214 },
215 },
216 }
217
218 for _, test := range tests {
219 test := test
220
221 t.Run(test.name, func(t *testing.T) {
222 t.Parallel()
223
224 got := SerializeTopology(test.topo, test.extraKeysAndValues...)
225 verifySerialization(t, got, test.want)
226 })
227 }
228
229 }
230
View as plain text