testcontainers

type BindMounter interface {
	GetBindOptions() *mount.BindOptions
}

type ComposeStack interface {
	Up(ctx context.Context, opts ...StackUpOption) error
	Down(ctx context.Context, opts ...StackDownOption) error
	Services() []string
	WaitForService(s string, strategy wait.Strategy) ComposeStack
	WithEnv(m map[string]string) ComposeStack
	WithOsEnv() ComposeStack
	ServiceContainer(ctx context.Context, svcName string) (*DockerContainer, error)
}

type ComposeStackFiles []string

type ComposeStackOption interface {
	// contains filtered or unexported methods
}

type ComposeVersion interface {
	Format(parts ...string) string
}

type Container interface {
	GetContainerID() string                                         // get the container id from the provider
	Endpoint(context.Context, string) (string, error)               // get proto://ip:port string for the first exposed port
	PortEndpoint(context.Context, nat.Port, string) (string, error) // get proto://ip:port string for the given exposed port
	Host(context.Context) (string, error)                           // get host where the container port is exposed
	MappedPort(context.Context, nat.Port) (nat.Port, error)         // get externally mapped port for a container port
	Ports(context.Context) (nat.PortMap, error)                     // get all exposed ports
	SessionID() string                                              // get session id
	IsRunning() bool
	Start(context.Context) error                 // start the container
	Stop(context.Context, *time.Duration) error  // stop the container
	Terminate(context.Context) error             // terminate the container
	Logs(context.Context) (io.ReadCloser, error) // Get logs of the container
	FollowOutput(LogConsumer)
	StartLogProducer(context.Context) error
	StopLogProducer() error
	Name(context.Context) (string, error)                        // get container name
	State(context.Context) (*types.ContainerState, error)        // returns container's running state
	Networks(context.Context) ([]string, error)                  // get container networks
	NetworkAliases(context.Context) (map[string][]string, error) // get container network aliases for a network
	Exec(ctx context.Context, cmd []string, options ...tcexec.ProcessOption) (int, io.Reader, error)
	ContainerIP(context.Context) (string, error)    // get container ip
	ContainerIPs(context.Context) ([]string, error) // get all container IPs
	CopyToContainer(ctx context.Context, fileContent []byte, containerFilePath string, fileMode int64) error
	CopyDirToContainer(ctx context.Context, hostDirPath string, containerParentPath string, fileMode int64) error
	CopyFileToContainer(ctx context.Context, hostFilePath string, containerFilePath string, fileMode int64) error
	CopyFileFromContainer(ctx context.Context, filePath string) (io.ReadCloser, error)
}

type ContainerFile struct {
	HostFilePath      string
	ContainerFilePath string
	FileMode          int64
}

type ContainerMount struct {
	// Source is typically either a GenericBindMountSource or a GenericVolumeMountSource
	Source ContainerMountSource
	// Target is the path where the mount should be mounted within the container
	Target ContainerMountTarget
	// ReadOnly determines if the mount should be read-only
	ReadOnly bool
}

type ContainerMountSource interface {
	// Source will be used as Source field in the final mount
	// this might either be a volume name, a host path or might be empty e.g. for Tmpfs
	Source() string

	// Type determines the final mount type
	// possible options are limited by the Docker API
	Type() MountType
}

type ContainerMountTarget string

type ContainerMounts []ContainerMount

type ContainerProvider interface {
	CreateContainer(context.Context, ContainerRequest) (Container, error)        // create a container without starting it
	ReuseOrCreateContainer(context.Context, ContainerRequest) (Container, error) // reuses a container if it exists or creates a container without starting
	RunContainer(context.Context, ContainerRequest) (Container, error)           // create a container and start it
	Health(context.Context) error
	Config() TestContainersConfig
}

type ContainerRequest struct {
	FromDockerfile
	Image           string
	Entrypoint      []string
	Env             map[string]string
	ExposedPorts    []string // allow specifying protocol info
	Cmd             []string
	Labels          map[string]string
	Mounts          ContainerMounts
	Tmpfs           map[string]string
	RegistryCred    string
	WaitingFor      wait.Strategy
	Name            string // for specifying container name
	Hostname        string
	ExtraHosts      []string
	Privileged      bool                // for starting privileged container
	Networks        []string            // for specifying network names
	NetworkAliases  map[string][]string // for specifying network aliases
	NetworkMode     container.NetworkMode
	Resources       container.Resources
	Files           []ContainerFile // files which will be copied when container starts
	User            string          // for specifying uid:gid
	SkipReaper      bool            // indicates whether we skip setting up a reaper for this
	ReaperImage     string          // alternative reaper image
	AutoRemove      bool            // if set to true, the container will be removed from the host when stopped
	AlwaysPullImage bool            // Always pull image
	ImagePlatform   string          // ImagePlatform describes the platform which the image runs on.
	Binds           []string
	ShmSize         int64    // Amount of memory shared with the host (in bytes)
	CapAdd          []string // Add Linux capabilities
	CapDrop         []string // Drop Linux capabilities
}

type DefaultNetwork string

type DeprecatedContainer interface {
	GetHostEndpoint(ctx context.Context, port string) (string, string, error)
	GetIPAddress(ctx context.Context) (string, error)
	LivenessCheckPorts(ctx context.Context) (nat.PortSet, error)
	Terminate(ctx context.Context) error
}

type DockerBindMountSource struct {
	*mount.BindOptions

	// HostPath is the path mounted into the container
	// the same host path might be mounted to multiple locations withing a single container
	HostPath string
}

type DockerCompose interface {
	Down() ExecError
	Invoke() ExecError
	WaitForService(string, wait.Strategy) DockerCompose
	WithCommand([]string) DockerCompose
	WithEnv(map[string]string) DockerCompose
	WithExposedService(string, int, wait.Strategy) DockerCompose
}

type DockerContainer struct {
	// Container ID from Docker
	ID         string
	WaitingFor wait.Strategy
	Image      string
	// contains filtered or unexported fields
}

type DockerNetwork struct {
	ID     string // Network ID from Docker
	Driver string
	Name   string
	// contains filtered or unexported fields
}

type DockerProvider struct {
	*DockerProviderOptions
	// contains filtered or unexported fields
}

type DockerProviderOption interface {
	ApplyDockerTo(opts *DockerProviderOptions)
}

type DockerProviderOptionFunc func(opts *DockerProviderOptions)

type DockerProviderOptions struct {
	*GenericProviderOptions
	// contains filtered or unexported fields
}

type DockerTmpfsMountSource struct {
	GenericTmpfsMountSource
	*mount.TmpfsOptions
}

type DockerVolumeMountSource struct {
	*mount.VolumeOptions

	// Name refers to the name of the volume to be mounted
	// the same volume might be mounted to multiple locations within a single container
	Name string
}

type ExecError struct {
	Command      []string
	StdoutOutput []byte
	StderrOutput []byte
	Error        error
	Stdout       error
	Stderr       error
}

type FileFromContainer struct {
	// contains filtered or unexported fields
}

type FromDockerfile struct {
	Context        string                      // the path to the context of of the docker build
	ContextArchive io.Reader                   // the tar archive file to send to docker that contains the build context
	Dockerfile     string                      // the path from the context to the Dockerfile for the image, defaults to "Dockerfile"
	BuildArgs      map[string]*string          // enable user to pass build args to docker daemon
	PrintBuildLog  bool                        // enable user to print build log
	AuthConfigs    map[string]types.AuthConfig // enable auth configs to be able to pull from an authenticated docker registry
}

type GenericBindMountSource struct {
	// HostPath is the path mounted into the container
	// the same host path might be mounted to multiple locations withing a single container
	HostPath string
}

type GenericContainerRequest struct {
	ContainerRequest              // embedded request for provider
	Started          bool         // whether to auto-start the container
	ProviderType     ProviderType // which provider to use, Docker if empty
	Logger           Logging      // provide a container specific Logging - use default global logger if empty
	Reuse            bool         // reuse an existing container if it exists or create a new one. a container name mustn't be empty
}

type GenericNetworkRequest struct {
	NetworkRequest              // embedded request for provider
	ProviderType   ProviderType // which provider to use, Docker if empty
}

type GenericProvider interface {
	ContainerProvider
	NetworkProvider
}

type GenericProviderOption interface {
	ApplyGenericTo(opts *GenericProviderOptions)
}

type GenericProviderOptionFunc func(opts *GenericProviderOptions)

type GenericProviderOptions struct {
	Logger         Logging
	DefaultNetwork string
}

type GenericTmpfsMountSource struct {
}

type GenericVolumeMountSource struct {
	// Name refers to the name of the volume to be mounted
	// the same volume might be mounted to multiple locations within a single container
	Name string
}

type IgnoreOrphans bool

type ImageBuildInfo interface {
	GetContext() (io.Reader, error)              // the path to the build context
	GetDockerfile() string                       // the relative path to the Dockerfile, including the fileitself
	ShouldPrintBuildLog() bool                   // allow build log to be printed to stdout
	ShouldBuildImage() bool                      // return true if the image needs to be built
	GetBuildArgs() map[string]*string            // return the environment args used to build the from Dockerfile
	GetAuthConfigs() map[string]types.AuthConfig // return the auth configs to be able to pull from an authenticated docker registry
}

type LocalDockerCompose struct {
	ComposeVersion
	*LocalDockerComposeOptions
	Executable       string
	ComposeFilePaths []string

	Identifier string
	Cmd        []string
	Env        map[string]string
	Services   map[string]interface{}

	WaitStrategyMap map[waitService]wait.Strategy
	// contains filtered or unexported fields
}

type LocalDockerComposeOption interface {
	ApplyToLocalCompose(opts *LocalDockerComposeOptions)
}

type LocalDockerComposeOptions struct {
	Logger Logging
}

type LocalDockerComposeOptionsFunc func(opts *LocalDockerComposeOptions)

type Log struct {
	LogType string
	Content []byte
}

type LogConsumer interface {
	Accept(Log)
}

type LoggerOption struct {
	// contains filtered or unexported fields
}

type Logging interface {
	Printf(format string, v ...interface{})
}

type MountType uint

type Network interface {
	Remove(context.Context) error // removes the network
}

type NetworkProvider interface {
	CreateNetwork(context.Context, NetworkRequest) (Network, error)            // create a network
	GetNetwork(context.Context, NetworkRequest) (types.NetworkResource, error) // get a network
}

type NetworkRequest struct {
	Driver         string
	CheckDuplicate bool
	Internal       bool
	EnableIPv6     bool
	Name           string
	Labels         map[string]string
	Attachable     bool
	IPAM           *network.IPAM

	SkipReaper  bool   // indicates whether we skip setting up a reaper for this
	ReaperImage string //alternative reaper registry
}

type ParallelContainerRequest []GenericContainerRequest

type ParallelContainersError struct {
	Errors []ParallelContainersRequestError
}

type ParallelContainersOptions struct {
	WorkersCount int // count of parallel workers. If field empty(zero), default value will be 'defaultWorkersCount'
}

type ParallelContainersRequestError struct {
	Request GenericContainerRequest
	Error   error
}

type ProviderType int

type Reaper struct {
	Provider  ReaperProvider
	SessionID string
	Endpoint  string
}

type ReaperProvider interface {
	RunContainer(ctx context.Context, req ContainerRequest) (Container, error)
	Config() TestContainersConfig
}

type RemoveImages uint8

type RemoveOrphans bool

type StackDownOption interface {
	// contains filtered or unexported methods
}

type StackIdentifier string

type StackUpOption interface {
	// contains filtered or unexported methods
}

type TestContainersConfig struct {
	Host           string `properties:"docker.host,default="`
	TLSVerify      int    `properties:"docker.tls.verify,default=0"`
	CertPath       string `properties:"docker.cert.path,default="`
	RyukPrivileged bool   `properties:"ryuk.container.privileged,default=false"`
}

type TmpfsMounter interface {
	GetTmpfsOptions() *mount.TmpfsOptions
}

type VolumeMounter interface {
	GetVolumeOptions() *mount.VolumeOptions
}

type Wait bool