loader_test.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827
  1. package loader
  2. import (
  3. "fmt"
  4. "io/ioutil"
  5. "os"
  6. "sort"
  7. "testing"
  8. "time"
  9. "github.com/docker/docker/cli/compose/types"
  10. "github.com/stretchr/testify/assert"
  11. )
  12. func buildConfigDetails(source types.Dict) types.ConfigDetails {
  13. workingDir, err := os.Getwd()
  14. if err != nil {
  15. panic(err)
  16. }
  17. return types.ConfigDetails{
  18. WorkingDir: workingDir,
  19. ConfigFiles: []types.ConfigFile{
  20. {Filename: "filename.yml", Config: source},
  21. },
  22. Environment: nil,
  23. }
  24. }
  25. var sampleYAML = `
  26. version: "3"
  27. services:
  28. foo:
  29. image: busybox
  30. networks:
  31. with_me:
  32. bar:
  33. image: busybox
  34. environment:
  35. - FOO=1
  36. networks:
  37. - with_ipam
  38. volumes:
  39. hello:
  40. driver: default
  41. driver_opts:
  42. beep: boop
  43. networks:
  44. default:
  45. driver: bridge
  46. driver_opts:
  47. beep: boop
  48. with_ipam:
  49. ipam:
  50. driver: default
  51. config:
  52. - subnet: 172.28.0.0/16
  53. `
  54. var sampleDict = types.Dict{
  55. "version": "3",
  56. "services": types.Dict{
  57. "foo": types.Dict{
  58. "image": "busybox",
  59. "networks": types.Dict{"with_me": nil},
  60. },
  61. "bar": types.Dict{
  62. "image": "busybox",
  63. "environment": []interface{}{"FOO=1"},
  64. "networks": []interface{}{"with_ipam"},
  65. },
  66. },
  67. "volumes": types.Dict{
  68. "hello": types.Dict{
  69. "driver": "default",
  70. "driver_opts": types.Dict{
  71. "beep": "boop",
  72. },
  73. },
  74. },
  75. "networks": types.Dict{
  76. "default": types.Dict{
  77. "driver": "bridge",
  78. "driver_opts": types.Dict{
  79. "beep": "boop",
  80. },
  81. },
  82. "with_ipam": types.Dict{
  83. "ipam": types.Dict{
  84. "driver": "default",
  85. "config": []interface{}{
  86. types.Dict{
  87. "subnet": "172.28.0.0/16",
  88. },
  89. },
  90. },
  91. },
  92. },
  93. }
  94. var sampleConfig = types.Config{
  95. Services: []types.ServiceConfig{
  96. {
  97. Name: "foo",
  98. Image: "busybox",
  99. Environment: map[string]string{},
  100. Networks: map[string]*types.ServiceNetworkConfig{
  101. "with_me": nil,
  102. },
  103. },
  104. {
  105. Name: "bar",
  106. Image: "busybox",
  107. Environment: map[string]string{"FOO": "1"},
  108. Networks: map[string]*types.ServiceNetworkConfig{
  109. "with_ipam": nil,
  110. },
  111. },
  112. },
  113. Networks: map[string]types.NetworkConfig{
  114. "default": {
  115. Driver: "bridge",
  116. DriverOpts: map[string]string{
  117. "beep": "boop",
  118. },
  119. },
  120. "with_ipam": {
  121. Ipam: types.IPAMConfig{
  122. Driver: "default",
  123. Config: []*types.IPAMPool{
  124. {
  125. Subnet: "172.28.0.0/16",
  126. },
  127. },
  128. },
  129. },
  130. },
  131. Volumes: map[string]types.VolumeConfig{
  132. "hello": {
  133. Driver: "default",
  134. DriverOpts: map[string]string{
  135. "beep": "boop",
  136. },
  137. },
  138. },
  139. }
  140. func TestParseYAML(t *testing.T) {
  141. dict, err := ParseYAML([]byte(sampleYAML))
  142. if !assert.NoError(t, err) {
  143. return
  144. }
  145. assert.Equal(t, sampleDict, dict)
  146. }
  147. func TestLoad(t *testing.T) {
  148. actual, err := Load(buildConfigDetails(sampleDict))
  149. if !assert.NoError(t, err) {
  150. return
  151. }
  152. assert.Equal(t, serviceSort(sampleConfig.Services), serviceSort(actual.Services))
  153. assert.Equal(t, sampleConfig.Networks, actual.Networks)
  154. assert.Equal(t, sampleConfig.Volumes, actual.Volumes)
  155. }
  156. func TestLoadV31(t *testing.T) {
  157. actual, err := loadYAML(`
  158. version: "3.1"
  159. services:
  160. foo:
  161. image: busybox
  162. secrets: [super]
  163. secrets:
  164. super:
  165. external: true
  166. `)
  167. if !assert.NoError(t, err) {
  168. return
  169. }
  170. assert.Equal(t, len(actual.Services), 1)
  171. assert.Equal(t, len(actual.Secrets), 1)
  172. }
  173. func TestParseAndLoad(t *testing.T) {
  174. actual, err := loadYAML(sampleYAML)
  175. if !assert.NoError(t, err) {
  176. return
  177. }
  178. assert.Equal(t, serviceSort(sampleConfig.Services), serviceSort(actual.Services))
  179. assert.Equal(t, sampleConfig.Networks, actual.Networks)
  180. assert.Equal(t, sampleConfig.Volumes, actual.Volumes)
  181. }
  182. func TestInvalidTopLevelObjectType(t *testing.T) {
  183. _, err := loadYAML("1")
  184. assert.Error(t, err)
  185. assert.Contains(t, err.Error(), "Top-level object must be a mapping")
  186. _, err = loadYAML("\"hello\"")
  187. assert.Error(t, err)
  188. assert.Contains(t, err.Error(), "Top-level object must be a mapping")
  189. _, err = loadYAML("[\"hello\"]")
  190. assert.Error(t, err)
  191. assert.Contains(t, err.Error(), "Top-level object must be a mapping")
  192. }
  193. func TestNonStringKeys(t *testing.T) {
  194. _, err := loadYAML(`
  195. version: "3"
  196. 123:
  197. foo:
  198. image: busybox
  199. `)
  200. assert.Error(t, err)
  201. assert.Contains(t, err.Error(), "Non-string key at top level: 123")
  202. _, err = loadYAML(`
  203. version: "3"
  204. services:
  205. foo:
  206. image: busybox
  207. 123:
  208. image: busybox
  209. `)
  210. assert.Error(t, err)
  211. assert.Contains(t, err.Error(), "Non-string key in services: 123")
  212. _, err = loadYAML(`
  213. version: "3"
  214. services:
  215. foo:
  216. image: busybox
  217. networks:
  218. default:
  219. ipam:
  220. config:
  221. - 123: oh dear
  222. `)
  223. assert.Error(t, err)
  224. assert.Contains(t, err.Error(), "Non-string key in networks.default.ipam.config[0]: 123")
  225. _, err = loadYAML(`
  226. version: "3"
  227. services:
  228. dict-env:
  229. image: busybox
  230. environment:
  231. 1: FOO
  232. `)
  233. assert.Error(t, err)
  234. assert.Contains(t, err.Error(), "Non-string key in services.dict-env.environment: 1")
  235. }
  236. func TestSupportedVersion(t *testing.T) {
  237. _, err := loadYAML(`
  238. version: "3"
  239. services:
  240. foo:
  241. image: busybox
  242. `)
  243. assert.NoError(t, err)
  244. _, err = loadYAML(`
  245. version: "3.0"
  246. services:
  247. foo:
  248. image: busybox
  249. `)
  250. assert.NoError(t, err)
  251. }
  252. func TestUnsupportedVersion(t *testing.T) {
  253. _, err := loadYAML(`
  254. version: "2"
  255. services:
  256. foo:
  257. image: busybox
  258. `)
  259. assert.Error(t, err)
  260. assert.Contains(t, err.Error(), "version")
  261. _, err = loadYAML(`
  262. version: "2.0"
  263. services:
  264. foo:
  265. image: busybox
  266. `)
  267. assert.Error(t, err)
  268. assert.Contains(t, err.Error(), "version")
  269. }
  270. func TestInvalidVersion(t *testing.T) {
  271. _, err := loadYAML(`
  272. version: 3
  273. services:
  274. foo:
  275. image: busybox
  276. `)
  277. assert.Error(t, err)
  278. assert.Contains(t, err.Error(), "version must be a string")
  279. }
  280. func TestV1Unsupported(t *testing.T) {
  281. _, err := loadYAML(`
  282. foo:
  283. image: busybox
  284. `)
  285. assert.Error(t, err)
  286. }
  287. func TestNonMappingObject(t *testing.T) {
  288. _, err := loadYAML(`
  289. version: "3"
  290. services:
  291. - foo:
  292. image: busybox
  293. `)
  294. assert.Error(t, err)
  295. assert.Contains(t, err.Error(), "services must be a mapping")
  296. _, err = loadYAML(`
  297. version: "3"
  298. services:
  299. foo: busybox
  300. `)
  301. assert.Error(t, err)
  302. assert.Contains(t, err.Error(), "services.foo must be a mapping")
  303. _, err = loadYAML(`
  304. version: "3"
  305. networks:
  306. - default:
  307. driver: bridge
  308. `)
  309. assert.Error(t, err)
  310. assert.Contains(t, err.Error(), "networks must be a mapping")
  311. _, err = loadYAML(`
  312. version: "3"
  313. networks:
  314. default: bridge
  315. `)
  316. assert.Error(t, err)
  317. assert.Contains(t, err.Error(), "networks.default must be a mapping")
  318. _, err = loadYAML(`
  319. version: "3"
  320. volumes:
  321. - data:
  322. driver: local
  323. `)
  324. assert.Error(t, err)
  325. assert.Contains(t, err.Error(), "volumes must be a mapping")
  326. _, err = loadYAML(`
  327. version: "3"
  328. volumes:
  329. data: local
  330. `)
  331. assert.Error(t, err)
  332. assert.Contains(t, err.Error(), "volumes.data must be a mapping")
  333. }
  334. func TestNonStringImage(t *testing.T) {
  335. _, err := loadYAML(`
  336. version: "3"
  337. services:
  338. foo:
  339. image: ["busybox", "latest"]
  340. `)
  341. assert.Error(t, err)
  342. assert.Contains(t, err.Error(), "services.foo.image must be a string")
  343. }
  344. func TestValidEnvironment(t *testing.T) {
  345. config, err := loadYAML(`
  346. version: "3"
  347. services:
  348. dict-env:
  349. image: busybox
  350. environment:
  351. FOO: "1"
  352. BAR: 2
  353. BAZ: 2.5
  354. QUUX:
  355. list-env:
  356. image: busybox
  357. environment:
  358. - FOO=1
  359. - BAR=2
  360. - BAZ=2.5
  361. - QUUX=
  362. `)
  363. assert.NoError(t, err)
  364. expected := types.MappingWithEquals{
  365. "FOO": "1",
  366. "BAR": "2",
  367. "BAZ": "2.5",
  368. "QUUX": "",
  369. }
  370. assert.Equal(t, 2, len(config.Services))
  371. for _, service := range config.Services {
  372. assert.Equal(t, expected, service.Environment)
  373. }
  374. }
  375. func TestInvalidEnvironmentValue(t *testing.T) {
  376. _, err := loadYAML(`
  377. version: "3"
  378. services:
  379. dict-env:
  380. image: busybox
  381. environment:
  382. FOO: ["1"]
  383. `)
  384. assert.Error(t, err)
  385. assert.Contains(t, err.Error(), "services.dict-env.environment.FOO must be a string, number or null")
  386. }
  387. func TestInvalidEnvironmentObject(t *testing.T) {
  388. _, err := loadYAML(`
  389. version: "3"
  390. services:
  391. dict-env:
  392. image: busybox
  393. environment: "FOO=1"
  394. `)
  395. assert.Error(t, err)
  396. assert.Contains(t, err.Error(), "services.dict-env.environment must be a mapping")
  397. }
  398. func TestEnvironmentInterpolation(t *testing.T) {
  399. config, err := loadYAML(`
  400. version: "3"
  401. services:
  402. test:
  403. image: busybox
  404. labels:
  405. - home1=$HOME
  406. - home2=${HOME}
  407. - nonexistent=$NONEXISTENT
  408. - default=${NONEXISTENT-default}
  409. networks:
  410. test:
  411. driver: $HOME
  412. volumes:
  413. test:
  414. driver: $HOME
  415. `)
  416. assert.NoError(t, err)
  417. home := os.Getenv("HOME")
  418. expectedLabels := types.MappingWithEquals{
  419. "home1": home,
  420. "home2": home,
  421. "nonexistent": "",
  422. "default": "default",
  423. }
  424. assert.Equal(t, expectedLabels, config.Services[0].Labels)
  425. assert.Equal(t, home, config.Networks["test"].Driver)
  426. assert.Equal(t, home, config.Volumes["test"].Driver)
  427. }
  428. func TestUnsupportedProperties(t *testing.T) {
  429. dict, err := ParseYAML([]byte(`
  430. version: "3"
  431. services:
  432. web:
  433. image: web
  434. build: ./web
  435. links:
  436. - bar
  437. db:
  438. image: db
  439. build: ./db
  440. `))
  441. assert.NoError(t, err)
  442. configDetails := buildConfigDetails(dict)
  443. _, err = Load(configDetails)
  444. assert.NoError(t, err)
  445. unsupported := GetUnsupportedProperties(configDetails)
  446. assert.Equal(t, []string{"build", "links"}, unsupported)
  447. }
  448. func TestDeprecatedProperties(t *testing.T) {
  449. dict, err := ParseYAML([]byte(`
  450. version: "3"
  451. services:
  452. web:
  453. image: web
  454. container_name: web
  455. db:
  456. image: db
  457. container_name: db
  458. expose: ["5434"]
  459. `))
  460. assert.NoError(t, err)
  461. configDetails := buildConfigDetails(dict)
  462. _, err = Load(configDetails)
  463. assert.NoError(t, err)
  464. deprecated := GetDeprecatedProperties(configDetails)
  465. assert.Equal(t, 2, len(deprecated))
  466. assert.Contains(t, deprecated, "container_name")
  467. assert.Contains(t, deprecated, "expose")
  468. }
  469. func TestForbiddenProperties(t *testing.T) {
  470. _, err := loadYAML(`
  471. version: "3"
  472. services:
  473. foo:
  474. image: busybox
  475. volumes:
  476. - /data
  477. volume_driver: some-driver
  478. bar:
  479. extends:
  480. service: foo
  481. `)
  482. assert.Error(t, err)
  483. assert.IsType(t, &ForbiddenPropertiesError{}, err)
  484. fmt.Println(err)
  485. forbidden := err.(*ForbiddenPropertiesError).Properties
  486. assert.Equal(t, 2, len(forbidden))
  487. assert.Contains(t, forbidden, "volume_driver")
  488. assert.Contains(t, forbidden, "extends")
  489. }
  490. func durationPtr(value time.Duration) *time.Duration {
  491. return &value
  492. }
  493. func int64Ptr(value int64) *int64 {
  494. return &value
  495. }
  496. func uint64Ptr(value uint64) *uint64 {
  497. return &value
  498. }
  499. func TestFullExample(t *testing.T) {
  500. bytes, err := ioutil.ReadFile("full-example.yml")
  501. assert.NoError(t, err)
  502. config, err := loadYAML(string(bytes))
  503. if !assert.NoError(t, err) {
  504. return
  505. }
  506. workingDir, err := os.Getwd()
  507. assert.NoError(t, err)
  508. homeDir := os.Getenv("HOME")
  509. stopGracePeriod := time.Duration(20 * time.Second)
  510. expectedServiceConfig := types.ServiceConfig{
  511. Name: "foo",
  512. CapAdd: []string{"ALL"},
  513. CapDrop: []string{"NET_ADMIN", "SYS_ADMIN"},
  514. CgroupParent: "m-executor-abcd",
  515. Command: []string{"bundle", "exec", "thin", "-p", "3000"},
  516. ContainerName: "my-web-container",
  517. DependsOn: []string{"db", "redis"},
  518. Deploy: types.DeployConfig{
  519. Mode: "replicated",
  520. Replicas: uint64Ptr(6),
  521. Labels: map[string]string{"FOO": "BAR"},
  522. UpdateConfig: &types.UpdateConfig{
  523. Parallelism: uint64Ptr(3),
  524. Delay: time.Duration(10 * time.Second),
  525. FailureAction: "continue",
  526. Monitor: time.Duration(60 * time.Second),
  527. MaxFailureRatio: 0.3,
  528. },
  529. Resources: types.Resources{
  530. Limits: &types.Resource{
  531. NanoCPUs: "0.001",
  532. MemoryBytes: 50 * 1024 * 1024,
  533. },
  534. Reservations: &types.Resource{
  535. NanoCPUs: "0.0001",
  536. MemoryBytes: 20 * 1024 * 1024,
  537. },
  538. },
  539. RestartPolicy: &types.RestartPolicy{
  540. Condition: "on_failure",
  541. Delay: durationPtr(5 * time.Second),
  542. MaxAttempts: uint64Ptr(3),
  543. Window: durationPtr(2 * time.Minute),
  544. },
  545. Placement: types.Placement{
  546. Constraints: []string{"node=foo"},
  547. },
  548. },
  549. Devices: []string{"/dev/ttyUSB0:/dev/ttyUSB0"},
  550. DNS: []string{"8.8.8.8", "9.9.9.9"},
  551. DNSSearch: []string{"dc1.example.com", "dc2.example.com"},
  552. DomainName: "foo.com",
  553. Entrypoint: []string{"/code/entrypoint.sh", "-p", "3000"},
  554. Environment: map[string]string{
  555. "RACK_ENV": "development",
  556. "SHOW": "true",
  557. "SESSION_SECRET": "",
  558. "FOO": "1",
  559. "BAR": "2",
  560. "BAZ": "3",
  561. },
  562. EnvFile: []string{
  563. "./example1.env",
  564. "./example2.env",
  565. },
  566. Expose: []string{"3000", "8000"},
  567. ExternalLinks: []string{
  568. "redis_1",
  569. "project_db_1:mysql",
  570. "project_db_1:postgresql",
  571. },
  572. ExtraHosts: map[string]string{
  573. "otherhost": "50.31.209.229",
  574. "somehost": "162.242.195.82",
  575. },
  576. HealthCheck: &types.HealthCheckConfig{
  577. Test: types.HealthCheckTest([]string{"CMD-SHELL", "echo \"hello world\""}),
  578. Interval: "10s",
  579. Timeout: "1s",
  580. Retries: uint64Ptr(5),
  581. },
  582. Hostname: "foo",
  583. Image: "redis",
  584. Ipc: "host",
  585. Labels: map[string]string{
  586. "com.example.description": "Accounting webapp",
  587. "com.example.number": "42",
  588. "com.example.empty-label": "",
  589. },
  590. Links: []string{
  591. "db",
  592. "db:database",
  593. "redis",
  594. },
  595. Logging: &types.LoggingConfig{
  596. Driver: "syslog",
  597. Options: map[string]string{
  598. "syslog-address": "tcp://192.168.0.42:123",
  599. },
  600. },
  601. MacAddress: "02:42:ac:11:65:43",
  602. NetworkMode: "container:0cfeab0f748b9a743dc3da582046357c6ef497631c1a016d28d2bf9b4f899f7b",
  603. Networks: map[string]*types.ServiceNetworkConfig{
  604. "some-network": {
  605. Aliases: []string{"alias1", "alias3"},
  606. Ipv4Address: "",
  607. Ipv6Address: "",
  608. },
  609. "other-network": {
  610. Ipv4Address: "172.16.238.10",
  611. Ipv6Address: "2001:3984:3989::10",
  612. },
  613. "other-other-network": nil,
  614. },
  615. Pid: "host",
  616. Ports: []string{
  617. "3000",
  618. "3000-3005",
  619. "8000:8000",
  620. "9090-9091:8080-8081",
  621. "49100:22",
  622. "127.0.0.1:8001:8001",
  623. "127.0.0.1:5000-5010:5000-5010",
  624. },
  625. Privileged: true,
  626. ReadOnly: true,
  627. Restart: "always",
  628. SecurityOpt: []string{
  629. "label=level:s0:c100,c200",
  630. "label=type:svirt_apache_t",
  631. },
  632. StdinOpen: true,
  633. StopSignal: "SIGUSR1",
  634. StopGracePeriod: &stopGracePeriod,
  635. Tmpfs: []string{"/run", "/tmp"},
  636. Tty: true,
  637. Ulimits: map[string]*types.UlimitsConfig{
  638. "nproc": {
  639. Single: 65535,
  640. },
  641. "nofile": {
  642. Soft: 20000,
  643. Hard: 40000,
  644. },
  645. },
  646. User: "someone",
  647. Volumes: []string{
  648. "/var/lib/mysql",
  649. "/opt/data:/var/lib/mysql",
  650. fmt.Sprintf("%s:/code", workingDir),
  651. fmt.Sprintf("%s/static:/var/www/html", workingDir),
  652. fmt.Sprintf("%s/configs:/etc/configs/:ro", homeDir),
  653. "datavolume:/var/lib/mysql",
  654. },
  655. WorkingDir: "/code",
  656. }
  657. assert.Equal(t, []types.ServiceConfig{expectedServiceConfig}, config.Services)
  658. expectedNetworkConfig := map[string]types.NetworkConfig{
  659. "some-network": {},
  660. "other-network": {
  661. Driver: "overlay",
  662. DriverOpts: map[string]string{
  663. "foo": "bar",
  664. "baz": "1",
  665. },
  666. Ipam: types.IPAMConfig{
  667. Driver: "overlay",
  668. Config: []*types.IPAMPool{
  669. {Subnet: "172.16.238.0/24"},
  670. {Subnet: "2001:3984:3989::/64"},
  671. },
  672. },
  673. },
  674. "external-network": {
  675. External: types.External{
  676. Name: "external-network",
  677. External: true,
  678. },
  679. },
  680. "other-external-network": {
  681. External: types.External{
  682. Name: "my-cool-network",
  683. External: true,
  684. },
  685. },
  686. }
  687. assert.Equal(t, expectedNetworkConfig, config.Networks)
  688. expectedVolumeConfig := map[string]types.VolumeConfig{
  689. "some-volume": {},
  690. "other-volume": {
  691. Driver: "flocker",
  692. DriverOpts: map[string]string{
  693. "foo": "bar",
  694. "baz": "1",
  695. },
  696. },
  697. "external-volume": {
  698. External: types.External{
  699. Name: "external-volume",
  700. External: true,
  701. },
  702. },
  703. "other-external-volume": {
  704. External: types.External{
  705. Name: "my-cool-volume",
  706. External: true,
  707. },
  708. },
  709. }
  710. assert.Equal(t, expectedVolumeConfig, config.Volumes)
  711. }
  712. func loadYAML(yaml string) (*types.Config, error) {
  713. dict, err := ParseYAML([]byte(yaml))
  714. if err != nil {
  715. return nil, err
  716. }
  717. return Load(buildConfigDetails(dict))
  718. }
  719. func serviceSort(services []types.ServiceConfig) []types.ServiceConfig {
  720. sort.Sort(servicesByName(services))
  721. return services
  722. }
  723. type servicesByName []types.ServiceConfig
  724. func (sbn servicesByName) Len() int { return len(sbn) }
  725. func (sbn servicesByName) Swap(i, j int) { sbn[i], sbn[j] = sbn[j], sbn[i] }
  726. func (sbn servicesByName) Less(i, j int) bool { return sbn[i].Name < sbn[j].Name }
  727. func TestLoadAttachableNetwork(t *testing.T) {
  728. config, err := loadYAML(`
  729. version: "3.1"
  730. networks:
  731. mynet1:
  732. driver: overlay
  733. attachable: true
  734. mynet2:
  735. driver: bridge
  736. `)
  737. assert.NoError(t, err)
  738. expected := map[string]types.NetworkConfig{
  739. "mynet1": {
  740. Driver: "overlay",
  741. Attachable: true,
  742. },
  743. "mynet2": {
  744. Driver: "bridge",
  745. Attachable: false,
  746. },
  747. }
  748. assert.Equal(t, expected, config.Networks)
  749. }