177 lines
4.7 KiB
Go
177 lines
4.7 KiB
Go
|
// Licensed to Elasticsearch B.V. under one or more contributor
|
||
|
// license agreements. See the NOTICE file distributed with
|
||
|
// this work for additional information regarding copyright
|
||
|
// ownership. Elasticsearch B.V. licenses this file to you under
|
||
|
// the Apache License, Version 2.0 (the "License"); you may
|
||
|
// not use this file except in compliance with the License.
|
||
|
// You may obtain a copy of the License at
|
||
|
//
|
||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||
|
//
|
||
|
// Unless required by applicable law or agreed to in writing,
|
||
|
// software distributed under the License is distributed on an
|
||
|
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||
|
// KIND, either express or implied. See the License for the
|
||
|
// specific language governing permissions and limitations
|
||
|
// under the License.
|
||
|
|
||
|
package syslog
|
||
|
|
||
|
import (
|
||
|
"fmt"
|
||
|
"strconv"
|
||
|
"testing"
|
||
|
"time"
|
||
|
|
||
|
"github.com/stretchr/testify/assert"
|
||
|
)
|
||
|
|
||
|
func TestSeverity(t *testing.T) {
|
||
|
e := newEvent()
|
||
|
e.SetPriority([]byte("13"))
|
||
|
assert.Equal(t, 5, e.Severity())
|
||
|
}
|
||
|
|
||
|
func TestFacility(t *testing.T) {
|
||
|
e := newEvent()
|
||
|
e.SetPriority([]byte("13"))
|
||
|
assert.Equal(t, 1, e.Facility())
|
||
|
}
|
||
|
|
||
|
func TestHasPriority(t *testing.T) {
|
||
|
e := newEvent()
|
||
|
e.SetPriority([]byte("13"))
|
||
|
assert.True(t, e.HasPriority())
|
||
|
assert.Equal(t, 13, e.Priority())
|
||
|
assert.Equal(t, 5, e.Severity())
|
||
|
assert.Equal(t, 1, e.Facility())
|
||
|
}
|
||
|
|
||
|
func TestNoPrioritySet(t *testing.T) {
|
||
|
e := newEvent()
|
||
|
assert.False(t, e.HasPriority())
|
||
|
assert.Equal(t, -1, e.Priority())
|
||
|
assert.Equal(t, -1, e.Severity())
|
||
|
assert.Equal(t, -1, e.Facility())
|
||
|
}
|
||
|
|
||
|
func TestHasPid(t *testing.T) {
|
||
|
e := newEvent()
|
||
|
assert.False(t, e.HasPid())
|
||
|
e.SetPid([]byte(strconv.Itoa(20)))
|
||
|
assert.True(t, e.HasPid())
|
||
|
}
|
||
|
|
||
|
func TestDateParsing(t *testing.T) {
|
||
|
// 2018-09-12T18:14:04.537585-07:00
|
||
|
e := newEvent()
|
||
|
e.SetYear([]byte("2018"))
|
||
|
e.SetDay(itb(12))
|
||
|
e.SetMonth([]byte("Sept"))
|
||
|
e.SetHour(itb(18))
|
||
|
e.SetMinute(itb(14))
|
||
|
e.SetSecond(itb(04))
|
||
|
e.SetNanosecond(itb(5555))
|
||
|
|
||
|
// Use google parser to compare.
|
||
|
t1, _ := time.Parse(time.RFC3339, "2018-09-12T18:14:04.5555-07:00")
|
||
|
t1 = t1.UTC()
|
||
|
t2, _ := time.Parse(time.RFC3339, "2018-09-12T18:14:04.5555+07:00")
|
||
|
t2 = t2.UTC()
|
||
|
alreadyutc := time.Date(2018, 9, 12, 18, 14, 04, 555500000, time.UTC)
|
||
|
|
||
|
tests := []struct {
|
||
|
name string
|
||
|
tzBytes []byte
|
||
|
expected time.Time
|
||
|
}{
|
||
|
{name: "-07:00", tzBytes: []byte("-07:00"), expected: t1},
|
||
|
{name: "-0700", tzBytes: []byte("-0700"), expected: t1},
|
||
|
{name: "-07", tzBytes: []byte("-07"), expected: t1},
|
||
|
{name: "+07:00", tzBytes: []byte("+07:00"), expected: t2},
|
||
|
{name: "+0700", tzBytes: []byte("+0700"), expected: t2},
|
||
|
{name: "+07", tzBytes: []byte("+07"), expected: t2},
|
||
|
{name: "z+00:00", tzBytes: []byte("z+00:00"), expected: alreadyutc},
|
||
|
{name: "z+0000", tzBytes: []byte("z+0000"), expected: alreadyutc},
|
||
|
{name: "z+00", tzBytes: []byte("z+00"), expected: alreadyutc},
|
||
|
{name: "Z+00:00", tzBytes: []byte("Z+00:00"), expected: alreadyutc},
|
||
|
{name: "Z+0000", tzBytes: []byte("Z+0000"), expected: alreadyutc},
|
||
|
{name: "Z+00", tzBytes: []byte("Z+00"), expected: alreadyutc},
|
||
|
}
|
||
|
|
||
|
for _, test := range tests {
|
||
|
t.Run(test.name, func(t *testing.T) {
|
||
|
e.SetTimeZone(test.tzBytes)
|
||
|
new := e.Timestamp(nil)
|
||
|
assert.Equal(t, test.expected, new)
|
||
|
})
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestNanosecondParsing(t *testing.T) {
|
||
|
e := newEvent()
|
||
|
e.SetYear([]byte("2018"))
|
||
|
e.SetDay(itb(12))
|
||
|
e.SetMonth([]byte("Sept"))
|
||
|
e.SetHour(itb(18))
|
||
|
e.SetMinute(itb(14))
|
||
|
e.SetSecond(itb(04))
|
||
|
|
||
|
// Use google parser to compare.
|
||
|
dt := func(s string) int {
|
||
|
ti, _ := time.Parse(time.RFC3339, s)
|
||
|
return ti.UTC().Nanosecond()
|
||
|
}
|
||
|
|
||
|
tests := []struct {
|
||
|
name string
|
||
|
nanosecond []byte
|
||
|
expected int
|
||
|
}{
|
||
|
{nanosecond: []byte("5555"), expected: dt("2018-09-12T18:14:04.5555-07:00")},
|
||
|
{nanosecond: []byte("5"), expected: dt("2018-09-12T18:14:04.5-07:00")},
|
||
|
{nanosecond: []byte("0005"), expected: dt("2018-09-12T18:14:04.0005-07:00")},
|
||
|
{nanosecond: []byte("000545"), expected: dt("2018-09-12T18:14:04.000545-07:00")},
|
||
|
{nanosecond: []byte("00012345"), expected: dt("2018-09-12T18:14:04.00012345-07:00")},
|
||
|
}
|
||
|
|
||
|
for _, test := range tests {
|
||
|
t.Run(string(test.nanosecond), func(t *testing.T) {
|
||
|
e.SetNanosecond(test.nanosecond)
|
||
|
assert.Equal(t, test.expected, e.Nanosecond())
|
||
|
})
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func TestIsValid(t *testing.T) {
|
||
|
e := newEvent()
|
||
|
assert.False(t, e.IsValid())
|
||
|
|
||
|
now := time.Now()
|
||
|
|
||
|
e.SetDay(itb(now.Day()))
|
||
|
assert.False(t, e.IsValid())
|
||
|
|
||
|
e.SetMonth([]byte(now.Month().String()))
|
||
|
assert.False(t, e.IsValid())
|
||
|
|
||
|
e.SetHour(itb(now.Hour()))
|
||
|
assert.False(t, e.IsValid())
|
||
|
|
||
|
e.SetMinute(itb(now.Minute()))
|
||
|
assert.False(t, e.IsValid())
|
||
|
|
||
|
e.SetSecond(itb(now.Second()))
|
||
|
assert.False(t, e.IsValid())
|
||
|
|
||
|
e.SetMessage([]byte("hello world"))
|
||
|
assert.True(t, e.IsValid())
|
||
|
}
|
||
|
|
||
|
func itb(i int) []byte {
|
||
|
if i < 10 {
|
||
|
return []byte(fmt.Sprintf("0%d", i))
|
||
|
}
|
||
|
return []byte(strconv.Itoa(i))
|
||
|
}
|