func TestIPv6Addr(t *testing.T) {
app := newTestApp()
flag := app.Flag("addr", "").ResolvedIP()
_, err := app.Parse([]string{"--addr", net.IPv6interfacelocalallnodes.String()})
assert.NoError(t, err)
assert.NotNil(t, *flag)
assert.Equal(t, net.IPv6interfacelocalallnodes, *flag)
}
func TestIPv4Addr(t *testing.T) {
app := newTestApp()
flag := app.Flag("addr", "").ResolvedIP()
_, err := app.Parse([]string{"--addr", net.IPv4(1, 2, 3, 4).String()})
assert.NoError(t, err)
assert.NotNil(t, *flag)
assert.Equal(t, net.IPv4(1, 2, 3, 4), *flag)
}
func TestRegexp(t *testing.T) {
app := newTestApp()
flag := app.Flag("reg", "").Regexp()
_, err := app.Parse([]string{"--reg", "^abc$"})
assert.NoError(t, err)
assert.NotNil(t, *flag)
assert.Equal(t, "^abc$", (*flag).String())
assert.Regexp(t, *flag, "abc")
assert.NotRegexp(t, *flag, "abcd")
}
func Test_Compression(t *testing.T) {
fc := &fakeCompressor{}
RegisterCompressor(CompressionAlgorithm_GZIP, fc)
fd := &fakeDecompressor{}
RegisterDecompressor(CompressionAlgorithm_GZIP, fd)
assert.EqualValues(t, false, fc.called)
buf := new(bytes.Buffer)
wc := wire.NewWriteContext(buf)
_, err := CompressWire(wc, &CompressionSettings{
Algorithm: CompressionAlgorithm_BROTLI,
Quality: 3,
})
assert.NotNil(t, err)
cwc, err := CompressWire(wc, &CompressionSettings{
Algorithm: CompressionAlgorithm_GZIP,
Quality: 3,
})
assert.NoError(t, err)
assert.EqualValues(t, true, fc.called)
assert.EqualValues(t, 3, fc.quality)
assert.NoError(t, cwc.WriteMessage(&SyncHeader{
FileIndex: 672,
}))
rc := wire.NewReadContext(bytes.NewReader(buf.Bytes()))
sh := &SyncHeader{}
assert.NoError(t, rc.ReadMessage(sh))
assert.EqualValues(t, 672, sh.FileIndex)
assert.NotNil(t, rc.ReadMessage(sh))
}
func Test_FanOut(t *testing.T) {
t.Logf("Testing fail fast...")
ts := &TestSink{
FailingBlock: BlockLocation{
FileIndex: 2,
BlockIndex: 2,
},
}
fos, err := NewFanOutSink(ts, 8)
assert.NoError(t, err)
fos.Start()
hadError := false
for i := 0; i < 8; i++ {
for j := 0; j < 8; j++ {
loc := BlockLocation{
FileIndex: int64(i),
BlockIndex: int64(j),
}
sErr := fos.Store(loc, []byte{})
if sErr != nil {
hadError = true
}
}
}
assert.True(t, hadError)
err = fos.Close()
assert.NoError(t, err)
t.Logf("Testing tail errors...")
fos, err = NewFanOutSink(ts, 8)
assert.NoError(t, err)
fos.Start()
// Store shouldn't err, just queue it...
err = fos.Store(ts.FailingBlock, []byte{})
assert.NoError(t, err)
// but close should catch the error
err = fos.Close()
assert.NotNil(t, err)
}