proxy_test.go 5.9 KB

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