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)
}
