lib/go-tc/traffic_monitor_test.go - trafficcontrol - Git at Google

 package tc

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF 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.
  */

 import (
 	"encoding/json"
 	"fmt"
 	"testing"
 	"time"

 	"github.com/apache/trafficcontrol/lib/go-util"
 )

 func makeFakeStats(text string) map[string][]ResultStatVal {
 	return map[string][]ResultStatVal{
 		text + "stat1": {
 			{
 				Span: 50,
 				Time: time.Now(),
 				Val:  50,
 			},
 		},
 		text + "stat2": {
 			{
 				Span: 50,
 				Time: time.Now(),
 				Val:  50,
 			},
 			{
 				Span: 50,
 				Time: time.Now(),
 				Val:  50,
 			},
 		},
 		text + "stat3": {
 			{
 				Span: 50,
 				Time: time.Now(),
 				Val:  50,
 			},
 			{
 				Span: 50,
 				Time: time.Now(),
 				Val:  50,
 			},
 			{
 				Span: 50,
 				Time: time.Now(),
 				Val:  50,
 			},
 		},
 	}
 }

 func makeFakeInterfaces() map[string]map[string][]ResultStatVal {
 	return map[string]map[string][]ResultStatVal{
 		"interface1": makeFakeStats("interf"),
 		"interface2": makeFakeStats("interf"),
 		"interface3": makeFakeStats("interf"),
 	}
 }
 func TestLegacyStatsConversion(t *testing.T) {
 	stats := Stats{
 		CommonAPIData: CommonAPIData{},
 		Caches:        make(map[string]ServerStats),
 	}
 	config := TrafficMonitorConfigMap{
 		TrafficServer: make(map[string]TrafficServer),
 	}
 	for _, cacheName := range []string{"cache1", "cache2", "cache3"} {
 		stats.Caches[cacheName] = ServerStats{
 			Interfaces: makeFakeInterfaces(),
 			Stats:      makeFakeStats(""),
 		}
 		interfaces := []ServerInterfaceInfo{}
 		for name, _ := range stats.Caches[cacheName].Interfaces {
 			interfaces = append(interfaces, ServerInterfaceInfo{
 				IPAddresses: []ServerIPAddress{
 					{
 						Address:        "192.168.0.8",
 						Gateway:        util.StrPtr("192.168.0.1"),
 						ServiceAddress: true,
 					},
 				},
 				MaxBandwidth: util.Uint64Ptr(1500),
 				Monitor:      false,
 				MTU:          util.UInt64Ptr(1500),
 				Name:         name,
 			})
 		}
 		interfaces[0].Monitor = true
 		config.TrafficServer[cacheName] = TrafficServer{
 			Interfaces: interfaces,
 		}
 	}

 	issues, legacyStats := stats.ToLegacy(config)

 	if len(issues) != 0 {
 		t.Error("expect no issues")
 	}

 	if legacyStats.CommonAPIData != stats.CommonAPIData {
 		t.Error("expected CommonAPIData to be the same")
 	}

 	if len(legacyStats.Caches) != len(stats.Caches) {
 		t.Errorf("expected %v caches, got %v", len(stats.Caches), len(legacyStats.Caches))
 	}

 	for cacheName, legacyCache := range legacyStats.Caches {
 		cache, ok := stats.Caches[string(cacheName)]
 		if !ok {
 			t.Errorf("new interface %v found in upgraded stats, but not in legacy stats", cacheName)
 		}
 		interf := cache.Interfaces["interface1"]
 		if len(interf)+len(cache.Stats) != len(legacyCache) {
 			t.Errorf("expected %v stats, got %v", len(interf)+len(cache.Stats), len(legacyCache))
 		}
 	}
 }

 func TestLegacyStatsNilConversion(t *testing.T) {
 	stats := Stats{
 		CommonAPIData: CommonAPIData{},
 		Caches:        nil,
 	}
 	config := TrafficMonitorConfigMap{
 		TrafficServer: nil,
 	}
 	issues, legacyStats := stats.ToLegacy(config)

 	if legacyStats.CommonAPIData != stats.CommonAPIData {
 		t.Error("expected CommonAPIData to be the same")
 	}

 	if len(issues) != 0 {
 		t.Error("expect no issues")
 	}
 }

 func TestLegacyMonitorConfigValid(t *testing.T) {
 	mc := (*LegacyTrafficMonitorConfigMap)(nil)
 	if LegacyMonitorConfigValid(mc) == nil {
 		t.Errorf("MonitorCopnfigValid(nil) expected: error, actual: nil")
 	}
 	mc = &LegacyTrafficMonitorConfigMap{}
 	if LegacyMonitorConfigValid(mc) == nil {
 		t.Errorf("MonitorConfigValid({}) expected: error, actual: nil")
 	}

 	validMC := &LegacyTrafficMonitorConfigMap{
 		TrafficServer:   map[string]LegacyTrafficServer{"a": {}},
 		CacheGroup:      map[string]TMCacheGroup{"a": {}},
 		TrafficMonitor:  map[string]TrafficMonitor{"a": {}},
 		DeliveryService: map[string]TMDeliveryService{"a": {}},
 		Profile:         map[string]TMProfile{"a": {}},
 		Config: map[string]interface{}{
 			"peers.polling.interval":  42.0,
 			"health.polling.interval": 24.0,
 		},
 	}
 	if err := LegacyMonitorConfigValid(validMC); err != nil {
 		t.Errorf("MonitorConfigValid(%++v) expected: nil, actual: %+v", validMC, err)
 	}
 }

 func ExampleHealthThreshold_String() {
 	ht := HealthThreshold{Comparator: ">=", Val: 500}
 	fmt.Println(ht)
 	// Output: >=500.000000
 }

 func ExampleTMParameters_UnmarshalJSON() {
 	const data = `{
 		"health.connection.timeout": 5,
 		"health.polling.url": "https://example.com/",
 		"health.polling.format": "stats_over_http",
 		"history.count": 1,
 		"health.threshold.bandwidth": ">50",
 		"health.threshold.foo": "<=500"
 	}`

 	var params TMParameters
 	if err := json.Unmarshal([]byte(data), &params); err != nil {
 		fmt.Printf("Failed to unmarshal: %v\n", err)
 		return
 	}
 	fmt.Printf("timeout: %d\n", params.HealthConnectionTimeout)
 	fmt.Printf("url: %s\n", params.HealthPollingURL)
 	fmt.Printf("format: %s\n", params.HealthPollingFormat)
 	fmt.Printf("history: %d\n", params.HistoryCount)
 	fmt.Printf("# of Thresholds: %d - foo: %s, bandwidth: %s\n", len(params.Thresholds), params.Thresholds["foo"], params.Thresholds["bandwidth"])

 	// Output: timeout: 5
 	// url: https://example.com/
 	// format: stats_over_http
 	// history: 1
 	// # of Thresholds: 2 - foo: <=500.000000, bandwidth: >50.000000
 }

 func ExampleTrafficMonitorConfigMap_Valid() {
 	mc := &TrafficMonitorConfigMap{
 		CacheGroup: map[string]TMCacheGroup{"a": {}},
 		Config: map[string]interface{}{
 			"peers.polling.interval":  0.0,
 			"health.polling.interval": 0.0,
 		},
 		DeliveryService: map[string]TMDeliveryService{"a": {}},
 		Profile:         map[string]TMProfile{"a": {}},
 		TrafficMonitor:  map[string]TrafficMonitor{"a": {}},
 		TrafficServer:   map[string]TrafficServer{"a": {}},
 	}

 	fmt.Printf("Validity error: %v", mc.Valid())

 	// Output: Validity error: <nil>
 }

 func ExampleLegacyTrafficMonitorConfigMap_Upgrade() {
 	lcm := LegacyTrafficMonitorConfigMap{
 		CacheGroup: map[string]TMCacheGroup{
 			"test": {
 				Name: "test",
 				Coordinates: MonitoringCoordinates{
 					Latitude:  0,
 					Longitude: 0,
 				},
 			},
 		},
 		Config: map[string]interface{}{
 			"foo": "bar",
 		},
 		DeliveryService: map[string]TMDeliveryService{
 			"test": {
 				XMLID:              "test",
 				TotalTPSThreshold:  -1,
 				ServerStatus:       "testStatus",
 				TotalKbpsThreshold: -1,
 			},
 		},
 		Profile: map[string]TMProfile{
 			"test": {
 				Parameters: TMParameters{
 					HealthConnectionTimeout: -1,
 					HealthPollingURL:        "testURL",
 					HealthPollingFormat:     "astats",
 					HealthPollingType:       "http",
 					HistoryCount:            -1,
 					MinFreeKbps:             -1,
 					Thresholds: map[string]HealthThreshold{
 						"availableBandwidthInKbps": {
 							Comparator: "<",
 							Val:        -1,
 						},
 					},
 				},
 				Name: "test",
 				Type: "testType",
 			},
 		},
 		TrafficMonitor: map[string]TrafficMonitor{
 			"test": {
 				Port:         -1,
 				IP6:          "::1",
 				IP:           "0.0.0.0",
 				HostName:     "test",
 				FQDN:         "test.quest",
 				Profile:      "test",
 				Location:     "test",
 				ServerStatus: "testStatus",
 			},
 		},
 		TrafficServer: map[string]LegacyTrafficServer{
 			"test": {
 				CacheGroup:       "test",
 				DeliveryServices: []TSDeliveryService{},
 				FQDN:             "test.quest",
 				HashID:           "test",
 				HostName:         "test",
 				HTTPSPort:        -1,
 				InterfaceName:    "testInterface",
 				IP:               "0.0.0.1",
 				IP6:              "::2",
 				Port:             -1,
 				Profile:          "test",
 				ServerStatus:     "testStatus",
 				Type:             "testType",
 			},
 		},
 	}

 	cm := lcm.Upgrade()
 	fmt.Println("# of Cachegroups:", len(cm.CacheGroup))
 	fmt.Println("Cachegroup Name:", cm.CacheGroup["test"].Name)
 	fmt.Printf("Cachegroup Coordinates: (%v,%v)\n", cm.CacheGroup["test"].Coordinates.Latitude, cm.CacheGroup["test"].Coordinates.Longitude)
 	fmt.Println("# of Config parameters:", len(cm.Config))
 	fmt.Println(`Config["foo"]:`, cm.Config["foo"])
 	fmt.Println("# of DeliveryServices:", len(cm.DeliveryService))
 	fmt.Println("DeliveryService XMLID:", cm.DeliveryService["test"].XMLID)
 	fmt.Println("DeliveryService TotalTPSThreshold:", cm.DeliveryService["test"].TotalTPSThreshold)
 	fmt.Println("DeliveryService ServerStatus:", cm.DeliveryService["test"].ServerStatus)
 	fmt.Println("DeliveryService TotalKbpsThreshold:", cm.DeliveryService["test"].TotalKbpsThreshold)
 	fmt.Println("# of Profiles:", len(cm.Profile))
 	fmt.Println("Profile Name:", cm.Profile["test"].Name)
 	fmt.Println("Profile Type:", cm.Profile["test"].Type)
 	fmt.Println("Profile HealthConnectionTimeout:", cm.Profile["test"].Parameters.HealthConnectionTimeout)
 	fmt.Println("Profile HealthPollingURL:", cm.Profile["test"].Parameters.HealthPollingURL)
 	fmt.Println("Profile HealthPollingFormat:", cm.Profile["test"].Parameters.HealthPollingFormat)
 	fmt.Println("Profile HealthPollingType:", cm.Profile["test"].Parameters.HealthPollingType)
 	fmt.Println("Profile HistoryCount:", cm.Profile["test"].Parameters.HistoryCount)
 	fmt.Println("Profile MinFreeKbps:", cm.Profile["test"].Parameters.MinFreeKbps)
 	fmt.Println("# of Profile Thresholds:", len(cm.Profile["test"].Parameters.Thresholds))
 	fmt.Println("Profile availableBandwidthInKbps Threshold:", cm.Profile["test"].Parameters.Thresholds["availableBandwidthInKbps"])
 	fmt.Println("# of TrafficMonitors:", len(cm.TrafficMonitor))
 	fmt.Println("TrafficMonitor Port:", cm.TrafficMonitor["test"].Port)
 	fmt.Println("TrafficMonitor IP6:", cm.TrafficMonitor["test"].IP6)
 	fmt.Println("TrafficMonitor IP:", cm.TrafficMonitor["test"].IP)
 	fmt.Println("TrafficMonitor HostName:", cm.TrafficMonitor["test"].HostName)
 	fmt.Println("TrafficMonitor FQDN:", cm.TrafficMonitor["test"].FQDN)
 	fmt.Println("TrafficMonitor Profile:", cm.TrafficMonitor["test"].Profile)
 	fmt.Println("TrafficMonitor Location:", cm.TrafficMonitor["test"].Location)
 	fmt.Println("TrafficMonitor ServerStatus:", cm.TrafficMonitor["test"].ServerStatus)
 	fmt.Println("# of TrafficServers:", len(cm.TrafficServer))
 	fmt.Println("TrafficServer CacheGroup:", cm.TrafficServer["test"].CacheGroup)
 	fmt.Println("TrafficServer # of DeliveryServices:", len(cm.TrafficServer["test"].DeliveryServices))
 	fmt.Println("TrafficServer FQDN:", cm.TrafficServer["test"].FQDN)
 	fmt.Println("TrafficServer HashID:", cm.TrafficServer["test"].HashID)
 	fmt.Println("TrafficServer HostName:", cm.TrafficServer["test"].HostName)
 	fmt.Println("TrafficServer HTTPSPort:", cm.TrafficServer["test"].HTTPSPort)
 	fmt.Println("TrafficServer # of Interfaces:", len(cm.TrafficServer["test"].Interfaces))
 	fmt.Println("TrafficServer Interface Name:", cm.TrafficServer["test"].Interfaces[0].Name)
 	fmt.Println("TrafficServer # of Interface IP Addresses:", len(cm.TrafficServer["test"].Interfaces[0].IPAddresses))
 	fmt.Println("TrafficServer first IP Address:", cm.TrafficServer["test"].Interfaces[0].IPAddresses[0].Address)
 	fmt.Println("TrafficServer second IP Address:", cm.TrafficServer["test"].Interfaces[0].IPAddresses[1].Address)
 	fmt.Println("TrafficServer Port:", cm.TrafficServer["test"].Port)
 	fmt.Println("TrafficServer Profile:", cm.TrafficServer["test"].Profile)
 	fmt.Println("TrafficServer ServerStatus:", cm.TrafficServer["test"].ServerStatus)
 	fmt.Println("TrafficServer Type:", cm.TrafficServer["test"].Type)

 	// Output: # of Cachegroups: 1
 	// Cachegroup Name: test
 	// Cachegroup Coordinates: (0,0)
 	// # of Config parameters: 1
 	// Config["foo"]: bar
 	// # of DeliveryServices: 1
 	// DeliveryService XMLID: test
 	// DeliveryService TotalTPSThreshold: -1
 	// DeliveryService ServerStatus: testStatus
 	// DeliveryService TotalKbpsThreshold: -1
 	// # of Profiles: 1
 	// Profile Name: test
 	// Profile Type: testType
 	// Profile HealthConnectionTimeout: -1
 	// Profile HealthPollingURL: testURL
 	// Profile HealthPollingFormat: astats
 	// Profile HealthPollingType: http
 	// Profile HistoryCount: -1
 	// Profile MinFreeKbps: -1
 	// # of Profile Thresholds: 1
 	// Profile availableBandwidthInKbps Threshold: <-1.000000
 	// # of TrafficMonitors: 1
 	// TrafficMonitor Port: -1
 	// TrafficMonitor IP6: ::1
 	// TrafficMonitor IP: 0.0.0.0
 	// TrafficMonitor HostName: test
 	// TrafficMonitor FQDN: test.quest
 	// TrafficMonitor Profile: test
 	// TrafficMonitor Location: test
 	// TrafficMonitor ServerStatus: testStatus
 	// # of TrafficServers: 1
 	// TrafficServer CacheGroup: test
 	// TrafficServer # of DeliveryServices: 0
 	// TrafficServer FQDN: test.quest
 	// TrafficServer HashID: test
 	// TrafficServer HostName: test
 	// TrafficServer HTTPSPort: -1
 	// TrafficServer # of Interfaces: 1
 	// TrafficServer Interface Name: testInterface
 	// TrafficServer # of Interface IP Addresses: 2
 	// TrafficServer first IP Address: 0.0.0.1
 	// TrafficServer second IP Address: ::2
 	// TrafficServer Port: -1
 	// TrafficServer Profile: test
 	// TrafficServer ServerStatus: testStatus
 	// TrafficServer Type: testType
 }

 func TestTrafficMonitorConfigMap_Valid(t *testing.T) {
 	var mc *TrafficMonitorConfigMap = nil
 	err := mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of nil config map")
 	} else {
 		t.Logf("Got expected error: checking validity of nil config map: %v", err)
 	}
 	mc = &TrafficMonitorConfigMap{
 		CacheGroup: nil,
 		Config: map[string]interface{}{
 			"peers.polling.interval":  42.0,
 			"health.polling.interval": 24.0,
 		},
 		DeliveryService: map[string]TMDeliveryService{"a": {}},
 		Profile:         map[string]TMProfile{"a": {}},
 		TrafficMonitor:  map[string]TrafficMonitor{"a": {}},
 		TrafficServer:   map[string]TrafficServer{"a": {}},
 	}

 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with nil CacheGroup")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with nil CacheGroup: %v", err)
 	}

 	mc.CacheGroup = map[string]TMCacheGroup{}
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with no CacheGroups")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with no CacheGroups: %v", err)
 	}

 	mc.CacheGroup["a"] = TMCacheGroup{}
 	mc.Config = nil
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with nil Config")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with nil Config: %v", err)
 	}

 	mc.Config = map[string]interface{}{}
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with empty Config")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with empty Config: %v", err)
 	}

 	mc.Config["peers.polling.interval"] = 42.0
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map without health.polling.interval")
 	} else {
 		t.Logf("Got expected error: checking validity of config map without health.polling.interval: %v", err)
 	}

 	delete(mc.Config, "peers.polling.interval")
 	mc.Config["health.polling.interval"] = 42.0
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map without peers.polling.interval")
 	} else {
 		t.Logf("Got expected error: checking validity of config map without peers.polling.interval: %v", err)
 	}

 	mc.Config["peers.polling.interval"] = 42.0
 	mc.DeliveryService = nil
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with nil DeliveryService")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with nil DeliveryService: %v", err)
 	}

 	mc.DeliveryService = map[string]TMDeliveryService{}
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with no DeliveryServices")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with no DeliveryServices: %v", err)
 	}

 	mc.DeliveryService["a"] = TMDeliveryService{}
 	mc.Profile = nil
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with nil Profile")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with nil Profile: %v", err)
 	}

 	mc.Profile = map[string]TMProfile{}
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with no Profiles")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with no Profiles: %v", err)
 	}

 	mc.Profile["a"] = TMProfile{}
 	mc.TrafficMonitor = nil
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with nil TrafficMonitor")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with nil TrafficMonitor: %v", err)
 	}

 	mc.TrafficMonitor = map[string]TrafficMonitor{}
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with no TrafficMonitors")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with no TrafficMonitors: %v", err)
 	}

 	mc.TrafficMonitor["a"] = TrafficMonitor{}
 	mc.TrafficServer = nil
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with nil TrafficServer")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with nil TrafficServer: %v", err)
 	}

 	mc.TrafficServer = map[string]TrafficServer{}
 	err = mc.Valid()
 	if err == nil {
 		t.Error("Didn't get expected error checking validity of config map with no TrafficServers")
 	} else {
 		t.Logf("Got expected error: checking validity of config map with no TrafficServers: %v", err)
 	}
 }

 func TestTrafficMonitorTransformToMap(t *testing.T) {
 	tmc := TrafficMonitorConfig{
 		TrafficServers: []TrafficServer{
 			{
 				HostName: "testHostname",
 				Interfaces: []ServerInterfaceInfo{
 					{
 						Name: "testInterface",
 						IPAddresses: []ServerIPAddress{
 							{
 								Address:        "::1",
 								ServiceAddress: true,
 							},
 						},
 					},
 				},
 			},
 		},
 		CacheGroups: []TMCacheGroup{
 			TMCacheGroup{},
 		},
 		Config: map[string]interface{}{
 			"peers.polling.interval":  5.0,
 			"health.polling.interval": 5.0,
 		},
 		TrafficMonitors: []TrafficMonitor{
 			TrafficMonitor{},
 		},
 		DeliveryServices: []TMDeliveryService{{XMLID: "foo"}},
 		Profiles: []TMProfile{
 			{
 				Name: "test",
 				Parameters: TMParameters{
 					Thresholds: map[string]HealthThreshold{
 						"availableBandwidthInKbps": {
 							Comparator: ">",
 							Val:        42,
 						},
 					},
 				},
 			},
 		},
 	}

 	converted, err := TrafficMonitorTransformToMap(&tmc)
 	if err != nil {
 		t.Fatalf("Unexpected error converting valid TrafficMonitorConfig to map: %v", err)
 	}
 	if converted == nil {
 		t.Fatal("Null map after conversion")
 	}

 	if len(converted.TrafficServer) != 1 {
 		t.Errorf("Incorrect number of traffic servers after conversion; expected: 1, got: %d", len(converted.TrafficServer))
 	}

 	if len(converted.DeliveryService) != 1 {
 		t.Errorf("Incorrect number of deliveryServices after conversion; expected: 1, got: %d", len(converted.DeliveryService))
 	}
 	if _, ok := converted.DeliveryService["foo"]; !ok {
 		t.Error("Expected delivery service 'foo' to exist in map after conversion, but it didn't")
 	}

 	if _, ok := converted.TrafficServer["testHostname"]; !ok {
 		t.Error("Expected server 'testHostname' to exist in map after conversion, but it didn't")
 	} else if len(converted.TrafficServer["testHostname"].Interfaces) != 1 {
 		t.Errorf("Incorrect number of interfaces on converted traffic server; expected: 1, got: %d", len(converted.TrafficServer["testHostname"].Interfaces))
 	} else if len(converted.TrafficServer["testHostname"].Interfaces[0].IPAddresses) != 1 {
 		t.Errorf("Incorrect number of IP addresses on converted traffic server's interface; expected: 1, got: %d", len(converted.TrafficServer["testHostname"].Interfaces[0].IPAddresses))
 	}
 }
	package tc

	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF 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.
	*/

	import (
	"encoding/json"
	"fmt"
	"testing"
	"time"

	"github.com/apache/trafficcontrol/lib/go-util"
	)

	func makeFakeStats(text string) map[string][]ResultStatVal {
	return map[string][]ResultStatVal{
	text + "stat1": {
	{
	Span: 50,
	Time: time.Now(),
	Val: 50,
	},
	},
	text + "stat2": {
	{
	Span: 50,
	Time: time.Now(),
	Val: 50,
	},
	{
	Span: 50,
	Time: time.Now(),
	Val: 50,
	},
	},
	text + "stat3": {
	{
	Span: 50,
	Time: time.Now(),
	Val: 50,
	},
	{
	Span: 50,
	Time: time.Now(),
	Val: 50,
	},
	{
	Span: 50,
	Time: time.Now(),
	Val: 50,
	},
	},
	}
	}

	func makeFakeInterfaces() map[string]map[string][]ResultStatVal {
	return map[string]map[string][]ResultStatVal{
	"interface1": makeFakeStats("interf"),
	"interface2": makeFakeStats("interf"),
	"interface3": makeFakeStats("interf"),
	}
	}
	func TestLegacyStatsConversion(t *testing.T) {
	stats := Stats{
	CommonAPIData: CommonAPIData{},
	Caches: make(map[string]ServerStats),
	}
	config := TrafficMonitorConfigMap{
	TrafficServer: make(map[string]TrafficServer),
	}
	for _, cacheName := range []string{"cache1", "cache2", "cache3"} {
	stats.Caches[cacheName] = ServerStats{
	Interfaces: makeFakeInterfaces(),
	Stats: makeFakeStats(""),
	}
	interfaces := []ServerInterfaceInfo{}
	for name, _ := range stats.Caches[cacheName].Interfaces {
	interfaces = append(interfaces, ServerInterfaceInfo{
	IPAddresses: []ServerIPAddress{
	{
	Address: "192.168.0.8",
	Gateway: util.StrPtr("192.168.0.1"),
	ServiceAddress: true,
	},
	},
	MaxBandwidth: util.Uint64Ptr(1500),
	Monitor: false,
	MTU: util.UInt64Ptr(1500),
	Name: name,
	})
	}
	interfaces[0].Monitor = true
	config.TrafficServer[cacheName] = TrafficServer{
	Interfaces: interfaces,
	}
	}

	issues, legacyStats := stats.ToLegacy(config)

	if len(issues) != 0 {
	t.Error("expect no issues")
	}

	if legacyStats.CommonAPIData != stats.CommonAPIData {
	t.Error("expected CommonAPIData to be the same")
	}

	if len(legacyStats.Caches) != len(stats.Caches) {
	t.Errorf("expected %v caches, got %v", len(stats.Caches), len(legacyStats.Caches))
	}

	for cacheName, legacyCache := range legacyStats.Caches {
	cache, ok := stats.Caches[string(cacheName)]
	if !ok {
	t.Errorf("new interface %v found in upgraded stats, but not in legacy stats", cacheName)
	}
	interf := cache.Interfaces["interface1"]
	if len(interf)+len(cache.Stats) != len(legacyCache) {
	t.Errorf("expected %v stats, got %v", len(interf)+len(cache.Stats), len(legacyCache))
	}
	}
	}

	func TestLegacyStatsNilConversion(t *testing.T) {
	stats := Stats{
	CommonAPIData: CommonAPIData{},
	Caches: nil,
	}
	config := TrafficMonitorConfigMap{
	TrafficServer: nil,
	}
	issues, legacyStats := stats.ToLegacy(config)

	if legacyStats.CommonAPIData != stats.CommonAPIData {
	t.Error("expected CommonAPIData to be the same")
	}

	if len(issues) != 0 {
	t.Error("expect no issues")
	}
	}

	func TestLegacyMonitorConfigValid(t *testing.T) {
	mc := (*LegacyTrafficMonitorConfigMap)(nil)
	if LegacyMonitorConfigValid(mc) == nil {
	t.Errorf("MonitorCopnfigValid(nil) expected: error, actual: nil")
	}
	mc = &LegacyTrafficMonitorConfigMap{}
	if LegacyMonitorConfigValid(mc) == nil {
	t.Errorf("MonitorConfigValid({}) expected: error, actual: nil")
	}

	validMC := &LegacyTrafficMonitorConfigMap{
	TrafficServer: map[string]LegacyTrafficServer{"a": {}},
	CacheGroup: map[string]TMCacheGroup{"a": {}},
	TrafficMonitor: map[string]TrafficMonitor{"a": {}},
	DeliveryService: map[string]TMDeliveryService{"a": {}},
	Profile: map[string]TMProfile{"a": {}},
	Config: map[string]interface{}{
	"peers.polling.interval": 42.0,
	"health.polling.interval": 24.0,
	},
	}
	if err := LegacyMonitorConfigValid(validMC); err != nil {
	t.Errorf("MonitorConfigValid(%++v) expected: nil, actual: %+v", validMC, err)
	}
	}

	func ExampleHealthThreshold_String() {
	ht := HealthThreshold{Comparator: ">=", Val: 500}
	fmt.Println(ht)
	// Output: >=500.000000
	}

	func ExampleTMParameters_UnmarshalJSON() {
	const data = `{
	"health.connection.timeout": 5,
	"health.polling.url": "https://example.com/",
	"health.polling.format": "stats_over_http",
	"history.count": 1,
	"health.threshold.bandwidth": ">50",
	"health.threshold.foo": "<=500"
	}`

	var params TMParameters
	if err := json.Unmarshal([]byte(data), &params); err != nil {
	fmt.Printf("Failed to unmarshal: %v\n", err)
	return
	}
	fmt.Printf("timeout: %d\n", params.HealthConnectionTimeout)
	fmt.Printf("url: %s\n", params.HealthPollingURL)
	fmt.Printf("format: %s\n", params.HealthPollingFormat)
	fmt.Printf("history: %d\n", params.HistoryCount)
	fmt.Printf("# of Thresholds: %d - foo: %s, bandwidth: %s\n", len(params.Thresholds), params.Thresholds["foo"], params.Thresholds["bandwidth"])

	// Output: timeout: 5
	// url: https://example.com/
	// format: stats_over_http
	// history: 1
	// # of Thresholds: 2 - foo: <=500.000000, bandwidth: >50.000000
	}

	func ExampleTrafficMonitorConfigMap_Valid() {
	mc := &TrafficMonitorConfigMap{
	CacheGroup: map[string]TMCacheGroup{"a": {}},
	Config: map[string]interface{}{
	"peers.polling.interval": 0.0,
	"health.polling.interval": 0.0,
	},
	DeliveryService: map[string]TMDeliveryService{"a": {}},
	Profile: map[string]TMProfile{"a": {}},
	TrafficMonitor: map[string]TrafficMonitor{"a": {}},
	TrafficServer: map[string]TrafficServer{"a": {}},
	}

	fmt.Printf("Validity error: %v", mc.Valid())

	// Output: Validity error: <nil>
	}

	func ExampleLegacyTrafficMonitorConfigMap_Upgrade() {
	lcm := LegacyTrafficMonitorConfigMap{
	CacheGroup: map[string]TMCacheGroup{
	"test": {
	Name: "test",
	Coordinates: MonitoringCoordinates{
	Latitude: 0,
	Longitude: 0,
	},
	},
	},
	Config: map[string]interface{}{
	"foo": "bar",
	},
	DeliveryService: map[string]TMDeliveryService{
	"test": {
	XMLID: "test",
	TotalTPSThreshold: -1,
	ServerStatus: "testStatus",
	TotalKbpsThreshold: -1,
	},
	},
	Profile: map[string]TMProfile{
	"test": {
	Parameters: TMParameters{
	HealthConnectionTimeout: -1,
	HealthPollingURL: "testURL",
	HealthPollingFormat: "astats",
	HealthPollingType: "http",
	HistoryCount: -1,
	MinFreeKbps: -1,
	Thresholds: map[string]HealthThreshold{
	"availableBandwidthInKbps": {
	Comparator: "<",
	Val: -1,
	},
	},
	},
	Name: "test",
	Type: "testType",
	},
	},
	TrafficMonitor: map[string]TrafficMonitor{
	"test": {
	Port: -1,
	IP6: "::1",
	IP: "0.0.0.0",
	HostName: "test",
	FQDN: "test.quest",
	Profile: "test",
	Location: "test",
	ServerStatus: "testStatus",
	},
	},
	TrafficServer: map[string]LegacyTrafficServer{
	"test": {
	CacheGroup: "test",
	DeliveryServices: []TSDeliveryService{},
	FQDN: "test.quest",
	HashID: "test",
	HostName: "test",
	HTTPSPort: -1,
	InterfaceName: "testInterface",
	IP: "0.0.0.1",
	IP6: "::2",
	Port: -1,
	Profile: "test",
	ServerStatus: "testStatus",
	Type: "testType",
	},
	},
	}

	cm := lcm.Upgrade()
	fmt.Println("# of Cachegroups:", len(cm.CacheGroup))
	fmt.Println("Cachegroup Name:", cm.CacheGroup["test"].Name)
	fmt.Printf("Cachegroup Coordinates: (%v,%v)\n", cm.CacheGroup["test"].Coordinates.Latitude, cm.CacheGroup["test"].Coordinates.Longitude)
	fmt.Println("# of Config parameters:", len(cm.Config))
	fmt.Println(`Config["foo"]:`, cm.Config["foo"])
	fmt.Println("# of DeliveryServices:", len(cm.DeliveryService))
	fmt.Println("DeliveryService XMLID:", cm.DeliveryService["test"].XMLID)
	fmt.Println("DeliveryService TotalTPSThreshold:", cm.DeliveryService["test"].TotalTPSThreshold)
	fmt.Println("DeliveryService ServerStatus:", cm.DeliveryService["test"].ServerStatus)
	fmt.Println("DeliveryService TotalKbpsThreshold:", cm.DeliveryService["test"].TotalKbpsThreshold)
	fmt.Println("# of Profiles:", len(cm.Profile))
	fmt.Println("Profile Name:", cm.Profile["test"].Name)
	fmt.Println("Profile Type:", cm.Profile["test"].Type)
	fmt.Println("Profile HealthConnectionTimeout:", cm.Profile["test"].Parameters.HealthConnectionTimeout)
	fmt.Println("Profile HealthPollingURL:", cm.Profile["test"].Parameters.HealthPollingURL)
	fmt.Println("Profile HealthPollingFormat:", cm.Profile["test"].Parameters.HealthPollingFormat)
	fmt.Println("Profile HealthPollingType:", cm.Profile["test"].Parameters.HealthPollingType)
	fmt.Println("Profile HistoryCount:", cm.Profile["test"].Parameters.HistoryCount)
	fmt.Println("Profile MinFreeKbps:", cm.Profile["test"].Parameters.MinFreeKbps)
	fmt.Println("# of Profile Thresholds:", len(cm.Profile["test"].Parameters.Thresholds))
	fmt.Println("Profile availableBandwidthInKbps Threshold:", cm.Profile["test"].Parameters.Thresholds["availableBandwidthInKbps"])
	fmt.Println("# of TrafficMonitors:", len(cm.TrafficMonitor))
	fmt.Println("TrafficMonitor Port:", cm.TrafficMonitor["test"].Port)
	fmt.Println("TrafficMonitor IP6:", cm.TrafficMonitor["test"].IP6)
	fmt.Println("TrafficMonitor IP:", cm.TrafficMonitor["test"].IP)
	fmt.Println("TrafficMonitor HostName:", cm.TrafficMonitor["test"].HostName)
	fmt.Println("TrafficMonitor FQDN:", cm.TrafficMonitor["test"].FQDN)
	fmt.Println("TrafficMonitor Profile:", cm.TrafficMonitor["test"].Profile)
	fmt.Println("TrafficMonitor Location:", cm.TrafficMonitor["test"].Location)
	fmt.Println("TrafficMonitor ServerStatus:", cm.TrafficMonitor["test"].ServerStatus)
	fmt.Println("# of TrafficServers:", len(cm.TrafficServer))
	fmt.Println("TrafficServer CacheGroup:", cm.TrafficServer["test"].CacheGroup)
	fmt.Println("TrafficServer # of DeliveryServices:", len(cm.TrafficServer["test"].DeliveryServices))
	fmt.Println("TrafficServer FQDN:", cm.TrafficServer["test"].FQDN)
	fmt.Println("TrafficServer HashID:", cm.TrafficServer["test"].HashID)
	fmt.Println("TrafficServer HostName:", cm.TrafficServer["test"].HostName)
	fmt.Println("TrafficServer HTTPSPort:", cm.TrafficServer["test"].HTTPSPort)
	fmt.Println("TrafficServer # of Interfaces:", len(cm.TrafficServer["test"].Interfaces))
	fmt.Println("TrafficServer Interface Name:", cm.TrafficServer["test"].Interfaces[0].Name)
	fmt.Println("TrafficServer # of Interface IP Addresses:", len(cm.TrafficServer["test"].Interfaces[0].IPAddresses))
	fmt.Println("TrafficServer first IP Address:", cm.TrafficServer["test"].Interfaces[0].IPAddresses[0].Address)
	fmt.Println("TrafficServer second IP Address:", cm.TrafficServer["test"].Interfaces[0].IPAddresses[1].Address)
	fmt.Println("TrafficServer Port:", cm.TrafficServer["test"].Port)
	fmt.Println("TrafficServer Profile:", cm.TrafficServer["test"].Profile)
	fmt.Println("TrafficServer ServerStatus:", cm.TrafficServer["test"].ServerStatus)
	fmt.Println("TrafficServer Type:", cm.TrafficServer["test"].Type)

	// Output: # of Cachegroups: 1
	// Cachegroup Name: test
	// Cachegroup Coordinates: (0,0)
	// # of Config parameters: 1
	// Config["foo"]: bar
	// # of DeliveryServices: 1
	// DeliveryService XMLID: test
	// DeliveryService TotalTPSThreshold: -1
	// DeliveryService ServerStatus: testStatus
	// DeliveryService TotalKbpsThreshold: -1
	// # of Profiles: 1
	// Profile Name: test
	// Profile Type: testType
	// Profile HealthConnectionTimeout: -1
	// Profile HealthPollingURL: testURL
	// Profile HealthPollingFormat: astats
	// Profile HealthPollingType: http
	// Profile HistoryCount: -1
	// Profile MinFreeKbps: -1
	// # of Profile Thresholds: 1
	// Profile availableBandwidthInKbps Threshold: <-1.000000
	// # of TrafficMonitors: 1
	// TrafficMonitor Port: -1
	// TrafficMonitor IP6: ::1
	// TrafficMonitor IP: 0.0.0.0
	// TrafficMonitor HostName: test
	// TrafficMonitor FQDN: test.quest
	// TrafficMonitor Profile: test
	// TrafficMonitor Location: test
	// TrafficMonitor ServerStatus: testStatus
	// # of TrafficServers: 1
	// TrafficServer CacheGroup: test
	// TrafficServer # of DeliveryServices: 0
	// TrafficServer FQDN: test.quest
	// TrafficServer HashID: test
	// TrafficServer HostName: test
	// TrafficServer HTTPSPort: -1
	// TrafficServer # of Interfaces: 1
	// TrafficServer Interface Name: testInterface
	// TrafficServer # of Interface IP Addresses: 2
	// TrafficServer first IP Address: 0.0.0.1
	// TrafficServer second IP Address: ::2
	// TrafficServer Port: -1
	// TrafficServer Profile: test
	// TrafficServer ServerStatus: testStatus
	// TrafficServer Type: testType
	}

	func TestTrafficMonitorConfigMap_Valid(t *testing.T) {
	var mc *TrafficMonitorConfigMap = nil
	err := mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of nil config map")
	} else {
	t.Logf("Got expected error: checking validity of nil config map: %v", err)
	}
	mc = &TrafficMonitorConfigMap{
	CacheGroup: nil,
	Config: map[string]interface{}{
	"peers.polling.interval": 42.0,
	"health.polling.interval": 24.0,
	},
	DeliveryService: map[string]TMDeliveryService{"a": {}},
	Profile: map[string]TMProfile{"a": {}},
	TrafficMonitor: map[string]TrafficMonitor{"a": {}},
	TrafficServer: map[string]TrafficServer{"a": {}},
	}

	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with nil CacheGroup")
	} else {
	t.Logf("Got expected error: checking validity of config map with nil CacheGroup: %v", err)
	}

	mc.CacheGroup = map[string]TMCacheGroup{}
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with no CacheGroups")
	} else {
	t.Logf("Got expected error: checking validity of config map with no CacheGroups: %v", err)
	}

	mc.CacheGroup["a"] = TMCacheGroup{}
	mc.Config = nil
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with nil Config")
	} else {
	t.Logf("Got expected error: checking validity of config map with nil Config: %v", err)
	}

	mc.Config = map[string]interface{}{}
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with empty Config")
	} else {
	t.Logf("Got expected error: checking validity of config map with empty Config: %v", err)
	}

	mc.Config["peers.polling.interval"] = 42.0
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map without health.polling.interval")
	} else {
	t.Logf("Got expected error: checking validity of config map without health.polling.interval: %v", err)
	}

	delete(mc.Config, "peers.polling.interval")
	mc.Config["health.polling.interval"] = 42.0
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map without peers.polling.interval")
	} else {
	t.Logf("Got expected error: checking validity of config map without peers.polling.interval: %v", err)
	}

	mc.Config["peers.polling.interval"] = 42.0
	mc.DeliveryService = nil
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with nil DeliveryService")
	} else {
	t.Logf("Got expected error: checking validity of config map with nil DeliveryService: %v", err)
	}

	mc.DeliveryService = map[string]TMDeliveryService{}
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with no DeliveryServices")
	} else {
	t.Logf("Got expected error: checking validity of config map with no DeliveryServices: %v", err)
	}

	mc.DeliveryService["a"] = TMDeliveryService{}
	mc.Profile = nil
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with nil Profile")
	} else {
	t.Logf("Got expected error: checking validity of config map with nil Profile: %v", err)
	}

	mc.Profile = map[string]TMProfile{}
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with no Profiles")
	} else {
	t.Logf("Got expected error: checking validity of config map with no Profiles: %v", err)
	}

	mc.Profile["a"] = TMProfile{}
	mc.TrafficMonitor = nil
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with nil TrafficMonitor")
	} else {
	t.Logf("Got expected error: checking validity of config map with nil TrafficMonitor: %v", err)
	}

	mc.TrafficMonitor = map[string]TrafficMonitor{}
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with no TrafficMonitors")
	} else {
	t.Logf("Got expected error: checking validity of config map with no TrafficMonitors: %v", err)
	}

	mc.TrafficMonitor["a"] = TrafficMonitor{}
	mc.TrafficServer = nil
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with nil TrafficServer")
	} else {
	t.Logf("Got expected error: checking validity of config map with nil TrafficServer: %v", err)
	}

	mc.TrafficServer = map[string]TrafficServer{}
	err = mc.Valid()
	if err == nil {
	t.Error("Didn't get expected error checking validity of config map with no TrafficServers")
	} else {
	t.Logf("Got expected error: checking validity of config map with no TrafficServers: %v", err)
	}
	}

	func TestTrafficMonitorTransformToMap(t *testing.T) {
	tmc := TrafficMonitorConfig{
	TrafficServers: []TrafficServer{
	{
	HostName: "testHostname",
	Interfaces: []ServerInterfaceInfo{
	{
	Name: "testInterface",
	IPAddresses: []ServerIPAddress{
	{
	Address: "::1",
	ServiceAddress: true,
	},
	},
	},
	},
	},
	},
	CacheGroups: []TMCacheGroup{
	TMCacheGroup{},
	},
	Config: map[string]interface{}{
	"peers.polling.interval": 5.0,
	"health.polling.interval": 5.0,
	},
	TrafficMonitors: []TrafficMonitor{
	TrafficMonitor{},
	},
	DeliveryServices: []TMDeliveryService{{XMLID: "foo"}},
	Profiles: []TMProfile{
	{
	Name: "test",
	Parameters: TMParameters{
	Thresholds: map[string]HealthThreshold{
	"availableBandwidthInKbps": {
	Comparator: ">",
	Val: 42,
	},
	},
	},
	},
	},
	}

	converted, err := TrafficMonitorTransformToMap(&tmc)
	if err != nil {
	t.Fatalf("Unexpected error converting valid TrafficMonitorConfig to map: %v", err)
	}
	if converted == nil {
	t.Fatal("Null map after conversion")
	}

	if len(converted.TrafficServer) != 1 {
	t.Errorf("Incorrect number of traffic servers after conversion; expected: 1, got: %d", len(converted.TrafficServer))
	}

	if len(converted.DeliveryService) != 1 {
	t.Errorf("Incorrect number of deliveryServices after conversion; expected: 1, got: %d", len(converted.DeliveryService))
	}
	if _, ok := converted.DeliveryService["foo"]; !ok {
	t.Error("Expected delivery service 'foo' to exist in map after conversion, but it didn't")
	}

	if _, ok := converted.TrafficServer["testHostname"]; !ok {
	t.Error("Expected server 'testHostname' to exist in map after conversion, but it didn't")
	} else if len(converted.TrafficServer["testHostname"].Interfaces) != 1 {
	t.Errorf("Incorrect number of interfaces on converted traffic server; expected: 1, got: %d", len(converted.TrafficServer["testHostname"].Interfaces))
	} else if len(converted.TrafficServer["testHostname"].Interfaces[0].IPAddresses) != 1 {
	t.Errorf("Incorrect number of IP addresses on converted traffic server's interface; expected: 1, got: %d", len(converted.TrafficServer["testHostname"].Interfaces[0].IPAddresses))
	}
	}