github.com/moby/docker@v26.1.3+incompatible/daemon/config/config_linux_test.go (about)

     1  package config // import "github.com/docker/docker/daemon/config"
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/docker/docker/opts"
     7  	units "github.com/docker/go-units"
     8  	"github.com/spf13/pflag"
     9  	"gotest.tools/v3/assert"
    10  	is "gotest.tools/v3/assert/cmp"
    11  )
    12  
    13  func TestGetConflictFreeConfiguration(t *testing.T) {
    14  	configFile := makeConfigFile(t, `
    15  		{
    16  			"debug": true,
    17  			"default-ulimits": {
    18  				"nofile": {
    19  					"Name": "nofile",
    20  					"Hard": 2048,
    21  					"Soft": 1024
    22  				}
    23  			},
    24  			"log-opts": {
    25  				"tag": "test_tag"
    26  			},
    27  			"default-network-opts": {
    28  				"overlay": {
    29  					"com.docker.network.driver.mtu": "1337"
    30  				}
    31  			}
    32  		}`)
    33  
    34  	flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
    35  	var debug bool
    36  	flags.BoolVarP(&debug, "debug", "D", false, "")
    37  	flags.Var(opts.NewNamedUlimitOpt("default-ulimits", nil), "default-ulimit", "")
    38  	flags.Var(opts.NewNamedMapOpts("log-opts", nil, nil), "log-opt", "")
    39  	flags.Var(opts.NewNamedMapMapOpts("default-network-opts", nil, nil), "default-network-opt", "")
    40  
    41  	cc, err := getConflictFreeConfiguration(configFile, flags)
    42  	assert.NilError(t, err)
    43  
    44  	assert.Check(t, cc.Debug)
    45  
    46  	expectedUlimits := map[string]*units.Ulimit{
    47  		"nofile": {
    48  			Name: "nofile",
    49  			Hard: 2048,
    50  			Soft: 1024,
    51  		},
    52  	}
    53  
    54  	assert.Check(t, is.DeepEqual(expectedUlimits, cc.Ulimits))
    55  }
    56  
    57  func TestDaemonConfigurationMerge(t *testing.T) {
    58  	configFile := makeConfigFile(t, `
    59  		{
    60  			"debug": true,
    61  			"default-ulimits": {
    62  				"nofile": {
    63  					"Name": "nofile",
    64  					"Hard": 2048,
    65  					"Soft": 1024
    66  				}
    67  			}
    68  		}`)
    69  
    70  	conf, err := New()
    71  	assert.NilError(t, err)
    72  
    73  	flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
    74  	flags.BoolVarP(&conf.Debug, "debug", "D", false, "")
    75  	flags.BoolVarP(&conf.AutoRestart, "restart", "r", true, "")
    76  	flags.Var(opts.NewNamedUlimitOpt("default-ulimits", &conf.Ulimits), "default-ulimit", "")
    77  	flags.StringVar(&conf.LogConfig.Type, "log-driver", "json-file", "")
    78  	flags.Var(opts.NewNamedMapOpts("log-opts", conf.LogConfig.Config, nil), "log-opt", "")
    79  	assert.Check(t, flags.Set("restart", "true"))
    80  	assert.Check(t, flags.Set("log-driver", "syslog"))
    81  	assert.Check(t, flags.Set("log-opt", "tag=from_flag"))
    82  
    83  	cc, err := MergeDaemonConfigurations(conf, flags, configFile)
    84  	assert.NilError(t, err)
    85  
    86  	assert.Check(t, cc.Debug)
    87  	assert.Check(t, cc.AutoRestart)
    88  
    89  	expectedLogConfig := LogConfig{
    90  		Type:   "syslog",
    91  		Config: map[string]string{"tag": "from_flag"},
    92  	}
    93  
    94  	assert.Check(t, is.DeepEqual(expectedLogConfig, cc.LogConfig))
    95  
    96  	expectedUlimits := map[string]*units.Ulimit{
    97  		"nofile": {
    98  			Name: "nofile",
    99  			Hard: 2048,
   100  			Soft: 1024,
   101  		},
   102  	}
   103  
   104  	assert.Check(t, is.DeepEqual(expectedUlimits, cc.Ulimits))
   105  }
   106  
   107  func TestDaemonConfigurationMergeShmSize(t *testing.T) {
   108  	configFile := makeConfigFile(t, `{"default-shm-size": "1g"}`)
   109  
   110  	c, err := New()
   111  	assert.NilError(t, err)
   112  
   113  	flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
   114  	shmSize := opts.MemBytes(DefaultShmSize)
   115  	flags.Var(&shmSize, "default-shm-size", "")
   116  
   117  	cc, err := MergeDaemonConfigurations(c, flags, configFile)
   118  	assert.NilError(t, err)
   119  
   120  	expectedValue := 1 * 1024 * 1024 * 1024
   121  	assert.Check(t, is.Equal(int64(expectedValue), cc.ShmSize.Value()))
   122  }
   123  
   124  func TestUnixGetInitPath(t *testing.T) {
   125  	testCases := []struct {
   126  		config           *Config
   127  		expectedInitPath string
   128  	}{
   129  		{
   130  			config: &Config{
   131  				InitPath: "some-init-path",
   132  			},
   133  			expectedInitPath: "some-init-path",
   134  		},
   135  		{
   136  			config: &Config{
   137  				DefaultInitBinary: "foo-init-bin",
   138  			},
   139  			expectedInitPath: "foo-init-bin",
   140  		},
   141  		{
   142  			config: &Config{
   143  				InitPath:          "init-path-A",
   144  				DefaultInitBinary: "init-path-B",
   145  			},
   146  			expectedInitPath: "init-path-A",
   147  		},
   148  		{
   149  			config:           &Config{},
   150  			expectedInitPath: "docker-init",
   151  		},
   152  	}
   153  	for _, tc := range testCases {
   154  		assert.Equal(t, tc.config.GetInitPath(), tc.expectedInitPath)
   155  	}
   156  }