2015-09-27 16:59:51 +03:00
// This is the main file that sets up integration tests using go-check.
2017-07-06 17:28:13 +03:00
package integration
2015-09-27 16:59:51 +03:00
import (
2017-05-17 16:22:44 +03:00
"bytes"
2021-11-25 13:10:06 +03:00
"context"
2017-10-13 12:08:03 +03:00
"flag"
2015-09-27 16:59:51 +03:00
"fmt"
2015-09-28 23:37:19 +03:00
"os"
"os/exec"
"path/filepath"
2019-06-17 12:48:05 +03:00
"strings"
2015-09-27 16:59:51 +03:00
"testing"
2015-09-28 23:37:19 +03:00
"text/template"
2020-10-09 10:32:03 +03:00
"time"
2015-09-27 16:59:51 +03:00
2021-11-25 13:10:06 +03:00
"github.com/compose-spec/compose-go/cli"
"github.com/compose-spec/compose-go/types"
"github.com/docker/cli/cli/config/configfile"
"github.com/docker/compose/v2/cmd/formatter"
composeapi "github.com/docker/compose/v2/pkg/api"
"github.com/docker/compose/v2/pkg/compose"
dockertypes "github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/client"
2019-07-15 11:22:03 +03:00
"github.com/fatih/structs"
2016-04-02 13:40:21 +03:00
"github.com/go-check/check"
2020-09-16 16:46:04 +03:00
"github.com/traefik/traefik/v2/pkg/log"
2015-09-27 16:59:51 +03:00
checker "github.com/vdemeester/shakers"
)
2020-07-07 15:42:03 +03:00
var (
integration = flag . Bool ( "integration" , false , "run integration tests" )
showLog = flag . Bool ( "tlog" , false , "always show Traefik logs" )
)
2017-10-13 12:08:03 +03:00
2015-09-27 16:59:51 +03:00
func Test ( t * testing . T ) {
2017-10-13 12:08:03 +03:00
if ! * integration {
2019-09-13 20:28:04 +03:00
log . WithoutContext ( ) . Info ( "Integration tests disabled." )
2017-10-13 12:08:03 +03:00
return
}
2021-11-25 13:10:06 +03:00
check . Suite ( & AccessLogSuite { } )
check . Suite ( & AcmeSuite { } )
check . Suite ( & ConsulCatalogSuite { } )
check . Suite ( & ConsulSuite { } )
check . Suite ( & DockerComposeSuite { } )
check . Suite ( & DockerSuite { } )
check . Suite ( & ErrorPagesSuite { } )
check . Suite ( & EtcdSuite { } )
check . Suite ( & FileSuite { } )
check . Suite ( & GRPCSuite { } )
check . Suite ( & HeadersSuite { } )
check . Suite ( & HealthCheckSuite { } )
check . Suite ( & HostResolverSuite { } )
check . Suite ( & HTTPSSuite { } )
check . Suite ( & HTTPSuite { } )
check . Suite ( & K8sSuite { } )
check . Suite ( & KeepAliveSuite { } )
check . Suite ( & LogRotationSuite { } )
check . Suite ( & MarathonSuite15 { } )
check . Suite ( & MarathonSuite { } )
check . Suite ( & ProxyProtocolSuite { } )
check . Suite ( & RateLimitSuite { } )
check . Suite ( & RedisSuite { } )
check . Suite ( & RestSuite { } )
check . Suite ( & RetrySuite { } )
check . Suite ( & SimpleSuite { } )
check . Suite ( & TCPSuite { } )
check . Suite ( & TimeoutSuite { } )
check . Suite ( & TLSClientHeadersSuite { } )
check . Suite ( & TracingSuite { } )
check . Suite ( & UDPSuite { } )
check . Suite ( & WebsocketSuite { } )
check . Suite ( & ZookeeperSuite { } )
2019-08-26 16:06:05 +03:00
check . TestingT ( t )
2015-09-27 16:59:51 +03:00
}
var traefikBinary = "../dist/traefik"
type BaseSuite struct {
2021-11-25 13:10:06 +03:00
composeProject * types . Project
dockerComposeService composeapi . Service
dockerClient * client . Client
2015-09-27 16:59:51 +03:00
}
func ( s * BaseSuite ) TearDownSuite ( c * check . C ) {
2021-11-25 13:10:06 +03:00
if s . composeProject != nil && s . dockerComposeService != nil {
s . composeDown ( c )
2015-09-27 16:59:51 +03:00
}
}
2021-11-25 13:10:06 +03:00
// createComposeProject creates the docker compose project stored as a field in the BaseSuite.
// This method should be called before starting and/or stopping compose services.
2015-09-27 16:59:51 +03:00
func ( s * BaseSuite ) createComposeProject ( c * check . C , name string ) {
2021-11-25 13:10:06 +03:00
projectName := fmt . Sprintf ( "traefik-integration-test-%s" , name )
2016-03-27 20:58:08 +03:00
composeFile := fmt . Sprintf ( "resources/compose/%s.yml" , name )
2016-12-12 20:30:31 +03:00
2021-11-25 13:10:06 +03:00
var err error
s . dockerClient , err = client . NewClientWithOpts ( )
2016-12-12 20:30:31 +03:00
c . Assert ( err , checker . IsNil )
2021-11-25 13:10:06 +03:00
s . dockerComposeService = compose . NewComposeService ( s . dockerClient , & configfile . ConfigFile { } )
ops , err := cli . NewProjectOptions ( [ ] string { composeFile } , cli . WithName ( projectName ) )
c . Assert ( err , checker . IsNil )
s . composeProject , err = cli . ProjectFromOptions ( ops )
c . Assert ( err , checker . IsNil )
2015-09-27 16:59:51 +03:00
}
2015-09-28 23:37:19 +03:00
2021-11-25 13:10:06 +03:00
// composeUp starts the given services of the current docker compose project, if they are not already started.
// Already running services are not affected (i.e. not stopped).
func ( s * BaseSuite ) composeUp ( c * check . C , services ... string ) {
c . Assert ( s . composeProject , check . NotNil )
c . Assert ( s . dockerComposeService , check . NotNil )
// We use Create and Restart instead of Up, because the only option that actually works to control which containers
// are started is within the RestartOptions.
err := s . dockerComposeService . Create ( context . Background ( ) , s . composeProject , composeapi . CreateOptions { } )
c . Assert ( err , checker . IsNil )
err = s . dockerComposeService . Restart ( context . Background ( ) , s . composeProject , composeapi . RestartOptions { Services : services } )
c . Assert ( err , checker . IsNil )
}
// composeStop stops the given services of the current docker compose project and removes the corresponding containers.
func ( s * BaseSuite ) composeStop ( c * check . C , services ... string ) {
c . Assert ( s . dockerComposeService , check . NotNil )
c . Assert ( s . composeProject , check . NotNil )
err := s . dockerComposeService . Stop ( context . Background ( ) , s . composeProject , composeapi . StopOptions { Services : services } )
c . Assert ( err , checker . IsNil )
err = s . dockerComposeService . Remove ( context . Background ( ) , s . composeProject , composeapi . RemoveOptions {
Services : services ,
Force : true ,
} )
c . Assert ( err , checker . IsNil )
}
// composeDown stops all compose project services and removes the corresponding containers.
func ( s * BaseSuite ) composeDown ( c * check . C ) {
c . Assert ( s . dockerComposeService , check . NotNil )
c . Assert ( s . composeProject , check . NotNil )
err := s . dockerComposeService . Down ( context . Background ( ) , s . composeProject . Name , composeapi . DownOptions { } )
c . Assert ( err , checker . IsNil )
2017-05-17 16:22:44 +03:00
}
func ( s * BaseSuite ) cmdTraefik ( args ... string ) ( * exec . Cmd , * bytes . Buffer ) {
cmd := exec . Command ( traefikBinary , args ... )
var out bytes . Buffer
cmd . Stdout = & out
cmd . Stderr = & out
return cmd , & out
}
2020-10-09 10:32:03 +03:00
func ( s * BaseSuite ) killCmd ( cmd * exec . Cmd ) {
err := cmd . Process . Kill ( )
if err != nil {
log . WithoutContext ( ) . Errorf ( "Kill: %v" , err )
}
time . Sleep ( 100 * time . Millisecond )
}
2017-09-13 11:34:04 +03:00
func ( s * BaseSuite ) traefikCmd ( args ... string ) ( * exec . Cmd , func ( * check . C ) ) {
cmd , out := s . cmdTraefik ( args ... )
return cmd , func ( c * check . C ) {
2018-06-27 16:08:05 +03:00
if c . Failed ( ) || * showLog {
2019-08-11 13:22:14 +03:00
s . displayLogK3S ( c )
2021-11-25 13:10:06 +03:00
s . displayLogCompose ( c )
2017-09-13 11:34:04 +03:00
s . displayTraefikLog ( c , out )
}
}
}
2019-08-11 13:22:14 +03:00
func ( s * BaseSuite ) displayLogK3S ( c * check . C ) {
filePath := "./fixtures/k8s/config.skip/k3s.log"
if _ , err := os . Stat ( filePath ) ; err == nil {
2021-03-04 22:08:03 +03:00
content , errR := os . ReadFile ( filePath )
2019-08-11 13:22:14 +03:00
if errR != nil {
log . WithoutContext ( ) . Error ( errR )
}
log . WithoutContext ( ) . Println ( string ( content ) )
}
log . WithoutContext ( ) . Println ( )
log . WithoutContext ( ) . Println ( "################################" )
log . WithoutContext ( ) . Println ( )
}
2021-11-25 13:10:06 +03:00
func ( s * BaseSuite ) displayLogCompose ( c * check . C ) {
if s . dockerComposeService == nil || s . composeProject == nil {
log . WithoutContext ( ) . Infof ( "%s: No docker compose logs." , c . TestName ( ) )
return
}
log . WithoutContext ( ) . Infof ( "%s: docker compose logs: " , c . TestName ( ) )
logWriter := log . WithoutContext ( ) . WriterLevel ( log . GetLevel ( ) )
logConsumer := formatter . NewLogConsumer ( context . Background ( ) , logWriter , false , true )
err := s . dockerComposeService . Logs ( context . Background ( ) , s . composeProject . Name , logConsumer , composeapi . LogOptions { } )
c . Assert ( err , checker . IsNil )
log . WithoutContext ( ) . Println ( )
log . WithoutContext ( ) . Println ( "################################" )
log . WithoutContext ( ) . Println ( )
}
2017-05-17 16:22:44 +03:00
func ( s * BaseSuite ) displayTraefikLog ( c * check . C , output * bytes . Buffer ) {
if output == nil || output . Len ( ) == 0 {
2019-08-11 13:22:14 +03:00
log . WithoutContext ( ) . Infof ( "%s: No Traefik logs." , c . TestName ( ) )
2017-05-17 16:22:44 +03:00
} else {
2019-08-11 13:22:14 +03:00
log . WithoutContext ( ) . Infof ( "%s: Traefik logs: " , c . TestName ( ) )
log . WithoutContext ( ) . Infof ( output . String ( ) )
2017-05-17 16:22:44 +03:00
}
}
2019-01-21 21:06:02 +03:00
func ( s * BaseSuite ) getDockerHost ( ) string {
2015-09-28 23:37:19 +03:00
dockerHost := os . Getenv ( "DOCKER_HOST" )
if dockerHost == "" {
// Default docker socket
dockerHost = "unix:///var/run/docker.sock"
}
2021-11-25 13:10:06 +03:00
2019-01-21 21:06:02 +03:00
return dockerHost
2016-04-28 02:43:43 +03:00
}
2015-09-28 23:37:19 +03:00
2016-04-28 02:43:43 +03:00
func ( s * BaseSuite ) adaptFile ( c * check . C , path string , tempObjects interface { } ) string {
2015-09-28 23:37:19 +03:00
// Load file
tmpl , err := template . ParseFiles ( path )
c . Assert ( err , checker . IsNil )
folder , prefix := filepath . Split ( path )
2021-03-04 22:08:03 +03:00
tmpFile , err := os . CreateTemp ( folder , strings . TrimSuffix ( prefix , filepath . Ext ( prefix ) ) + "_*" + filepath . Ext ( prefix ) )
2015-09-28 23:37:19 +03:00
c . Assert ( err , checker . IsNil )
defer tmpFile . Close ( )
2019-07-15 11:22:03 +03:00
model := structs . Map ( tempObjects )
model [ "SelfFilename" ] = tmpFile . Name ( )
err = tmpl . ExecuteTemplate ( tmpFile , prefix , model )
2015-09-28 23:37:19 +03:00
c . Assert ( err , checker . IsNil )
err = tmpFile . Sync ( )
c . Assert ( err , checker . IsNil )
return tmpFile . Name ( )
}
2021-11-25 13:10:06 +03:00
func ( s * BaseSuite ) getComposeServiceIP ( c * check . C , name string ) string {
filter := filters . NewArgs (
filters . Arg ( "label" , fmt . Sprintf ( "%s=%s" , composeapi . ProjectLabel , s . composeProject . Name ) ) ,
filters . Arg ( "label" , fmt . Sprintf ( "%s=%s" , composeapi . ServiceLabel , name ) ) ,
)
containers , err := s . dockerClient . ContainerList ( context . Background ( ) , dockertypes . ContainerListOptions { Filters : filter } )
c . Assert ( err , checker . IsNil )
c . Assert ( containers , checker . HasLen , 1 )
networkNames := s . composeProject . NetworkNames ( )
c . Assert ( networkNames , checker . HasLen , 1 )
network := s . composeProject . Networks [ networkNames [ 0 ] ]
return containers [ 0 ] . NetworkSettings . Networks [ network . Name ] . IPAddress
}
func ( s * BaseSuite ) getContainerIP ( c * check . C , name string ) string {
container , err := s . dockerClient . ContainerInspect ( context . Background ( ) , name )
c . Assert ( err , checker . IsNil )
c . Assert ( container . NetworkSettings . Networks , check . NotNil )
for _ , network := range container . NetworkSettings . Networks {
return network . IPAddress
}
// Should never happen.
c . Error ( "No network found" )
return ""
}
func withConfigFile ( file string ) string {
return "--configFile=" + file
}