Adds tests for the low-level template functions.

consul/prepared_query/template.go

@@ -60,7 +60,7 @@ func Compile(query *structs.PreparedQuery) (*CompiledTemplate, error) {
 	parse := func(path string, v reflect.Value) error {
 		tree, err := hil.Parse(v.String())
 		if err != nil {
-			return fmt.Errorf("Bad Service%s field with contents '%s': %s", path, v.String(), err)
+			return fmt.Errorf("Bad format '%s' in Service%s: %s", v.String(), path, err)
 		}
 
 		ct.trees[path] = tree
@@ -79,6 +79,15 @@ func Compile(query *structs.PreparedQuery) (*CompiledTemplate, error) {
 		}
 	}
 
+	// Finally do a test render with the supplied name prefix. This will
+	// help catch errors before run time, and this is the most minimal
+	// prefix it will be expected to run with. The results might not make
+	// sense and create a valid service to lookup, but it should render
+	// without any errors.
+	if _, err = ct.Render(ct.query.Name); err != nil {
+		return nil, err
+	}
+
 	return ct, nil
 }
 
@@ -107,7 +116,8 @@ func (ct *CompiledTemplate) Render(name string) (*structs.PreparedQuery, error)
 	// from multiple goroutines.
 	var matches []string
 	if ct.re != nil {
-		matches = ct.re.Copy().FindStringSubmatch(name)
+		re := ct.re.Copy()
+		matches = re.FindStringSubmatch(name)
 	}
 
 	// Create a safe match function that can't fail at run time. It will
@@ -159,10 +169,10 @@ func (ct *CompiledTemplate) Render(name string) (*structs.PreparedQuery, error)
 
 		hv, ht, err := hil.Eval(tree, config)
 		if err != nil {
-			return err
+			return fmt.Errorf("Bad evaluation for '%s' in Service%s: %s", v.String(), path, err)
 		}
 		if ht != ast.TypeString {
-			return fmt.Errorf("Expected Service%s filed to be a string, got %s", path, ht)
+			return fmt.Errorf("Expected Service%s field to be a string, got %s", path, ht)
 		}
 
 		v.SetString(hv.(string))

consul/prepared_query/template_test.go

@@ -1,14 +1,18 @@
 package prepared_query
 
 import (
-	"fmt"
+	"reflect"
+	"strings"
 	"testing"
 
 	"github.com/hashicorp/consul/consul/structs"
+	"github.com/mitchellh/copystructure"
 )
 
 var (
-	bench = &structs.PreparedQuery{
+	// bigBench is a test query that uses all the features of templates, not
+	// in a realistic way, but in a complete way.
+	bigBench = &structs.PreparedQuery{
 		Name: "hello",
 		Template: structs.QueryTemplateOptions{
 			Type:   structs.QueryTemplateTypeNamePrefixMatch,
@@ -16,22 +20,58 @@ var (
 		},
 		Service: structs.ServiceQuery{
 			Service: "${name.full}",
-			Tags:    []string{"${name.prefix}", "${name.suffix}", "${match(0)}", "${match(1)}", "${match(2)}"},
+			Failover: structs.QueryDatacenterOptions{
+				Datacenters: []string{
+					"${name.full}",
+					"${name.prefix}",
+					"${name.suffix}",
+					"${match(0)}",
+					"${match(1)}",
+					"${match(2)}",
+				},
+			},
+			Tags: []string{
+				"${name.full}",
+				"${name.prefix}",
+				"${name.suffix}",
+				"${match(0)}",
+				"${match(1)}",
+				"${match(2)}",
+			},
+		},
+	}
+
+	// smallBench is a small prepared query just for doing geo failover. This
+	// is a minimal, useful configuration.
+	smallBench = &structs.PreparedQuery{
+		Name: "",
+		Template: structs.QueryTemplateOptions{
+			Type: structs.QueryTemplateTypeNamePrefixMatch,
+		},
+		Service: structs.ServiceQuery{
+			Service: "${name.full}",
+			Failover: structs.QueryDatacenterOptions{
+				Datacenters: []string{
+					"dc1",
+					"dc2",
+					"dc3",
+				},
+			},
 		},
 	}
 )
 
-func BenchmarkTemplate_Compile(b *testing.B) {
+func compileBench(b *testing.B, query *structs.PreparedQuery) {
 	for i := 0; i < b.N; i++ {
-		_, err := Compile(bench)
+		_, err := Compile(query)
 		if err != nil {
 			b.Fatalf("err: %v", err)
 		}
 	}
 }
 
-func BenchmarkTemplate_Render(b *testing.B) {
+func renderBench(b *testing.B, query *structs.PreparedQuery) {
-	compiled, err := Compile(bench)
+	compiled, err := Compile(query)
 	if err != nil {
 		b.Fatalf("err: %v", err)
 	}
@@ -44,29 +84,205 @@ func BenchmarkTemplate_Render(b *testing.B) {
 	}
 }
 
+func BenchmarkTemplate_CompileSmall(b *testing.B) {
+	compileBench(b, smallBench)
+}
+
+func BenchmarkTemplate_CompileBig(b *testing.B) {
+	compileBench(b, bigBench)
+}
+
+func BenchmarkTemplate_RenderSmall(b *testing.B) {
+	renderBench(b, smallBench)
+}
+
+func BenchmarkTemplate_RenderBig(b *testing.B) {
+	renderBench(b, bigBench)
+}
+
 func TestTemplate_Compile(t *testing.T) {
-	query := &structs.PreparedQuery{
+	// Start with an empty query that's not even a template.
-		Name: "hello",
+	query := &structs.PreparedQuery{}
+	_, err := Compile(query)
+	if err == nil || !strings.Contains(err.Error(), "Bad Template") {
+		t.Fatalf("bad: %v", err)
+	}
+	if IsTemplate(query) {
+		t.Fatalf("should not be a template")
+	}
+
+	// Make it a basic template, keeping a copy before we compile.
+	query.Template.Type = structs.QueryTemplateTypeNamePrefixMatch
+	query.Template.Regexp = "^(hello)there$"
+	query.Service.Service = "${name.full}"
+	query.Service.Tags = []string{"${match(1)}"}
+	backup, err := copystructure.Copy(query)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+	ct, err := Compile(query)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+	if !IsTemplate(query) {
+		t.Fatalf("should be a template")
+	}
+
+	// Do a sanity check render on it.
+	actual, err := ct.Render("hellothere")
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+
+	// See if it rendered correctly.
+	expected := &structs.PreparedQuery{
 		Template: structs.QueryTemplateOptions{
 			Type:   structs.QueryTemplateTypeNamePrefixMatch,
-			Regexp: "^hello-(.*)$",
+			Regexp: "^(hello)there$",
 		},
 		Service: structs.ServiceQuery{
-			Service: "${name.full}",
+			Service: "hellothere",
-			Tags:    []string{"${name.prefix}", "${name.suffix}", "${match(0)}", "${match(1)}", "${match(2)}"},
+			Tags: []string{
+				"hello",
+			},
 		},
 	}
-
+	if !reflect.DeepEqual(actual, expected) {
-	compiled, err := Compile(query)
+		t.Fatalf("bad: %#v", actual)
-	if err != nil {
-		t.Fatalf("err: %v", err)
 	}
 
-	rendered, err := compiled.Render("hello-everyone")
+	// Prove that it didn't alter the definition we compiled.
-	if err != nil {
+	if !reflect.DeepEqual(query, backup.(*structs.PreparedQuery)) {
-		t.Fatalf("err: %v", err)
+		t.Fatalf("bad: %#v", query)
 	}
 
-	fmt.Printf("%#v\n", *query)
+	// Try a bad HIL interpolation (syntax error).
-	fmt.Printf("%#v\n", *rendered)
+	query.Service.Service = "${name.full"
+	_, err = Compile(query)
+	if err == nil || !strings.Contains(err.Error(), "Bad format") {
+		t.Fatalf("bad: %v", err)
+	}
+
+	// Try a bad HIL interpolation (syntax ok but unknown variable).
+	query.Service.Service = "${name.nope}"
+	_, err = Compile(query)
+	if err == nil || !strings.Contains(err.Error(), "unknown variable") {
+		t.Fatalf("bad: %v", err)
+	}
+
+	// Try a bad regexp.
+	query.Template.Regexp = "^(nope$"
+	query.Service.Service = "${name.full}"
+	_, err = Compile(query)
+	if err == nil || !strings.Contains(err.Error(), "Bad Regexp") {
+		t.Fatalf("bad: %v", err)
+	}
+}
+
+func TestTemplate_Render(t *testing.T) {
+	// Try a noop template that is all static.
+	{
+		query := &structs.PreparedQuery{
+			Template: structs.QueryTemplateOptions{
+				Type: structs.QueryTemplateTypeNamePrefixMatch,
+			},
+			Service: structs.ServiceQuery{
+				Service: "hellothere",
+			},
+		}
+		ct, err := Compile(query)
+		if err != nil {
+			t.Fatalf("err: %v", err)
+		}
+
+		actual, err := ct.Render("unused")
+		if err != nil {
+			t.Fatalf("err: %v", err)
+		}
+		if !reflect.DeepEqual(actual, query) {
+			t.Fatalf("bad: %#v", actual)
+		}
+	}
+
+	// Try all the variables and functions.
+	query := &structs.PreparedQuery{
+		Name: "hello-",
+		Template: structs.QueryTemplateOptions{
+			Type:   structs.QueryTemplateTypeNamePrefixMatch,
+			Regexp: "^(.*?)-(.*?)-(.*)$",
+		},
+		Service: structs.ServiceQuery{
+			Service: "${name.prefix} xxx ${name.full} xxx ${name.suffix}",
+			Tags: []string{
+				"${match(0)}",
+				"${match(1)}",
+				"${match(2)}",
+				"${match(3)}",
+				"${match(4)}",
+				"${40 + 2}",
+			},
+		},
+	}
+	ct, err := Compile(query)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+
+	// Run a case that matches the regexp.
+	{
+		actual, err := ct.Render("hello-foo-bar-none")
+		if err != nil {
+			t.Fatalf("err: %v", err)
+		}
+		expected := &structs.PreparedQuery{
+			Name: "hello-",
+			Template: structs.QueryTemplateOptions{
+				Type:   structs.QueryTemplateTypeNamePrefixMatch,
+				Regexp: "^(.*?)-(.*?)-(.*)$",
+			},
+			Service: structs.ServiceQuery{
+				Service: "hello- xxx hello-foo-bar-none xxx foo-bar-none",
+				Tags: []string{
+					"hello-foo-bar-none",
+					"hello",
+					"foo",
+					"bar-none",
+					"",
+					"42",
+				},
+			},
+		}
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("bad: %#v", actual)
+		}
+	}
+
+	// Run a case that doesn't match the regexp
+	{
+		actual, err := ct.Render("hello-nope")
+		if err != nil {
+			t.Fatalf("err: %v", err)
+		}
+		expected := &structs.PreparedQuery{
+			Name: "hello-",
+			Template: structs.QueryTemplateOptions{
+				Type:   structs.QueryTemplateTypeNamePrefixMatch,
+				Regexp: "^(.*?)-(.*?)-(.*)$",
+			},
+			Service: structs.ServiceQuery{
+				Service: "hello- xxx hello-nope xxx nope",
+				Tags: []string{
+					"",
+					"",
+					"",
+					"",
+					"",
+					"42",
+				},
+			},
+		}
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("bad: %#v", actual)
+		}
+	}
 }