service_test.go 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250
  1. package convert
  2. import (
  3. "sort"
  4. "strings"
  5. "testing"
  6. "time"
  7. "github.com/docker/docker/api/types/container"
  8. "github.com/docker/docker/api/types/swarm"
  9. composetypes "github.com/docker/docker/cli/compose/types"
  10. "github.com/docker/docker/pkg/testutil/assert"
  11. )
  12. func TestConvertRestartPolicyFromNone(t *testing.T) {
  13. policy, err := convertRestartPolicy("no", nil)
  14. assert.NilError(t, err)
  15. assert.Equal(t, policy, (*swarm.RestartPolicy)(nil))
  16. }
  17. func TestConvertRestartPolicyFromUnknown(t *testing.T) {
  18. _, err := convertRestartPolicy("unknown", nil)
  19. assert.Error(t, err, "unknown restart policy: unknown")
  20. }
  21. func TestConvertRestartPolicyFromAlways(t *testing.T) {
  22. policy, err := convertRestartPolicy("always", nil)
  23. expected := &swarm.RestartPolicy{
  24. Condition: swarm.RestartPolicyConditionAny,
  25. }
  26. assert.NilError(t, err)
  27. assert.DeepEqual(t, policy, expected)
  28. }
  29. func TestConvertRestartPolicyFromFailure(t *testing.T) {
  30. policy, err := convertRestartPolicy("on-failure:4", nil)
  31. attempts := uint64(4)
  32. expected := &swarm.RestartPolicy{
  33. Condition: swarm.RestartPolicyConditionOnFailure,
  34. MaxAttempts: &attempts,
  35. }
  36. assert.NilError(t, err)
  37. assert.DeepEqual(t, policy, expected)
  38. }
  39. func TestConvertEnvironment(t *testing.T) {
  40. source := map[string]string{
  41. "foo": "bar",
  42. "key": "value",
  43. }
  44. env := convertEnvironment(source)
  45. sort.Strings(env)
  46. assert.DeepEqual(t, env, []string{"foo=bar", "key=value"})
  47. }
  48. func TestConvertResourcesFull(t *testing.T) {
  49. source := composetypes.Resources{
  50. Limits: &composetypes.Resource{
  51. NanoCPUs: "0.003",
  52. MemoryBytes: composetypes.UnitBytes(300000000),
  53. },
  54. Reservations: &composetypes.Resource{
  55. NanoCPUs: "0.002",
  56. MemoryBytes: composetypes.UnitBytes(200000000),
  57. },
  58. }
  59. resources, err := convertResources(source)
  60. assert.NilError(t, err)
  61. expected := &swarm.ResourceRequirements{
  62. Limits: &swarm.Resources{
  63. NanoCPUs: 3000000,
  64. MemoryBytes: 300000000,
  65. },
  66. Reservations: &swarm.Resources{
  67. NanoCPUs: 2000000,
  68. MemoryBytes: 200000000,
  69. },
  70. }
  71. assert.DeepEqual(t, resources, expected)
  72. }
  73. func TestConvertResourcesOnlyMemory(t *testing.T) {
  74. source := composetypes.Resources{
  75. Limits: &composetypes.Resource{
  76. MemoryBytes: composetypes.UnitBytes(300000000),
  77. },
  78. Reservations: &composetypes.Resource{
  79. MemoryBytes: composetypes.UnitBytes(200000000),
  80. },
  81. }
  82. resources, err := convertResources(source)
  83. assert.NilError(t, err)
  84. expected := &swarm.ResourceRequirements{
  85. Limits: &swarm.Resources{
  86. MemoryBytes: 300000000,
  87. },
  88. Reservations: &swarm.Resources{
  89. MemoryBytes: 200000000,
  90. },
  91. }
  92. assert.DeepEqual(t, resources, expected)
  93. }
  94. func TestConvertHealthcheck(t *testing.T) {
  95. retries := uint64(10)
  96. source := &composetypes.HealthCheckConfig{
  97. Test: []string{"EXEC", "touch", "/foo"},
  98. Timeout: "30s",
  99. Interval: "2ms",
  100. Retries: &retries,
  101. }
  102. expected := &container.HealthConfig{
  103. Test: source.Test,
  104. Timeout: 30 * time.Second,
  105. Interval: 2 * time.Millisecond,
  106. Retries: 10,
  107. }
  108. healthcheck, err := convertHealthcheck(source)
  109. assert.NilError(t, err)
  110. assert.DeepEqual(t, healthcheck, expected)
  111. }
  112. func TestConvertHealthcheckDisable(t *testing.T) {
  113. source := &composetypes.HealthCheckConfig{Disable: true}
  114. expected := &container.HealthConfig{
  115. Test: []string{"NONE"},
  116. }
  117. healthcheck, err := convertHealthcheck(source)
  118. assert.NilError(t, err)
  119. assert.DeepEqual(t, healthcheck, expected)
  120. }
  121. func TestConvertHealthcheckDisableWithTest(t *testing.T) {
  122. source := &composetypes.HealthCheckConfig{
  123. Disable: true,
  124. Test: []string{"EXEC", "touch"},
  125. }
  126. _, err := convertHealthcheck(source)
  127. assert.Error(t, err, "test and disable can't be set")
  128. }
  129. func TestConvertEndpointSpec(t *testing.T) {
  130. source := []composetypes.ServicePortConfig{
  131. {
  132. Protocol: "udp",
  133. Target: 53,
  134. Published: 1053,
  135. Mode: "host",
  136. },
  137. {
  138. Target: 8080,
  139. Published: 80,
  140. },
  141. }
  142. endpoint, err := convertEndpointSpec(source)
  143. expected := swarm.EndpointSpec{
  144. Ports: []swarm.PortConfig{
  145. {
  146. TargetPort: 8080,
  147. PublishedPort: 80,
  148. },
  149. {
  150. Protocol: "udp",
  151. TargetPort: 53,
  152. PublishedPort: 1053,
  153. PublishMode: "host",
  154. },
  155. },
  156. }
  157. assert.NilError(t, err)
  158. assert.DeepEqual(t, *endpoint, expected)
  159. }
  160. func TestConvertServiceNetworksOnlyDefault(t *testing.T) {
  161. networkConfigs := networkMap{}
  162. networks := map[string]*composetypes.ServiceNetworkConfig{}
  163. configs, err := convertServiceNetworks(
  164. networks, networkConfigs, NewNamespace("foo"), "service")
  165. expected := []swarm.NetworkAttachmentConfig{
  166. {
  167. Target: "foo_default",
  168. Aliases: []string{"service"},
  169. },
  170. }
  171. assert.NilError(t, err)
  172. assert.DeepEqual(t, configs, expected)
  173. }
  174. func TestConvertServiceNetworks(t *testing.T) {
  175. networkConfigs := networkMap{
  176. "front": composetypes.NetworkConfig{
  177. External: composetypes.External{
  178. External: true,
  179. Name: "fronttier",
  180. },
  181. },
  182. "back": composetypes.NetworkConfig{},
  183. }
  184. networks := map[string]*composetypes.ServiceNetworkConfig{
  185. "front": {
  186. Aliases: []string{"something"},
  187. },
  188. "back": {
  189. Aliases: []string{"other"},
  190. },
  191. }
  192. configs, err := convertServiceNetworks(
  193. networks, networkConfigs, NewNamespace("foo"), "service")
  194. expected := []swarm.NetworkAttachmentConfig{
  195. {
  196. Target: "foo_back",
  197. Aliases: []string{"other", "service"},
  198. },
  199. {
  200. Target: "fronttier",
  201. Aliases: []string{"something", "service"},
  202. },
  203. }
  204. sortedConfigs := byTargetSort(configs)
  205. sort.Sort(&sortedConfigs)
  206. assert.NilError(t, err)
  207. assert.DeepEqual(t, []swarm.NetworkAttachmentConfig(sortedConfigs), expected)
  208. }
  209. type byTargetSort []swarm.NetworkAttachmentConfig
  210. func (s byTargetSort) Len() int {
  211. return len(s)
  212. }
  213. func (s byTargetSort) Less(i, j int) bool {
  214. return strings.Compare(s[i].Target, s[j].Target) < 0
  215. }
  216. func (s byTargetSort) Swap(i, j int) {
  217. s[i], s[j] = s[j], s[i]
  218. }