src/pkt_test.go

   1 /*
   2 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
   3 Copyright (C) 2016-2021 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, version 3 of the License.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 package nncp
  19
  20 import (
  21         "bytes"
  22         "crypto/rand"
  23         "io"
  24         "testing"
  25         "testing/quick"
  26
  27         xdr "github.com/davecgh/go-xdr/xdr2"
  28 )
  29
  30 func TestPktEncWrite(t *testing.T) {
  31         nodeOur, err := NewNodeGenerate()
  32         if err != nil {
  33                 panic(err)
  34         }
  35         nodeTheir, err := NewNodeGenerate()
  36         if err != nil {
  37                 panic(err)
  38         }
  39         f := func(
  40                 path string,
  41                 pathSize uint8,
  42                 dataSize uint32,
  43                 size, minSize uint16,
  44                 wrappers uint8,
  45         ) bool {
  46                 dataSize %= 1 << 20
  47                 data := make([]byte, dataSize)
  48                 if _, err = io.ReadFull(rand.Reader, data); err != nil {
  49                         panic(err)
  50                 }
  51                 var ct bytes.Buffer
  52                 if len(path) > int(pathSize) {
  53                         path = path[:int(pathSize)]
  54                 }
  55                 nice := uint8(123)
  56                 pkt, err := NewPkt(PktTypeFile, nice, []byte(path))
  57                 if err != nil {
  58                         panic(err)
  59                 }
  60                 wrappers %= 8
  61                 _, _, err = PktEncWrite(
  62                         nodeOur,
  63                         nodeTheir.Their(),
  64                         pkt,
  65                         nice,
  66                         int64(minSize),
  67                         MaxFileSize,
  68                         int(wrappers),
  69                         bytes.NewReader(data),
  70                         &ct,
  71                 )
  72                 if err != nil {
  73                         return false
  74                 }
  75                 var pktEnc PktEnc
  76                 if _, err = xdr.Unmarshal(&ct, &pktEnc); err != nil {
  77                         return false
  78                 }
  79                 if *pktEnc.Sender != *nodeOur.Id {
  80                         return false
  81                 }
  82                 return true
  83         }
  84         if err := quick.Check(f, nil); err != nil {
  85                 t.Error(err)
  86         }
  87 }
  88
  89 func TestPktEncRead(t *testing.T) {
  90         node1, err := NewNodeGenerate()
  91         if err != nil {
  92                 panic(err)
  93         }
  94         node2, err := NewNodeGenerate()
  95         if err != nil {
  96                 panic(err)
  97         }
  98         f := func(
  99                 path string,
 100                 pathSize uint8,
 101                 dataSize uint32,
 102                 minSize uint16,
 103                 wrappers uint8,
 104         ) bool {
 105                 dataSize %= 1 << 20
 106                 data := make([]byte, dataSize)
 107                 if _, err = io.ReadFull(rand.Reader, data); err != nil {
 108                         panic(err)
 109                 }
 110                 var ct bytes.Buffer
 111                 if len(path) > int(pathSize) {
 112                         path = path[:int(pathSize)]
 113                 }
 114                 nice := uint8(123)
 115                 pkt, err := NewPkt(PktTypeFile, nice, []byte(path))
 116                 if err != nil {
 117                         panic(err)
 118                 }
 119                 wrappers %= 8
 120                 _, _, err = PktEncWrite(
 121                         node1,
 122                         node2.Their(),
 123                         pkt,
 124                         nice,
 125                         int64(minSize),
 126                         MaxFileSize,
 127                         int(wrappers),
 128                         bytes.NewReader(data),
 129                         &ct,
 130                 )
 131                 if err != nil {
 132                         return false
 133                 }
 134                 var pt bytes.Buffer
 135                 nodes := make(map[NodeId]*Node)
 136                 nodes[*node1.Id] = node1.Their()
 137                 _, node, sizeGot, err := PktEncRead(node2, nodes, &ct, &pt, true, nil)
 138                 if err != nil {
 139                         return false
 140                 }
 141                 if *node.Id != *node1.Id {
 142                         return false
 143                 }
 144                 if sizeGot != int64(len(data)+int(PktOverhead)) {
 145                         return false
 146                 }
 147                 var pktBuf bytes.Buffer
 148                 xdr.Marshal(&pktBuf, &pkt)
 149                 return bytes.Compare(pt.Bytes(), append(pktBuf.Bytes(), data...)) == 0
 150         }
 151         if err := quick.Check(f, nil); err != nil {
 152                 t.Error(err)
 153         }
 154 }