kotovalexarian-likes-github/moby--moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
Code Releases Activity

pkg/term: refactor TestEscapeProxyRead

Browse source 
- 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>
This commit is contained in:
Sebastiaan van Stijn 2019-08-27 14:58:04 +02:00
parent 5c0d487416
commit 556d26c07d
No known key found for this signature in database
GPG key ID: 76698F39D527CE8C
1 changed files with 130 additions and 94 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

148
pkg/term/proxy_test.go
View file

@ -2,7 +2,6 @@ package term // import "github.com/docker/docker/pkg/term"
import ( import (
"bytes" "bytes"
"fmt"
"testing" "testing"
"gotest.tools/assert" "gotest.tools/assert"
@ -10,106 +9,143 @@ import (
) )
func TestEscapeProxyRead(t *testing.T) { func TestEscapeProxyRead(t *testing.T) {
t.Run("no escape keys, keys a", func(t *testing.T) {
escapeKeys, _ := ToBytes("") escapeKeys, _ := ToBytes("")
keys, _ := ToBytes("a") keys, _ := ToBytes("a")
reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys) reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf := make([]byte, len(keys)) buf := make([]byte, len(keys))
nr, err := reader.Read(buf) nr, err := reader.Read(buf)
assert.NilError(t, err) assert.NilError(t, err)
assert.Equal(t, nr, len(keys), fmt.Sprintf("nr %d should be equal to the number of %d", nr, len(keys))) assert.Equal(t, nr, len(keys))
assert.DeepEqual(t, keys, buf) assert.DeepEqual(t, keys, buf)
})
keys, _ = ToBytes("a,b,c") t.Run("no escape keys, keys a,b,c", func(t *testing.T) {
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys) escapeKeys, _ := ToBytes("")
buf = make([]byte, len(keys)) keys, _ := ToBytes("a,b,c")
nr, err = reader.Read(buf) reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf := make([]byte, len(keys))
nr, err := reader.Read(buf)
assert.NilError(t, err) assert.NilError(t, err)
assert.Equal(t, nr, len(keys), fmt.Sprintf("nr %d should be equal to the number of %d", nr, len(keys))) assert.Equal(t, nr, len(keys))
assert.DeepEqual(t, keys, buf) assert.DeepEqual(t, keys, buf)
})
keys, _ = ToBytes("") t.Run("no escape keys, no keys", func(t *testing.T) {
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys) escapeKeys, _ := ToBytes("")
buf = make([]byte, len(keys)) keys, _ := ToBytes("")
nr, err = reader.Read(buf) reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf := make([]byte, len(keys))
nr, err := reader.Read(buf)
assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read") assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read")
assert.Equal(t, nr, 0, "nr should be zero") assert.Equal(t, nr, 0)
assert.Check(t, is.Len(keys, 0)) assert.Check(t, is.Len(keys, 0))
assert.Check(t, is.Len(buf, 0)) assert.Check(t, is.Len(buf, 0))
})
escapeKeys, _ = ToBytes("DEL") t.Run("DEL escape key, keys a,b,c,+", func(t *testing.T) {
keys, _ = ToBytes("a,b,c,+") escapeKeys, _ := ToBytes("DEL")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys) keys, _ := ToBytes("a,b,c,+")
buf = make([]byte, len(keys)) reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
nr, err = reader.Read(buf)
buf := make([]byte, len(keys))
nr, err := reader.Read(buf)
assert.NilError(t, err) assert.NilError(t, err)
assert.Equal(t, nr, len(keys), fmt.Sprintf("nr %d should be equal to the number of %d", nr, len(keys))) assert.Equal(t, nr, len(keys))
assert.DeepEqual(t, keys, buf) assert.DeepEqual(t, keys, buf)
})
keys, _ = ToBytes("") t.Run("DEL escape key, no keys", func(t *testing.T) {
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys) escapeKeys, _ := ToBytes("DEL")
buf = make([]byte, len(keys)) keys, _ := ToBytes("")
nr, err = reader.Read(buf) reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf := make([]byte, len(keys))
nr, err := reader.Read(buf)
assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read") assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read")
assert.Equal(t, nr, 0, "nr should be zero") assert.Equal(t, nr, 0)
assert.Check(t, is.Len(keys, 0)) assert.Check(t, is.Len(keys, 0))
assert.Check(t, is.Len(buf, 0)) assert.Check(t, is.Len(buf, 0))
})
escapeKeys, _ = ToBytes("ctrl-x,ctrl-@") t.Run("ctrl-x,ctrl-@ escape key, keys DEL", func(t *testing.T) {
keys, _ = ToBytes("DEL") escapeKeys, _ := ToBytes("ctrl-x,ctrl-@")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys) keys, _ := ToBytes("DEL")
buf = make([]byte, len(keys)) reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
nr, err = reader.Read(buf)
buf := make([]byte, len(keys))
nr, err := reader.Read(buf)
assert.NilError(t, err) assert.NilError(t, err)
assert.Equal(t, nr, 1, fmt.Sprintf("nr %d should be equal to the number of 1", nr)) assert.Equal(t, nr, 1)
assert.DeepEqual(t, keys, buf) assert.DeepEqual(t, keys, buf)
})
escapeKeys, _ = ToBytes("ctrl-c") t.Run("ctrl-c escape key, keys ctrl-c", func(t *testing.T) {
keys, _ = ToBytes("ctrl-c") escapeKeys, _ := ToBytes("ctrl-c")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys) keys, _ := ToBytes("ctrl-c")
buf = make([]byte, len(keys)) reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
nr, err = reader.Read(buf)
buf := make([]byte, len(keys))
nr, err := reader.Read(buf)
assert.Error(t, err, "read escape sequence") assert.Error(t, err, "read escape sequence")
assert.Equal(t, nr, 0, "nr should be equal to 0") assert.Equal(t, nr, 0)
assert.DeepEqual(t, keys, buf) assert.DeepEqual(t, keys, buf)
})
escapeKeys, _ = ToBytes("ctrl-c,ctrl-z") t.Run("ctrl-c,ctrl-z escape key, keys ctrl-c,ctrl-z", func(t *testing.T) {
keys, _ = ToBytes("ctrl-c,ctrl-z") escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys) keys, _ := ToBytes("ctrl-c,ctrl-z")
buf = make([]byte, 1) reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
nr, err = reader.Read(buf)
buf := make([]byte, 1)
nr, err := reader.Read(buf)
assert.NilError(t, err) assert.NilError(t, err)
assert.Equal(t, nr, 0, "nr should be equal to 0") assert.Equal(t, nr, 0)
assert.DeepEqual(t, keys[0:1], buf) assert.DeepEqual(t, keys[0:1], buf)
nr, err = reader.Read(buf) nr, err = reader.Read(buf)
assert.Error(t, err, "read escape sequence") assert.Error(t, err, "read escape sequence")
assert.Equal(t, nr, 0, "nr should be equal to 0") assert.Equal(t, nr, 0)
assert.DeepEqual(t, keys[1:], buf) assert.DeepEqual(t, keys[1:], buf)
})
escapeKeys, _ = ToBytes("ctrl-c,ctrl-z") t.Run("ctrl-c,ctrl-z escape key, keys ctrl-c,DEL,+", func(t *testing.T) {
keys, _ = ToBytes("ctrl-c,DEL,+") escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys) keys, _ := ToBytes("ctrl-c,DEL,+")
buf = make([]byte, 1) reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
nr, err = reader.Read(buf)
buf := make([]byte, 1)
nr, err := reader.Read(buf)
assert.NilError(t, err) assert.NilError(t, err)
assert.Equal(t, nr, 0, "nr should be equal to 0") assert.Equal(t, nr, 0)
assert.DeepEqual(t, keys[0:1], buf) assert.DeepEqual(t, keys[0:1], buf)
buf = make([]byte, len(keys)) buf = make([]byte, len(keys))
nr, err = reader.Read(buf) nr, err = reader.Read(buf)
assert.NilError(t, err) assert.NilError(t, err)
assert.Equal(t, nr, len(keys), fmt.Sprintf("nr should be equal to %d", len(keys))) assert.Equal(t, nr, len(keys))
assert.DeepEqual(t, keys, buf) assert.DeepEqual(t, keys, buf)
})
escapeKeys, _ = ToBytes("ctrl-c,ctrl-z") t.Run("ctrl-c,ctrl-z escape key, keys ctrl-c,DEL", func(t *testing.T) {
keys, _ = ToBytes("ctrl-c,DEL") escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys) keys, _ := ToBytes("ctrl-c,DEL")
buf = make([]byte, 1) reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
nr, err = reader.Read(buf)
buf := make([]byte, 1)
nr, err := reader.Read(buf)
assert.NilError(t, err) assert.NilError(t, err)
assert.Equal(t, nr, 0, "nr should be equal to 0") assert.Equal(t, nr, 0)
assert.DeepEqual(t, keys[0:1], buf) assert.DeepEqual(t, keys[0:1], buf)
buf = make([]byte, len(keys)) buf = make([]byte, len(keys))
nr, err = reader.Read(buf) nr, err = reader.Read(buf)
assert.NilError(t, err) assert.NilError(t, err)
assert.Equal(t, nr, len(keys), fmt.Sprintf("nr should be equal to %d", len(keys))) assert.Equal(t, nr, len(keys))
assert.DeepEqual(t, keys, buf) assert.DeepEqual(t, keys, buf)
})
} }