mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
Add tests for engine.SafEvent
This commit is contained in:
Trial97
committed by
Dan Christian Bogos
Dan Christian Bogos
parent
03198d1da4
commit
44ec51048e
@@ -121,7 +121,7 @@ func (me MapEvent) AsMapStringIgnoreErrors(ignoredFlds utils.StringMap) (mp map[
|
||||
if ignoredFlds.HasKey(k) {
|
||||
continue
|
||||
}
|
||||
if out, can := utils.CastFieldIfToString(v); can {
|
||||
if out, err := utils.IfaceAsString(v); err == nil {
|
||||
mp[k] = out
|
||||
}
|
||||
}
|
||||
|
||||
@@ -53,487 +53,561 @@ func TestSafEventMapEvent(t *testing.T) {
|
||||
}
|
||||
|
||||
func TestSafEventClone(t *testing.T) {
|
||||
var rply *SafEvent
|
||||
safEv = safEv.Clone()
|
||||
t.Run("clone1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
rply = safEv.Clone()
|
||||
if !reflect.DeepEqual(safEv, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", safEv, rply)
|
||||
}
|
||||
})
|
||||
t.Run("clone2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test4", false)
|
||||
if reflect.DeepEqual(safEv, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", safEv, rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("clone", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Clone()
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test4", true)
|
||||
})
|
||||
}
|
||||
rply := safEv.Clone()
|
||||
if !reflect.DeepEqual(safEv, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", safEv, rply)
|
||||
}
|
||||
rply.Set("test4", false)
|
||||
if reflect.DeepEqual(safEv, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", safEv, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventString(t *testing.T) {
|
||||
var rply string
|
||||
expected := safEv.Me.String()
|
||||
t.Run("string1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
rply = safEv.String()
|
||||
if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("string2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test4", false)
|
||||
rply = safEv.String()
|
||||
safEv.RLock()
|
||||
expected = safEv.Me.String()
|
||||
safEv.RUnlock()
|
||||
if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", safEv, rply)
|
||||
}
|
||||
})
|
||||
t.Run("string3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test4", true)
|
||||
rply = safEv.String()
|
||||
safEv.RLock()
|
||||
expected = safEv.Me.String()
|
||||
safEv.RUnlock()
|
||||
if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", safEv, rply)
|
||||
}
|
||||
})
|
||||
if rply := safEv.String(); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
se := safEv.Clone()
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("string", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
se.String()
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
se.Remove("test4")
|
||||
})
|
||||
}
|
||||
se.Remove("test5")
|
||||
expected = se.Me.String()
|
||||
if rply := se.String(); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventHasField(t *testing.T) {
|
||||
t.Run("field1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if rply := safEv.HasField("test4"); !rply {
|
||||
t.Errorf("Expecting true, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("field2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test4")
|
||||
if rply := safEv.HasField("test4"); rply {
|
||||
t.Errorf("Expecting false, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("field3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test4", true)
|
||||
if rply := safEv.HasField("test4"); !rply {
|
||||
t.Errorf("Expecting true, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
if rply := safEv.HasField("test4"); !rply {
|
||||
t.Errorf("Expecting true, received: %+v", rply)
|
||||
}
|
||||
se := safEv.Clone()
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("field", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
se.HasField("test4")
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
se.Remove("test4")
|
||||
})
|
||||
}
|
||||
se.Remove("test5")
|
||||
if rply := se.HasField("test5"); rply {
|
||||
t.Errorf("Expecting false, received: %+v", rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGet(t *testing.T) {
|
||||
t.Run("get1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if rply, has := safEv.Get("test5"); !has {
|
||||
t.Errorf("Expecting 'test5' to be a field")
|
||||
} else if rply != "test" {
|
||||
t.Errorf("Expecting test, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("get2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test5")
|
||||
if rply, has := safEv.Get("test5"); has {
|
||||
t.Errorf("Expecting 'test5' to not be a field, recived %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("get3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test5", false)
|
||||
if rply, has := safEv.Get("test5"); !has {
|
||||
t.Errorf("Expecting 'test5' to be a field")
|
||||
} else if rply != false {
|
||||
t.Errorf("Expecting false, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("get", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Get("test4")
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test4", true)
|
||||
})
|
||||
}
|
||||
safEv.Remove("test4")
|
||||
if rply, has := safEv.Get("test4"); has {
|
||||
t.Errorf("Expecting 'test4' to not be a field, recived: %+v", rply)
|
||||
}
|
||||
safEv.Set("test4", false)
|
||||
if rply, has := safEv.Get("test4"); !has {
|
||||
t.Errorf("Expecting 'test4' to be a field")
|
||||
} else if rply != false {
|
||||
t.Errorf("Expecting false, received: %+v", rply)
|
||||
}
|
||||
safEv.Set("test4", true)
|
||||
if rply, has := safEv.Get("test4"); !has {
|
||||
t.Errorf("Expecting 'test4' to be a field")
|
||||
} else if rply != true {
|
||||
t.Errorf("Expecting true, received: %+v", rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetIgnoreErrors(t *testing.T) {
|
||||
t.Run("getIgnore1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if rply := safEv.GetIgnoreErrors("test2"); rply != 42 {
|
||||
t.Errorf("Expecting 42, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("getIgnore2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test2")
|
||||
if rply := safEv.GetIgnoreErrors("test2"); rply != nil {
|
||||
t.Errorf("Expecting null, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("getIgnore3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test2", 43)
|
||||
if rply := safEv.GetIgnoreErrors("test2"); rply != 43 {
|
||||
t.Errorf("Expecting 43, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getIgnore", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.GetIgnoreErrors("test4")
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test4", true)
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test4")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test4")
|
||||
if rply := safEv.GetIgnoreErrors("test4"); rply != nil {
|
||||
t.Errorf("Expecting: null, recived: %+v", rply)
|
||||
}
|
||||
safEv.Set("test4", false)
|
||||
if rply := safEv.GetIgnoreErrors("test4"); rply != false {
|
||||
t.Errorf("Expecting false, received: %+v", rply)
|
||||
}
|
||||
safEv.Set("test4", true)
|
||||
if rply := safEv.GetIgnoreErrors("test4"); rply != true {
|
||||
t.Errorf("Expecting true, received: %+v", rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetString(t *testing.T) {
|
||||
t.Run("getString1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if rply, err := safEv.GetString("test6"); err != nil {
|
||||
t.Error(err)
|
||||
} else if rply != "10s" {
|
||||
t.Errorf("Expecting 10s, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("getString2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if rply, err := safEv.GetString("test"); err == nil {
|
||||
t.Errorf("Expecting 'test' to not be a field, recived %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("getString3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test7", "43s")
|
||||
if rply, err := safEv.GetString("test7"); err != nil {
|
||||
t.Error(err)
|
||||
} else if rply != "43s" {
|
||||
t.Errorf("Expecting 43s, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getString", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if _, err := safEv.GetString("test4"); err != nil && err != utils.ErrNotFound {
|
||||
t.Error(err)
|
||||
}
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test4", true)
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test4")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test2")
|
||||
if _, err := safEv.GetString("test2"); err != utils.ErrNotFound {
|
||||
t.Errorf("Expecting: %+v ,recived: %+v", utils.ErrNotFound, err)
|
||||
}
|
||||
safEv.Set("test2", 42.3)
|
||||
if rply, err := safEv.GetString("test2"); err != nil {
|
||||
t.Error(err)
|
||||
} else if rply != "42.3" {
|
||||
t.Errorf("Expecting 42.3, received: %+v", rply)
|
||||
}
|
||||
safEv.Set("test2", 42)
|
||||
if rply, err := safEv.GetString("test2"); err != nil {
|
||||
t.Error(err)
|
||||
} else if rply != "42" {
|
||||
t.Errorf("Expecting 42, received: %+v", rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetStringIgnoreErrors(t *testing.T) {
|
||||
t.Run("getStringIgnore1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test1", nil)
|
||||
if rply := safEv.GetStringIgnoreErrors("test1"); rply != "" {
|
||||
t.Errorf("Expecting , received: %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("getStringIgnore2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test2")
|
||||
if rply := safEv.GetStringIgnoreErrors("test2"); rply != "" {
|
||||
t.Errorf("Expecting null, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("getStringIgnore3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test1", 43)
|
||||
if rply := safEv.GetStringIgnoreErrors("test1"); rply != "43" {
|
||||
t.Errorf("Expecting 43, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getStringIgn", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.GetStringIgnoreErrors("test4")
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test4", true)
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test4")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test2")
|
||||
if rply := safEv.GetStringIgnoreErrors("test2"); rply != "" {
|
||||
t.Errorf("Expecting: ,recived: %+v", err)
|
||||
}
|
||||
safEv.Set("test2", 42.3)
|
||||
if rply := safEv.GetStringIgnoreErrors("test2"); rply != "42.3" {
|
||||
t.Errorf("Expecting 42.3, received: %+v", rply)
|
||||
}
|
||||
safEv.Set("test2", 42)
|
||||
if rply := safEv.GetStringIgnoreErrors("test2"); rply != "42" {
|
||||
t.Errorf("Expecting 42, received: %+v", rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetDuration(t *testing.T) {
|
||||
t.Run("getDuration1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Duration(43 * time.Second)
|
||||
if rply, err := safEv.GetDuration("test7"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("getDuration2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if rply, err := safEv.GetDuration("test"); err == nil {
|
||||
t.Errorf("Expecting 'test' to not be a field, recived %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("getDuration3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Duration(10 * time.Second)
|
||||
if rply, err := safEv.GetDuration("test6"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getDuration", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if _, err := safEv.GetDuration("test6"); err != nil && err != utils.ErrNotFound {
|
||||
t.Error(err)
|
||||
}
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test6", time.Duration(10*time.Second))
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test6")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test7")
|
||||
if _, err := safEv.GetDuration("test7"); err != utils.ErrNotFound {
|
||||
t.Errorf("Expecting: %+v ,recived: %+v", utils.ErrNotFound, err)
|
||||
}
|
||||
if rply, err := safEv.GetDuration("test5"); err == nil {
|
||||
t.Errorf("Expecting: error,recived: %+v", rply)
|
||||
}
|
||||
safEv.Set("test7", "42s")
|
||||
expected := time.Duration(42 * time.Second)
|
||||
if rply, err := safEv.GetDuration("test7"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
expected = time.Duration(10 * time.Second)
|
||||
safEv.Set("test6", expected)
|
||||
if rply, err := safEv.GetDuration("test6"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetDurationIgnoreErrors(t *testing.T) {
|
||||
t.Run("getDurationIgnore1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Duration(43 * time.Second)
|
||||
if rply := safEv.GetDurationIgnoreErrors("test7"); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("getDurationIgnore2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Duration(0)
|
||||
if rply := safEv.GetDurationIgnoreErrors("test"); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("getDurationIgnore3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Duration(10 * time.Second)
|
||||
if rply := safEv.GetDurationIgnoreErrors("test6"); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getDurationIgn", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.GetDurationIgnoreErrors("test6")
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test6", time.Duration(10*time.Second))
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test6")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test7")
|
||||
if rply := safEv.GetDurationIgnoreErrors("test7"); rply != time.Duration(0) {
|
||||
t.Errorf("Expecting: %+v ,recived: %+v", time.Duration(0), rply)
|
||||
}
|
||||
safEv.Set("test7", "42s")
|
||||
expected := time.Duration(42 * time.Second)
|
||||
if rply := safEv.GetDurationIgnoreErrors("test7"); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
expected = time.Duration(10 * time.Second)
|
||||
safEv.Set("test6", expected)
|
||||
if rply := safEv.GetDurationIgnoreErrors("test6"); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetDurationPtr(t *testing.T) {
|
||||
t.Run("getDurationPtr1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Duration(43 * time.Second)
|
||||
if rply, err := safEv.GetDurationPtr("test7"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(&expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("getDurationPtr2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if _, err := safEv.GetDurationPtr("test"); err != utils.ErrNotFound {
|
||||
t.Errorf("Expecting %+v, recived %+v", utils.ErrNotFound, err)
|
||||
}
|
||||
})
|
||||
t.Run("getDurationPtr3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Duration(11 * time.Second)
|
||||
safEv.Set("test6", expected)
|
||||
if rply, err := safEv.GetDurationPtr("test6"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(&expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getDurationPtr", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if _, err := safEv.GetDurationPtr("test6"); err != nil && err != utils.ErrNotFound {
|
||||
t.Error(err)
|
||||
}
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test6", time.Duration(10*time.Second))
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test6")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test7")
|
||||
if _, err := safEv.GetDurationPtr("test7"); err != utils.ErrNotFound {
|
||||
t.Errorf("Expecting: %+v ,recived: %+v", utils.ErrNotFound, err)
|
||||
}
|
||||
if rply, err := safEv.GetDurationPtr("test5"); err == nil {
|
||||
t.Errorf("Expecting: error,recived: %+v", rply)
|
||||
}
|
||||
safEv.Set("test7", "42s")
|
||||
expected := time.Duration(42 * time.Second)
|
||||
if rply, err := safEv.GetDurationPtr("test7"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(&expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
expected = time.Duration(10 * time.Second)
|
||||
safEv.Set("test6", expected)
|
||||
if rply, err := safEv.GetDurationPtr("test6"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(&expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetDurationPtrOrDefault(t *testing.T) {
|
||||
def := time.Duration(450)
|
||||
safEv = NewSafEvent(sMap)
|
||||
t.Run("getDurationPtrDef1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Duration(42 * time.Second)
|
||||
if rply, err := safEv.GetDurationPtrOrDefault("test7", &def); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(&expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("getDurationPtrDef2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Duration(12 * time.Second)
|
||||
if rply, err := safEv.GetDurationPtrOrDefault("othertest", &expected); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(&expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("getDurationPtrDef3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if rply, err := safEv.GetDurationPtrOrDefault("test5", &def); err == nil {
|
||||
t.Errorf("Expecting error, recived %+v", rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getDurationPtrDef", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if _, err := safEv.GetDurationPtrOrDefault("test6", &def); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test6", time.Duration(10*time.Second))
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test6")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test7")
|
||||
if rply, err := safEv.GetDurationPtrOrDefault("test7", &def); err != nil {
|
||||
t.Errorf("Expecting: %+v ,recived: %+v", utils.ErrNotFound, err)
|
||||
} else if !reflect.DeepEqual(&def, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", def, rply)
|
||||
}
|
||||
if rply, err := safEv.GetDurationPtrOrDefault("test5", &def); err == nil {
|
||||
t.Errorf("Expecting: error,recived: %+v", rply)
|
||||
}
|
||||
safEv.Set("test7", "42s")
|
||||
expected := time.Duration(42 * time.Second)
|
||||
if rply, err := safEv.GetDurationPtrOrDefault("test7", &def); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(&expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
expected = time.Duration(10 * time.Second)
|
||||
safEv.Set("test6", expected)
|
||||
if rply, err := safEv.GetDurationPtrOrDefault("test6", &def); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(&expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetGetTime(t *testing.T) {
|
||||
t.Run("getTime1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
|
||||
if rply, err := safEv.GetTime("test8", ""); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("getTime2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if rply, err := safEv.GetTime("test", ""); err == nil {
|
||||
t.Errorf("Expecting 'test' to not be a field, recived %+v", rply)
|
||||
}
|
||||
if rply, err := safEv.GetTime("test4", ""); err == nil {
|
||||
t.Errorf("Expecting 'test' to not be a field, recived %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("getTime3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
|
||||
if rply, err := safEv.GetTime("test9", ""); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
func TestSafEventGetTime(t *testing.T) {
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getTime", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if _, err := safEv.GetTime("test8", ""); err != nil && err != utils.ErrNotFound {
|
||||
t.Error(err)
|
||||
}
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test8")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test9")
|
||||
if _, err := safEv.GetTime("test9", ""); err != utils.ErrNotFound {
|
||||
t.Errorf("Expecting: %+v ,recived: %+v", utils.ErrNotFound, err)
|
||||
}
|
||||
if rply, err := safEv.GetTime("test5", ""); err == nil {
|
||||
t.Errorf("Expecting: error,recived: %+v", rply)
|
||||
}
|
||||
safEv.Set("test9", "2010-11-10T23:00:00Z")
|
||||
expected := time.Date(2010, 11, 10, 23, 0, 0, 0, time.UTC)
|
||||
if rply, err := safEv.GetTime("test9", ""); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
expected = time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
|
||||
safEv.Set("test8", expected)
|
||||
if rply, err := safEv.GetTime("test8", ""); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetTimeIgnoreErrors(t *testing.T) {
|
||||
t.Run("getTimeIgnore1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
|
||||
if rply := safEv.GetTimeIgnoreErrors("test8", ""); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("getTimeIgnore2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test8", nil)
|
||||
if rply := safEv.GetTimeIgnoreErrors("test", ""); !rply.IsZero() {
|
||||
t.Errorf("Expecting January 1, year 1, 00:00:00.000000000 UTC, received: %+v", rply)
|
||||
}
|
||||
})
|
||||
t.Run("getTimeIgnore3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
|
||||
if rply := safEv.GetTimeIgnoreErrors("test9", ""); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getTimeIgn", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.GetTimeIgnoreErrors("test8", "")
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test8")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test9")
|
||||
if rply := safEv.GetTimeIgnoreErrors("test9", ""); !rply.IsZero() {
|
||||
t.Errorf("Expecting January 1, year 1, 00:00:00.000000000 UTC, received: %+v", rply)
|
||||
}
|
||||
if rply := safEv.GetTimeIgnoreErrors("test5", ""); !rply.IsZero() {
|
||||
t.Errorf("Expecting January 1, year 1, 00:00:00.000000000 UTC, received: %+v", rply)
|
||||
}
|
||||
safEv.Set("test9", "2010-11-10T23:00:00Z")
|
||||
expected := time.Date(2010, 11, 10, 23, 0, 0, 0, time.UTC)
|
||||
if rply := safEv.GetTimeIgnoreErrors("test9", ""); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
expected = time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
|
||||
safEv.Set("test8", expected)
|
||||
if rply := safEv.GetTimeIgnoreErrors("test8", ""); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetSetString(t *testing.T) {
|
||||
t.Run("getSetString1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
var expected string
|
||||
if expected, err = safEv.GetString("test1"); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if rply, err := safEv.GetSetString("test1", "test"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
safEv.Remove("test1")
|
||||
safEv.Remove("test2")
|
||||
expected = "test"
|
||||
if rply, err := safEv.GetSetString("test1", expected); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
if rply, err := safEv.GetString("test1"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("getSetString2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
expected := "test"
|
||||
if rply, err := safEv.GetSetString("test2", "test"); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getSetString", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.GetSetString("test4", "true")
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test4")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test2")
|
||||
expected := "test2"
|
||||
if rply, err := safEv.GetSetString("test2", expected); err != nil {
|
||||
t.Error(err)
|
||||
} else if rply != expected {
|
||||
t.Errorf("Expecting: %+v ,recived: %+v", expected, rply)
|
||||
}
|
||||
safEv.Set("test2", 42.3)
|
||||
if rply, err := safEv.GetSetString("test2", ""); err != nil {
|
||||
t.Error(err)
|
||||
} else if rply != "42.3" {
|
||||
t.Errorf("Expecting 42.3, received: %+v", rply)
|
||||
}
|
||||
safEv.Set("test2", 42)
|
||||
if rply, err := safEv.GetSetString("test2", "test"); err != nil {
|
||||
t.Error(err)
|
||||
} else if rply != "42" {
|
||||
t.Errorf("Expecting 42, received: %+v", rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventGetMapInterface(t *testing.T) {
|
||||
t.Run("getMapInt1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if rply := safEv.GetMapInterface(); !reflect.DeepEqual(sMap, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", sMap, rply)
|
||||
}
|
||||
})
|
||||
t.Run("getMapInt2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
sMap["test10"] = true
|
||||
safEv.Set("test10", true)
|
||||
})
|
||||
t.Run("getMapInt3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
sMap["test12"] = "time"
|
||||
safEv.Set("test12", "time")
|
||||
if rply := safEv.GetMapInterface(); !reflect.DeepEqual(sMap, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", sMap, rply)
|
||||
} else if rply["test12"] = 12; !reflect.DeepEqual(sMap, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", sMap, rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("getMapInt", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.GetMapInterface()
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test8")
|
||||
})
|
||||
}
|
||||
safEv.Remove("test8")
|
||||
if rply := safEv.GetMapInterface(); !reflect.DeepEqual(sMap, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", sMap, rply)
|
||||
}
|
||||
safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
|
||||
if rply := safEv.GetMapInterface(); !reflect.DeepEqual(sMap, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", sMap, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventAsMapInterface(t *testing.T) {
|
||||
t.Run("asMapInt1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
if rply := safEv.AsMapInterface(); !reflect.DeepEqual(sMap, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", sMap, rply)
|
||||
}
|
||||
})
|
||||
t.Run("asMapInt2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test10", true)
|
||||
})
|
||||
t.Run("asMapInt3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test12", "time")
|
||||
expected := safEv.GetMapInterface()
|
||||
if rply := safEv.AsMapInterface(); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
} else if rply["test12"] = 12; reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("asMapInt", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.AsMapInterface()
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test8")
|
||||
})
|
||||
}
|
||||
rply := safEv.AsMapInterface()
|
||||
if !reflect.DeepEqual(sMap, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", sMap, rply)
|
||||
}
|
||||
safEv.Remove("test8")
|
||||
if reflect.DeepEqual(sMap, rply) {
|
||||
t.Errorf("Expecting not be %+v, received: %+v", sMap, rply)
|
||||
}
|
||||
safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
|
||||
}
|
||||
|
||||
func TestSafEventAsMapString(t *testing.T) {
|
||||
t.Run("asMapStr1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
var expected map[string]string
|
||||
if expected, err = safEv.Me.AsMapString(nil); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if rply, err := safEv.AsMapString(nil); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("asMapStr2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test10")
|
||||
})
|
||||
t.Run("asMapStr3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test12")
|
||||
var expected map[string]string
|
||||
if expected, err = safEv.Me.AsMapString(nil); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
delete(expected, "test2")
|
||||
if rply, err := safEv.AsMapString(utils.StringMap{"test2": true}); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("asMapStr", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.AsMapString(nil)
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test9", true)
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test9")
|
||||
})
|
||||
}
|
||||
var expected map[string]string
|
||||
if expected, err = safEv.Me.AsMapString(nil); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if rply, err := safEv.AsMapString(nil); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
delete(expected, "test1")
|
||||
if rply, err := safEv.AsMapString(utils.StringMap{"test1": true}); err != nil {
|
||||
t.Error(err)
|
||||
} else if !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventAsMapStringIgnoreErrors(t *testing.T) {
|
||||
t.Run("asMapStrIgn1", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
var expected map[string]string
|
||||
safEv.RLock()
|
||||
if expected, err = safEv.Me.AsMapString(nil); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
safEv.RUnlock()
|
||||
if rply := safEv.AsMapStringIgnoreErrors(nil); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
t.Run("asMapStrIgn2", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test10", "test3")
|
||||
})
|
||||
t.Run("asMapStrIgn3", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test12", 42)
|
||||
var expected map[string]string
|
||||
if expected, err = safEv.Me.AsMapString(utils.StringMap{"test12": true}); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if rply := safEv.AsMapStringIgnoreErrors(utils.StringMap{"test12": true}); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
})
|
||||
for i := 0; i < 10; i++ {
|
||||
t.Run("asMapStr", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.AsMapStringIgnoreErrors(nil)
|
||||
})
|
||||
t.Run("set", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Set("test9", true)
|
||||
})
|
||||
t.Run("remove", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
safEv.Remove("test9")
|
||||
})
|
||||
}
|
||||
var expected map[string]string
|
||||
if expected, err = safEv.Me.AsMapString(nil); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if rply := safEv.AsMapStringIgnoreErrors(nil); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected["test8"], rply["test8"])
|
||||
}
|
||||
delete(expected, "test1")
|
||||
if rply := safEv.AsMapStringIgnoreErrors(utils.StringMap{"test1": true}); !reflect.DeepEqual(expected, rply) {
|
||||
t.Errorf("Expecting %+v, received: %+v", expected, rply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSafEventAsCDR(t *testing.T) {
|
||||
|
||||
Reference in New Issue
Block a user