Cleaning up tests to be more resilient

Small refactor of self render

Author: drekle

mhlib/app.go

@@ -21,6 +21,7 @@ import (
 	"io/ioutil"
 	"os"
 	"regexp"
+	"strings"
 	"text/template"
 
 	"github.com/imdario/mergo"
@@ -218,7 +219,7 @@ func (a *App) render(configFile string) (*string, *string, *[]byte, error) {
 	// Self-render the main.yaml with gomplate functions and datasources
 	//   This does not apply to the app.yaml files.
 	contents := string(data)
-	renderedContents, err := selfRender(contents, true)
+	renderedContents, err := selfRender(contents)
 	if err != nil {
 		return nil, nil, nil, fmt.Errorf("Failed to selfRender configFile %v: %v", configFile, err)
 	}
@@ -241,7 +242,6 @@ func (a *App) render(configFile string) (*string, *string, *[]byte, error) {
 	// combining literal with app.yaml
 	data = append(data, appData...)
 
-
 	// Fakechart to send to helm rendering engine
 	fakeChart := &chart.Chart{
 		Metadata: &chart.Metadata{
@@ -294,64 +294,70 @@ func (a *App) render(configFile string) (*string, *string, *[]byte, error) {
 	return &chart, &chartVersion, &overrides, nil
 }
 
-
-func selfRender(templateValuesStr string, enableGomplate bool) (string, error) {
+func selfRender(templateValuesStr string) (string, error) {
 	/*
-	This function will accept an input string and run it through the
-	  templating engine as both the values dictionary as well as the
-	  template string.  It will repeat the process until the templating
-	  result stops changing.
+		This function will accept an input string and run it through the
+		  templating engine as both the values dictionary as well as the
+		  template string.  It will repeat the process until the templating
+		  result stops changing.
 	*/
 
-	type Values map[string]interface{}
+	type gomplateConfig struct {
+		Gomplate gomplate.Config `yaml:"gomplate,omitempty"`
+	}
+	var gomp gomplateConfig
+	err := yaml.Unmarshal([]byte(templateValuesStr), &gomp)
+	if err != nil {
+		return "", err
+	}
+
+	funcs := template.FuncMap{
+		//Add case insensitive handling as marshalled inline structures are public by default, but may be lowercase templates
+		"MyEq": strings.EqualFold,
+	}
+	if len(gomp.Gomplate.DataSources) > 0 {
+		d, err := data.NewData(gomp.Gomplate.DataSources, gomp.Gomplate.DataSourceHeaders)
+		if err != nil {
+			return "", err
+		}
+		for k, v := range gomplate.Funcs(d) {
+			funcs[k] = v
+		}
+	}
+	tmpl := template.New("SelfTemplate").
+		Delims("[[", "]]").
+		Option("missingkey=error").
+		Funcs(funcs)
 
 	lastRender := templateValuesStr
 	for i := 0; i < 10; i++ {
 
 		// Unmarshal the file as a values dict
-		vals := Values{}
-		err := yaml.Unmarshal([]byte(templateValuesStr), &vals)
-		if err != nil { return "", err }
-
-		tmpl := template.New("SelfTemplate")
-		tmpl.Delims("[[", "]]")
-
-		if enableGomplate {
-			// Read the defined gomplate datasources and
-			//   datasourcehaders from the values dict
-			var dataSources []string
-			var dataSourceHeaders []string
-			var gompData gomplate.Config
-			yaml.Unmarshal([]byte(templateValuesStr), &gompData)
-			dataSources = gompData.DataSources
-			dataSourceHeaders = gompData.DataSourceHeaders
-
-			// Access gomplate datasources and function library
-			d, err := data.NewData(dataSources, dataSourceHeaders)
-			if err != nil { return "", err }
-
-			// Configure go/text/template to use gomplate
-			//   datasources and function library.
-			tmpl.Option("missingkey=error")
-			tmpl.Funcs(gomplate.Funcs(d))
+		vals := map[string]interface{}{}
+		err := yaml.Unmarshal([]byte(lastRender), &vals)
+		if err != nil {
+			return "", err
 		}
 
 		// Run the the file through the tempating engine as both values
 		//   file and template file
-		tmpl.Parse(string(templateValuesStr))
-		if err != nil { return "", err }
+		tmpl.Parse(string(lastRender))
+		if err != nil {
+			return "", err
+		}
 		out := new(bytes.Buffer)
 		err = tmpl.Execute(out, vals)
-		if err != nil { return "", err }
+		if err != nil {
+			return "", err
+		}
 
 		newRender := out.String()
 		if lastRender == newRender {
 			return newRender, nil // self-templating succeeded
 		} else {
 			lastRender = newRender
-			templateValuesStr = newRender
 		}
 	}
 
-	return templateValuesStr, errors.New("Self-templating failed")
+	return lastRender, errors.New("Self-templating failed")
 }

mhlib/app_test.go

@@ -1,67 +1,68 @@
 package mhlib
 
 import (
+	"fmt"
+	"net"
 	"testing"
 )
 
-
 func TestSelfRender(t *testing.T) {
 
-	// With datasources
+	// Without datasources
 	templateString := `
-gomplate:
-  datasources:
-  - "http_obj=https://httpbin.org/get"
-  datasourceheaders: []
 values:
   a: foo
   b: '[[ .values.a ]]bar' # foobar
   c: '[[ .values.b ]]baz' # foobarbaz
-  f: 'Func Test: [[ net.LookupIP "example.com" ]]'
 `
 	expected := `
-gomplate:
-  datasources:
-  - "http_obj=https://httpbin.org/get"
-  datasourceheaders: []
 values:
   a: foo
   b: 'foobar' # foobar
   c: 'foobarbaz' # foobarbaz
-  f: 'Func Test: 10.114.236.103'
 `
-	out, err := selfRender(templateString, true)
-	if err != nil {
-		t.Log(err)
-		t.Fail()
-	}
-	if out != expected {
-		t.Logf("Actual: %s\nExpected: %s\n", out, expected)
-		t.Fail()
+	if out, err := selfRender(templateString); out != expected {
+		if err != nil {
+			t.Log(err)
+			t.FailNow()
+		}
+		t.Logf("\nActual: %s\nExpected: %s\n", out, expected)
+		t.FailNow()
 	}
 
-	// Without datasources
-	templateString = `
-values:
-  a: foo
-  b: '[[ .values.a ]]bar' # foobar
-  c: '[[ .values.b ]]baz' # foobarbaz
-`
-	expected = `
+}
+
+func TestSelfRenderDataSources(t *testing.T) {
+
+	// With datasources
+	templateString := `
+gomplate:
+  datasources:
+  - "http_obj=https://httpbin.org/get"
+  datasourceheaders: []
 values:
-  a: foo
-  b: 'foobar' # foobar
-  c: 'foobarbaz' # foobarbaz
+  a: 'Func Test: [[ net.LookupIP "example.com" ]]'
 `
-	out, err = selfRender(templateString, true)
+
+	ips, err := net.LookupIP("example.com")
 	if err != nil {
 		t.Log(err)
-		t.Fail()
+		t.FailNow()
 	}
-	if out != expected {
-		t.Logf("Actual: %s\nExpected: %s\n", out, expected)
-		t.Fail()
+	expected := fmt.Sprintf(`
+gomplate:
+  datasources:
+  - "http_obj=https://httpbin.org/get"
+  datasourceheaders: []
+values:
+  a: 'Func Test: %s'
+`, ips[0].String())
+	if out, err := selfRender(templateString); out != expected {
+		if err != nil {
+			t.Log(err)
+			t.FailNow()
+		}
+		t.Logf("\nActual: %s\nExpected: %s\n", out, expected)
+		t.FailNow()
 	}
-
-
 }