示例#1
0
func TestKeyInMap(t *testing.T) {
	paramsMap["testmap"] = "two"
	keyin := testmap.Check(data.CreateParameters(paramsMap))
	if !keyin {
		t.Error("Key 'testmap' has value, that present in map, check should return true")
	}
}
示例#2
0
func TestKeyNotInMap(t *testing.T) {
	paramsMap["testmap"] = "not in map"
	keynotin := testmap.Check(data.CreateParameters(paramsMap))
	if keynotin {
		t.Error("Key 'testmap' has value, that is not exists in map, check should return false")
	}
}
示例#3
0
func CreateParameters(call Call) data.Parameters {
	return data.CreateParameters(map[string]data.Parameter{
		"Time": time.Now().Unix(),

		"callTime": call.CallTime.Format(time.RFC822),
		"code":     call.CountryCode,
		"prefix":   call.Prefix,
		"number":   call.Number,
		"duration": uint(call.Duration),
	})
}
示例#4
0
func TestStaticModifier(t *testing.T) {
	s := Static{&data.SingleWeight{5}}
	params := data.CreateParameters(map[string]data.Parameter{"Type": uint(0), "Time": int64(0)})
	s1 := data.SingleWeight{6}

	result := s.Modify(&s1, params)

	if result.(*data.SingleWeight).Value != 5 {
		t.Error("Static modifier should return weight, stored in value, it is 5, not ",
			result.(*data.SingleWeight).Value)
	}
}
示例#5
0
func BenchmarkMap(b *testing.B) {
	paramsMap["testmap"] = "two"
	for i := int64(0); i < 500; i++ {
		paramsMap[strconv.FormatInt(i, 10)+"qqq"] = strconv.FormatInt(i, 16)
		testmap.Values[strconv.FormatInt(i, 10)+"qwe"] = struct{}{}
	}
	params := data.CreateParameters(paramsMap)

	for i := 0; i < b.N; i++ {
		testmap.Check(params)
	}
}
示例#6
0
// middle condition failed, modifier not applied -> initial weight
func TestNotApplied(t *testing.T) {
	failedParamsMap := make(map[string]data.Parameter)
	for key, value := range paramsMap {
		failedParamsMap[key] = value
	}
	failedParamsMap["second"] = "failed"

	rule := RuleRecord{"rule", conditions[0:3], mods}
	_, affected := rule.Calculate(&weight, data.CreateParameters(failedParamsMap))

	if affected {
		t.Error("Second condition of rule should fail, so the affected should be false")
	}
}
示例#7
0
func TestSingleModifier(t *testing.T) {
	f := func(value data.Comparable) data.Comparable {
		return value.(int) + 5
	}

	iw := data.SingleWeight{7}
	iwm := SingleModifier{f}
	params := data.CreateParameters(map[string]data.Parameter{"Type": uint(0), "Time": int64(0)})

	result := iwm.Modify(&iw, params)
	iwmResult := result.(*data.SingleWeight)

	if iwmResult.Value != 12 {
		t.Error("Int value modifier error, result should be 12, but given ", iwmResult.Value)
	}
}
示例#8
0
func TestExclude(t *testing.T) {
	testmap := Map{
		Name: "testmap",
		Values: map[data.Parameter]struct{}{
			"one":   struct{}{},
			"two":   struct{}{},
			"three": struct{}{},
		},
		Exclude: true,
	}
	paramsMap["testmap"] = "four"
	keyin := testmap.Check(data.CreateParameters(paramsMap))
	if !keyin {
		t.Error("Key 'testmap' has value, that not present in map, but exclude is true, result should be true")
	}
}
示例#9
0
var mods = []Modifier{
	&modifier.Static{&data.SingleWeight{9}},
	&modifier.Static{&data.SingleWeight{10}},
}
var weight = data.SingleWeight{5}
var paramsMap = map[string]data.Parameter{
	"zero":   "hour",
	"first":  "two",
	"second": "four",
	"third":  "nine",
	"last":   "unused",
	"Type":   uint(2),
	"Time":   int64(3),
}
var params = data.CreateParameters(paramsMap)

// conditions passed, modifier applied -> mod weight
func TestApplied(t *testing.T) {
	rule := RuleRecord{"rule", conditions[0:3], mods}
	calculated, affected := rule.Calculate(&weight, params)

	if !affected {
		t.Error("Rule affects weight cause conditions should be passed, but false given")
	}
	result := calculated.(*data.SingleWeight)

	if result.Value.(int) != 10 {
		t.Error("Modifier of rule was set to return 10, but given ", result.Value)
	}
}
示例#10
0
			}),
			false,
		},
		&condition.Map{
			"prefix",
			condition.SliceToMap([]data.Parameter{
				"900", "902", "904", "908", "950", "951", "952", "953",
			}),
			false,
		},
	},
	[]expert.Modifier{
		&modifier.Static{
			&data.ParamsWeight{
				data.CreateParameters(map[string]data.Parameter{
					"operator": "Tele2",
				}),
				nil,
			},
		},
	},
}

var local = &expert.RuleRecord{
	"Tele2 locations",
	[]expert.Condition{
		&condition.Map{
			"code",
			condition.SliceToMap([]data.Parameter{
				"+7", "8",
			}),
示例#11
0
package condition

import (
	"github.com/graarh/golang/expert/data"
	"testing"
)

var intervalParams = data.CreateParameters(map[string]data.Parameter{
	"Time": int64(10),
	"Type": uint(0),
})

var Any = Point{0, false}

func getPoint(value int64) Point {
	if value == 0 {
		return Any
	}
	return Point{value, true}
}

func createInterval(from, to int64) Interval {
	return Interval{getPoint(from), getPoint(to), TimeValue}
}

func TestAlwaysPass(t *testing.T) {
	interval := createInterval(0, 0)
	if interval.Check(intervalParams) != true {
		t.Error("0,0 interval should always pass")
	}
}
示例#12
0
func TestKeyAbsent(t *testing.T) {
	nokey := testmap.Check(data.CreateParameters(paramsMap))
	if nokey {
		t.Error("Key 'testmap' is not present in params, check should return false")
	}
}