Skip to content
Snippets Groups Projects
Commit 50b69bc6 authored by Jake Taylor's avatar Jake Taylor :lips:
Browse files

Merge branch 'XX-2700/MessageParseTesting' into 'release'

Add testing for message parsing

See merge request !481
parents cdb08989 59a33da6
No related branches found
No related tags found
No related merge requests found
///////////////////////////////////////////////////////////////////////////////
// Copyright © 2020 xx network SEZC //
// //
// Use of this source code is governed by a license that can be found in the //
// LICENSE file //
///////////////////////////////////////////////////////////////////////////////
package parse
import (
"bytes"
"gitlab.com/elixxir/client/interfaces/message"
"reflect"
"testing"
"time"
)
func TestnewFirstMessagePart(t *testing.T) {
now := time.Now()
fmp := newFirstMessagePart(message.Text, uint32(6), uint8(2), now,
[]byte{'t', 'e', 's', 't', 'i', 'n', 'g'})
// Expected firstMessagePart for checking against, generated by fmp in TestNewFirstMessagePart
var efmp = firstMessagePart{
messagePart: messagePart{
Data: []byte{0, 0, 4, 53, 0, 0, 13, 2, 0, 0, 0, 2, 1, 0, 0, 0, 14, 215, 133, 90, 117, 0, 0, 0, 0, 255, 255,
116, 101, 115, 116, 105, 110, 103, 115, 116, 114, 105, 110, 103},
Id: []byte{0, 0, 4, 53},
Part: []byte{0},
Len: []byte{0, 13},
Contents: []byte{116, 101, 115, 116, 105, 110, 103, 115, 116, 114, 105, 110, 103},
},
NumParts: []byte{2},
Type: []byte{0, 0, 0, 2},
Timestamp: []byte{1, 0, 0, 0, 14, 215, 133, 90, 117, 0, 0, 0, 0, 255, 255},
}
if fmp.GetType() != message.Text {
// Test that newFirstMessagePart returns a correctly made firstMessagePart
func TestNewFirstMessagePart(t *testing.T) {
fmp := newFirstMessagePart(
message.Text,
1077,
2,
time.Unix(1609786229, 0).UTC(),
[]byte{'t', 'e', 's', 't', 'i', 'n', 'g',
's', 't', 'r', 'i', 'n', 'g'},
)
gotTime, err := fmp.GetTimestamp()
if err != nil {
t.Error(err)
}
expectedTime, err := fmp.GetTimestamp()
if err != nil {
t.Error(err)
}
if !gotTime.Equal(expectedTime) {
t.Errorf("Got time: %v, expected time: %v", gotTime, expectedTime)
}
if !reflect.DeepEqual(fmp, efmp) {
t.Errorf("Expected and got firstMessagePart did not match.\n\tGot: %#v\n\tExpected: %#v", fmp, efmp)
}
}
if fmp.GetNumParts() != uint8(2) {
// Test that FirstMessagePartFromBytes returns a correctly made firstMessagePart from the bytes of one
func TestFirstMessagePartFromBytes(t *testing.T) {
fmp := FirstMessagePartFromBytes(efmp.Data)
if !reflect.DeepEqual(fmp, efmp) {
t.Error("Expected and got firstMessagePart did not match")
}
}
recorded_now, err := fmp.GetTimestamp()
if err != nil {
t.Fatal(err)
// Test that GetType returns the correct type for a firstMessagePart
func TestFirstMessagePart_GetType(t *testing.T) {
if efmp.GetType() != message.Text {
t.Errorf("Got %v, expected %v", efmp.GetType(), message.Text)
}
}
if recorded_now != now {
// Test that GetNumParts returns the correct number of parts for a firstMessagePart
func TestFirstMessagePart_GetNumParts(t *testing.T) {
if efmp.GetNumParts() != 2 {
t.Errorf("Got %v, expected %v", efmp.GetNumParts(), 2)
}
}
if !bytes.Equal(fmp.Bytes(), []byte{'t', 'e', 's', 't', 'i', 'n', 'g'}) {
// Test that GetTimestamp returns the correct timestamp for a firstMessagePart
func TestFirstMessagePart_GetTimestamp(t *testing.T) {
et, err := efmp.GetTimestamp()
if err != nil {
t.Error(err)
}
if !time.Unix(1609786229, 0).Equal(et) {
t.Errorf("Got %v, expected %v", et, time.Unix(1609786229, 0))
}
}
// Test that GetTimestamp returns the correct bytes for a firstMessagePart
func TestFirstMessagePart_Bytes(t *testing.T) {
if bytes.Compare(efmp.Bytes(), efmp.Data) != 0 {
t.Errorf("Got %v, expected %v", efmp.Bytes(), efmp.Data)
}
}
///////////////////////////////////////////////////////////////////////////////
// Copyright © 2020 xx network SEZC //
// //
// Use of this source code is governed by a license that can be found in the //
// LICENSE file //
///////////////////////////////////////////////////////////////////////////////
package parse
import (
"bytes"
"reflect"
"testing"
)
// Expected messagePart for checking against, generated by gotmp in Test_newMessagePart
var emp = messagePart{
Data: []uint8{0x0, 0x0, 0x0, 0x20, 0x6, 0x0, 0x7, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67},
Id: []uint8{0x0, 0x0, 0x0, 0x20}, Part: []uint8{0x6},
Len: []uint8{0x0, 0x7},
Contents: []uint8{0x74, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67},
}
// This tests that a new function part is successfully created
func Test_newMessagePart(t *testing.T) {
gotmp := newMessagePart(32, 6, []byte{'t', 'e', 's', 't', 'i', 'n', 'g'})
if !reflect.DeepEqual(gotmp, emp) {
t.Errorf("MessagePart received and MessagePart expected do not match.\n\tGot: %#v\n\tExpected: %#v", gotmp, emp)
}
}
// Test that GetID returns the correct ID
func TestMessagePart_GetID(t *testing.T) {
if emp.GetID() != 32 {
t.Errorf("received and expected do not match."+
"\n\tGot: %#v\n\tExpected: %#v", emp.GetID(), 32)
}
}
// Test that GetPart returns the correct part number
func TestMessagePart_GetPart(t *testing.T) {
if emp.GetPart() != 6 {
t.Errorf("received and expected do not match."+
"\n\tGot: %#v\n\tExpected: %#v", emp.GetPart(), 6)
}
}
// Test that GetContents returns the message contests
func TestMessagePart_GetContents(t *testing.T) {
if bytes.Compare(emp.GetContents(), []byte{'t', 'e', 's', 't', 'i', 'n', 'g'}) != 0 {
t.Errorf("received and expected do not match."+
"\n\tGot: %#v\n\tExpected: %#v", emp.GetContents(), 6)
}
}
// Test that GetSizedContents returns the message contests
func TestMessagePart_GetSizedContents(t *testing.T) {
if bytes.Compare(emp.GetSizedContents(), []byte{'t', 'e', 's', 't', 'i', 'n', 'g'}) != 0 {
t.Errorf("received and expected do not match."+
"\n\tGot: %#v\n\tExpected: %#v", emp.GetSizedContents(), 6)
}
}
// Test that GetContentsLength returns the message length
func TestMessagePart_GetContentsLength(t *testing.T) {
if emp.GetContentsLength() != 7 {
t.Errorf("received and expected do not match."+
"\n\tGot: %#v\n\tExpected: %#v", emp.GetContentsLength(), 7)
}
}
///////////////////////////////////////////////////////////////////////////////
// Copyright © 2020 xx network SEZC //
// //
// Use of this source code is governed by a license that can be found in the //
// LICENSE file //
///////////////////////////////////////////////////////////////////////////////
package parse
import (
"gitlab.com/elixxir/client/interfaces/message"
"gitlab.com/elixxir/client/storage"
"gitlab.com/xx_network/primitives/id"
"testing"
"time"
)
var ipsumTestStr = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras sit amet euismod est. Donec dolor " +
"neque, efficitur et interdum eu, lacinia quis mi. Duis bibendum elit ac lacus finibus pharetra. Suspendisse " +
"blandit erat in odio faucibus consectetur. Suspendisse sed consequat purus. Curabitur fringilla mi sit amet odio " +
"interdum suscipit. Etiam vitae dui posuere, congue mi a, convallis odio. In commodo risus at lorem volutpat " +
"placerat. In cursus magna purus, suscipit dictum lorem aliquam non. Praesent efficitur."
// Test that NewPartitioner outputs a correctly made Partitioner
func TestNewPartitioner(t *testing.T) {
storeSession := storage.InitTestingSession(t)
p := NewPartitioner(4096, storeSession)
if p.baseMessageSize != 4096 {
t.Errorf("baseMessageSize content mismatch"+
"\n\texpected: %v\n\treceived: %v",
4096, p.baseMessageSize)
}
if p.deltaFirstPart != 20 {
t.Errorf("deltaFirstPart content mismatch"+
"\n\texpected: %v\n\treceived: %v",
20, p.deltaFirstPart)
}
if p.firstContentsSize != 4069 {
t.Errorf("firstContentsSize content mismatch"+
"\n\texpected: %v\n\treceived: %v",
4069, p.firstContentsSize)
}
if p.maxSize != 1042675 {
t.Errorf("maxSize content mismatch"+
"\n\texpected: %v\n\treceived: %v",
1042675, p.maxSize)
}
if p.partContentsSize != 4089 {
t.Errorf("partContentsSize content mismatch"+
"\n\texpected: %v\n\treceived: %v",
4089, p.partContentsSize)
}
if p.session != storeSession {
t.Errorf("session content mismatch")
}
}
// Test that no error is returned running Partition
func TestPartitioner_Partition(t *testing.T) {
storeSession := storage.InitTestingSession(t)
p := NewPartitioner(len(ipsumTestStr), storeSession)
_, _, err := p.Partition(&id.DummyUser, message.Text,
time.Now(), []byte(ipsumTestStr))
if err != nil {
t.Error(err)
}
}
// Test that HandlePartition can handle a message part
func TestPartitioner_HandlePartition(t *testing.T) {
storeSession := storage.InitTestingSession(t)
p := NewPartitioner(len(ipsumTestStr), storeSession)
m := newMessagePart(1107, 1, []byte(ipsumTestStr))
_, _ = p.HandlePartition(
&id.DummyUser,
message.None,
m.Bytes(),
[]byte{'t', 'e', 's', 't', 'i', 'n', 'g',
's', 't', 'r', 'i', 'n', 'g'},
)
}
// Test that HandlePartition can handle a first message part
func TestPartitioner_HandleFirstPartition(t *testing.T) {
storeSession := storage.InitTestingSession(t)
p := NewPartitioner(len(ipsumTestStr), storeSession)
m := newFirstMessagePart(message.Text, 1107, 1, time.Now(), []byte(ipsumTestStr))
_, _ = p.HandlePartition(
&id.DummyUser,
message.None,
m.Bytes(),
[]byte{'t', 'e', 's', 't', 'i', 'n', 'g',
's', 't', 'r', 'i', 'n', 'g'},
)
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment