syncthing/lib/protocol/protocol_test.go

316 lines
6.7 KiB
Go
Raw Normal View History

2015-01-13 12:31:14 +00:00
// Copyright (C) 2014 The Protocol Authors.
2014-09-22 19:42:11 +00:00
package protocol
import (
"bytes"
2014-09-22 19:42:11 +00:00
"encoding/json"
2016-01-12 08:19:44 +00:00
"errors"
2014-09-22 19:42:11 +00:00
"io"
"io/ioutil"
2014-10-21 06:40:05 +00:00
"strings"
2014-09-22 19:42:11 +00:00
"testing"
"testing/quick"
2016-01-12 11:12:06 +00:00
"time"
2014-09-22 19:42:11 +00:00
"github.com/syncthing/syncthing/lib/rand"
2014-09-22 19:42:11 +00:00
)
var (
c0ID = NewDeviceID([]byte{1})
c1ID = NewDeviceID([]byte{2})
quickCfg = &quick.Config{}
2014-09-22 19:42:11 +00:00
)
func TestPing(t *testing.T) {
ar, aw := io.Pipe()
br, bw := io.Pipe()
c0 := NewConnection(c0ID, ar, bw, newTestModel(), "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection)
2015-07-10 06:34:54 +00:00
c0.Start()
c1 := NewConnection(c1ID, br, aw, newTestModel(), "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection)
2015-07-10 06:34:54 +00:00
c1.Start()
c0.ClusterConfig(ClusterConfig{})
c1.ClusterConfig(ClusterConfig{})
2014-09-22 19:42:11 +00:00
if ok := c0.ping(); !ok {
t.Error("c0 ping failed")
}
if ok := c1.ping(); !ok {
t.Error("c1 ping failed")
}
}
func TestClose(t *testing.T) {
m0 := newTestModel()
m1 := newTestModel()
ar, aw := io.Pipe()
br, bw := io.Pipe()
c0 := NewConnection(c0ID, ar, bw, m0, "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection)
2015-07-10 06:34:54 +00:00
c0.Start()
c1 := NewConnection(c1ID, br, aw, m1, "name", CompressAlways)
2015-07-10 06:34:54 +00:00
c1.Start()
c0.ClusterConfig(ClusterConfig{})
c1.ClusterConfig(ClusterConfig{})
2014-09-22 19:42:11 +00:00
2016-01-12 08:19:44 +00:00
c0.close(errors.New("manual close"))
2014-09-22 19:42:11 +00:00
<-c0.closed
2016-01-12 08:19:44 +00:00
if err := m0.closedError(); err == nil || !strings.Contains(err.Error(), "manual close") {
2014-09-22 19:42:11 +00:00
t.Fatal("Connection should be closed")
}
// None of these should panic, some should return an error
if c0.ping() {
t.Error("Ping should not return true")
}
c0.Index("default", nil)
c0.Index("default", nil)
2014-09-22 19:42:11 +00:00
if _, err := c0.Request("default", "foo", 0, 0, nil, false); err == nil {
2014-09-22 19:42:11 +00:00
t.Error("Request should return an error")
}
}
func TestMarshalIndexMessage(t *testing.T) {
2016-03-08 08:07:18 +00:00
if testing.Short() {
quickCfg.MaxCount = 10
}
f := func(m1 Index) bool {
2016-03-04 13:16:27 +00:00
if len(m1.Files) == 0 {
m1.Files = nil
}
2015-08-28 07:01:21 +00:00
for i, f := range m1.Files {
2016-02-02 11:48:09 +00:00
if len(f.Blocks) == 0 {
m1.Files[i].Blocks = nil
} else {
for j := range f.Blocks {
f.Blocks[j].Offset = 0
if len(f.Blocks[j].Hash) == 0 {
f.Blocks[j].Hash = nil
}
2014-09-22 19:42:11 +00:00
}
}
if len(f.Version.Counters) == 0 {
m1.Files[i].Version.Counters = nil
}
2014-09-22 19:42:11 +00:00
}
return testMarshal(t, "index", &m1, &Index{})
2014-09-22 19:42:11 +00:00
}
if err := quick.Check(f, quickCfg); err != nil {
t.Error(err)
}
}
func TestMarshalRequestMessage(t *testing.T) {
2016-03-08 08:07:18 +00:00
if testing.Short() {
quickCfg.MaxCount = 10
}
f := func(m1 Request) bool {
2016-03-04 13:16:27 +00:00
if len(m1.Hash) == 0 {
m1.Hash = nil
}
return testMarshal(t, "request", &m1, &Request{})
2014-09-22 19:42:11 +00:00
}
if err := quick.Check(f, quickCfg); err != nil {
t.Error(err)
}
}
func TestMarshalResponseMessage(t *testing.T) {
2016-03-08 08:07:18 +00:00
if testing.Short() {
quickCfg.MaxCount = 10
}
f := func(m1 Response) bool {
2014-09-22 19:42:11 +00:00
if len(m1.Data) == 0 {
m1.Data = nil
}
return testMarshal(t, "response", &m1, &Response{})
2014-09-22 19:42:11 +00:00
}
if err := quick.Check(f, quickCfg); err != nil {
t.Error(err)
}
}
func TestMarshalClusterConfigMessage(t *testing.T) {
2016-03-08 08:07:18 +00:00
if testing.Short() {
quickCfg.MaxCount = 10
}
f := func(m1 ClusterConfig) bool {
2016-03-04 13:16:27 +00:00
if len(m1.Folders) == 0 {
m1.Folders = nil
}
for i := range m1.Folders {
if len(m1.Folders[i].Devices) == 0 {
m1.Folders[i].Devices = nil
}
}
return testMarshal(t, "clusterconfig", &m1, &ClusterConfig{})
2014-09-22 19:42:11 +00:00
}
if err := quick.Check(f, quickCfg); err != nil {
t.Error(err)
}
}
func TestMarshalCloseMessage(t *testing.T) {
2016-03-08 08:07:18 +00:00
if testing.Short() {
quickCfg.MaxCount = 10
}
f := func(m1 Close) bool {
return testMarshal(t, "close", &m1, &Close{})
2014-09-22 19:42:11 +00:00
}
if err := quick.Check(f, quickCfg); err != nil {
t.Error(err)
}
}
func testMarshal(t *testing.T, prefix string, m1, m2 message) bool {
buf, err := m1.Marshal()
2014-09-22 19:42:11 +00:00
if err != nil {
t.Fatal(err)
}
err = m2.Unmarshal(buf)
2014-09-22 19:42:11 +00:00
if err != nil {
t.Fatal(err)
}
bs1, _ := json.MarshalIndent(m1, "", " ")
bs2, _ := json.MarshalIndent(m2, "", " ")
if !bytes.Equal(bs1, bs2) {
ioutil.WriteFile(prefix+"-1.txt", bs1, 0644)
ioutil.WriteFile(prefix+"-2.txt", bs1, 0644)
return false
2014-09-22 19:42:11 +00:00
}
2016-01-12 11:12:06 +00:00
return true
2016-01-12 11:12:06 +00:00
}
2016-01-20 19:37:48 +00:00
func TestMarshalledIndexMessageSize(t *testing.T) {
// We should be able to handle a 1 TiB file without
// blowing the default max message size.
if testing.Short() {
t.Skip("this test requires a lot of memory")
return
2016-01-20 19:37:48 +00:00
}
const (
maxMessageSize = MaxMessageLen
fileSize = 1 << 40
blockSize = BlockSize
)
f := FileInfo{
Name: "a normal length file name withoout any weird stuff.txt",
Type: FileInfoTypeFile,
Size: fileSize,
Permissions: 0666,
ModifiedS: time.Now().Unix(),
Version: Vector{Counters: []Counter{{ID: 1 << 60, Value: 1}, {ID: 2 << 60, Value: 1}}},
Blocks: make([]BlockInfo, fileSize/blockSize),
2016-01-20 19:37:48 +00:00
}
for i := 0; i < fileSize/blockSize; i++ {
f.Blocks[i].Offset = int64(i) * blockSize
f.Blocks[i].Size = blockSize
f.Blocks[i].Hash = []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 20, 1, 2, 3, 4, 5, 6, 7, 8, 9, 30, 1, 2}
2016-01-20 19:37:48 +00:00
}
idx := Index{
Folder: "some folder ID",
Files: []FileInfo{f},
2016-01-20 19:37:48 +00:00
}
msgSize := idx.ProtoSize()
if msgSize > maxMessageSize {
t.Errorf("Message size %d bytes is larger than max %d", msgSize, maxMessageSize)
2016-01-20 19:37:48 +00:00
}
}
func TestLZ4Compression(t *testing.T) {
c := new(rawConnection)
2016-01-20 19:37:48 +00:00
for i := 0; i < 10; i++ {
dataLen := 150 + rand.Intn(150)
data := make([]byte, dataLen)
_, err := io.ReadFull(rand.Reader, data[100:])
if err != nil {
t.Fatal(err)
}
comp, err := c.lz4Compress(data)
if err != nil {
t.Errorf("compressing %d bytes: %v", dataLen, err)
continue
}
res, err := c.lz4Decompress(comp)
if err != nil {
t.Errorf("decompressing %d bytes to %d: %v", len(comp), dataLen, err)
continue
}
if len(res) != len(data) {
t.Errorf("Incorrect len %d != expected %d", len(res), len(data))
}
if !bytes.Equal(data, res) {
t.Error("Incorrect decompressed data")
}
t.Logf("OK #%d, %d -> %d -> %d", i, dataLen, len(comp), dataLen)
2016-01-20 19:37:48 +00:00
}
}
func TestCheckFilename(t *testing.T) {
cases := []struct {
name string
ok bool
}{
// Valid filenames
{"foo", true},
{"foo/bar/baz", true},
{"foo/bar:baz", true}, // colon is ok in general, will be filtered on windows
{`\`, true}, // path separator on the wire is forward slash, so as above
{`\.`, true},
{`\..`, true},
{".foo", true},
{"foo..", true},
// Invalid filenames
{"foo/..", false},
{"foo/../bar", false},
{"../foo/../bar", false},
{"", false},
{".", false},
{"..", false},
{"/", false},
{"/.", false},
{"/..", false},
{"/foo", false},
{"./foo", false},
{"foo./", false},
{"foo/.", false},
{"foo/", false},
}
for _, tc := range cases {
err := checkFilename(tc.name)
if (err == nil) != tc.ok {
t.Errorf("Unexpected result for checkFilename(%q): %v", tc.name, err)
}
}
}