nsz Git - epoint/blob - pkg/document/document_test.go

   1 package document
   2
   3 import (
   4         "bytes"
   5         "crypto/openpgp"
   6         "testing"
   7 )
   8
   9 var signedData = []struct {
  10         text string
  11         ok   bool
  12         hash string
  13         body string
  14         sig  string
  15 }{
  16         {
  17                 `-----BEGIN PGP SIGNED MESSAGE-----
  18 Hash: SHA1
  19
  20 body
  21 -----BEGIN PGP SIGNATURE-----
  22 sig
  23 `, true, "SHA1", "body", "-----BEGIN PGP SIGNATURE-----\nsig\n"},
  24         {
  25                 `-----BEGIN PGP SIGNED MESSAGE-----
  26 Hash: SHA1
  27 Hash: SHA256
  28
  29 - body
  30 -----BEGIN PGP SIGNATURE-----
  31 sig
  32 `, false, "", "body", "-----BEGIN PGP SIGNATURE-----\nsig\n"},
  33 }
  34
  35 func TestSigned(t *testing.T) {
  36         for _, x := range signedData {
  37                 c, err := ParseSigned([]byte(x.text))
  38                 if err != nil {
  39                         t.Errorf("parsing %q failed: %s\n", x.text, err)
  40                         continue
  41                 }
  42                 if string(c.Body) != x.body {
  43                         t.Errorf("expected: %q, got %q\n", x.body, c.Body)
  44                 }
  45                 if string(c.Signature) != x.sig {
  46                         t.Errorf("expected: %q, got %q\n", x.sig, c.Signature)
  47                 }
  48         }
  49         for _, x := range signedData {
  50                 if !x.ok {
  51                         continue
  52                 }
  53                 c := &Signed{x.hash, []byte(x.body), []byte(x.sig)}
  54                 s, err := FormatSigned(c)
  55                 if err != nil {
  56                         t.Errorf("formating %#v failed: %s\n", c, err)
  57                         continue
  58                 }
  59                 if string(s) != x.text {
  60                         t.Errorf("expected: %q, got %q\n", x.text, s)
  61                 }
  62         }
  63 }
  64
  65 var docData = []struct {
  66         text string
  67         ok   bool
  68         t    string
  69         k    []string
  70         v    []string
  71 }{
  72         {
  73                 `Content-Type: text/vnd.epoint.draft; charset=utf-8
  74
  75 K1: v1
  76 K2-Foo: v 2
  77 K3: v 3
  78 `, true, "Draft", []string{"K1", "K2-Foo", "K3"}, []string{"v1", "v 2", "v 3"}},
  79         {
  80                 `Content-Type: text/vnd.epoint.debit; charset=utf-8
  81
  82 K1:  v1
  83 K2-Foo: v 2
  84 K3: v 3
  85 `, true, "DebitCert", []string{"K1", "K2-Foo", "K3"}, []string{" v1", "v 2", "v 3"}},
  86         {
  87                 `Content-Type: text/vnd.epoint.credit; charset=utf-8
  88
  89 K1: v1
  90 K2-Foo: v 2
  91 K3: v
  92  3
  93 `, false, "CreditCert", []string{"K1", "K2-Foo", "K3"}, []string{"v1", "v 2", "v 3"}},
  94 }
  95
  96 func TestDocument(t *testing.T) {
  97         for _, x := range docData {
  98                 doc, err := ParseDocument([]byte(x.text))
  99                 if err != nil {
 100                         t.Errorf("parsing %q failed: %s\n", x.text, err)
 101                         continue
 102                 }
 103                 if string(doc.Type) != x.t {
 104                         t.Errorf("expected: %q, got %q\n", x.t, doc.Type)
 105                 }
 106                 if len(doc.Fields) != len(x.k) {
 107                         t.Errorf("expected: %d fields, got %d\n", len(x.k), len(doc.Fields))
 108                 }
 109                 for i, k := range x.k {
 110                         if doc.Fields[k] != x.v[i] {
 111                                 t.Errorf("value of %s expected to be %s, got %s\n", k, x.v[i], doc.Fields[k])
 112                         }
 113                 }
 114         }
 115         for _, x := range docData {
 116                 if !x.ok {
 117                         continue
 118                 }
 119                 doc := new(Document)
 120                 doc.Type = x.t
 121                 doc.Fields = make(map[string]string)
 122                 doc.Order = x.k
 123                 for i, k := range x.k {
 124                         doc.Fields[k] = x.v[i]
 125                 }
 126                 s, err := FormatDocument(doc)
 127                 if err != nil {
 128                         t.Errorf("formating %#v failed: %s\n", doc, err)
 129                         continue
 130                 }
 131                 if string(s) != x.text {
 132                         t.Errorf("expected: %q, got %q\n", x.text, s)
 133                 }
 134         }
 135 }
 136
 137 const draftBody = `Content-Type: text/vnd.epoint.draft; charset=utf-8
 138
 139 Drawer: 000000000000000000000000000000000000000A
 140 Beneficiary: 000000000000000000000000000000000000000B
 141 Amount: 1
 142 Denomination: half euro
 143 Issuer: 000000000000000000000000000000000000000D
 144 Authorized-By: 000000000000000000000000000000000000000C
 145 Maturity-Date: 2011-11-13T12:20:35Z
 146 Expiry-Date: 2011-12-27T09:18:46Z
 147 Nonce: 42
 148 Notes: some notes
 149 `
 150
 151 func TestDraft(t *testing.T) {
 152         doc, err := ParseDocument([]byte(draftBody))
 153         if err != nil {
 154                 t.Errorf("ParseDocument failed: %s\n", err)
 155                 return
 156         }
 157         iv, err := ParseStruct(doc)
 158         if err != nil {
 159                 t.Errorf("ParseStruct %v failed: %s\n", doc, err)
 160                 return
 161         }
 162         d, ok := iv.(*Draft)
 163         if !ok {
 164                 t.Errorf("expected *Draft got %#v\n", iv)
 165                 return
 166         }
 167         doc, err = FormatStruct(d)
 168         if err != nil {
 169                 t.Errorf("format %v draft failed: %s\n", d, err)
 170                 return
 171         }
 172         s, err := FormatDocument(doc)
 173         if err != nil {
 174                 t.Errorf("format %v doc failed: %s\n", doc, err)
 175                 return
 176         }
 177         if string(s) != draftBody {
 178                 t.Errorf("parsed %#v\nexpected: %s\ngot: %s\n", d, draftBody, s)
 179         }
 180 }
 181
 182 const debitBody = `Content-Type: text/vnd.epoint.debit; charset=utf-8
 183
 184 Holder: 0000000000000000000000000000000000000009
 185 Serial: 13
 186 Balance: 23
 187 Denomination: half euro
 188 Issuer: 000000000000000000000000000000000000000B
 189 Date: 2011-11-13T12:20:35Z
 190 Authorized-By: 000000000000000000000000000000000000000A
 191 Notes: -
 192 Last-Debit-Serial: 0
 193 Last-Credit-Serial: 12
 194 Last-Cert: 000000000000000000000000000000000000000C
 195 References: 000000000000000000000000000000000000000C
 196  000000000000000000000000000000000000000F
 197 Difference: 1
 198 Draft: 000000000000000000000000000000000000000D
 199 Beneficiary: 000000000000000000000000000000000000000E
 200 `
 201
 202 func TestCert(t *testing.T) {
 203         doc, err := ParseDocument([]byte(debitBody))
 204         if err != nil {
 205                 t.Errorf("ParseDocument failed: %s\n", err)
 206                 return
 207         }
 208         iv, err := ParseStruct(doc)
 209         if err != nil {
 210                 t.Errorf("ParseStruct %v failed: %s\n", doc, err)
 211                 return
 212         }
 213         d, ok := iv.(*DebitCert)
 214         if !ok {
 215                 t.Errorf("expected *DebitCert got %#v\n", iv)
 216                 return
 217         }
 218         doc, err = FormatStruct(d)
 219         if err != nil {
 220                 t.Errorf("format %v draft failed: %s\n", d, err)
 221                 return
 222         }
 223         s, err := FormatDocument(doc)
 224         if err != nil {
 225                 t.Errorf("format %v doc failed: %s\n", doc, err)
 226                 return
 227         }
 228         if string(s) != debitBody {
 229                 t.Errorf("parsed %#v\nexpected: %s\ngot: %s\n", d, debitBody, s)
 230         }
 231 }
 232
 233 func parsekey(key []byte, t *testing.T) *openpgp.Entity {
 234         elist, err := openpgp.ReadArmoredKeyRing(bytes.NewBuffer(key))
 235         if err != nil {
 236                 t.Error(err)
 237                 return nil
 238         }
 239         if len(elist) != 1 {
 240                 t.Errorf("expected one key, got %d", len(elist))
 241                 return nil
 242         }
 243         return elist[0]
 244 }
 245
 246 func TestSign(t *testing.T) {
 247         k1 := parsekey(skey1, t)
 248         k2 := parsekey(pkey2, t)
 249         if k1 == nil || k2 == nil {
 250                 t.Errorf("parsing keys failed")
 251                 return
 252         }
 253         signed, err := Sign([]byte(debitBody), k1)
 254         if err != nil {
 255                 t.Errorf("Sign failed: %s", err)
 256                 return
 257         }
 258         err = Verify(signed, openpgp.EntityList{k1})
 259         if err != nil {
 260                 t.Errorf("Verify failed: %s", err)
 261         }
 262         err = Verify(signed, openpgp.EntityList{k2})
 263         if err == nil {
 264                 t.Errorf("Verify succeeded with wrong key")
 265         }
 266 }
 267
 268 var skey1 = []byte(`-----BEGIN PGP PRIVATE KEY BLOCK-----
 269
 270 xcD7BAAAAAARBACk0rlXXCXw5iK4aUOHEop5PhrSfRL/9LW6EaN879Mck1vLsKlE
 271 WBpubaEphvy6nWZmB9cdNlwoa5vLV/bZOL50mCt9dwzkOPA7CiCroC5WkUWMOdlu
 272 boauVkF27Rpt+6+27nZ0zF7c+f62FYRx+z+rU7oc4bpkxWJrnoWF/O9dMQCg////
 273 /////////yVOr555FtYHqq8D/36lyJh3e+S7KdzcRyiecY9ydMnNflcNPVUvOz7k
 274 PD3ve6aOV3hpJlIMyscduhPzfEBkOV1a8zNKBKvYztXn/0dsZhlTk26K3elqOdjE
 275 rBCAor4/6GOiSwi9Q4J+VK+tpyQzcE6jwS5Q5b0IwTDGihQC/CDaec/g3pMcQUNI
 276 0ysQBACIdEX3XRinq+oFm3+YFu5bC1Ewry7eVxukto18dtMJnU69oMjF3x7Uio5A
 277 kvYNWYPxdtLjEzk/HMo/3Mg6u/jK006CPqZRcx/m3B5R7gYb5D9PyF/tJsrht4nD
 278 eDuCAT00kHKYMElgwSzXg03cFcC5AEMf6U7MsrX1JLwY5Dq12gAAoOX6RPKzHB+1
 279 U7YCHnNg0H1dkf9eCuzNBklzc3VlcsJMBBMRCAAWBQIAAAAACRCRl3ps/DHg6wIZ
 280 AQIbAwAAIroAoBn5gA6TmLKXU9ASu+ENhV0UxowzAKA9Y/4CiQzAeCDcKIcWCg7W
 281 3r6Jow==
 282 =NVdT
 283 -----END PGP PRIVATE KEY BLOCK-----
 284 `)
 285
 286 var pkey2 = []byte(`-----BEGIN PGP PUBLIC KEY BLOCK-----
 287
 288 xsDiBAAAAAARBACk0rlXXCXw5iK4aUOHEop5PhrSfRL/9LW6EaN879Mck1vLsKlE
 289 WBpubaEphvy6nWZmB9cdNlwoa5vLV/bZOL50mCt9dwzkOPA7CiCroC5WkUWMOdlu
 290 boauVkF27Rpt+6+27nZ0zF7c+f62FYRx+z+rU7oc4bpkxWJrnoWF/O9dMQCg////
 291 /////////yVOr555FtYHqq8D/36lyJh3e+S7KdzcRyiecY9ydMnNflcNPVUvOz7k
 292 PD3ve6aOV3hpJlIMyscduhPzfEBkOV1a8zNKBKvYztXn/0dsZhlTk26K3elqOdjE
 293 rBCAor4/6GOiSwi9Q4J+VK+tpyQzcE6jwS5Q5b0IwTDGihQC/CDaec/g3pMcQUNI
 294 0ysQBACFl7Go0A5UqlnmwRmsLfvAEBM2+tsIoBlBDEwcgd+nJZzCQpAqO/OpSqHk
 295 Yx4imGcdknfPLkMmN+Kz9j4o0T+LZuYyblhuj2t1M9lf0Is/Go0Drf/7oc2KpHAo
 296 nfKu7fkM5nfZWFsgE9TxOz8SQa2RuuhpbkpB2k0Vg2TbqTpFeM0GSXNzdWVywkwE
 297 ExEIABYFAgAAAAAJEKqJF6U/VQ52AhkBAhsDAADIMwCgt/kmhRwmlzcnc1S3Qlfo
 298 BD0PBa8AoG5Vm9U4gzWQM/BzVxDToJPB1ZHf
 299 =MNqN
 300 -----END PGP PUBLIC KEY BLOCK-----
 301 `)