1. docker
  2. Commit bc02d42d9ec6d6741946e2edbd13ff8a78bbdb80
Browse code

Make sure template inspector always prints a carriage return.

To match with the raw inspector.
Adds tests to verify its functionality.

Signed-off-by: David Calavera <david.calavera@gmail.com>

David Calavera authored on 2015/12/11 10:36:08
Showing 2 changed files
api/client/inspect/inspector.go
History View file @ bc02d42
... ... 
@@ -48,6 +48,10 @@ func (i *TemplateInspector) Inspect(typedElement interface{}, rawElement []byte)
48 48
49 49 
 // Flush write the result of inspecting all elements into the output stream.
50 50 
 func (i *TemplateInspector) Flush() error {
51 
+	if i.buffer.Len() == 0 {
52 
+		_, err := io.WriteString(i.outputStream, "\n")
53 
+		return err
54 
+	}
51 55 
 	_, err := io.Copy(i.outputStream, i.buffer)
52 56 
 	return err
53 57 
 }
api/client/inspect/inspector_test.go
History View file @ bc02d42
54 58 
new file mode 100644
... ... 
@@ -0,0 +1,189 @@
0 
+package inspect
1 
+
2 
+import (
3 
+	"bytes"
4 
+	"strings"
5 
+	"testing"
6 
+	"text/template"
7 
+)
8 
+
9 
+type testElement struct {
10 
+	DNS string `json:"Dns"`
11 
+}
12 
+
13 
+func TestTemplateInspectorDefault(t *testing.T) {
14 
+	b := new(bytes.Buffer)
15 
+	tmpl, err := template.New("test").Parse("{{.DNS}}")
16 
+	if err != nil {
17 
+		t.Fatal(err)
18 
+	}
19 
+	i := NewTemplateInspector(b, tmpl)
20 
+	if err := i.Inspect(testElement{"0.0.0.0"}, nil); err != nil {
21 
+		t.Fatal(err)
22 
+	}
23 
+
24 
+	if err := i.Flush(); err != nil {
25 
+		t.Fatal(err)
26 
+	}
27 
+	if b.String() != "0.0.0.0\n" {
28 
+		t.Fatalf("Expected `0.0.0.0\\n`, got `%s`", b.String())
29 
+	}
30 
+}
31 
+
32 
+func TestTemplateInspectorEmpty(t *testing.T) {
33 
+	b := new(bytes.Buffer)
34 
+	tmpl, err := template.New("test").Parse("{{.DNS}}")
35 
+	if err != nil {
36 
+		t.Fatal(err)
37 
+	}
38 
+	i := NewTemplateInspector(b, tmpl)
39 
+
40 
+	if err := i.Flush(); err != nil {
41 
+		t.Fatal(err)
42 
+	}
43 
+	if b.String() != "\n" {
44 
+		t.Fatalf("Expected `\\n`, got `%s`", b.String())
45 
+	}
46 
+}
47 
+
48 
+func TestTemplateInspectorTemplateError(t *testing.T) {
49 
+	b := new(bytes.Buffer)
50 
+	tmpl, err := template.New("test").Parse("{{.Foo}}")
51 
+	if err != nil {
52 
+		t.Fatal(err)
53 
+	}
54 
+	i := NewTemplateInspector(b, tmpl)
55 
+
56 
+	err = i.Inspect(testElement{"0.0.0.0"}, nil)
57 
+	if err == nil {
58 
+		t.Fatal("Expected error got nil")
59 
+	}
60 
+
61 
+	if !strings.HasPrefix(err.Error(), "Template parsing error") {
62 
+		t.Fatalf("Expected template error, got %v", err)
63 
+	}
64 
+}
65 
+
66 
+func TestTemplateInspectorRawFallback(t *testing.T) {
67 
+	b := new(bytes.Buffer)
68 
+	tmpl, err := template.New("test").Parse("{{.Dns}}")
69 
+	if err != nil {
70 
+		t.Fatal(err)
71 
+	}
72 
+	i := NewTemplateInspector(b, tmpl)
73 
+	if err := i.Inspect(testElement{"0.0.0.0"}, []byte(`{"Dns": "0.0.0.0"}`)); err != nil {
74 
+		t.Fatal(err)
75 
+	}
76 
+
77 
+	if err := i.Flush(); err != nil {
78 
+		t.Fatal(err)
79 
+	}
80 
+	if b.String() != "0.0.0.0\n" {
81 
+		t.Fatalf("Expected `0.0.0.0\\n`, got `%s`", b.String())
82 
+	}
83 
+}
84 
+
85 
+func TestTemplateInspectorRawFallbackError(t *testing.T) {
86 
+	b := new(bytes.Buffer)
87 
+	tmpl, err := template.New("test").Parse("{{.Dns}}")
88 
+	if err != nil {
89 
+		t.Fatal(err)
90 
+	}
91 
+	i := NewTemplateInspector(b, tmpl)
92 
+	err = i.Inspect(testElement{"0.0.0.0"}, []byte(`{"Foo": "0.0.0.0"}`))
93 
+	if err == nil {
94 
+		t.Fatal("Expected error got nil")
95 
+	}
96 
+
97 
+	if !strings.HasPrefix(err.Error(), "Template parsing error") {
98 
+		t.Fatalf("Expected template error, got %v", err)
99 
+	}
100 
+}
101 
+
102 
+func TestTemplateInspectorMultiple(t *testing.T) {
103 
+	b := new(bytes.Buffer)
104 
+	tmpl, err := template.New("test").Parse("{{.DNS}}")
105 
+	if err != nil {
106 
+		t.Fatal(err)
107 
+	}
108 
+	i := NewTemplateInspector(b, tmpl)
109 
+
110 
+	if err := i.Inspect(testElement{"0.0.0.0"}, nil); err != nil {
111 
+		t.Fatal(err)
112 
+	}
113 
+	if err := i.Inspect(testElement{"1.1.1.1"}, nil); err != nil {
114 
+		t.Fatal(err)
115 
+	}
116 
+
117 
+	if err := i.Flush(); err != nil {
118 
+		t.Fatal(err)
119 
+	}
120 
+	if b.String() != "0.0.0.0\n1.1.1.1\n" {
121 
+		t.Fatalf("Expected `0.0.0.0\\n1.1.1.1\\n`, got `%s`", b.String())
122 
+	}
123 
+}
124 
+
125 
+func TestIndentedInspectorDefault(t *testing.T) {
126 
+	b := new(bytes.Buffer)
127 
+	i := NewIndentedInspector(b)
128 
+	if err := i.Inspect(testElement{"0.0.0.0"}, nil); err != nil {
129 
+		t.Fatal(err)
130 
+	}
131 
+
132 
+	if err := i.Flush(); err != nil {
133 
+		t.Fatal(err)
134 
+	}
135 
+
136 
+	expected := `[
137 
+    {
138 
+        "Dns": "0.0.0.0"
139 
+    }
140 
+]
141 
+`
142 
+	if b.String() != expected {
143 
+		t.Fatalf("Expected `%s`, got `%s`", expected, b.String())
144 
+	}
145 
+}
146 
+
147 
+func TestIndentedInspectorMultiple(t *testing.T) {
148 
+	b := new(bytes.Buffer)
149 
+	i := NewIndentedInspector(b)
150 
+	if err := i.Inspect(testElement{"0.0.0.0"}, nil); err != nil {
151 
+		t.Fatal(err)
152 
+	}
153 
+
154 
+	if err := i.Inspect(testElement{"1.1.1.1"}, nil); err != nil {
155 
+		t.Fatal(err)
156 
+	}
157 
+
158 
+	if err := i.Flush(); err != nil {
159 
+		t.Fatal(err)
160 
+	}
161 
+
162 
+	expected := `[
163 
+    {
164 
+        "Dns": "0.0.0.0"
165 
+    },
166 
+    {
167 
+        "Dns": "1.1.1.1"
168 
+    }
169 
+]
170 
+`
171 
+	if b.String() != expected {
172 
+		t.Fatalf("Expected `%s`, got `%s`", expected, b.String())
173 
+	}
174 
+}
175 
+
176 
+func TestIndentedInspectorEmpty(t *testing.T) {
177 
+	b := new(bytes.Buffer)
178 
+	i := NewIndentedInspector(b)
179 
+
180 
+	if err := i.Flush(); err != nil {
181 
+		t.Fatal(err)
182 
+	}
183 
+
184 
+	expected := "[]\n"
185 
+	if b.String() != expected {
186 
+		t.Fatalf("Expected `%s`, got `%s`", expected, b.String())
187 
+	}
188 
+}