mirror of
https://github.com/zrepl/zrepl.git
synced 2024-11-23 08:54:12 +01:00
73c9033583
Don't use jobrun for daemon, just call JobDo() once, the job must organize stuff itself. Sacrifice all the oneshot commands, they will be reintroduced as client-calls to the daemon.
137 lines
3.3 KiB
Go
137 lines
3.3 KiB
Go
package cmd
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/zrepl/zrepl/util"
|
|
"github.com/zrepl/zrepl/zfs"
|
|
)
|
|
|
|
func TestSampleConfigsAreParsedWithoutErrors(t *testing.T) {
|
|
|
|
paths:= []string{
|
|
"./sampleconf/localbackup/host1.yml",
|
|
"./sampleconf/pullbackup/backuphost.yml",
|
|
"./sampleconf/pullbackup/productionhost.yml",
|
|
}
|
|
|
|
for _, p := range paths {
|
|
|
|
_, err := ParseConfig(p)
|
|
if err != nil {
|
|
t.Errorf("error parsing %s:\n%+v", p, err)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func TestParseRetentionGridStringParsing(t *testing.T) {
|
|
|
|
intervals, err := parseRetentionGridIntervalsString("2x10m(keep=2) | 1x1h | 3x1w")
|
|
|
|
assert.Nil(t, err)
|
|
assert.Len(t, intervals, 6)
|
|
proto := util.RetentionInterval{
|
|
KeepCount: 2,
|
|
Length: 10 * time.Minute,
|
|
}
|
|
assert.EqualValues(t, proto, intervals[0])
|
|
assert.EqualValues(t, proto, intervals[1])
|
|
|
|
proto.KeepCount = 1
|
|
proto.Length = 1 * time.Hour
|
|
assert.EqualValues(t, proto, intervals[2])
|
|
|
|
proto.Length = 7 * 24 * time.Hour
|
|
assert.EqualValues(t, proto, intervals[3])
|
|
assert.EqualValues(t, proto, intervals[4])
|
|
assert.EqualValues(t, proto, intervals[5])
|
|
|
|
intervals, err = parseRetentionGridIntervalsString("|")
|
|
assert.Error(t, err)
|
|
intervals, err = parseRetentionGridIntervalsString("2x10m")
|
|
assert.NoError(t, err)
|
|
|
|
intervals, err = parseRetentionGridIntervalsString("1x10m(keep=all)")
|
|
assert.NoError(t, err)
|
|
assert.Len(t, intervals, 1)
|
|
assert.EqualValues(t, util.RetentionGridKeepCountAll, intervals[0].KeepCount)
|
|
|
|
}
|
|
|
|
func TestDatasetMapFilter(t *testing.T) {
|
|
|
|
expectMapping := func(m map[string]string, from, to string) {
|
|
dmf, err := parseDatasetMapFilter(m, false)
|
|
if err != nil {
|
|
t.Logf("expect test map to be valid: %s", err)
|
|
t.FailNow()
|
|
}
|
|
fromPath, err := zfs.NewDatasetPath(from)
|
|
if err != nil {
|
|
t.Logf("expect test from path to be valid: %s", err)
|
|
t.FailNow()
|
|
}
|
|
toPath, err := zfs.NewDatasetPath(to)
|
|
if err != nil {
|
|
t.Logf("expect test to path to be valid: %s", err)
|
|
t.FailNow()
|
|
}
|
|
|
|
res, err := dmf.Map(fromPath)
|
|
t.Logf("%s => %s", fromPath.ToString(), res.ToString())
|
|
assert.Nil(t, err)
|
|
assert.True(t, res.Equal(toPath))
|
|
}
|
|
|
|
expectFilter := func(m map[string]string, path string, pass bool) {
|
|
dmf, err := parseDatasetMapFilter(m, true)
|
|
if err != nil {
|
|
t.Logf("expect test filter to be valid: %s", err)
|
|
t.FailNow()
|
|
}
|
|
p, err := zfs.NewDatasetPath(path)
|
|
if err != nil {
|
|
t.Logf("expect test path to be valid: %s", err)
|
|
t.FailNow()
|
|
}
|
|
res, err := dmf.Filter(p)
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, pass, res)
|
|
}
|
|
|
|
map1 := map[string]string{
|
|
"a/b/c<": "root1",
|
|
"a/b<": "root2",
|
|
"<": "root3/b/c",
|
|
"q<": "root4/1/2",
|
|
}
|
|
|
|
expectMapping(map1, "a/b/c", "root1")
|
|
expectMapping(map1, "a/b/c/d", "root1/d")
|
|
expectMapping(map1, "a/b/e", "root2/e")
|
|
expectMapping(map1, "a/b", "root2")
|
|
expectMapping(map1, "x", "root3/b/c")
|
|
expectMapping(map1, "x/y", "root3/b/c/y")
|
|
expectMapping(map1, "q", "root4/1/2")
|
|
expectMapping(map1, "q/r", "root4/1/2/r")
|
|
|
|
filter1 := map[string]string{
|
|
"<": "omit",
|
|
"a<": "ok",
|
|
"a/b<": "omit",
|
|
}
|
|
|
|
expectFilter(filter1, "b", false)
|
|
expectFilter(filter1, "a", true)
|
|
expectFilter(filter1, "a/d", true)
|
|
expectFilter(filter1, "a/b", false)
|
|
expectFilter(filter1, "a/b/c", false)
|
|
|
|
filter2 := map[string]string{}
|
|
expectFilter(filter2, "foo", false) // default to omit
|
|
|
|
}
|