2cf1c762f8
This hopefully makes the test less flakey (or removes any flake that
would be caused by the test itself).
1. Adds tail of cluster daemon logs when there is a test failure so we
can more easily see what may be happening
2. Scans the daemon logs to check if the key is rotated before
restarting the daemon. This is a little hacky but a little better
than assuming it is done after a hard-coded 3 seconds.
3. Cleans up the `node ls` check such that it uses a poll function
Signed-off-by: Brian Goff <cpuguy83@gmail.com>
(cherry picked from commit fbdc02534a)
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
714 lines
19 KiB
Go
714 lines
19 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"strconv"
|
|
"sync"
|
|
"syscall"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/docker/docker/integration-cli/cli"
|
|
"github.com/docker/docker/integration-cli/daemon"
|
|
"github.com/docker/docker/integration-cli/environment"
|
|
"github.com/docker/docker/internal/test/suite"
|
|
"github.com/docker/docker/testutil"
|
|
testdaemon "github.com/docker/docker/testutil/daemon"
|
|
ienv "github.com/docker/docker/testutil/environment"
|
|
"github.com/docker/docker/testutil/fakestorage"
|
|
"github.com/docker/docker/testutil/fixtures/plugin"
|
|
"github.com/docker/docker/testutil/registry"
|
|
"go.opentelemetry.io/otel"
|
|
"go.opentelemetry.io/otel/attribute"
|
|
"go.opentelemetry.io/otel/codes"
|
|
"gotest.tools/v3/assert"
|
|
"gotest.tools/v3/skip"
|
|
)
|
|
|
|
const (
|
|
// the private registry to use for tests
|
|
privateRegistryURL = registry.DefaultURL
|
|
|
|
// path to containerd's ctr binary
|
|
ctrBinary = "ctr"
|
|
|
|
// the docker daemon binary to use
|
|
dockerdBinary = "dockerd"
|
|
)
|
|
|
|
var (
|
|
testEnvOnce sync.Once
|
|
testEnv *environment.Execution
|
|
|
|
// the docker client binary to use
|
|
dockerBinary = ""
|
|
|
|
baseContext context.Context
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
flag.Parse()
|
|
|
|
os.Exit(testRun(m))
|
|
}
|
|
|
|
func testRun(m *testing.M) (ret int) {
|
|
// Global set up
|
|
|
|
var err error
|
|
|
|
shutdown := testutil.ConfigureTracing()
|
|
ctx, span := otel.Tracer("").Start(context.Background(), "integration-cli/TestMain")
|
|
defer func() {
|
|
if err != nil {
|
|
span.SetStatus(codes.Error, err.Error())
|
|
ret = 255
|
|
} else {
|
|
if ret != 0 {
|
|
span.SetAttributes(attribute.Int("exitCode", ret))
|
|
span.SetStatus(codes.Error, "m.Run() exited with non-zero code")
|
|
}
|
|
}
|
|
span.End()
|
|
shutdown(ctx)
|
|
}()
|
|
|
|
baseContext = ctx
|
|
|
|
testEnv, err = environment.New(ctx)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if testEnv.IsLocalDaemon() {
|
|
setupLocalInfo()
|
|
}
|
|
|
|
dockerBinary = testEnv.DockerBinary()
|
|
|
|
err = ienv.EnsureFrozenImagesLinux(ctx, &testEnv.Execution)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
testEnv.Print()
|
|
printCliVersion()
|
|
|
|
return m.Run()
|
|
}
|
|
|
|
func printCliVersion() {
|
|
// Print output of "docker version"
|
|
cli.SetTestEnvironment(testEnv)
|
|
cmd := cli.Docker(cli.Args("version"))
|
|
if cmd.Error != nil {
|
|
fmt.Printf("WARNING: Failed to run 'docker version': %+v\n", cmd.Error)
|
|
return
|
|
}
|
|
|
|
fmt.Println("INFO: Testing with docker cli version:")
|
|
fmt.Println(cmd.Stdout())
|
|
}
|
|
|
|
func ensureTestEnvSetup(ctx context.Context, t *testing.T) {
|
|
testEnvOnce.Do(func() {
|
|
cli.SetTestEnvironment(testEnv)
|
|
fakestorage.SetTestEnvironment(&testEnv.Execution)
|
|
ienv.ProtectAll(ctx, t, &testEnv.Execution)
|
|
})
|
|
}
|
|
|
|
func TestDockerAPISuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerAPISuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerBenchmarkSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerBenchmarkSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIAttachSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIAttachSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIBuildSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIBuildSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLICommitSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLICommitSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLICpSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLICpSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLICreateSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLICreateSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIEventSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIEventSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIExecSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIExecSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIHealthSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIHealthSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIHistorySuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIHistorySuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIImagesSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIImagesSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIImportSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIImportSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIInfoSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIInfoSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIInspectSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIInspectSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLILinksSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLILinksSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLILoginSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLILoginSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLILogsSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLILogsSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLINetmodeSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLINetmodeSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLINetworkSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLINetworkSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIPluginLogDriverSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIPluginLogDriverSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIPluginsSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIPluginsSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIPortSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIPortSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIProxySuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIProxySuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIPruneSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIPruneSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIPsSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIPsSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIPullSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIPullSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIPushSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIPushSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIRestartSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIRestartSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIRmiSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIRmiSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIRunSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIRunSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLISaveLoadSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLISaveLoadSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLISearchSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLISearchSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLISNISuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLISNISuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIStartSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIStartSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIStatsSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIStatsSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLITopSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLITopSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIUpdateSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIUpdateSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerCLIVolumeSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerCLIVolumeSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerRegistrySuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerRegistrySuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerSchema1RegistrySuite(t *testing.T) {
|
|
skip.If(t, testEnv.UsingSnapshotter())
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerSchema1RegistrySuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerRegistryAuthHtpasswdSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerRegistryAuthHtpasswdSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerRegistryAuthTokenSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerRegistryAuthTokenSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerDaemonSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerDaemonSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerSwarmSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerSwarmSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerPluginSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerPluginSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerExternalVolumeSuite(t *testing.T) {
|
|
testRequires(t, DaemonIsLinux)
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerExternalVolumeSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerNetworkSuite(t *testing.T) {
|
|
testRequires(t, DaemonIsLinux)
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
suite.Run(ctx, t, &DockerNetworkSuite{ds: &DockerSuite{}})
|
|
}
|
|
|
|
func TestDockerHubPullSuite(t *testing.T) {
|
|
ctx := testutil.StartSpan(baseContext, t)
|
|
ensureTestEnvSetup(ctx, t)
|
|
// FIXME. Temporarily turning this off for Windows as GH16039 was breaking
|
|
// Windows to Linux CI @icecrime
|
|
testRequires(t, DaemonIsLinux)
|
|
suite.Run(ctx, t, newDockerHubPullSuite())
|
|
}
|
|
|
|
type DockerSuite struct{}
|
|
|
|
func (s *DockerSuite) OnTimeout(c *testing.T) {
|
|
if testEnv.IsRemoteDaemon() {
|
|
return
|
|
}
|
|
path := filepath.Join(os.Getenv("DEST"), "docker.pid")
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
c.Fatalf("Failed to get daemon PID from %s\n", path)
|
|
}
|
|
|
|
rawPid, err := strconv.ParseInt(string(b), 10, 32)
|
|
if err != nil {
|
|
c.Fatalf("Failed to parse pid from %s: %s\n", path, err)
|
|
}
|
|
|
|
daemonPid := int(rawPid)
|
|
if daemonPid > 0 {
|
|
testdaemon.SignalDaemonDump(daemonPid)
|
|
}
|
|
}
|
|
|
|
func (s *DockerSuite) TearDownTest(ctx context.Context, c *testing.T) {
|
|
testEnv.Clean(ctx, c)
|
|
}
|
|
|
|
type DockerRegistrySuite struct {
|
|
ds *DockerSuite
|
|
reg *registry.V2
|
|
d *daemon.Daemon
|
|
}
|
|
|
|
func (s *DockerRegistrySuite) OnTimeout(c *testing.T) {
|
|
s.d.DumpStackAndQuit()
|
|
}
|
|
|
|
func (s *DockerRegistrySuite) SetUpTest(ctx context.Context, c *testing.T) {
|
|
testRequires(c, DaemonIsLinux, RegistryHosting, testEnv.IsLocalDaemon)
|
|
s.reg = registry.NewV2(c)
|
|
s.reg.WaitReady(c)
|
|
s.d = daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
|
|
}
|
|
|
|
func (s *DockerRegistrySuite) TearDownTest(ctx context.Context, c *testing.T) {
|
|
if s.reg != nil {
|
|
s.reg.Close()
|
|
}
|
|
if s.d != nil {
|
|
s.d.Stop(c)
|
|
}
|
|
s.ds.TearDownTest(ctx, c)
|
|
}
|
|
|
|
type DockerSchema1RegistrySuite struct {
|
|
ds *DockerSuite
|
|
reg *registry.V2
|
|
d *daemon.Daemon
|
|
}
|
|
|
|
func (s *DockerSchema1RegistrySuite) OnTimeout(c *testing.T) {
|
|
s.d.DumpStackAndQuit()
|
|
}
|
|
|
|
func (s *DockerSchema1RegistrySuite) SetUpTest(ctx context.Context, c *testing.T) {
|
|
testRequires(c, DaemonIsLinux, RegistryHosting, NotArm64, testEnv.IsLocalDaemon)
|
|
s.reg = registry.NewV2(c, registry.Schema1)
|
|
s.reg.WaitReady(c)
|
|
s.d = daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
|
|
}
|
|
|
|
func (s *DockerSchema1RegistrySuite) TearDownTest(ctx context.Context, c *testing.T) {
|
|
if s.reg != nil {
|
|
s.reg.Close()
|
|
}
|
|
if s.d != nil {
|
|
s.d.Stop(c)
|
|
}
|
|
s.ds.TearDownTest(ctx, c)
|
|
}
|
|
|
|
type DockerRegistryAuthHtpasswdSuite struct {
|
|
ds *DockerSuite
|
|
reg *registry.V2
|
|
d *daemon.Daemon
|
|
}
|
|
|
|
func (s *DockerRegistryAuthHtpasswdSuite) OnTimeout(c *testing.T) {
|
|
s.d.DumpStackAndQuit()
|
|
}
|
|
|
|
func (s *DockerRegistryAuthHtpasswdSuite) SetUpTest(ctx context.Context, c *testing.T) {
|
|
testRequires(c, DaemonIsLinux, RegistryHosting, testEnv.IsLocalDaemon)
|
|
s.reg = registry.NewV2(c, registry.Htpasswd)
|
|
s.reg.WaitReady(c)
|
|
s.d = daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
|
|
}
|
|
|
|
func (s *DockerRegistryAuthHtpasswdSuite) TearDownTest(ctx context.Context, c *testing.T) {
|
|
if s.reg != nil {
|
|
out, err := s.d.Cmd("logout", privateRegistryURL)
|
|
assert.NilError(c, err, out)
|
|
s.reg.Close()
|
|
}
|
|
if s.d != nil {
|
|
s.d.Stop(c)
|
|
}
|
|
s.ds.TearDownTest(ctx, c)
|
|
}
|
|
|
|
type DockerRegistryAuthTokenSuite struct {
|
|
ds *DockerSuite
|
|
reg *registry.V2
|
|
d *daemon.Daemon
|
|
}
|
|
|
|
func (s *DockerRegistryAuthTokenSuite) OnTimeout(c *testing.T) {
|
|
s.d.DumpStackAndQuit()
|
|
}
|
|
|
|
func (s *DockerRegistryAuthTokenSuite) SetUpTest(ctx context.Context, c *testing.T) {
|
|
testRequires(c, DaemonIsLinux, RegistryHosting, testEnv.IsLocalDaemon)
|
|
s.d = daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
|
|
}
|
|
|
|
func (s *DockerRegistryAuthTokenSuite) TearDownTest(ctx context.Context, c *testing.T) {
|
|
if s.reg != nil {
|
|
out, err := s.d.Cmd("logout", privateRegistryURL)
|
|
assert.NilError(c, err, out)
|
|
s.reg.Close()
|
|
}
|
|
if s.d != nil {
|
|
s.d.Stop(c)
|
|
}
|
|
s.ds.TearDownTest(ctx, c)
|
|
}
|
|
|
|
func (s *DockerRegistryAuthTokenSuite) setupRegistryWithTokenService(c *testing.T, tokenURL string) {
|
|
if s == nil {
|
|
c.Fatal("registry suite isn't initialized")
|
|
}
|
|
s.reg = registry.NewV2(c, registry.Token(tokenURL))
|
|
s.reg.WaitReady(c)
|
|
}
|
|
|
|
type DockerDaemonSuite struct {
|
|
ds *DockerSuite
|
|
d *daemon.Daemon
|
|
}
|
|
|
|
func (s *DockerDaemonSuite) OnTimeout(c *testing.T) {
|
|
s.d.DumpStackAndQuit()
|
|
}
|
|
|
|
func (s *DockerDaemonSuite) SetUpTest(ctx context.Context, c *testing.T) {
|
|
testRequires(c, DaemonIsLinux, testEnv.IsLocalDaemon)
|
|
s.d = daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
|
|
}
|
|
|
|
func (s *DockerDaemonSuite) TearDownTest(ctx context.Context, c *testing.T) {
|
|
testRequires(c, DaemonIsLinux, testEnv.IsLocalDaemon)
|
|
if s.d != nil {
|
|
s.d.Stop(c)
|
|
}
|
|
s.ds.TearDownTest(ctx, c)
|
|
}
|
|
|
|
func (s *DockerDaemonSuite) TearDownSuite(ctx context.Context, c *testing.T) {
|
|
filepath.Walk(testdaemon.SockRoot, func(path string, fi os.FileInfo, err error) error {
|
|
if err != nil {
|
|
// ignore errors here
|
|
// not cleaning up sockets is not really an error
|
|
return nil
|
|
}
|
|
if fi.Mode() == os.ModeSocket {
|
|
syscall.Unlink(path)
|
|
}
|
|
return nil
|
|
})
|
|
os.RemoveAll(testdaemon.SockRoot)
|
|
}
|
|
|
|
const defaultSwarmPort = 2477
|
|
|
|
type DockerSwarmSuite struct {
|
|
server *httptest.Server
|
|
ds *DockerSuite
|
|
daemonsLock sync.Mutex // protect access to daemons and portIndex
|
|
daemons []*daemon.Daemon
|
|
portIndex int
|
|
}
|
|
|
|
func (s *DockerSwarmSuite) OnTimeout(c *testing.T) {
|
|
s.daemonsLock.Lock()
|
|
defer s.daemonsLock.Unlock()
|
|
for _, d := range s.daemons {
|
|
d.DumpStackAndQuit()
|
|
}
|
|
}
|
|
|
|
func (s *DockerSwarmSuite) SetUpTest(ctx context.Context, c *testing.T) {
|
|
testRequires(c, DaemonIsLinux, testEnv.IsLocalDaemon)
|
|
}
|
|
|
|
func (s *DockerSwarmSuite) AddDaemon(ctx context.Context, c *testing.T, joinSwarm, manager bool) *daemon.Daemon {
|
|
c.Helper()
|
|
d := daemon.New(c, dockerBinary, dockerdBinary,
|
|
testdaemon.WithEnvironment(testEnv.Execution),
|
|
testdaemon.WithSwarmPort(defaultSwarmPort+s.portIndex),
|
|
)
|
|
if joinSwarm {
|
|
if len(s.daemons) > 0 {
|
|
d.StartAndSwarmJoin(ctx, c, s.daemons[0].Daemon, manager)
|
|
} else {
|
|
d.StartAndSwarmInit(ctx, c)
|
|
}
|
|
} else {
|
|
d.StartNodeWithBusybox(ctx, c)
|
|
}
|
|
|
|
s.daemonsLock.Lock()
|
|
s.portIndex++
|
|
s.daemons = append(s.daemons, d)
|
|
s.daemonsLock.Unlock()
|
|
|
|
return d
|
|
}
|
|
|
|
func (s *DockerSwarmSuite) TearDownTest(ctx context.Context, c *testing.T) {
|
|
testRequires(c, DaemonIsLinux)
|
|
s.daemonsLock.Lock()
|
|
for _, d := range s.daemons {
|
|
if d != nil {
|
|
if c.Failed() {
|
|
d.TailLogsT(c, 100)
|
|
}
|
|
d.Stop(c)
|
|
d.Cleanup(c)
|
|
}
|
|
}
|
|
s.daemons = nil
|
|
s.portIndex = 0
|
|
s.daemonsLock.Unlock()
|
|
s.ds.TearDownTest(ctx, c)
|
|
}
|
|
|
|
type DockerPluginSuite struct {
|
|
ds *DockerSuite
|
|
registry *registry.V2
|
|
}
|
|
|
|
func (ps *DockerPluginSuite) registryHost() string {
|
|
return privateRegistryURL
|
|
}
|
|
|
|
func (ps *DockerPluginSuite) getPluginRepo() string {
|
|
return path.Join(ps.registryHost(), "plugin", "basic")
|
|
}
|
|
|
|
func (ps *DockerPluginSuite) getPluginRepoWithTag() string {
|
|
return ps.getPluginRepo() + ":" + "latest"
|
|
}
|
|
|
|
func (ps *DockerPluginSuite) SetUpSuite(ctx context.Context, c *testing.T) {
|
|
testRequires(c, DaemonIsLinux, RegistryHosting)
|
|
ps.registry = registry.NewV2(c)
|
|
ps.registry.WaitReady(c)
|
|
|
|
ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
|
|
defer cancel()
|
|
|
|
err := plugin.CreateInRegistry(ctx, ps.getPluginRepo(), nil)
|
|
assert.NilError(c, err, "failed to create plugin")
|
|
}
|
|
|
|
func (ps *DockerPluginSuite) TearDownSuite(ctx context.Context, c *testing.T) {
|
|
if ps.registry != nil {
|
|
ps.registry.Close()
|
|
}
|
|
}
|
|
|
|
func (ps *DockerPluginSuite) TearDownTest(ctx context.Context, c *testing.T) {
|
|
ps.ds.TearDownTest(ctx, c)
|
|
}
|
|
|
|
func (ps *DockerPluginSuite) OnTimeout(c *testing.T) {
|
|
ps.ds.OnTimeout(c)
|
|
}
|