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

   1 package document
   2
   3 import (
   4         "testing"
   5 )
   6
   7 var signedData = []struct {
   8         text string
   9         ok   bool
  10         hash string
  11         body string
  12         sig  string
  13 }{
  14         {
  15                 `-----BEGIN PGP SIGNED MESSAGE-----
  16 Hash: SHA1
  17
  18 body
  19 -----BEGIN PGP SIGNATURE-----
  20 sig
  21 `, true, "SHA1", "body", "-----BEGIN PGP SIGNATURE-----\nsig\n"},
  22         {
  23                 `-----BEGIN PGP SIGNED MESSAGE-----
  24 Hash: SHA1
  25 Hash: SHA256
  26
  27 - body
  28 -----BEGIN PGP SIGNATURE-----
  29 sig
  30 `, false, "", "body", "-----BEGIN PGP SIGNATURE-----\nsig\n"},
  31 }
  32
  33 func TestSigned(t *testing.T) {
  34         for _, x := range signedData {
  35                 c, err := ParseSigned([]byte(x.text))
  36                 if err != nil {
  37                         t.Errorf("parsing %q failed: %s\n", x.text, err)
  38                         continue
  39                 }
  40                 if string(c.Body) != x.body {
  41                         t.Errorf("expected: %q, got %q\n", x.body, c.Body)
  42                 }
  43                 if string(c.Signature) != x.sig {
  44                         t.Errorf("expected: %q, got %q\n", x.sig, c.Signature)
  45                 }
  46         }
  47         for _, x := range signedData {
  48                 if !x.ok {
  49                         continue
  50                 }
  51                 c := &Signed{x.hash, []byte(x.body), []byte(x.sig)}
  52                 s, err := FormatSigned(c)
  53                 if err != nil {
  54                         t.Errorf("formating %#v failed: %s\n", c, err)
  55                         continue
  56                 }
  57                 if string(s) != x.text {
  58                         t.Errorf("expected: %q, got %q\n", x.text, s)
  59                 }
  60         }
  61 }
  62
  63 var docData = []struct {
  64         text string
  65         ok   bool
  66         t    string
  67         k    []string
  68         v    []string
  69 }{
  70         {
  71                 `Content-Type: text/vnd.epoint.draft; charset=utf-8
  72
  73 K1: v1
  74 K2-Foo: v 2
  75 K3: v 3
  76 `, true, "Draft", []string{"K1", "K2-Foo", "K3"}, []string{"v1", "v 2", "v 3"}},
  77         {
  78                 `Content-Type: text/vnd.epoint.debit; charset=utf-8
  79
  80 K1:  v1
  81 K2-Foo: v 2
  82 K3: v 3
  83 `, true, "DebitCert", []string{"K1", "K2-Foo", "K3"}, []string{" v1", "v 2", "v 3"}},
  84         {
  85                 `Content-Type: text/vnd.epoint.credit; charset=utf-8
  86
  87 K1: v1
  88 K2-Foo: v 2
  89 K3: v
  90  3
  91 `, false, "CreditCert", []string{"K1", "K2-Foo", "K3"}, []string{"v1", "v 2", "v 3"}},
  92 }
  93
  94 func TestDocument(t *testing.T) {
  95         for _, x := range docData {
  96                 doc, err := ParseDocument([]byte(x.text))
  97                 if err != nil {
  98                         t.Errorf("parsing %q failed: %s\n", x.text, err)
  99                         continue
 100                 }
 101                 if string(doc.Type) != x.t {
 102                         t.Errorf("expected: %q, got %q\n", x.t, doc.Type)
 103                 }
 104                 if len(doc.Fields) != len(x.k) {
 105                         t.Errorf("expected: %d fields, got %d\n", len(x.k), len(doc.Fields))
 106                 }
 107                 for i, k := range x.k {
 108                         if doc.Fields[k] != x.v[i] {
 109                                 t.Errorf("value of %s expected to be %s, got %s\n", k, x.v[i], doc.Fields[k])
 110                         }
 111                 }
 112         }
 113         for _, x := range docData {
 114                 if !x.ok {
 115                         continue
 116                 }
 117                 doc := new(Document)
 118                 doc.Type = x.t
 119                 doc.Fields = make(map[string]string)
 120                 doc.Order = x.k
 121                 for i, k := range x.k {
 122                         doc.Fields[k] = x.v[i]
 123                 }
 124                 s, err := FormatDocument(doc)
 125                 if err != nil {
 126                         t.Errorf("formating %#v failed: %s\n", doc, err)
 127                         continue
 128                 }
 129                 if string(s) != x.text {
 130                         t.Errorf("expected: %q, got %q\n", x.text, s)
 131                 }
 132         }
 133 }
 134
 135 const draftBody = `Content-Type: text/vnd.epoint.draft; charset=utf-8
 136
 137 Drawer: 000000000000000000000000000000000000000A
 138 Beneficiary: 000000000000000000000000000000000000000B
 139 Amount: 1
 140 Denomination: half euro
 141 Issuer: 000000000000000000000000000000000000000D
 142 Authorized-By: 000000000000000000000000000000000000000C
 143 Maturity-Date: 2011-11-13T12:20:35Z
 144 Expiry-Date: 2011-12-27T09:18:46Z
 145 Nonce: 42
 146 Notes: some notes
 147 `
 148
 149 func TestDraft(t *testing.T) {
 150         doc, err := ParseDocument([]byte(draftBody))
 151         if err != nil {
 152                 t.Errorf("ParseDocument failed: %s\n", err)
 153                 return
 154         }
 155         iv, err := ParseStruct(doc)
 156         if err != nil {
 157                 t.Errorf("ParseStruct %v failed: %s\n", doc, err)
 158                 return
 159         }
 160         d, ok := iv.(*Draft)
 161         if !ok {
 162                 t.Errorf("expected *Draft got %#v\n", iv)
 163                 return
 164         }
 165         doc, err = FormatStruct(d)
 166         if err != nil {
 167                 t.Errorf("format %v draft failed: %s\n", d, err)
 168                 return
 169         }
 170         s, err := FormatDocument(doc)
 171         if err != nil {
 172                 t.Errorf("format %v doc failed: %s\n", doc, err)
 173                 return
 174         }
 175         if string(s) != draftBody {
 176                 t.Errorf("parsed %#v\nexpected: %s\ngot: %s\n", d, draftBody, s)
 177         }
 178 }
 179
 180 const debitBody = `Content-Type: text/vnd.epoint.debit; charset=utf-8
 181
 182 Holder: 0000000000000000000000000000000000000009
 183 Serial: 13
 184 Balance: 23
 185 Denomination: half euro
 186 Issuer: 000000000000000000000000000000000000000B
 187 Date: 2011-11-13T12:20:35Z
 188 Authorized-By: 000000000000000000000000000000000000000A
 189 Notes: -
 190 Last-Debit-Serial: 0
 191 Last-Credit-Serial: 12
 192 Last-Cert: 000000000000000000000000000000000000000C
 193 References: 000000000000000000000000000000000000000C
 194  000000000000000000000000000000000000000F
 195 Difference: 1
 196 Draft: 000000000000000000000000000000000000000D
 197 Beneficiary: 000000000000000000000000000000000000000E
 198 `
 199
 200 func TestCert(t *testing.T) {
 201         doc, err := ParseDocument([]byte(debitBody))
 202         if err != nil {
 203                 t.Errorf("ParseDocument failed: %s\n", err)
 204                 return
 205         }
 206         iv, err := ParseStruct(doc)
 207         if err != nil {
 208                 t.Errorf("ParseStruct %v failed: %s\n", doc, err)
 209                 return
 210         }
 211         d, ok := iv.(*DebitCert)
 212         if !ok {
 213                 t.Errorf("expected *DebitCert got %#v\n", iv)
 214                 return
 215         }
 216         doc, err = FormatStruct(d)
 217         if err != nil {
 218                 t.Errorf("format %v draft failed: %s\n", d, err)
 219                 return
 220         }
 221         s, err := FormatDocument(doc)
 222         if err != nil {
 223                 t.Errorf("format %v doc failed: %s\n", doc, err)
 224                 return
 225         }
 226         if string(s) != debitBody {
 227                 t.Errorf("parsed %#v\nexpected: %s\ngot: %s\n", d, debitBody, s)
 228         }
 229 }