k8s middleware cleanup, testcases, basic SRV (#181)

* Removing unnecessary gitignore pattern

* Updating Makefile to run unittests for subpackages

* Adding Corefile validation to ignore overlapping zones

* Fixing SRV query handling

* Updating README.md now that SRV works

* Fixing debug message, adding code comment

* Clarifying implementation of zone normalization

* "Overlapping zones" is ill-defined. Reimplemented zone overlap/subzone
  checking to contain these functions in k8s middleware and provide
  better code comments explaining the normalization.

* Separate build verbosity from test verbosity

* Cleaning up comments to match repo code style

* Merging warning messages into single message
* Moving function docs to before function declaration

* Adding test cases for k8sclient connector

* Tests cover connector create and setting base url
* Fixed bugs in connector create and setting base url functions

* Updaing README to group and order development work

* Priority focused on achieving functional parity with SkyDNS.

* Adding work items to README and cleaning up formatting

* More README format cleaning

* List formating

* Refactoring k8s API call to allow dependency injection

* Add test cases for data parsing from k8s into dataobject structures

* URL is dependency-injected to allow replacement with a mock http
  server during test execution

* Adding more data validation for JSON parsing tests

* Adding test case for GetResourceList()

* Adding notes about SkyDNS embedded IP and port record names

* Marked test case implemented.

* Fixing formatting for example command.

* Fixing formatting

* Adding notes about Docker image building.

* Adding SkyDNS work item

* Updating TODO list

* Adding name template to Corefile to specify how k8s record names are assembled

* Adding template support for multi-segment zones

* Updating example CoreFile for k8s with template comment

* Misc whitespace cleanup

* Adding SkyDNS naming notes

* Adding namespace filtering to CoreFile config

* Updating example k8sCoreFile to specify namespaces

* Removing unused codepath

* Adding check for valid namespace

* More README TODO restructuring to focus effort

* Adding template validation while parsing CoreFile

* Record name template is considered invalid if it contains a symbol of the form ${bar} where the symbol
  "${bar}" is not an accepted template symbol.

* Refactoring generation of answer records

* Parse typeName out of query string
* Refactor answer record creation as operation over list of ServiceItems

* Moving k8s API caching into SkyDNS equivalency segment

* Adding function to assemble record names from template

* Warning: This commit may be broken. Syncing to get laptop code over to dev machine.

* More todo notes

* Adding comment describing sample test data.

* Update k8sCorefile

* Adding comment

* Adding filtering support for kubernetes "type"

* Required refactoring to support reuse of the StringInSlice function.

* Cleaning up formatting

* Adding note about SkyDNS supporting word "any".

* baseUrl -> baseURL

* Also removed debug statement from core/setup/kubernetes.go

* Fixing test breaking from Url -> URL naming changes

* Changing record name template language ${...} -> {...}

* Fix formatting with go fmt

* Updating all k8sclient data getters to return error value

* Adding error message to k8sclient data accessors

* Cleaning up setup for kubernetes

* Removed verbose nils in initial k8s middleware instance
* Set reasonable defaults if CoreFile has no parameters in the
kubernetes block. (k8s endpoint, and name template)

* Formatting cleanup -- go fmt

1 files changed, 129 insertions, 0 deletions

diff --git a/middleware/kubernetes/nametemplate/nametemplate_test.go b/middleware/kubernetes/nametemplate/nametemplate_test.go
new file mode 100644
index 000000000..a866c4fb6
--- /dev/null
+++ b/middleware/kubernetes/nametemplate/nametemplate_test.go
@@ -0,0 +1,129 @@
+package nametemplate
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const (
+	zone      = 0
+	namespace = 1
+	service   = 2
+)
+
+// Map of format string :: expected locations of name symbols in the format.
+// -1 value indicates that symbol does not exist in format.
+var exampleTemplates = map[string][]int{
+	"{service}.{namespace}.{zone}": []int{2, 1, 0}, // service symbol expected @ position 0, namespace @ 1, zone @ 2
+	"{namespace}.{zone}":           []int{1, 0, -1},
+	"":                             []int{-1, -1, -1},
+}
+
+func TestSetTemplate(t *testing.T) {
+	fmt.Printf("\n")
+	for s, expectedValue := range exampleTemplates {
+
+		n := new(NameTemplate)
+		n.SetTemplate(s)
+
+		// check the indexes resulting from calling SetTemplate() against expectedValues
+		if expectedValue[zone] != -1 {
+			if n.Element["zone"] != expectedValue[zone] {
+				t.Errorf("Expected zone at index '%v', instead found at index '%v' for format string '%v'", expectedValue[zone], n.Element["zone"], s)
+			}
+		}
+	}
+}
+
+func TestGetServiceFromSegmentArray(t *testing.T) {
+	var (
+		n               *NameTemplate
+		formatString    string
+		queryString     string
+		splitQuery      []string
+		expectedService string
+		actualService   string
+	)
+
+	// Case where template contains {service}
+	n = new(NameTemplate)
+	formatString = "{service}.{namespace}.{zone}"
+	n.SetTemplate(formatString)
+
+	queryString = "myservice.mynamespace.coredns"
+	splitQuery = strings.Split(queryString, ".")
+	expectedService = "myservice"
+	actualService = n.GetServiceFromSegmentArray(splitQuery)
+
+	if actualService != expectedService {
+		t.Errorf("Expected service name '%v', instead got service name '%v' for query string '%v' and format '%v'", expectedService, actualService, queryString, formatString)
+	}
+
+	// Case where template does not contain {service}
+	n = new(NameTemplate)
+	formatString = "{namespace}.{zone}"
+	n.SetTemplate(formatString)
+
+	queryString = "mynamespace.coredns"
+	splitQuery = strings.Split(queryString, ".")
+	expectedService = ""
+	actualService = n.GetServiceFromSegmentArray(splitQuery)
+
+	if actualService != expectedService {
+		t.Errorf("Expected service name '%v', instead got service name '%v' for query string '%v' and format '%v'", expectedService, actualService, queryString, formatString)
+	}
+}
+
+func TestGetZoneFromSegmentArray(t *testing.T) {
+	var (
+		n            *NameTemplate
+		formatString string
+		queryString  string
+		splitQuery   []string
+		expectedZone string
+		actualZone   string
+	)
+
+	// Case where template contains {zone}
+	n = new(NameTemplate)
+	formatString = "{service}.{namespace}.{zone}"
+	n.SetTemplate(formatString)
+
+	queryString = "myservice.mynamespace.coredns"
+	splitQuery = strings.Split(queryString, ".")
+	expectedZone = "coredns"
+	actualZone = n.GetZoneFromSegmentArray(splitQuery)
+
+	if actualZone != expectedZone {
+		t.Errorf("Expected zone name '%v', instead got zone name '%v' for query string '%v' and format '%v'", expectedZone, actualZone, queryString, formatString)
+	}
+
+	// Case where template does not contain {zone}
+	n = new(NameTemplate)
+	formatString = "{service}.{namespace}"
+	n.SetTemplate(formatString)
+
+	queryString = "mynamespace.coredns"
+	splitQuery = strings.Split(queryString, ".")
+	expectedZone = ""
+	actualZone = n.GetZoneFromSegmentArray(splitQuery)
+
+	if actualZone != expectedZone {
+		t.Errorf("Expected zone name '%v', instead got zone name '%v' for query string '%v' and format '%v'", expectedZone, actualZone, queryString, formatString)
+	}
+
+	// Case where zone is multiple segments
+	n = new(NameTemplate)
+	formatString = "{service}.{namespace}.{zone}"
+	n.SetTemplate(formatString)
+
+	queryString = "myservice.mynamespace.coredns.cluster.local"
+	splitQuery = strings.Split(queryString, ".")
+	expectedZone = "coredns.cluster.local"
+	actualZone = n.GetZoneFromSegmentArray(splitQuery)
+
+	if actualZone != expectedZone {
+		t.Errorf("Expected zone name '%v', instead got zone name '%v' for query string '%v' and format '%v'", expectedZone, actualZone, queryString, formatString)
+	}
+}