func TestFlowTable_jsonFlowConversationEthernetPath(t *testing.T) {
ft := flow.NewTestFlowTableComplex(t, nil, nil)
fa := &FlowApi{
FlowTable: ft,
}
statStr := fa.jsonFlowConversationEthernetPath(flow.FlowProtocol_ETHERNET)
if statStr == `{"nodes":[],"links":[]}` {
t.Error("stat should not be empty")
}
var decoded interface{}
if err := json.Unmarshal([]byte(statStr), &decoded); err != nil {
t.Error("JSON parsing failed:", err)
}
schema := v.Object(
v.ObjKV("nodes", v.Array(v.ArrEach(v.Object(
v.ObjKV("name", v.String(v.StrMin(1))),
v.ObjKV("group", v.Number(v.NumMin(0), v.NumMax(20))),
)))),
v.ObjKV("links", v.Array(v.ArrEach(v.Object(
v.ObjKV("source", v.Number(v.NumMin(0), v.NumMax(20))),
v.ObjKV("target", v.Number(v.NumMin(0), v.NumMax(20))),
v.ObjKV("value", v.Number(v.NumMin(0), v.NumMax(9999))),
)))),
)
if path, err := schema.Validate(decoded); err != nil {
t.Errorf("Failed (%s). Path: %s", err, path)
}
}
func (this SimulationView) GetValidationSchema() valid.Validator {
return valid.Object(
valid.ObjKV("data", valid.Object(
valid.ObjKV("pairs", valid.Array(valid.ArrEach(valid.Optional(valid.Object(
valid.ObjKV("request", valid.Object(
valid.ObjKV("requestType", valid.Optional(valid.String())),
valid.ObjKV("path", valid.Optional(valid.String())),
valid.ObjKV("method", valid.Optional(valid.String())),
valid.ObjKV("scheme", valid.Optional(valid.String())),
valid.ObjKV("query", valid.Optional(valid.String())),
valid.ObjKV("body", valid.Optional(valid.String())),
valid.ObjKV("headers", valid.Optional(valid.Object())),
)),
valid.ObjKV("response", valid.Object(
valid.ObjKV("status", valid.Optional(valid.Number())),
valid.ObjKV("body", valid.Optional(valid.String())),
valid.ObjKV("encodedBody", valid.Optional(valid.Boolean())),
valid.ObjKV("headers", valid.Optional(valid.Object())),
)),
))))),
valid.ObjKV("globalActions", valid.Optional(valid.Object(
valid.ObjKV("delays", valid.Array(valid.ArrEach(valid.Optional(valid.Object(
valid.ObjKV("urlPattern", valid.Optional(valid.String())),
valid.ObjKV("httpMethod", valid.Optional(valid.String())),
valid.ObjKV("delay", valid.Optional(valid.Number())),
))))),
))),
)),
valid.ObjKV("meta", valid.Object(
valid.ObjKV("schemaVersion", valid.String()),
)),
)
}
func TestObject(t *testing.T) {
var np *map[interface{}]interface{}
test(t, "basic object", true, v.Object(), maep{})
test(t, "nil", false, v.Object(), nil)
test(t, "nil map ptr", false, v.Object(), np)
test(t, "non-object", false, v.Object(), 3)
testObjKeys(t)
testObjValues(t)
testObjKVs(t)
}
func testObjKVs(t *testing.T) {
counter, countingValidator := createCountingValidator()
sch := v.Object(
v.ObjKV(nil, v.And(v.String(v.StrIs("1")), v.Function(countingValidator))),
v.ObjKV("1", v.And(v.String(v.StrIs("b")), v.Function(countingValidator))),
v.ObjKV(true, v.And(v.Number(v.NumIs(3)), v.Function(countingValidator))),
)
m := maep{
nil: "1",
"1": "b",
true: 3,
}
test(t, "mixed objkvs", true, sch, m)
if *counter != 3 {
t.Fatalf("value counter should be 3, got %d", *counter)
}
m = maep{
nil: "1",
"1": 2,
true: 3,
}
test(t, "!mixed objkvs", false, sch, m)
m = maep{
nil: "1",
"1": nil,
true: 3,
}
test(t, "!mixed objkvs (nil)", false, sch, m)
}
// Validates config structure
func validateConfig(configMap map[string]interface{}) error {
schema := v.Object(v.ObjKeys(v.String()),
v.ObjValues(v.Array(v.ArrEach(v.Object(
v.ObjKV("docker", v.Object(
v.ObjKV("image", v.String()),
v.ObjKV("command", v.String()),
v.ObjKV("permissions", v.Optional(v.Object(
v.ObjKV("cwd", v.Boolean()),
))),
)),
)))),
)
if path, err := schema.Validate(configMap); err != nil {
return fmt.Errorf("Invalid hop definition at %s. Error (%s)",
path, err)
}
return nil
}
func test_jsonFlowDiscovery(t *testing.T, DiscoType discoType) {
ft := flow.NewTestFlowTableComplex(t, nil, nil)
fa := &FlowApi{
FlowTable: ft,
}
disco := fa.jsonFlowDiscovery(DiscoType)
if disco == `{"name":"root","children":[]}` {
t.Error("disco should not be empty")
}
var decoded interface{}
if err := json.Unmarshal([]byte(disco), &decoded); err != nil {
t.Error("JSON parsing failed:", err)
}
schema := v.Object(
v.ObjKV("name", v.String(v.StrMin(1))), // root
v.ObjKV("children", v.Array(v.ArrEach(v.Object(
v.ObjKV("name", v.String(v.StrMin(1))), // Ethernet
v.ObjKV("children", v.Array(v.ArrEach(v.Object(
v.ObjKV("name", v.String(v.StrMin(1))), // IPv4
v.ObjKV("children", v.Array(v.ArrEach(v.Object(
v.ObjKV("name", v.String(v.StrMin(1))), // TCP or UDP
v.ObjKV("children", v.Array(v.ArrEach(v.Object(
v.ObjKV("name", v.String(v.StrMin(1))), // Payload
v.ObjKV("size", v.Number(v.NumMin(0), v.NumMax(9999))),
)))),
)))),
)))),
)))),
)
if path, err := schema.Validate(decoded); err != nil {
t.Errorf("Failed (%s). Path: %s", err, path)
}
}
func testObjValues(t *testing.T) {
counter, countingValidator := createCountingValidator()
sch := v.Object(
v.ObjValues(v.String()),
v.ObjValues(v.Function(countingValidator)),
)
m := maep{
nil: "1",
1: "b",
true: "c",
}
test(t, "only string objvalues", true, sch, m)
if *counter != 3 {
t.Fatalf("value counter should be 3, got %d", *counter)
}
m = maep{
nil: "1",
1: 1,
}
test(t, "!only string objvalues", false, sch, m)
}
func testObjKeys(t *testing.T) {
counter, countingValidator := createCountingValidator()
sch := v.Object(
v.ObjKeys(v.String()),
v.ObjKeys(v.Function(countingValidator)),
)
m := maep{
"a": nil,
"b": 1,
"c": true,
}
test(t, "only string objkeys", true, sch, m)
if *counter != 3 {
t.Fatalf("key counter should be 3, got %d", *counter)
}
m = maep{
"a": nil,
1: 1,
}
test(t, "!only string objkeys", false, sch, m)
}
func TestFlowJSON(t *testing.T) {
f := Flow{
UUID: "uuid-1",
LayersPath: "layerpath-1",
Statistics: &FlowStatistics{
Start: 1111,
Last: 222,
Endpoints: []*FlowEndpointsStatistics{
{
Type: FlowEndpointType_ETHERNET,
AB: &FlowEndpointStatistics{
Value: "value-1",
Bytes: 33,
Packets: 34,
},
BA: &FlowEndpointStatistics{
Value: "value-2",
Bytes: 44,
Packets: 55,
},
},
},
},
ProbeGraphPath: "probepath-1",
IfSrcGraphPath: "srcgraphpath-1",
IfDstGraphPath: "dstgraphpath-1",
}
j, err := json.Marshal(f)
if err != nil {
t.Error(err.Error())
}
schema := v.Object(
v.ObjKV("UUID", v.String()),
v.ObjKV("LayersPath", v.String()),
v.ObjKV("ProbeGraphPath", v.String()),
v.ObjKV("IfSrcGraphPath", v.String()),
v.ObjKV("IfDstGraphPath", v.String()),
v.ObjKV("Statistics", v.Object(
v.ObjKV("Start", v.Number()),
v.ObjKV("Last", v.Number()),
v.ObjKV("Endpoints", v.Array(v.ArrEach(v.Object(
v.ObjKV("Type", v.String()),
v.ObjKV("AB", v.Object(
v.ObjKV("Value", v.String()),
v.ObjKV("Packets", v.Number()),
v.ObjKV("Bytes", v.Number()),
)),
v.ObjKV("AB", v.Object(
v.ObjKV("Value", v.String()),
v.ObjKV("Packets", v.Number()),
v.ObjKV("Bytes", v.Number()),
)),
)))),
)),
)
var data interface{}
if err := json.Unmarshal(j, &data); err != nil {
t.Fatal("JSON parsing failed. Err =", err)
}
if path, err := schema.Validate(data); err != nil {
t.Fatalf("Validation failed at %s. Error (%s)", path, err)
}
var e Flow
if err := json.Unmarshal(j, &e); err != nil {
t.Fatal("JSON parsing failed. Err =", err)
}
if !reflect.DeepEqual(f, e) {
t.Fatal("Unmarshalled flow not equal to the original")
}
}
func TestFlowJSON(t *testing.T) {
f := Flow{
UUID: "uuid-1",
LayersPath: "layerpath-1",
Link: &FlowLayer{
Protocol: FlowProtocol_ETHERNET,
A: "value-1",
B: "value-2",
},
Metric: &FlowMetric{
Start: 1111,
Last: 222,
ABBytes: 33,
ABPackets: 34,
BABytes: 44,
BAPackets: 55,
},
NodeTID: "probe-tid",
ANodeTID: "anode-tid",
BNodeTID: "bnode-tid",
}
j, err := json.Marshal(f)
if err != nil {
t.Error(err.Error())
}
schema := v.Object(
v.ObjKV("UUID", v.String()),
v.ObjKV("LayersPath", v.String()),
v.ObjKV("NodeTID", v.String()),
v.ObjKV("ANodeTID", v.String()),
v.ObjKV("BNodeTID", v.String()),
v.ObjKV("Link", v.Object(
v.ObjKV("Protocol", v.String()),
v.ObjKV("A", v.String()),
v.ObjKV("B", v.String()),
)),
v.ObjKV("Metric", v.Object(
v.ObjKV("Start", v.Number()),
v.ObjKV("Last", v.Number()),
v.ObjKV("ABPackets", v.Number()),
v.ObjKV("ABBytes", v.Number()),
v.ObjKV("BAPackets", v.Number()),
v.ObjKV("BABytes", v.Number()),
)),
)
var data interface{}
if err := json.Unmarshal(j, &data); err != nil {
t.Fatal("JSON parsing failed. Err =", err)
}
if path, err := schema.Validate(data); err != nil {
t.Fatalf("Validation failed at %s. Error (%s)", path, err)
}
var e Flow
if err := json.Unmarshal(j, &e); err != nil {
t.Fatal("JSON parsing failed. Err =", err)
}
if !reflect.DeepEqual(f, e) {
t.Fatal("Unmarshalled flow not equal to the original")
}
}
func init() {
// set up raw json data
rawJson := []byte(`
{
"status": true,
"data": {
"token": "CAFED00D",
"debug": 69306,
"items": [
{ "url": "https://news.ycombinator.com/", "comment": "clickbaits" },
{ "url": "http://golang.org/", "comment": "some darn gophers" },
{ "url": "http://www.kickstarter.com/", "comment": "opensource projects. yeah.." }
],
"ghost2": null,
"meta": {
"g": 1,
"xyzzy": 0.25,
"blöö": 0.5
}
}
}`)
// decode json
if err := json.Unmarshal(rawJson, &decoded); err != nil {
log.Panic("JSON parsing failed. Err =", err)
}
// set up a custom validator function
myValidatorFunc := func(data interface{}) (path string, err error) {
path = "myValidatorFunc"
validate, ok := data.(string)
if !ok {
return path, fmt.Errorf("expected string, got %v", reflect.TypeOf(data))
}
if validate != "CAFED00D" {
return path, fmt.Errorf("expected CAFED00D, got %s", validate)
}
return "", nil
}
// construct the schema which is used to validate data
schema = v.Object(
v.ObjKV("status", v.Boolean()),
v.ObjKV("data", v.Object(
v.ObjKV("token", v.Function(myValidatorFunc)),
v.ObjKV("debug", v.Number(v.NumMin(1), v.NumMax(99999))),
v.ObjKV("items", v.Array(v.ArrEach(v.Object(
v.ObjKV("url", v.String(v.StrMin(1))),
v.ObjKV("comment", v.Optional(v.String())),
)))),
v.ObjKV("ghost", v.Optional(v.String())),
v.ObjKV("ghost2", v.Optional(v.String())),
v.ObjKV("meta", v.Object(
v.ObjKeys(v.String()),
v.ObjValues(v.Or(v.Number(v.NumMin(.01), v.NumMax(1.1)), v.String())),
)),
)),
)
}