mirror of https://github.com/docker/cli.git
1348 lines
28 KiB
Go
1348 lines
28 KiB
Go
package loader
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"sort"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/docker/cli/cli/compose/types"
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func buildConfigDetails(source map[string]interface{}, env map[string]string) types.ConfigDetails {
|
|
workingDir, err := os.Getwd()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return types.ConfigDetails{
|
|
WorkingDir: workingDir,
|
|
ConfigFiles: []types.ConfigFile{
|
|
{Filename: "filename.yml", Config: source},
|
|
},
|
|
Environment: env,
|
|
}
|
|
}
|
|
|
|
func loadYAML(yaml string) (*types.Config, error) {
|
|
return loadYAMLWithEnv(yaml, nil)
|
|
}
|
|
|
|
func loadYAMLWithEnv(yaml string, env map[string]string) (*types.Config, error) {
|
|
dict, err := ParseYAML([]byte(yaml))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return Load(buildConfigDetails(dict, env))
|
|
}
|
|
|
|
var sampleYAML = `
|
|
version: "3"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
networks:
|
|
with_me:
|
|
bar:
|
|
image: busybox
|
|
environment:
|
|
- FOO=1
|
|
networks:
|
|
- with_ipam
|
|
volumes:
|
|
hello:
|
|
driver: default
|
|
driver_opts:
|
|
beep: boop
|
|
networks:
|
|
default:
|
|
driver: bridge
|
|
driver_opts:
|
|
beep: boop
|
|
with_ipam:
|
|
ipam:
|
|
driver: default
|
|
config:
|
|
- subnet: 172.28.0.0/16
|
|
`
|
|
|
|
var sampleDict = map[string]interface{}{
|
|
"version": "3",
|
|
"services": map[string]interface{}{
|
|
"foo": map[string]interface{}{
|
|
"image": "busybox",
|
|
"networks": map[string]interface{}{"with_me": nil},
|
|
},
|
|
"bar": map[string]interface{}{
|
|
"image": "busybox",
|
|
"environment": []interface{}{"FOO=1"},
|
|
"networks": []interface{}{"with_ipam"},
|
|
},
|
|
},
|
|
"volumes": map[string]interface{}{
|
|
"hello": map[string]interface{}{
|
|
"driver": "default",
|
|
"driver_opts": map[string]interface{}{
|
|
"beep": "boop",
|
|
},
|
|
},
|
|
},
|
|
"networks": map[string]interface{}{
|
|
"default": map[string]interface{}{
|
|
"driver": "bridge",
|
|
"driver_opts": map[string]interface{}{
|
|
"beep": "boop",
|
|
},
|
|
},
|
|
"with_ipam": map[string]interface{}{
|
|
"ipam": map[string]interface{}{
|
|
"driver": "default",
|
|
"config": []interface{}{
|
|
map[string]interface{}{
|
|
"subnet": "172.28.0.0/16",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
func strPtr(val string) *string {
|
|
return &val
|
|
}
|
|
|
|
var sampleConfig = types.Config{
|
|
Services: []types.ServiceConfig{
|
|
{
|
|
Name: "foo",
|
|
Image: "busybox",
|
|
Environment: map[string]*string{},
|
|
Networks: map[string]*types.ServiceNetworkConfig{
|
|
"with_me": nil,
|
|
},
|
|
},
|
|
{
|
|
Name: "bar",
|
|
Image: "busybox",
|
|
Environment: map[string]*string{"FOO": strPtr("1")},
|
|
Networks: map[string]*types.ServiceNetworkConfig{
|
|
"with_ipam": nil,
|
|
},
|
|
},
|
|
},
|
|
Networks: map[string]types.NetworkConfig{
|
|
"default": {
|
|
Driver: "bridge",
|
|
DriverOpts: map[string]string{
|
|
"beep": "boop",
|
|
},
|
|
},
|
|
"with_ipam": {
|
|
Ipam: types.IPAMConfig{
|
|
Driver: "default",
|
|
Config: []*types.IPAMPool{
|
|
{
|
|
Subnet: "172.28.0.0/16",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Volumes: map[string]types.VolumeConfig{
|
|
"hello": {
|
|
Driver: "default",
|
|
DriverOpts: map[string]string{
|
|
"beep": "boop",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
func TestParseYAML(t *testing.T) {
|
|
dict, err := ParseYAML([]byte(sampleYAML))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, sampleDict, dict)
|
|
}
|
|
|
|
func TestLoad(t *testing.T) {
|
|
actual, err := Load(buildConfigDetails(sampleDict, nil))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, serviceSort(sampleConfig.Services), serviceSort(actual.Services))
|
|
assert.Equal(t, sampleConfig.Networks, actual.Networks)
|
|
assert.Equal(t, sampleConfig.Volumes, actual.Volumes)
|
|
}
|
|
|
|
func TestLoadV31(t *testing.T) {
|
|
actual, err := loadYAML(`
|
|
version: "3.1"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
secrets: [super]
|
|
secrets:
|
|
super:
|
|
external: true
|
|
`)
|
|
require.NoError(t, err)
|
|
assert.Len(t, actual.Services, 1)
|
|
assert.Len(t, actual.Secrets, 1)
|
|
}
|
|
|
|
func TestLoadV33(t *testing.T) {
|
|
actual, err := loadYAML(`
|
|
version: "3.3"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
credential_spec:
|
|
File: "/foo"
|
|
configs: [super]
|
|
configs:
|
|
super:
|
|
external: true
|
|
`)
|
|
require.NoError(t, err)
|
|
require.Len(t, actual.Services, 1)
|
|
assert.Equal(t, actual.Services[0].CredentialSpec.File, "/foo")
|
|
require.Len(t, actual.Configs, 1)
|
|
}
|
|
|
|
func TestParseAndLoad(t *testing.T) {
|
|
actual, err := loadYAML(sampleYAML)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, serviceSort(sampleConfig.Services), serviceSort(actual.Services))
|
|
assert.Equal(t, sampleConfig.Networks, actual.Networks)
|
|
assert.Equal(t, sampleConfig.Volumes, actual.Volumes)
|
|
}
|
|
|
|
func TestInvalidTopLevelObjectType(t *testing.T) {
|
|
_, err := loadYAML("1")
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "Top-level object must be a mapping")
|
|
|
|
_, err = loadYAML("\"hello\"")
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "Top-level object must be a mapping")
|
|
|
|
_, err = loadYAML("[\"hello\"]")
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "Top-level object must be a mapping")
|
|
}
|
|
|
|
func TestNonStringKeys(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
123:
|
|
foo:
|
|
image: busybox
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "Non-string key at top level: 123")
|
|
|
|
_, err = loadYAML(`
|
|
version: "3"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
123:
|
|
image: busybox
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "Non-string key in services: 123")
|
|
|
|
_, err = loadYAML(`
|
|
version: "3"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
networks:
|
|
default:
|
|
ipam:
|
|
config:
|
|
- 123: oh dear
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "Non-string key in networks.default.ipam.config[0]: 123")
|
|
|
|
_, err = loadYAML(`
|
|
version: "3"
|
|
services:
|
|
dict-env:
|
|
image: busybox
|
|
environment:
|
|
1: FOO
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "Non-string key in services.dict-env.environment: 1")
|
|
}
|
|
|
|
func TestSupportedVersion(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
`)
|
|
require.NoError(t, err)
|
|
|
|
_, err = loadYAML(`
|
|
version: "3.0"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
`)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestUnsupportedVersion(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "2"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "version")
|
|
|
|
_, err = loadYAML(`
|
|
version: "2.0"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "version")
|
|
}
|
|
|
|
func TestInvalidVersion(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: 3
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "version must be a string")
|
|
}
|
|
|
|
func TestV1Unsupported(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
foo:
|
|
image: busybox
|
|
`)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestNonMappingObject(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
services:
|
|
- foo:
|
|
image: busybox
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "services must be a mapping")
|
|
|
|
_, err = loadYAML(`
|
|
version: "3"
|
|
services:
|
|
foo: busybox
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "services.foo must be a mapping")
|
|
|
|
_, err = loadYAML(`
|
|
version: "3"
|
|
networks:
|
|
- default:
|
|
driver: bridge
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "networks must be a mapping")
|
|
|
|
_, err = loadYAML(`
|
|
version: "3"
|
|
networks:
|
|
default: bridge
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "networks.default must be a mapping")
|
|
|
|
_, err = loadYAML(`
|
|
version: "3"
|
|
volumes:
|
|
- data:
|
|
driver: local
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "volumes must be a mapping")
|
|
|
|
_, err = loadYAML(`
|
|
version: "3"
|
|
volumes:
|
|
data: local
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "volumes.data must be a mapping")
|
|
}
|
|
|
|
func TestNonStringImage(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
services:
|
|
foo:
|
|
image: ["busybox", "latest"]
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "services.foo.image must be a string")
|
|
}
|
|
|
|
func TestLoadWithEnvironment(t *testing.T) {
|
|
config, err := loadYAMLWithEnv(`
|
|
version: "3"
|
|
services:
|
|
dict-env:
|
|
image: busybox
|
|
environment:
|
|
FOO: "1"
|
|
BAR: 2
|
|
BAZ: 2.5
|
|
QUX:
|
|
QUUX:
|
|
list-env:
|
|
image: busybox
|
|
environment:
|
|
- FOO=1
|
|
- BAR=2
|
|
- BAZ=2.5
|
|
- QUX=
|
|
- QUUX
|
|
`, map[string]string{"QUX": "qux"})
|
|
assert.NoError(t, err)
|
|
|
|
expected := types.MappingWithEquals{
|
|
"FOO": strPtr("1"),
|
|
"BAR": strPtr("2"),
|
|
"BAZ": strPtr("2.5"),
|
|
"QUX": strPtr("qux"),
|
|
"QUUX": nil,
|
|
}
|
|
|
|
assert.Equal(t, 2, len(config.Services))
|
|
|
|
for _, service := range config.Services {
|
|
assert.Equal(t, expected, service.Environment)
|
|
}
|
|
}
|
|
|
|
func TestInvalidEnvironmentValue(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
services:
|
|
dict-env:
|
|
image: busybox
|
|
environment:
|
|
FOO: ["1"]
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "services.dict-env.environment.FOO must be a string, number or null")
|
|
}
|
|
|
|
func TestInvalidEnvironmentObject(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
services:
|
|
dict-env:
|
|
image: busybox
|
|
environment: "FOO=1"
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "services.dict-env.environment must be a mapping")
|
|
}
|
|
|
|
func TestLoadWithEnvironmentInterpolation(t *testing.T) {
|
|
home := "/home/foo"
|
|
config, err := loadYAMLWithEnv(`
|
|
version: "3"
|
|
services:
|
|
test:
|
|
image: busybox
|
|
labels:
|
|
- home1=$HOME
|
|
- home2=${HOME}
|
|
- nonexistent=$NONEXISTENT
|
|
- default=${NONEXISTENT-default}
|
|
networks:
|
|
test:
|
|
driver: $HOME
|
|
volumes:
|
|
test:
|
|
driver: $HOME
|
|
`, map[string]string{
|
|
"HOME": home,
|
|
"FOO": "foo",
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
|
|
expectedLabels := types.Labels{
|
|
"home1": home,
|
|
"home2": home,
|
|
"nonexistent": "",
|
|
"default": "default",
|
|
}
|
|
|
|
assert.Equal(t, expectedLabels, config.Services[0].Labels)
|
|
assert.Equal(t, home, config.Networks["test"].Driver)
|
|
assert.Equal(t, home, config.Volumes["test"].Driver)
|
|
}
|
|
|
|
func TestLoadWithInterpolationCastFull(t *testing.T) {
|
|
dict, err := ParseYAML([]byte(`
|
|
version: "3.4"
|
|
services:
|
|
web:
|
|
configs:
|
|
- source: appconfig
|
|
mode: $theint
|
|
secrets:
|
|
- source: super
|
|
mode: $theint
|
|
healthcheck:
|
|
retries: ${theint}
|
|
disable: $thebool
|
|
deploy:
|
|
replicas: $theint
|
|
update_config:
|
|
parallelism: $theint
|
|
max_failure_ratio: $thefloat
|
|
restart_policy:
|
|
max_attempts: $theint
|
|
ports:
|
|
- $theint
|
|
- "34567"
|
|
- target: $theint
|
|
published: $theint
|
|
ulimits:
|
|
nproc: $theint
|
|
nofile:
|
|
hard: $theint
|
|
soft: $theint
|
|
privileged: $thebool
|
|
read_only: $thebool
|
|
stdin_open: ${thebool}
|
|
tty: $thebool
|
|
volumes:
|
|
- source: data
|
|
type: volume
|
|
read_only: $thebool
|
|
volume:
|
|
nocopy: $thebool
|
|
|
|
configs:
|
|
appconfig:
|
|
external: $thebool
|
|
secrets:
|
|
super:
|
|
external: $thebool
|
|
volumes:
|
|
data:
|
|
external: $thebool
|
|
networks:
|
|
front:
|
|
external: $thebool
|
|
internal: $thebool
|
|
attachable: $thebool
|
|
|
|
`))
|
|
require.NoError(t, err)
|
|
env := map[string]string{
|
|
"theint": "555",
|
|
"thefloat": "3.14",
|
|
"thebool": "true",
|
|
}
|
|
|
|
config, err := Load(buildConfigDetails(dict, env))
|
|
require.NoError(t, err)
|
|
expected := &types.Config{
|
|
Filename: "filename.yml",
|
|
Services: []types.ServiceConfig{
|
|
{
|
|
Name: "web",
|
|
Configs: []types.ServiceConfigObjConfig{
|
|
{
|
|
Source: "appconfig",
|
|
Mode: uint32Ptr(555),
|
|
},
|
|
},
|
|
Secrets: []types.ServiceSecretConfig{
|
|
{
|
|
Source: "super",
|
|
Mode: uint32Ptr(555),
|
|
},
|
|
},
|
|
HealthCheck: &types.HealthCheckConfig{
|
|
Retries: uint64Ptr(555),
|
|
Disable: true,
|
|
},
|
|
Deploy: types.DeployConfig{
|
|
Replicas: uint64Ptr(555),
|
|
UpdateConfig: &types.UpdateConfig{
|
|
Parallelism: uint64Ptr(555),
|
|
MaxFailureRatio: 3.14,
|
|
},
|
|
RestartPolicy: &types.RestartPolicy{
|
|
MaxAttempts: uint64Ptr(555),
|
|
},
|
|
},
|
|
Ports: []types.ServicePortConfig{
|
|
{Target: 555, Mode: "ingress", Protocol: "tcp"},
|
|
{Target: 34567, Mode: "ingress", Protocol: "tcp"},
|
|
{Target: 555, Published: 555},
|
|
},
|
|
Ulimits: map[string]*types.UlimitsConfig{
|
|
"nproc": {Single: 555},
|
|
"nofile": {Hard: 555, Soft: 555},
|
|
},
|
|
Privileged: true,
|
|
ReadOnly: true,
|
|
StdinOpen: true,
|
|
Tty: true,
|
|
Volumes: []types.ServiceVolumeConfig{
|
|
{
|
|
Source: "data",
|
|
Type: "volume",
|
|
ReadOnly: true,
|
|
Volume: &types.ServiceVolumeVolume{NoCopy: true},
|
|
},
|
|
},
|
|
Environment: types.MappingWithEquals{},
|
|
},
|
|
},
|
|
Configs: map[string]types.ConfigObjConfig{
|
|
"appconfig": {External: types.External{External: true}, Name: "appconfig"},
|
|
},
|
|
Secrets: map[string]types.SecretConfig{
|
|
"super": {External: types.External{External: true}, Name: "super"},
|
|
},
|
|
Volumes: map[string]types.VolumeConfig{
|
|
"data": {External: types.External{External: true}, Name: "data"},
|
|
},
|
|
Networks: map[string]types.NetworkConfig{
|
|
"front": {
|
|
External: types.External{External: true},
|
|
Name: "front",
|
|
Internal: true,
|
|
Attachable: true,
|
|
},
|
|
},
|
|
}
|
|
|
|
assert.Equal(t, expected, config)
|
|
}
|
|
|
|
func TestUnsupportedProperties(t *testing.T) {
|
|
dict, err := ParseYAML([]byte(`
|
|
version: "3"
|
|
services:
|
|
web:
|
|
image: web
|
|
build:
|
|
context: ./web
|
|
links:
|
|
- bar
|
|
pid: host
|
|
db:
|
|
image: db
|
|
build:
|
|
context: ./db
|
|
`))
|
|
require.NoError(t, err)
|
|
|
|
configDetails := buildConfigDetails(dict, nil)
|
|
|
|
_, err = Load(configDetails)
|
|
require.NoError(t, err)
|
|
|
|
unsupported := GetUnsupportedProperties(dict)
|
|
assert.Equal(t, []string{"build", "links", "pid"}, unsupported)
|
|
}
|
|
|
|
func TestBuildProperties(t *testing.T) {
|
|
dict, err := ParseYAML([]byte(`
|
|
version: "3"
|
|
services:
|
|
web:
|
|
image: web
|
|
build: .
|
|
links:
|
|
- bar
|
|
db:
|
|
image: db
|
|
build:
|
|
context: ./db
|
|
`))
|
|
require.NoError(t, err)
|
|
configDetails := buildConfigDetails(dict, nil)
|
|
_, err = Load(configDetails)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestDeprecatedProperties(t *testing.T) {
|
|
dict, err := ParseYAML([]byte(`
|
|
version: "3"
|
|
services:
|
|
web:
|
|
image: web
|
|
container_name: web
|
|
db:
|
|
image: db
|
|
container_name: db
|
|
expose: ["5434"]
|
|
`))
|
|
require.NoError(t, err)
|
|
|
|
configDetails := buildConfigDetails(dict, nil)
|
|
|
|
_, err = Load(configDetails)
|
|
require.NoError(t, err)
|
|
|
|
deprecated := GetDeprecatedProperties(dict)
|
|
assert.Len(t, deprecated, 2)
|
|
assert.Contains(t, deprecated, "container_name")
|
|
assert.Contains(t, deprecated, "expose")
|
|
}
|
|
|
|
func TestForbiddenProperties(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
volumes:
|
|
- /data
|
|
volume_driver: some-driver
|
|
bar:
|
|
extends:
|
|
service: foo
|
|
`)
|
|
|
|
require.Error(t, err)
|
|
assert.IsType(t, &ForbiddenPropertiesError{}, err)
|
|
fmt.Println(err)
|
|
forbidden := err.(*ForbiddenPropertiesError).Properties
|
|
|
|
assert.Len(t, forbidden, 2)
|
|
assert.Contains(t, forbidden, "volume_driver")
|
|
assert.Contains(t, forbidden, "extends")
|
|
}
|
|
|
|
func TestInvalidResource(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
deploy:
|
|
resources:
|
|
impossible:
|
|
x: 1
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "Additional property impossible is not allowed")
|
|
}
|
|
|
|
func TestInvalidExternalAndDriverCombination(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
volumes:
|
|
external_volume:
|
|
external: true
|
|
driver: foobar
|
|
`)
|
|
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "conflicting parameters \"external\" and \"driver\" specified for volume")
|
|
assert.Contains(t, err.Error(), "external_volume")
|
|
}
|
|
|
|
func TestInvalidExternalAndDirverOptsCombination(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
volumes:
|
|
external_volume:
|
|
external: true
|
|
driver_opts:
|
|
beep: boop
|
|
`)
|
|
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "conflicting parameters \"external\" and \"driver_opts\" specified for volume")
|
|
assert.Contains(t, err.Error(), "external_volume")
|
|
}
|
|
|
|
func TestInvalidExternalAndLabelsCombination(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3"
|
|
volumes:
|
|
external_volume:
|
|
external: true
|
|
labels:
|
|
- beep=boop
|
|
`)
|
|
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "conflicting parameters \"external\" and \"labels\" specified for volume")
|
|
assert.Contains(t, err.Error(), "external_volume")
|
|
}
|
|
|
|
func TestLoadVolumeInvalidExternalNameAndNameCombination(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3.4"
|
|
volumes:
|
|
external_volume:
|
|
name: user_specified_name
|
|
external:
|
|
name: external_name
|
|
`)
|
|
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "volume.external.name and volume.name conflict; only use volume.name")
|
|
assert.Contains(t, err.Error(), "external_volume")
|
|
}
|
|
|
|
func durationPtr(value time.Duration) *time.Duration {
|
|
return &value
|
|
}
|
|
|
|
func uint64Ptr(value uint64) *uint64 {
|
|
return &value
|
|
}
|
|
|
|
func uint32Ptr(value uint32) *uint32 {
|
|
return &value
|
|
}
|
|
|
|
func TestFullExample(t *testing.T) {
|
|
bytes, err := ioutil.ReadFile("full-example.yml")
|
|
require.NoError(t, err)
|
|
|
|
homeDir := "/home/foo"
|
|
env := map[string]string{"HOME": homeDir, "QUX": "qux_from_environment"}
|
|
config, err := loadYAMLWithEnv(string(bytes), env)
|
|
require.NoError(t, err)
|
|
|
|
workingDir, err := os.Getwd()
|
|
require.NoError(t, err)
|
|
|
|
expectedConfig := fullExampleConfig(workingDir, homeDir)
|
|
|
|
assert.Equal(t, expectedConfig.Services, config.Services)
|
|
assert.Equal(t, expectedConfig.Networks, config.Networks)
|
|
assert.Equal(t, expectedConfig.Volumes, config.Volumes)
|
|
}
|
|
|
|
func TestLoadTmpfsVolume(t *testing.T) {
|
|
config, err := loadYAML(`
|
|
version: "3.6"
|
|
services:
|
|
tmpfs:
|
|
image: nginx:latest
|
|
volumes:
|
|
- type: tmpfs
|
|
target: /app
|
|
tmpfs:
|
|
size: 10000
|
|
`)
|
|
require.NoError(t, err)
|
|
|
|
expected := types.ServiceVolumeConfig{
|
|
Target: "/app",
|
|
Type: "tmpfs",
|
|
Tmpfs: &types.ServiceVolumeTmpfs{
|
|
Size: int64(10000),
|
|
},
|
|
}
|
|
|
|
require.Len(t, config.Services, 1)
|
|
assert.Len(t, config.Services[0].Volumes, 1)
|
|
assert.Equal(t, expected, config.Services[0].Volumes[0])
|
|
}
|
|
|
|
func TestLoadTmpfsVolumeAdditionalPropertyNotAllowed(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3.5"
|
|
services:
|
|
tmpfs:
|
|
image: nginx:latest
|
|
volumes:
|
|
- type: tmpfs
|
|
target: /app
|
|
tmpfs:
|
|
size: 10000
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "services.tmpfs.volumes.0 Additional property tmpfs is not allowed")
|
|
}
|
|
|
|
func TestLoadTmpfsVolumeSizeCanBeZero(t *testing.T) {
|
|
config, err := loadYAML(`
|
|
version: "3.6"
|
|
services:
|
|
tmpfs:
|
|
image: nginx:latest
|
|
volumes:
|
|
- type: tmpfs
|
|
target: /app
|
|
tmpfs:
|
|
size: 0
|
|
`)
|
|
require.NoError(t, err)
|
|
|
|
expected := types.ServiceVolumeConfig{
|
|
Target: "/app",
|
|
Type: "tmpfs",
|
|
Tmpfs: &types.ServiceVolumeTmpfs{},
|
|
}
|
|
|
|
require.Len(t, config.Services, 1)
|
|
assert.Len(t, config.Services[0].Volumes, 1)
|
|
assert.Equal(t, expected, config.Services[0].Volumes[0])
|
|
}
|
|
|
|
func TestLoadTmpfsVolumeSizeMustBeGTEQZero(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3.6"
|
|
services:
|
|
tmpfs:
|
|
image: nginx:latest
|
|
volumes:
|
|
- type: tmpfs
|
|
target: /app
|
|
tmpfs:
|
|
size: -1
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "services.tmpfs.volumes.0.tmpfs.size Must be greater than or equal to 0")
|
|
}
|
|
|
|
func TestLoadTmpfsVolumeSizeMustBeInteger(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3.6"
|
|
services:
|
|
tmpfs:
|
|
image: nginx:latest
|
|
volumes:
|
|
- type: tmpfs
|
|
target: /app
|
|
tmpfs:
|
|
size: 0.0001
|
|
`)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "services.tmpfs.volumes.0.tmpfs.size must be a integer")
|
|
}
|
|
|
|
func serviceSort(services []types.ServiceConfig) []types.ServiceConfig {
|
|
sort.Sort(servicesByName(services))
|
|
return services
|
|
}
|
|
|
|
type servicesByName []types.ServiceConfig
|
|
|
|
func (sbn servicesByName) Len() int { return len(sbn) }
|
|
func (sbn servicesByName) Swap(i, j int) { sbn[i], sbn[j] = sbn[j], sbn[i] }
|
|
func (sbn servicesByName) Less(i, j int) bool { return sbn[i].Name < sbn[j].Name }
|
|
|
|
func TestLoadAttachableNetwork(t *testing.T) {
|
|
config, err := loadYAML(`
|
|
version: "3.2"
|
|
networks:
|
|
mynet1:
|
|
driver: overlay
|
|
attachable: true
|
|
mynet2:
|
|
driver: bridge
|
|
`)
|
|
require.NoError(t, err)
|
|
|
|
expected := map[string]types.NetworkConfig{
|
|
"mynet1": {
|
|
Driver: "overlay",
|
|
Attachable: true,
|
|
},
|
|
"mynet2": {
|
|
Driver: "bridge",
|
|
Attachable: false,
|
|
},
|
|
}
|
|
|
|
assert.Equal(t, expected, config.Networks)
|
|
}
|
|
|
|
func TestLoadExpandedPortFormat(t *testing.T) {
|
|
config, err := loadYAML(`
|
|
version: "3.2"
|
|
services:
|
|
web:
|
|
image: busybox
|
|
ports:
|
|
- "80-82:8080-8082"
|
|
- "90-92:8090-8092/udp"
|
|
- "85:8500"
|
|
- 8600
|
|
- protocol: udp
|
|
target: 53
|
|
published: 10053
|
|
- mode: host
|
|
target: 22
|
|
published: 10022
|
|
`)
|
|
require.NoError(t, err)
|
|
|
|
expected := []types.ServicePortConfig{
|
|
{
|
|
Mode: "ingress",
|
|
Target: 8080,
|
|
Published: 80,
|
|
Protocol: "tcp",
|
|
},
|
|
{
|
|
Mode: "ingress",
|
|
Target: 8081,
|
|
Published: 81,
|
|
Protocol: "tcp",
|
|
},
|
|
{
|
|
Mode: "ingress",
|
|
Target: 8082,
|
|
Published: 82,
|
|
Protocol: "tcp",
|
|
},
|
|
{
|
|
Mode: "ingress",
|
|
Target: 8090,
|
|
Published: 90,
|
|
Protocol: "udp",
|
|
},
|
|
{
|
|
Mode: "ingress",
|
|
Target: 8091,
|
|
Published: 91,
|
|
Protocol: "udp",
|
|
},
|
|
{
|
|
Mode: "ingress",
|
|
Target: 8092,
|
|
Published: 92,
|
|
Protocol: "udp",
|
|
},
|
|
{
|
|
Mode: "ingress",
|
|
Target: 8500,
|
|
Published: 85,
|
|
Protocol: "tcp",
|
|
},
|
|
{
|
|
Mode: "ingress",
|
|
Target: 8600,
|
|
Published: 0,
|
|
Protocol: "tcp",
|
|
},
|
|
{
|
|
Target: 53,
|
|
Published: 10053,
|
|
Protocol: "udp",
|
|
},
|
|
{
|
|
Mode: "host",
|
|
Target: 22,
|
|
Published: 10022,
|
|
},
|
|
}
|
|
|
|
assert.Len(t, config.Services, 1)
|
|
assert.Equal(t, expected, config.Services[0].Ports)
|
|
}
|
|
|
|
func TestLoadExpandedMountFormat(t *testing.T) {
|
|
config, err := loadYAML(`
|
|
version: "3.2"
|
|
services:
|
|
web:
|
|
image: busybox
|
|
volumes:
|
|
- type: volume
|
|
source: foo
|
|
target: /target
|
|
read_only: true
|
|
volumes:
|
|
foo: {}
|
|
`)
|
|
require.NoError(t, err)
|
|
|
|
expected := types.ServiceVolumeConfig{
|
|
Type: "volume",
|
|
Source: "foo",
|
|
Target: "/target",
|
|
ReadOnly: true,
|
|
}
|
|
|
|
require.Len(t, config.Services, 1)
|
|
assert.Len(t, config.Services[0].Volumes, 1)
|
|
assert.Equal(t, expected, config.Services[0].Volumes[0])
|
|
}
|
|
|
|
func TestLoadExtraHostsMap(t *testing.T) {
|
|
config, err := loadYAML(`
|
|
version: "3.2"
|
|
services:
|
|
web:
|
|
image: busybox
|
|
extra_hosts:
|
|
"zulu": "162.242.195.82"
|
|
"alpha": "50.31.209.229"
|
|
`)
|
|
require.NoError(t, err)
|
|
|
|
expected := types.HostsList{
|
|
"alpha:50.31.209.229",
|
|
"zulu:162.242.195.82",
|
|
}
|
|
|
|
require.Len(t, config.Services, 1)
|
|
assert.Equal(t, expected, config.Services[0].ExtraHosts)
|
|
}
|
|
|
|
func TestLoadExtraHostsList(t *testing.T) {
|
|
config, err := loadYAML(`
|
|
version: "3.2"
|
|
services:
|
|
web:
|
|
image: busybox
|
|
extra_hosts:
|
|
- "zulu:162.242.195.82"
|
|
- "alpha:50.31.209.229"
|
|
- "zulu:ff02::1"
|
|
`)
|
|
require.NoError(t, err)
|
|
|
|
expected := types.HostsList{
|
|
"zulu:162.242.195.82",
|
|
"alpha:50.31.209.229",
|
|
"zulu:ff02::1",
|
|
}
|
|
|
|
require.Len(t, config.Services, 1)
|
|
assert.Equal(t, expected, config.Services[0].ExtraHosts)
|
|
}
|
|
|
|
func TestLoadVolumesWarnOnDeprecatedExternalNameVersion34(t *testing.T) {
|
|
buf, cleanup := patchLogrus()
|
|
defer cleanup()
|
|
|
|
source := map[string]interface{}{
|
|
"foo": map[string]interface{}{
|
|
"external": map[string]interface{}{
|
|
"name": "oops",
|
|
},
|
|
},
|
|
}
|
|
volumes, err := LoadVolumes(source, "3.4")
|
|
require.NoError(t, err)
|
|
expected := map[string]types.VolumeConfig{
|
|
"foo": {
|
|
Name: "oops",
|
|
External: types.External{External: true},
|
|
},
|
|
}
|
|
assert.Equal(t, expected, volumes)
|
|
assert.Contains(t, buf.String(), "volume.external.name is deprecated")
|
|
|
|
}
|
|
|
|
func patchLogrus() (*bytes.Buffer, func()) {
|
|
buf := new(bytes.Buffer)
|
|
out := logrus.StandardLogger().Out
|
|
logrus.SetOutput(buf)
|
|
return buf, func() { logrus.SetOutput(out) }
|
|
}
|
|
|
|
func TestLoadVolumesWarnOnDeprecatedExternalNameVersion33(t *testing.T) {
|
|
buf, cleanup := patchLogrus()
|
|
defer cleanup()
|
|
|
|
source := map[string]interface{}{
|
|
"foo": map[string]interface{}{
|
|
"external": map[string]interface{}{
|
|
"name": "oops",
|
|
},
|
|
},
|
|
}
|
|
volumes, err := LoadVolumes(source, "3.3")
|
|
require.NoError(t, err)
|
|
expected := map[string]types.VolumeConfig{
|
|
"foo": {
|
|
Name: "oops",
|
|
External: types.External{External: true},
|
|
},
|
|
}
|
|
assert.Equal(t, expected, volumes)
|
|
assert.Equal(t, "", buf.String())
|
|
}
|
|
|
|
func TestLoadV35(t *testing.T) {
|
|
actual, err := loadYAML(`
|
|
version: "3.5"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
isolation: process
|
|
configs:
|
|
foo:
|
|
name: fooqux
|
|
external: true
|
|
bar:
|
|
name: barqux
|
|
file: ./example1.env
|
|
secrets:
|
|
foo:
|
|
name: fooqux
|
|
external: true
|
|
bar:
|
|
name: barqux
|
|
file: ./full-example.yml
|
|
`)
|
|
require.NoError(t, err)
|
|
assert.Len(t, actual.Services, 1)
|
|
assert.Len(t, actual.Secrets, 2)
|
|
assert.Len(t, actual.Configs, 2)
|
|
assert.Equal(t, "process", actual.Services[0].Isolation)
|
|
}
|
|
|
|
func TestLoadV35InvalidIsolation(t *testing.T) {
|
|
// validation should be done only on the daemon side
|
|
actual, err := loadYAML(`
|
|
version: "3.5"
|
|
services:
|
|
foo:
|
|
image: busybox
|
|
isolation: invalid
|
|
configs:
|
|
super:
|
|
external: true
|
|
`)
|
|
require.NoError(t, err)
|
|
require.Len(t, actual.Services, 1)
|
|
assert.Equal(t, "invalid", actual.Services[0].Isolation)
|
|
}
|
|
|
|
func TestLoadSecretInvalidExternalNameAndNameCombination(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3.5"
|
|
secrets:
|
|
external_secret:
|
|
name: user_specified_name
|
|
external:
|
|
name: external_name
|
|
`)
|
|
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "secret.external.name and secret.name conflict; only use secret.name")
|
|
assert.Contains(t, err.Error(), "external_secret")
|
|
}
|
|
|
|
func TestLoadSecretsWarnOnDeprecatedExternalNameVersion35(t *testing.T) {
|
|
buf, cleanup := patchLogrus()
|
|
defer cleanup()
|
|
|
|
source := map[string]interface{}{
|
|
"foo": map[string]interface{}{
|
|
"external": map[string]interface{}{
|
|
"name": "oops",
|
|
},
|
|
},
|
|
}
|
|
details := types.ConfigDetails{
|
|
Version: "3.5",
|
|
}
|
|
secrets, err := LoadSecrets(source, details)
|
|
require.NoError(t, err)
|
|
expected := map[string]types.SecretConfig{
|
|
"foo": {
|
|
Name: "oops",
|
|
External: types.External{External: true},
|
|
},
|
|
}
|
|
assert.Equal(t, expected, secrets)
|
|
assert.Contains(t, buf.String(), "secret.external.name is deprecated")
|
|
}
|
|
|
|
func TestLoadNetworksWarnOnDeprecatedExternalNameVersion35(t *testing.T) {
|
|
buf, cleanup := patchLogrus()
|
|
defer cleanup()
|
|
|
|
source := map[string]interface{}{
|
|
"foo": map[string]interface{}{
|
|
"external": map[string]interface{}{
|
|
"name": "oops",
|
|
},
|
|
},
|
|
}
|
|
networks, err := LoadNetworks(source, "3.5")
|
|
require.NoError(t, err)
|
|
expected := map[string]types.NetworkConfig{
|
|
"foo": {
|
|
Name: "oops",
|
|
External: types.External{External: true},
|
|
},
|
|
}
|
|
assert.Equal(t, expected, networks)
|
|
assert.Contains(t, buf.String(), "network.external.name is deprecated")
|
|
|
|
}
|
|
|
|
func TestLoadNetworksWarnOnDeprecatedExternalNameVersion34(t *testing.T) {
|
|
buf, cleanup := patchLogrus()
|
|
defer cleanup()
|
|
|
|
source := map[string]interface{}{
|
|
"foo": map[string]interface{}{
|
|
"external": map[string]interface{}{
|
|
"name": "oops",
|
|
},
|
|
},
|
|
}
|
|
networks, err := LoadNetworks(source, "3.4")
|
|
require.NoError(t, err)
|
|
expected := map[string]types.NetworkConfig{
|
|
"foo": {
|
|
Name: "oops",
|
|
External: types.External{External: true},
|
|
},
|
|
}
|
|
assert.Equal(t, expected, networks)
|
|
assert.Equal(t, "", buf.String())
|
|
}
|
|
|
|
func TestLoadNetworkInvalidExternalNameAndNameCombination(t *testing.T) {
|
|
_, err := loadYAML(`
|
|
version: "3.5"
|
|
networks:
|
|
foo:
|
|
name: user_specified_name
|
|
external:
|
|
name: external_name
|
|
`)
|
|
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "network.external.name and network.name conflict; only use network.name")
|
|
assert.Contains(t, err.Error(), "foo")
|
|
}
|