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

Merge pull request #39800 from thaJeztah/refactor_TestEscapeProxyRead

Browse source 
pkg/term: refactor TestEscapeProxyRead
This commit is contained in:
Tibor Vass 2019-09-06 13:51:06 -07:00 • committed by GitHub
commit 4ce040289a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 130 additions and 94 deletions
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)
})
} }