1  import unittest2
 2  
 3  import
 4    ../protobuf_serialization,
 5    ../protobuf_serialization/codec
 6  
 7  type
 8  #  TestEnum = enum
 9  #    A1 = 0
10  #    B1 = 1000
11  #    C1 = 1000000
12  
13    Basic {.proto3.} = object
14      a {.fieldNumber: 1, pint.}: uint64
15      b {.fieldNumber: 2.}: string
16      # TODO char is not a basic protobuf type c {.fieldNumber: 3.}: char
17  
18    Wrapped {.proto3.} = object
19      d {.fieldNumber: 1, sint.}: int32
20      e {.fieldNumber: 2, sint.}: int64
21      f {.fieldNumber: 3.}: Basic
22      g {.fieldNumber: 4.}: string
23      h {.fieldNumber: 5.}: bool
24      #i {.fieldNumber: 6.}: TestEnum
25  
26  discard Protobuf.supports(Basic)
27  discard Protobuf.supports(Wrapped)
28  
29  suite "Test Object Encoding/Decoding":
30    test "Can encode/decode objects":
31  
32      let
33        obj = Basic(a: 100, b: "Test string.") # TODO, c: 'C')
34        encoded = Protobuf.encode(obj)
35      check Protobuf.decode(encoded, Basic) == obj
36  
37    test "Can encode/decode a wrapper object":
38      let obj = Wrapped(
39        d: 300,
40        e: 200,
41        f: Basic(a: 100, b: "Test string."), # TODO, c: 'C'),
42        g: "Other test string.",
43        h: true
44      )
45      check Protobuf.decode(Protobuf.encode(obj), type(Wrapped)) == obj
46  
47    test "Can encode/decode partial object":
48      let
49        obj = Wrapped(
50          d: 300,
51          e: 200,
52          f: Basic(a: 100, b: "Test string."), # c: 'C'),
53          g: "Other test string.",
54          h: true
55        )
56        writer = memoryOutput()
57  
58      writer.writeField(1, sint32(obj.d))
59      writer.writeField(3, obj.f, pbytes)
60      writer.writeField(4, pstring(obj.g))
61  
62      let result = Protobuf.decode(writer.getOutput(), type(Wrapped))
63      check result.d == obj.d
64      check result.f == obj.f
65      check result.g == obj.g
66      check result.e == 0
67      check result.h == false
68  
69    test "Can encode/decode out of order object":
70      let
71        obj = Wrapped(
72          d: 300,
73          e: 200,
74          f: Basic(a: 100, b: "Test string."), # c: 'C'),
75          g: "Other test string.",
76          h: true
77        )
78        writer = memoryOutput()
79  
80      writer.writeField(3, obj.f, pbytes)
81      #writer.writeField(6, penum(obj.i))
82      writer.writeField(1, sint64(obj.d))
83      writer.writeField(2, sint64(obj.e))
84      writer.writeField(5, pbool(obj.h))
85      writer.writeField(4, pstring(obj.g))
86  
87      check Protobuf.decode(writer.getOutput(), type(Wrapped)) == obj
88  
89    test "Can read repeated fields":
90      let
91        writer = memoryOutput()
92        basic: Basic = Basic(b: "Initial string.")
93        repeated = "Repeated string."
94  
95      writer.writeField(2, pstring(basic.b))
96      writer.writeField(2, pstring(repeated))
97  
98      check Protobuf.decode(writer.getOutput(), type(Basic)) == Basic(b: repeated)