1. docker
  2. Commit 79e5950b2f21b5fae8a305039df6e404c3980772
Browse code

pkg/term: refactor TestEscapeProxyRead

- use subtests to make it clearer what the individual test-cases
are, and to prevent tests from depending on values set by the
previous test(s).
- remove redundant messages in assert (gotest.tools already prints
a useful message if assertions fail).

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
(cherry picked from commit 556d26c07d068d92fd896428ab4ac890554239d7)
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Sebastiaan van Stijn authored on 2019/08/27 21:58:04
Showing 1 changed files
pkg/term/proxy_test.go
History View file @ 79e5950
... ... 
@@ -2,7 +2,6 @@ package term // import "github.com/docker/docker/pkg/term"
2 2
3 3 
 import (
4 4 
 	"bytes"
5 
-	"fmt"
6 5 
 	"testing"
7 6
8 7 
 	"gotest.tools/assert"
... ... 
@@ -10,106 +9,143 @@ import (
10 10 
 )
11 11
12 12 
 func TestEscapeProxyRead(t *testing.T) {
13 
-	escapeKeys, _ := ToBytes("")
14 
-	keys, _ := ToBytes("a")
15 
-	reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
16 
-	buf := make([]byte, len(keys))
17 
-	nr, err := reader.Read(buf)
18 
-	assert.NilError(t, err)
19 
-	assert.Equal(t, nr, len(keys), fmt.Sprintf("nr %d should be equal to the number of %d", nr, len(keys)))
20 
-	assert.DeepEqual(t, keys, buf)
21 
-
22 
-	keys, _ = ToBytes("a,b,c")
23 
-	reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
24 
-	buf = make([]byte, len(keys))
25 
-	nr, err = reader.Read(buf)
26 
-	assert.NilError(t, err)
27 
-	assert.Equal(t, nr, len(keys), fmt.Sprintf("nr %d should be equal to the number of %d", nr, len(keys)))
28 
-	assert.DeepEqual(t, keys, buf)
29 
-
30 
-	keys, _ = ToBytes("")
31 
-	reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
32 
-	buf = make([]byte, len(keys))
33 
-	nr, err = reader.Read(buf)
34 
-	assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read")
35 
-	assert.Equal(t, nr, 0, "nr should be zero")
36 
-	assert.Check(t, is.Len(keys, 0))
37 
-	assert.Check(t, is.Len(buf, 0))
38 
-
39 
-	escapeKeys, _ = ToBytes("DEL")
40 
-	keys, _ = ToBytes("a,b,c,+")
41 
-	reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
42 
-	buf = make([]byte, len(keys))
43 
-	nr, err = reader.Read(buf)
44 
-	assert.NilError(t, err)
45 
-	assert.Equal(t, nr, len(keys), fmt.Sprintf("nr %d should be equal to the number of %d", nr, len(keys)))
46 
-	assert.DeepEqual(t, keys, buf)
47 
-
48 
-	keys, _ = ToBytes("")
49 
-	reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
50 
-	buf = make([]byte, len(keys))
51 
-	nr, err = reader.Read(buf)
52 
-	assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read")
53 
-	assert.Equal(t, nr, 0, "nr should be zero")
54 
-	assert.Check(t, is.Len(keys, 0))
55 
-	assert.Check(t, is.Len(buf, 0))
56 
-
57 
-	escapeKeys, _ = ToBytes("ctrl-x,ctrl-@")
58 
-	keys, _ = ToBytes("DEL")
59 
-	reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
60 
-	buf = make([]byte, len(keys))
61 
-	nr, err = reader.Read(buf)
62 
-	assert.NilError(t, err)
63 
-	assert.Equal(t, nr, 1, fmt.Sprintf("nr %d should be equal to the number of 1", nr))
64 
-	assert.DeepEqual(t, keys, buf)
65 
-
66 
-	escapeKeys, _ = ToBytes("ctrl-c")
67 
-	keys, _ = ToBytes("ctrl-c")
68 
-	reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
69 
-	buf = make([]byte, len(keys))
70 
-	nr, err = reader.Read(buf)
71 
-	assert.Error(t, err, "read escape sequence")
72 
-	assert.Equal(t, nr, 0, "nr should be equal to 0")
73 
-	assert.DeepEqual(t, keys, buf)
74 
-
75 
-	escapeKeys, _ = ToBytes("ctrl-c,ctrl-z")
76 
-	keys, _ = ToBytes("ctrl-c,ctrl-z")
77 
-	reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
78 
-	buf = make([]byte, 1)
79 
-	nr, err = reader.Read(buf)
80 
-	assert.NilError(t, err)
81 
-	assert.Equal(t, nr, 0, "nr should be equal to 0")
82 
-	assert.DeepEqual(t, keys[0:1], buf)
83 
-	nr, err = reader.Read(buf)
84 
-	assert.Error(t, err, "read escape sequence")
85 
-	assert.Equal(t, nr, 0, "nr should be equal to 0")
86 
-	assert.DeepEqual(t, keys[1:], buf)
87 
-
88 
-	escapeKeys, _ = ToBytes("ctrl-c,ctrl-z")
89 
-	keys, _ = ToBytes("ctrl-c,DEL,+")
90 
-	reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
91 
-	buf = make([]byte, 1)
92 
-	nr, err = reader.Read(buf)
93 
-	assert.NilError(t, err)
94 
-	assert.Equal(t, nr, 0, "nr should be equal to 0")
95 
-	assert.DeepEqual(t, keys[0:1], buf)
96 
-	buf = make([]byte, len(keys))
97 
-	nr, err = reader.Read(buf)
98 
-	assert.NilError(t, err)
99 
-	assert.Equal(t, nr, len(keys), fmt.Sprintf("nr should be equal to %d", len(keys)))
100 
-	assert.DeepEqual(t, keys, buf)
101 
-
102 
-	escapeKeys, _ = ToBytes("ctrl-c,ctrl-z")
103 
-	keys, _ = ToBytes("ctrl-c,DEL")
104 
-	reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
105 
-	buf = make([]byte, 1)
106 
-	nr, err = reader.Read(buf)
107 
-	assert.NilError(t, err)
108 
-	assert.Equal(t, nr, 0, "nr should be equal to 0")
109 
-	assert.DeepEqual(t, keys[0:1], buf)
110 
-	buf = make([]byte, len(keys))
111 
-	nr, err = reader.Read(buf)
112 
-	assert.NilError(t, err)
113 
-	assert.Equal(t, nr, len(keys), fmt.Sprintf("nr should be equal to %d", len(keys)))
114 
-	assert.DeepEqual(t, keys, buf)
13 
+	t.Run("no escape keys, keys a", func(t *testing.T) {
14 
+		escapeKeys, _ := ToBytes("")
15 
+		keys, _ := ToBytes("a")
16 
+		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
17 
+
18 
+		buf := make([]byte, len(keys))
19 
+		nr, err := reader.Read(buf)
20 
+		assert.NilError(t, err)
21 
+		assert.Equal(t, nr, len(keys))
22 
+		assert.DeepEqual(t, keys, buf)
23 
+	})
24 
+
25 
+	t.Run("no escape keys, keys a,b,c", func(t *testing.T) {
26 
+		escapeKeys, _ := ToBytes("")
27 
+		keys, _ := ToBytes("a,b,c")
28 
+		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
29 
+
30 
+		buf := make([]byte, len(keys))
31 
+		nr, err := reader.Read(buf)
32 
+		assert.NilError(t, err)
33 
+		assert.Equal(t, nr, len(keys))
34 
+		assert.DeepEqual(t, keys, buf)
35 
+	})
36 
+
37 
+	t.Run("no escape keys, no keys", func(t *testing.T) {
38 
+		escapeKeys, _ := ToBytes("")
39 
+		keys, _ := ToBytes("")
40 
+		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
41 
+
42 
+		buf := make([]byte, len(keys))
43 
+		nr, err := reader.Read(buf)
44 
+		assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read")
45 
+		assert.Equal(t, nr, 0)
46 
+		assert.Check(t, is.Len(keys, 0))
47 
+		assert.Check(t, is.Len(buf, 0))
48 
+	})
49 
+
50 
+	t.Run("DEL escape key, keys a,b,c,+", func(t *testing.T) {
51 
+		escapeKeys, _ := ToBytes("DEL")
52 
+		keys, _ := ToBytes("a,b,c,+")
53 
+		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
54 
+
55 
+		buf := make([]byte, len(keys))
56 
+		nr, err := reader.Read(buf)
57 
+		assert.NilError(t, err)
58 
+		assert.Equal(t, nr, len(keys))
59 
+		assert.DeepEqual(t, keys, buf)
60 
+	})
61 
+
62 
+	t.Run("DEL escape key, no keys", func(t *testing.T) {
63 
+		escapeKeys, _ := ToBytes("DEL")
64 
+		keys, _ := ToBytes("")
65 
+		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
66 
+
67 
+		buf := make([]byte, len(keys))
68 
+		nr, err := reader.Read(buf)
69 
+		assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read")
70 
+		assert.Equal(t, nr, 0)
71 
+		assert.Check(t, is.Len(keys, 0))
72 
+		assert.Check(t, is.Len(buf, 0))
73 
+	})
74 
+
75 
+	t.Run("ctrl-x,ctrl-@ escape key, keys DEL", func(t *testing.T) {
76 
+		escapeKeys, _ := ToBytes("ctrl-x,ctrl-@")
77 
+		keys, _ := ToBytes("DEL")
78 
+		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
79 
+
80 
+		buf := make([]byte, len(keys))
81 
+		nr, err := reader.Read(buf)
82 
+		assert.NilError(t, err)
83 
+		assert.Equal(t, nr, 1)
84 
+		assert.DeepEqual(t, keys, buf)
85 
+	})
86 
+
87 
+	t.Run("ctrl-c escape key, keys ctrl-c", func(t *testing.T) {
88 
+		escapeKeys, _ := ToBytes("ctrl-c")
89 
+		keys, _ := ToBytes("ctrl-c")
90 
+		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
91 
+
92 
+		buf := make([]byte, len(keys))
93 
+		nr, err := reader.Read(buf)
94 
+		assert.Error(t, err, "read escape sequence")
95 
+		assert.Equal(t, nr, 0)
96 
+		assert.DeepEqual(t, keys, buf)
97 
+	})
98 
+
99 
+	t.Run("ctrl-c,ctrl-z escape key, keys ctrl-c,ctrl-z", func(t *testing.T) {
100 
+		escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")
101 
+		keys, _ := ToBytes("ctrl-c,ctrl-z")
102 
+		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
103 
+
104 
+		buf := make([]byte, 1)
105 
+		nr, err := reader.Read(buf)
106 
+		assert.NilError(t, err)
107 
+		assert.Equal(t, nr, 0)
108 
+		assert.DeepEqual(t, keys[0:1], buf)
109 
+
110 
+		nr, err = reader.Read(buf)
111 
+		assert.Error(t, err, "read escape sequence")
112 
+		assert.Equal(t, nr, 0)
113 
+		assert.DeepEqual(t, keys[1:], buf)
114 
+	})
115 
+
116 
+	t.Run("ctrl-c,ctrl-z escape key, keys ctrl-c,DEL,+", func(t *testing.T) {
117 
+		escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")
118 
+		keys, _ := ToBytes("ctrl-c,DEL,+")
119 
+		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
120 
+
121 
+		buf := make([]byte, 1)
122 
+		nr, err := reader.Read(buf)
123 
+		assert.NilError(t, err)
124 
+		assert.Equal(t, nr, 0)
125 
+		assert.DeepEqual(t, keys[0:1], buf)
126 
+
127 
+		buf = make([]byte, len(keys))
128 
+		nr, err = reader.Read(buf)
129 
+		assert.NilError(t, err)
130 
+		assert.Equal(t, nr, len(keys))
131 
+		assert.DeepEqual(t, keys, buf)
132 
+	})
133 
+
134 
+	t.Run("ctrl-c,ctrl-z escape key, keys ctrl-c,DEL", func(t *testing.T) {
135 
+		escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")
136 
+		keys, _ := ToBytes("ctrl-c,DEL")
137 
+		reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
138 
+
139 
+		buf := make([]byte, 1)
140 
+		nr, err := reader.Read(buf)
141 
+		assert.NilError(t, err)
142 
+		assert.Equal(t, nr, 0)
143 
+		assert.DeepEqual(t, keys[0:1], buf)
144 
+
145 
+		buf = make([]byte, len(keys))
146 
+		nr, err = reader.Read(buf)
147 
+		assert.NilError(t, err)
148 
+		assert.Equal(t, nr, len(keys))
149 
+		assert.DeepEqual(t, keys, buf)
150 
+	})
151 
+
115 152 
 }