equipment_test.gno
18.97 Kb · 486 lines
1package equipment
2
3import (
4 "chain"
5 "testing"
6
7 "gno.land/p/nt/testutils/v0"
8 "gno.land/p/nt/uassert/v0"
9 "gno.land/r/akkadia/beta/admin"
10)
11
12var equipmentTest = struct {
13 Admin, Operator, Owner, Other address
14 SetupDone bool
15}{
16 Admin: testutils.TestAddress("equipmentAdmin"),
17 Operator: testutils.TestAddress("equipmentOperator"),
18 Owner: testutils.TestAddress("equipmentOwner"),
19 Other: testutils.TestAddress("equipmentOther"),
20}
21
22func setupEquipmentTest(cur realm, t *testing.T) {
23 t.Helper()
24 resetEquipmentState()
25 testing.SetOriginSend(chain.Coins{})
26 if equipmentTest.SetupDone {
27 return
28 }
29 originalAdmin := admin.GetAdmin()
30 testing.SetOriginCaller(originalAdmin)
31 testing.SetRealm(testing.NewUserRealm(originalAdmin))
32 admin.TransferAdmin(cross(cur), equipmentTest.Admin)
33 testing.SetOriginCaller(equipmentTest.Admin)
34 testing.SetRealm(testing.NewUserRealm(equipmentTest.Admin))
35 admin.AcceptAdmin(cross(cur))
36 admin.SetOperator(cross(cur), equipmentTest.Operator)
37 equipmentTest.SetupDone = true
38}
39
40func TestMintAllocatesSequentialTokenIDs(cur realm, t *testing.T) {
41 setupEquipmentTest(cross(cur), t)
42 testing.SetOriginCaller(equipmentTest.Operator)
43 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
44 uassert.Equal(t, uint64(0), GetLatestTokenID())
45 first := Mint(cross(cur), equipmentTest.Owner, 0, "", "")
46 second := Mint(cross(cur), equipmentTest.Other, 0, "", "")
47 uassert.Equal(t, uint64(1), first)
48 uassert.Equal(t, uint64(2), second)
49 uassert.Equal(t, uint64(2), GetLatestTokenID())
50 uassert.Equal(t, equipmentTest.Owner, OwnerOf(1))
51 uassert.Equal(t, equipmentTest.Other, OwnerOf(2))
52 uassert.True(t, Has(1))
53 uassert.True(t, Has(2))
54 uassert.False(t, Has(3))
55
56 latestTokenID = maxEquipmentTokenID
57 uassert.AbortsWithMessage(t, cur, "equipment token id exhausted", func() {
58 Mint(cross(cur), equipmentTest.Owner, 0, "", "")
59 })
60}
61
62func TestEquipmentTransferAndBurn(cur realm, t *testing.T) {
63 setupEquipmentTest(cross(cur), t)
64 testing.SetOriginCaller(equipmentTest.Operator)
65 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
66 Mint(cross(cur), equipmentTest.Owner, 0, "", "")
67 testing.SetOriginCaller(equipmentTest.Owner)
68 testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
69 TransferFrom(cross(cur), equipmentTest.Owner, equipmentTest.Other, 1)
70 testing.SetOriginCaller(equipmentTest.Other)
71 testing.SetRealm(testing.NewUserRealm(equipmentTest.Other))
72 Burn(cross(cur), 1)
73 uassert.PanicsWithMessage(t, cur, "equipment metadata not found: 1", func() {
74 GetMetadata(1)
75 })
76 testing.SetOriginCaller(equipmentTest.Operator)
77 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
78 Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement", "3")
79 uassert.Equal(t, uint64(2), GetLatestTokenID())
80 uassert.Equal(t, equipmentTest.Owner, OwnerOf(2))
81 meta := GetMetadata(2)
82 uassert.Equal(t, "1101000", meta["definitionId"])
83 uassert.Equal(t, "3", meta["enhancement"])
84 uassert.True(t, meta[createdAtKey] != "")
85}
86
87func TestEquipmentApprovalAllowsTransferAndBurn(cur realm, t *testing.T) {
88 setupEquipmentTest(cross(cur), t)
89 testing.SetOriginCaller(equipmentTest.Operator)
90 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
91 Mint(cross(cur), equipmentTest.Owner, 0, "", "")
92 Mint(cross(cur), equipmentTest.Owner, 0, "", "")
93 testing.SetOriginCaller(equipmentTest.Owner)
94 testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
95 Approve(cross(cur), equipmentTest.Other, 1)
96 SetApprovalForAll(cross(cur), equipmentTest.Other, true)
97 testing.SetOriginCaller(equipmentTest.Other)
98 testing.SetRealm(testing.NewUserRealm(equipmentTest.Other))
99 TransferFrom(cross(cur), equipmentTest.Owner, equipmentTest.Admin, 1)
100 Burn(cross(cur), 2)
101 uassert.Equal(t, equipmentTest.Admin, OwnerOf(1))
102 uassert.Equal(t, int64(0), BalanceOf(equipmentTest.Owner))
103}
104
105func TestMintSecurity(cur realm, t *testing.T) {
106 setupEquipmentTest(cross(cur), t)
107 testing.SetOriginCaller(equipmentTest.Owner)
108 testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
109 uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
110 Mint(cross(cur), equipmentTest.Owner, 0, "", "")
111 })
112 testing.SetOriginCaller(equipmentTest.Operator)
113 testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/equipment_relay"))
114 uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
115 Mint(cross(cur), equipmentTest.Owner, 0, "", "")
116 })
117 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
118 testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
119 uassert.AbortsWithMessage(t, cur, "attached coins not allowed", func() {
120 Mint(cross(cur), equipmentTest.Owner, 0, "", "")
121 })
122}
123
124func TestEquipmentMetadata(cur realm, t *testing.T) {
125 setupEquipmentTest(cross(cur), t)
126 testing.SetOriginCaller(equipmentTest.Operator)
127 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
128 Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement,note", "3,a%2Cb")
129 meta := GetMetadata(1)
130 uassert.Equal(t, "1101000", meta["definitionId"])
131 uassert.Equal(t, "3", meta["enhancement"])
132 uassert.Equal(t, "a,b", meta["note"])
133 uassert.True(t, meta[createdAtKey] != "")
134 uassert.Equal(t, 4, len(meta))
135 meta["definitionId"] = "hacked"
136 uassert.Equal(t, "1101000", GetMetadata(1)["definitionId"])
137
138 cases := []struct {
139 keys, values, panicMsg string
140 }{
141 {"definitionId", "1", "reserved key: definitionId"},
142 {"tokenId", "1", "reserved key: tokenId"},
143 {"created_at", "1", "reserved key: created_at"},
144 {"a,a", "1,2", "attributes key duplicated: a"},
145 {"a,b", "1", "attributes keys and values count mismatch"},
146 {",a", "1,2", "attributes key must be not empty"},
147 }
148 for _, tc := range cases {
149 keys, values, panicMsg := tc.keys, tc.values, tc.panicMsg
150 uassert.AbortsWithMessage(t, cur, panicMsg, func() {
151 Mint(cross(cur), equipmentTest.Owner, 1, keys, values)
152 })
153 }
154 uassert.Equal(t, int64(1), BalanceOf(equipmentTest.Owner))
155 uassert.PanicsWithMessage(t, cur, "equipment metadata not found: 2", func() {
156 GetMetadata(2)
157 })
158}
159
160func TestEquipmentOwnedList(cur realm, t *testing.T) {
161 setupEquipmentTest(cross(cur), t)
162 testing.SetOriginCaller(equipmentTest.Operator)
163 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
164 uassert.Equal(t, 0, GetOwnedCount(equipmentTest.Owner))
165 uassert.Equal(t, 0, len(ListByOwner(equipmentTest.Owner, 1, 10)))
166 uassert.PanicsWithMessage(t, cur, "invalid equipment owner", func() {
167 GetOwnedCount(address(""))
168 })
169 uassert.PanicsWithMessage(t, cur, "page must be at least 1", func() {
170 ListByOwner(equipmentTest.Owner, 0, 1)
171 })
172 uassert.PanicsWithMessage(t, cur, "count must be at least 1", func() {
173 ListByOwner(equipmentTest.Owner, 1, 0)
174 })
175 uassert.PanicsWithMessage(t, cur, "count exceeds listLimit (max: 100)", func() {
176 ListByOwner(equipmentTest.Owner, 1, 101)
177 })
178 uassert.Equal(t, 100, GetListLimit())
179
180 Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement", "3")
181 Mint(cross(cur), equipmentTest.Owner, 1101001, "", "")
182 Mint(cross(cur), equipmentTest.Owner, 1101002, "", "")
183 uassert.Equal(t, 3, GetOwnedCount(equipmentTest.Owner))
184 uassert.Equal(t, int64(3), BalanceOf(equipmentTest.Owner))
185 page1 := ListByOwner(equipmentTest.Owner, 1, 2)
186 uassert.Equal(t, 2, len(page1))
187 uassert.Equal(t, "1", page1[0]["tokenId"])
188 uassert.Equal(t, "1101000", page1[0]["definitionId"])
189 uassert.Equal(t, "3", page1[0]["enhancement"])
190 uassert.Equal(t, "2", page1[1]["tokenId"])
191 page2 := ListByOwner(equipmentTest.Owner, 2, 2)
192 uassert.Equal(t, 1, len(page2))
193 uassert.Equal(t, "3", page2[0]["tokenId"])
194 uassert.Equal(t, 0, len(ListByOwner(equipmentTest.Owner, 3, 2)))
195 page1[0]["definitionId"] = "hacked"
196 uassert.Equal(t, "1101000", ListByOwner(equipmentTest.Owner, 1, 1)[0]["definitionId"])
197
198 testing.SetOriginCaller(equipmentTest.Owner)
199 testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
200 TransferFrom(cross(cur), equipmentTest.Owner, equipmentTest.Other, 1)
201 uassert.Equal(t, 2, GetOwnedCount(equipmentTest.Owner))
202 uassert.Equal(t, 1, GetOwnedCount(equipmentTest.Other))
203 uassert.Equal(t, "1", ListByOwner(equipmentTest.Other, 1, 10)[0]["tokenId"])
204 testing.SetOriginCaller(equipmentTest.Other)
205 testing.SetRealm(testing.NewUserRealm(equipmentTest.Other))
206 Burn(cross(cur), 1)
207 uassert.Equal(t, 0, GetOwnedCount(equipmentTest.Other))
208 uassert.Equal(t, 2, GetOwnedCount(equipmentTest.Owner))
209
210 testing.SetOriginCaller(equipmentTest.Operator)
211 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
212 Mint(cross(cur), equipmentTest.Admin, 1101999, "enhancement", "9")
213 uassert.Equal(t, uint64(4), GetLatestTokenID())
214 uassert.Equal(t, 1, GetOwnedCount(equipmentTest.Admin))
215 uassert.Equal(t, "4", ListByOwner(equipmentTest.Admin, 1, 1)[0]["tokenId"])
216 uassert.Equal(t, "1101999", ListByOwner(equipmentTest.Admin, 1, 1)[0]["definitionId"])
217 Mint(cross(cur), equipmentTest.Other, 1, "", "")
218 uassert.Equal(t, uint64(5), GetLatestTokenID())
219 uassert.Equal(t, 1, GetOwnedCount(equipmentTest.Other))
220}
221
222func TestSetListLimit(cur realm, t *testing.T) {
223 setupEquipmentTest(cross(cur), t)
224
225 testing.SetOriginCaller(equipmentTest.Admin)
226 testing.SetRealm(testing.NewUserRealm(equipmentTest.Admin))
227 SetListLimit(cross(cur), 50)
228 uassert.Equal(t, 50, GetListLimit())
229
230 SetListLimit(cross(cur), 1)
231 uassert.PanicsWithMessage(t, cur, "count exceeds listLimit (max: 1)", func() {
232 ListByOwner(equipmentTest.Owner, 1, 2)
233 })
234
235 uassert.AbortsWithMessage(t, cur, "limit must be at least 1", func() {
236 SetListLimit(cross(cur), 0)
237 })
238 uassert.AbortsWithMessage(t, cur, "limit must be at least 1", func() {
239 SetListLimit(cross(cur), -1)
240 })
241
242 testing.SetOriginCaller(equipmentTest.Operator)
243 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
244 uassert.AbortsWithMessage(t, cur, "admin access required", func() {
245 SetListLimit(cross(cur), 50)
246 })
247
248 testing.SetOriginCaller(equipmentTest.Owner)
249 testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
250 uassert.AbortsWithMessage(t, cur, "admin access required", func() {
251 SetListLimit(cross(cur), 50)
252 })
253
254 testing.SetOriginCaller(equipmentTest.Admin)
255 testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/equipment_admin_relay"))
256 uassert.AbortsWithMessage(t, cur, "admin access required", func() {
257 SetListLimit(cross(cur), 50)
258 })
259}
260
261func TestSetMinterRealm(cur realm, t *testing.T) {
262 setupEquipmentTest(cross(cur), t)
263 minterPath := "gno.land/r/example/equipment_minter"
264 minter := testing.NewCodeRealm(minterPath)
265 minterAddr := minter.Address()
266
267 uassert.Equal(t, minterAddr.String(), chain.PackageAddress(minterPath).String())
268 uassert.Equal(t, false, IsMinterRealm(minterAddr))
269
270 testing.SetOriginCaller(equipmentTest.Operator)
271 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
272 uassert.AbortsWithMessage(t, cur, "admin access required", func() {
273 SetMinterRealm(cross(cur), minterPath)
274 })
275
276 testing.SetOriginCaller(equipmentTest.Admin)
277 testing.SetRealm(testing.NewUserRealm(equipmentTest.Admin))
278 uassert.AbortsWithMessage(t, cur, "package path is required", func() {
279 SetMinterRealm(cross(cur), "")
280 })
281 uassert.AbortsWithMessage(t, cur, "invalid package path", func() {
282 SetMinterRealm(cross(cur), "gno.land/p/akkadia/beta/equipment")
283 })
284 SetMinterRealm(cross(cur), minterPath)
285 uassert.Equal(t, true, IsMinterRealm(minterAddr))
286 SetMinterRealm(cross(cur), minterPath)
287 uassert.Equal(t, true, IsMinterRealm(minterAddr))
288
289 UnsetMinterRealm(cross(cur), minterPath)
290 uassert.Equal(t, false, IsMinterRealm(minterAddr))
291 uassert.AbortsWithMessage(t, cur, "package path is not a minter realm", func() {
292 UnsetMinterRealm(cross(cur), minterPath)
293 })
294 uassert.AbortsWithMessage(t, cur, "package path is required", func() {
295 UnsetMinterRealm(cross(cur), "")
296 })
297
298 testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/equipment_admin_relay"))
299 uassert.AbortsWithMessage(t, cur, "admin access required", func() {
300 SetMinterRealm(cross(cur), minterPath)
301 })
302}
303
304func TestMintFromRealm(cur realm, t *testing.T) {
305 setupEquipmentTest(cross(cur), t)
306 minter := testing.NewCodeRealm("gno.land/r/example/equipment_minter")
307 unregistered := testing.NewCodeRealm("gno.land/r/example/equipment_minter_other")
308
309 testing.SetOriginCaller(equipmentTest.Owner)
310 testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
311 uassert.AbortsWithMessage(t, cur, "user calls not allowed: function must be called by a realm", func() {
312 MintFromRealm(cross(cur), equipmentTest.Owner, 0, "", "")
313 })
314
315 testing.SetRealm(unregistered)
316 uassert.AbortsWithMessage(t, cur, "minter realm required", func() {
317 MintFromRealm(cross(cur), equipmentTest.Owner, 0, "", "")
318 })
319
320 testing.SetOriginCaller(equipmentTest.Admin)
321 testing.SetRealm(testing.NewUserRealm(equipmentTest.Admin))
322 SetMinterRealm(cross(cur), "gno.land/r/example/equipment_minter")
323
324 testing.SetOriginCaller(equipmentTest.Owner)
325 testing.SetRealm(minter)
326 MintFromRealm(cross(cur), equipmentTest.Owner, 1101000, "enhancement", "3")
327 uassert.Equal(t, uint64(1), GetLatestTokenID())
328 uassert.Equal(t, equipmentTest.Owner, OwnerOf(1))
329 uassert.Equal(t, "1101000", GetMetadata(1)["definitionId"])
330 uassert.Equal(t, "3", GetMetadata(1)["enhancement"])
331 uassert.True(t, GetMetadata(1)[createdAtKey] != "")
332 uassert.Equal(t, 1, GetOwnedCount(equipmentTest.Owner))
333
334 uassert.AbortsWithMessage(t, cur, "equipment recipient must be origin caller", func() {
335 MintFromRealm(cross(cur), equipmentTest.Other, 0, "", "")
336 })
337 uassert.Equal(t, int64(1), BalanceOf(equipmentTest.Owner))
338
339 testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
340 MintFromRealm(cross(cur), equipmentTest.Owner, 1101001, "", "")
341 testing.SetOriginSend(chain.Coins{})
342 uassert.Equal(t, uint64(2), GetLatestTokenID())
343 uassert.Equal(t, equipmentTest.Owner, OwnerOf(2))
344}
345
346func TestBurnFromRealm(cur realm, t *testing.T) {
347 setupEquipmentTest(cross(cur), t)
348 minter := testing.NewCodeRealm("gno.land/r/example/equipment_minter")
349
350 testing.SetOriginCaller(equipmentTest.Operator)
351 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
352 Mint(cross(cur), equipmentTest.Owner, 0, "", "")
353 Mint(cross(cur), equipmentTest.Other, 0, "", "")
354
355 testing.SetOriginCaller(equipmentTest.Admin)
356 testing.SetRealm(testing.NewUserRealm(equipmentTest.Admin))
357 SetMinterRealm(cross(cur), "gno.land/r/example/equipment_minter")
358
359 testing.SetOriginCaller(equipmentTest.Owner)
360 testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
361 uassert.AbortsWithMessage(t, cur, "user calls not allowed: function must be called by a realm", func() {
362 BurnFromRealm(cross(cur), 1)
363 })
364
365 testing.SetRealm(minter)
366 uassert.AbortsWithMessage(t, cur, "equipment owner must be origin caller", func() {
367 BurnFromRealm(cross(cur), 2)
368 })
369 uassert.Equal(t, equipmentTest.Other, OwnerOf(2))
370
371 BurnFromRealm(cross(cur), 1)
372 uassert.Equal(t, int64(0), BalanceOf(equipmentTest.Owner))
373 uassert.PanicsWithMessage(t, cur, "equipment metadata not found: 1", func() {
374 GetMetadata(1)
375 })
376
377 testing.SetOriginCaller(equipmentTest.Operator)
378 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
379 Mint(cross(cur), equipmentTest.Owner, 1101000, "", "")
380
381 testing.SetOriginCaller(equipmentTest.Owner)
382 testing.SetRealm(minter)
383 uassert.AbortsWithMessage(t, cur, "reserved key: definitionId", func() {
384 MintFromRealm(cross(cur), equipmentTest.Owner, 1, "definitionId", "1")
385 })
386 uassert.Equal(t, equipmentTest.Owner, OwnerOf(3))
387 uassert.Equal(t, 1, GetOwnedCount(equipmentTest.Owner))
388 uassert.PanicsWithMessage(t, cur, "equipment metadata not found: 4", func() {
389 GetMetadata(4)
390 })
391
392 testing.SetOriginCaller(equipmentTest.Admin)
393 testing.SetRealm(testing.NewUserRealm(equipmentTest.Admin))
394 UnsetMinterRealm(cross(cur), "gno.land/r/example/equipment_minter")
395 testing.SetOriginCaller(equipmentTest.Owner)
396 testing.SetRealm(minter)
397 uassert.AbortsWithMessage(t, cur, "minter realm required", func() {
398 BurnFromRealm(cross(cur), 3)
399 })
400 uassert.Equal(t, equipmentTest.Owner, OwnerOf(3))
401}
402
403func TestSetMetadata(cur realm, t *testing.T) {
404 setupEquipmentTest(cross(cur), t)
405 testing.SetOriginCaller(equipmentTest.Operator)
406 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
407 Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement,note", "3,a%2Cb")
408 createdAt := GetMetadata(1)[createdAtKey]
409 uassert.True(t, createdAt != "")
410 SetMetadata(cross(cur), 1, "enhancement", "4")
411 meta := GetMetadata(1)
412 uassert.Equal(t, "1101000", meta["definitionId"])
413 uassert.Equal(t, "4", meta["enhancement"])
414 uassert.Equal(t, createdAt, meta[createdAtKey])
415 uassert.Equal(t, 3, len(meta))
416 uassert.Equal(t, "4", ListByOwner(equipmentTest.Owner, 1, 1)[0]["enhancement"])
417 meta["enhancement"] = "hacked"
418 uassert.Equal(t, "4", GetMetadata(1)["enhancement"])
419
420 uassert.AbortsWithMessage(t, cur, "reserved key: definitionId", func() {
421 SetMetadata(cross(cur), 1, "definitionId", "9")
422 })
423 uassert.AbortsWithMessage(t, cur, "reserved key: created_at", func() {
424 SetMetadata(cross(cur), 1, "created_at", "1")
425 })
426 uassert.AbortsWithMessage(t, cur, "equipment metadata not found: 2", func() {
427 SetMetadata(cross(cur), 2, "enhancement", "1")
428 })
429 uassert.Equal(t, "1101000", GetMetadata(1)["definitionId"])
430
431 testing.SetOriginCaller(equipmentTest.Owner)
432 testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
433 uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
434 SetMetadata(cross(cur), 1, "enhancement", "5")
435 })
436
437 testing.SetOriginCaller(equipmentTest.Operator)
438 testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/equipment_relay"))
439 uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
440 SetMetadata(cross(cur), 1, "enhancement", "5")
441 })
442}
443
444func TestSetMetadataFromRealm(cur realm, t *testing.T) {
445 setupEquipmentTest(cross(cur), t)
446 minterPath := "gno.land/r/example/equipment_minter"
447 minter := testing.NewCodeRealm(minterPath)
448
449 testing.SetOriginCaller(equipmentTest.Operator)
450 testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
451 Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement", "3")
452 Mint(cross(cur), equipmentTest.Other, 1101001, "enhancement", "1")
453
454 testing.SetOriginCaller(equipmentTest.Owner)
455 testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
456 uassert.AbortsWithMessage(t, cur, "user calls not allowed: function must be called by a realm", func() {
457 SetMetadataFromRealm(cross(cur), 1, "enhancement", "4")
458 })
459
460 testing.SetRealm(minter)
461 uassert.AbortsWithMessage(t, cur, "minter realm required", func() {
462 SetMetadataFromRealm(cross(cur), 1, "enhancement", "4")
463 })
464
465 testing.SetOriginCaller(equipmentTest.Admin)
466 testing.SetRealm(testing.NewUserRealm(equipmentTest.Admin))
467 SetMinterRealm(cross(cur), minterPath)
468
469 testing.SetOriginCaller(equipmentTest.Owner)
470 testing.SetRealm(minter)
471 uassert.AbortsWithMessage(t, cur, "equipment owner must be origin caller", func() {
472 SetMetadataFromRealm(cross(cur), 2, "enhancement", "9")
473 })
474 uassert.Equal(t, "1", GetMetadata(2)["enhancement"])
475
476 createdAt := GetMetadata(1)[createdAtKey]
477 SetMetadataFromRealm(cross(cur), 1, "enhancement", "4")
478 uassert.Equal(t, "1101000", GetMetadata(1)["definitionId"])
479 uassert.Equal(t, "4", GetMetadata(1)["enhancement"])
480 uassert.Equal(t, createdAt, GetMetadata(1)[createdAtKey])
481
482 testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
483 SetMetadataFromRealm(cross(cur), 1, "enhancement", "5")
484 testing.SetOriginSend(chain.Coins{})
485 uassert.Equal(t, "5", GetMetadata(1)["enhancement"])
486}