sum_test.go

package xsum_test

import (
	"bytes"
	"errors"
	"hash"
	"os"
	"path/filepath"
	"syscall"
	"testing"

	"golang.org/x/sync/semaphore"

	"github.com/sclevine/xsum"
)

func TestSum_EachList(t *testing.T) {
	sum := &xsum.Sum{Semaphore: semaphore.NewWeighted(2)}
	h := xsum.NewHashFunc("test", newDummyHash)
	mask := []byte{0x00, 0x8f, 0x28, 0x00, 0x40} // 0100
	tests := []struct {
		name  string
		files []xsum.File
		res   []sumResult
	}{
		{
			"files",
			[]xsum.File{
				{Hash: h, Path: "testdata/testdir", Mask: xsum.NewMask(0100, xsum.AttrEmpty)},
				{Hash: h, Path: "testdata/testdir", Mask: xsum.NewMask(0100, xsum.AttrNoData)},
				{Hash: h, Path: "testdata/testdir", Mask: xsum.NewMask(0100, xsum.AttrNoName)},
				{Hash: h, Path: "testdata/testdir", Mask: xsum.NewMask(0100, xsum.AttrFollow)},
				{Hash: h, Path: "testdata/testdir/testfile", Mask: xsum.NewMask(0000, xsum.AttrEmpty)},
			},
			[]sumResult{
				{
					sum: bl('{', 0x30, 0x7c,
						0x0a, 0x01, 0xff, // hashtype
						0x31, 0x77, // set
						0x30, 0x39, // testfilelink
						0x04, 0x29, '{', 0x30, 0x25, 0xa0, 0x11, 0x30, 0x0f, 0x0a, 0x01, -1, 0x04, 0x0a, '{', "testfile", '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x08, 0x00, 0x00, 0x40}, '}',
						0x04, 0x0c, "testfilelink",
						0x30, 0x3a, // testfile
						0x04, 0x2e, '{', 0x30, 0x2a, 0xa0, 0x16, 0x30, 0x14, 0x0a, 0x01, -1, 0x04, 0x0f, '{', "testcontents", 0x0a, '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x00, 0x00, 0x00, 0x00}, '}',
						0x04, 0x08, "testfile",
						'}'),
				},
				{
					sum: bl('{', 0x30, 0x51,
						0x0a, 0x01, 0xff, // hashtype
						0x31, 0x4c, // set
						0x30, 0x22, // testfile
						0x04, 0x16, '{', 0x30, 0x12, 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x00, 0x00, 0x00, 0x00}, '}',
						0x04, 0x08, "testfile",
						0x30, 0x26, // testfilelink
						0x04, 0x16, '{', 0x30, 0x12, 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x08, 0x00, 0x00, 0x40}, '}',
						0x04, 0x0c, "testfilelink",
						'}'),
				},
				{
					sum: bl('{', 0x30, 0x64,
						0x0a, 0x01, 0xff, // hashtype
						0x31, 0x5f, // set
						0x30, 0x2b, // testfilelink
						0x04, 0x29, '{', 0x30, 0x25, 0xa0, 0x11, 0x30, 0x0f, 0x0a, 0x01, -1, 0x04, 0x0a, '{', "testfile", '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x08, 0x00, 0x00, 0x40}, '}',
						0x30, 0x30, // testfile
						0x04, 0x2e, '{', 0x30, 0x2a, 0xa0, 0x16, 0x30, 0x14, 0x0a, 0x01, -1, 0x04, 0x0f, '{', "testcontents", 0x0a, '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x00, 0x00, 0x00, 0x00}, '}',
						'}'),
				},
				{
					sum: bl('{', 0x30, 0x81, 0x81,
						0x0a, 0x01, 0xff, // hashtype
						0x31, 0x7c, // set
						0x30, 0x3a, // testfile
						0x04, 0x2e, '{', 0x30, 0x2a, 0xa0, 0x16, 0x30, 0x14, 0x0a, 0x01, -1, 0x04, 0x0f, '{', "testcontents", 0x0a, '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x00, 0x00, 0x00, 0x00}, '}',
						0x04, 0x08, "testfile",
						0x30, 0x3e, // testfilelink
						0x04, 0x2e, '{', 0x30, 0x2a, 0xa0, 0x16, 0x30, 0x14, 0x0a, 0x01, -1, 0x04, 0x0f, '{', "testcontents", 0x0a, '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x00, 0x00, 0x00, 0x00}, '}',
						0x04, 0x0c, "testfilelink",
						'}'),
				},
				{sum: bl('{', "testcontents", 0x0a, '}')},
			},
		},
		{
			"links",
			[]xsum.File{
				{Hash: h, Path: "testdata/testdir/testfilelink", Mask: xsum.NewMask(0100, xsum.AttrEmpty)},
				{Hash: h, Path: "testdata/testdir/testfilelink", Mask: xsum.NewMask(0100, xsum.AttrInclusive)},
				{Hash: h, Path: "testdata/testdir/testfilelink", Mask: xsum.NewMask(0100, xsum.AttrFollow)},
				{Hash: h, Path: "testdata/testdir/testfilelink", Mask: xsum.NewMask(0100, xsum.AttrFollow|xsum.AttrInclusive)},
				{Hash: h, Path: "testdata/testdirlink", Mask: xsum.NewMask(0100, xsum.AttrEmpty)},
				{Hash: h, Path: "testdata/testdirlink", Mask: xsum.NewMask(0100, xsum.AttrInclusive)},
				{Hash: h, Path: "testdata/testdirlink", Mask: xsum.NewMask(0100, xsum.AttrFollow)},
				{Hash: h, Path: "testdata/testdirlink", Mask: xsum.NewMask(0100, xsum.AttrFollow|xsum.AttrInclusive)},
				{Hash: h, Path: "testdata/brokenlink", Mask: xsum.NewMask(0100, xsum.AttrEmpty)},
				{Hash: h, Path: "testdata/brokenlink", Mask: xsum.NewMask(0100, xsum.AttrInclusive)},
				{Hash: h, Path: "testdata/brokenlink", Mask: xsum.NewMask(0100, xsum.AttrFollow)},
				{Hash: h, Path: "testdata/brokenlink", Mask: xsum.NewMask(0100, xsum.AttrFollow|xsum.AttrInclusive)},
			},
			[]sumResult{
				{
					sum: bl('{', "testcontents", 0x0a, '}'),
				},
				{
					sum: bl('{', 0x30, 0x25,
						0xa0, 0x11, 0x30, 0x0f, 0x0a, 0x01, 0xff, 0x04, 0x0a, '{', "testfile", '}',
						0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, 0x00, 0x8f, 0x28, 0x00, 0x40, 0x03, 0x05, 0x00, 0x08, 0x00, 0x00, 0x40,
						'}'),
					lstat: true,
				},
				{
					sum: bl('{', "testcontents", 0x0a, '}'),
				},
				{
					sum: bl('{', 0x30, 0x2a,
						0xa0, 0x16, 0x30, 0x14, 0x0a, 0x01, 0xff, 0x04, 0x0f, '{', "testcontents", 0x0a, '}',
						0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, 0x00, 0x8f, 0x28, 0x00, 0x40, 0x03, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
						'}'),
				},
				{
					sum: bl('{', 0x30, 0x7c,
						0x0a, 0x01, 0xff, // hashtype
						0x31, 0x77, // set
						0x30, 0x39, // testfilelink
						0x04, 0x29, '{', 0x30, 0x25, 0xa0, 0x11, 0x30, 0x0f, 0x0a, 0x01, -1, 0x04, 0x0a, '{', "testfile", '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x08, 0x00, 0x00, 0x40}, '}',
						0x04, 0x0c, "testfilelink",
						0x30, 0x3a, // testfile
						0x04, 0x2e, '{', 0x30, 0x2a, 0xa0, 0x16, 0x30, 0x14, 0x0a, 0x01, -1, 0x04, 0x0f, '{', "testcontents", 0x0a, '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x00, 0x00, 0x00, 0x00}, '}',
						0x04, 0x08, "testfile",
						'}'),
				},
				{
					sum: bl('{', 0x30, 0x24,
						0xa0, 0x10, 0x30, 0x0e, 0x0a, 0x01, 0xff, 0x04, 0x09, '{', "testdir", '}',
						0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, 0x00, 0x8f, 0x28, 0x00, 0x40, 0x03, 0x05, 0x00, 0x08, 0x00, 0x00, 0x40,
						'}'),
					lstat: true,
				},
				{
					sum: bl('{', 0x30, 0x81, 0x81,
						0x0a, 0x01, 0xff, // hashtype
						0x31, 0x7c, // set
						0x30, 0x3a, // testfile
						0x04, 0x2e, '{', 0x30, 0x2a, 0xa0, 0x16, 0x30, 0x14, 0x0a, 0x01, -1, 0x04, 0x0f, '{', "testcontents", 0x0a, '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x00, 0x00, 0x00, 0x00}, '}',
						0x04, 0x08, "testfile",
						0x30, 0x3e, // testfilelink
						0x04, 0x2e, '{', 0x30, 0x2a, 0xa0, 0x16, 0x30, 0x14, 0x0a, 0x01, -1, 0x04, 0x0f, '{', "testcontents", 0x0a, '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x00, 0x00, 0x00, 0x00}, '}',
						0x04, 0x0c, "testfilelink",
						'}'),
				},
				{
					sum: bl('{', 0x30, 0x81, 0xa4,
						0xa0, 0x81, 0x8f, 0x30, 0x81, 0x8c, 0x0a, 0x01, 0xff, 0x04, 0x81, 0x86,
						'{', 0x30, 0x81, 0x81,
						0x0a, 0x01, 0xff, // hashtype
						0x31, 0x7c, // set
						0x30, 0x3a, // testfile
						0x04, 0x2e, '{', 0x30, 0x2a, 0xa0, 0x16, 0x30, 0x14, 0x0a, 0x01, -1, 0x04, 0x0f, '{', "testcontents", 0x0a, '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x00, 0x00, 0x00, 0x00}, '}',
						0x04, 0x08, "testfile",
						0x30, 0x3e, // testfilelink
						0x04, 0x2e, '{', 0x30, 0x2a, 0xa0, 0x16, 0x30, 0x14, 0x0a, 0x01, -1, 0x04, 0x0f, '{', "testcontents", 0x0a, '}', 0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, mask, 0x03, 0x05, []byte{0x00, 0x00, 0x00, 0x00, 0x00}, '}',
						0x04, 0x0c, "testfilelink",
						'}',
						0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, 0x00, 0x8f, 0x28, 0x00, 0x40, 0x03, 0x05, 0x00, 0x80, 0x00, 0x00, 0x40,
						'}'),
				},
				{
					err: errors.New("testdata/brokenlink: no such file or directory"),
				},
				{
					sum: bl('{', 0x30, 0x24,
						0xa0, 0x10, 0x30, 0x0e, 0x0a, 0x01, 0xff, 0x04, 0x09, '{', "invalid", '}',
						0xa1, 0x10, 0x30, 0x0e, 0x03, 0x05, 0x00, 0x8f, 0x28, 0x00, 0x40, 0x03, 0x05, 0x00, 0x08, 0x00, 0x00, 0x40,
						'}'),
					lstat: true,
				},
				{
					err: errors.New("testdata/brokenlink: no such file or directory"),
				},
				{
					err: errors.New("testdata/brokenlink: no such file or directory"),
				},
			},
		},
	}
	for _, tt := range tests {
		var nodes []*xsum.Node
		if err := sum.EachList(tt.files, func(node *xsum.Node) error {
			nodes = append(nodes, node)
			return nil
		}); err != nil {
			t.Errorf("xsum.EachList(`%s') error: %s", tt.name, err)
			continue
		}
		for i, node := range nodes {
			if node.File != tt.files[i] {
				t.Errorf("xsum.EachList(`%s#%d') Node file: %+v != %+v (expected)", tt.name, i, node.File, tt.files[i])
			}
			if nErr, rErr := node.Err, tt.res[i].err; (nErr != nil) != (rErr != nil) ||
				(rErr != nil && nErr.Error() != rErr.Error()) {
				t.Errorf("xsum.EachList(`%s#%d') error: %s", tt.name, i, node.Err)
				continue
			} else if rErr != nil {
				continue
			}
			if !bytes.Equal(node.Sum, tt.res[i].sum) {
				t.Errorf("xsum.EachList(`%s#%d') Node sum:\n% x\n!=\n% x\n(expected)", tt.name, i, node.Sum, tt.res[i].sum)
			}
			if tt.res[i].lstat {
				if m := lstatFileMode(t, tt.files[i].Path); node.Mode != m {
					t.Errorf("xsum.EachList(`%s#%d') Node lstat mode: %o != %o (expected)", tt.name, i, node.Mode, m)
				}
			} else {
				if m := statFileMode(t, tt.files[i].Path); node.Mode != m {
					t.Errorf("xsum.EachList(`%s#%d') Node stat mode: %o != %o (expected)", tt.name, i, node.Mode, m)
				}
			}
			if node.Sys.UID == nil || node.Sys.GID == nil {
				t.Errorf("xsum.EachList(`%s#%d') Node unexpected sys: %+v", tt.name, i, node.Sys)
			}
		}
	}
}

type sumResult struct {
	sum   []byte
	err   error
	lstat bool
}

func newDummyHash() hash.Hash {
	return &dummyHash{}
}

type dummyHash struct {
	b []byte
}

func (d *dummyHash) Write(p []byte) (n int, err error) {
	d.b = append(d.b, p...)
	return len(p), nil
}

func (d *dummyHash) Sum(b []byte) []byte {
	return append(b, append(append([]byte{'{'}, d.b...), '}')...)
}

func (d *dummyHash) Reset() {
	d.b = nil
}

func (d *dummyHash) Size() int {
	return len(d.b) + 2
}

func (d *dummyHash) BlockSize() int {
	return 64
}

func lstatFileMode(t *testing.T, path string) os.FileMode {
	t.Helper()
	fi, err := os.Lstat(path)
	if err != nil {
		t.Fatal(err)
	}
	return fi.Mode()
}

func statFileMode(t *testing.T, path string) os.FileMode {
	t.Helper()
	fi, err := os.Stat(path)
	if err != nil {
		t.Fatal(err)
	}
	return fi.Mode()
}

func bl(v ...interface{}) []byte {
	var out []byte
	for _, b := range v {
		switch b := b.(type) {
		case byte:
			out = append(out, b)
		case []byte:
			out = append(out, b...)
		case string:
			out = append(out, []byte(b)...)
		case int:
			out = append(out, byte(b))
		case rune:
			out = append(out, []byte(string([]rune{b}))...)
		}
	}
	return out
}

func mkdev(t *testing.T, dev int, mode os.FileMode) string {
	t.Helper()
	p, err := os.MkdirTemp("", "xsum-test")
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() {
		os.RemoveAll(p)
	})
	path := filepath.Join(p, "device")
	if err := syscall.Mknod(path, uint32(mode), dev); err != nil {
		t.Fatal(err)
	}
	return path
}