How to use NetworkAliases method of testcontainers Package

Best Testcontainers-go code snippet using testcontainers.NetworkAliases

base_container.go

Source:base_container.go

...41func (bc *BaseContainer) WithNetwork(network []string) *BaseContainer {42	bc.containerRequest.Networks = append(bc.containerRequest.Networks, network...)43	return bc44}45// WithNetworkAliases creates some aliases for the container.46func (bc *BaseContainer) WithNetworkAliases(aliases map[string][]string) *BaseContainer {47	if bc.containerRequest.NetworkAliases == nil {48		bc.containerRequest.NetworkAliases = make(map[string][]string)49	}50	for k, v := range aliases {51		bc.containerRequest.NetworkAliases[k] = append(bc.containerRequest.NetworkAliases[k], v...)52	}53	return bc54}55// GetANetworkAlias returns a network alias of the container.56func (bc *BaseContainer) GetANetworkAlias(network string) string {57	return bc.containerRequest.NetworkAliases[network][0]58}59// WithCmd sets the containers start up commands.60func (bc *BaseContainer) WithCmd(cmd []string) *BaseContainer {61	bc.containerRequest.Cmd = append(bc.containerRequest.Cmd, cmd...)62	return bc63}64// WithEnv sets the environment variable to the container.65func (bc *BaseContainer) WithEnv(env map[string]string) *BaseContainer {66	if bc.containerRequest.Env == nil {67		bc.containerRequest.Env = make(map[string]string)68	}69	for k, v := range env {70		bc.containerRequest.Env[k] = v71	}...

integration_cli_test.go

Source:integration_cli_test.go

...39			pwd:     "/piperbin",40			tempDir: "/test",41		},42		Networks:       []string{networkName},43		NetworkAliases: map[string][]string{networkName: {"karma"}},44	}45	reqSel := testcontainers.ContainerRequest{46		Image:          "selenium/standalone-chrome",47		Networks:       []string{networkName},48		NetworkAliases: map[string][]string{networkName: {"selenium"}},49	}50	provider, err := testcontainers.ProviderDocker.GetProvider()51	assert.NoError(t, err)52	network, err := provider.CreateNetwork(ctx, testcontainers.NetworkRequest{Name: networkName, CheckDuplicate: true})53	if err != nil {54		t.Fatal(err)55	}56	defer network.Remove(ctx)57	nodeContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{58		ContainerRequest: reqNode,59		Started:          true,60	})61	if err != nil {62		t.Fatal(err)...

utils.go

Source:utils.go

...11	if req.Networks == nil {12		req.Networks = make([]string, 0)13	}14	req.Networks = append(req.Networks, network)15	if req.NetworkAliases == nil {16		req.NetworkAliases = make(map[string][]string)17	}18	if _, ok := req.NetworkAliases[network]; !ok {19		req.NetworkAliases[network] = make([]string, 0)20	}21	req.NetworkAliases[network] = append(req.NetworkAliases[network], alias)22}23// GetHostAndPort retrieves the container host and port24func GetHostAndPort(ctx context.Context, c testcontainers.Container, exposedPort nat.Port) (host string, port nat.Port, err error) {25	if host, err = c.Host(ctx); err != nil {26		err = errors.Wrap(err, "Error reading container host name")27		return28	}29	if port, err = c.MappedPort(ctx, exposedPort); err != nil {30		err = errors.Wrap(err, "Error reading container mapped port")31		return32	}33	return34}35// GetAliasForNetwork retrieves the container alias in the specified network36func GetAliasForNetwork(ctx context.Context, req testcontainers.GenericContainerRequest, network string) (string, error) {37	hasNetwork := false38	for _, n := range req.Networks {39		if strings.EqualFold(n, network) {40			hasNetwork = true41			break42		}43	}44	if !hasNetwork {45		return "", errors.New("the container is not in the specified network")46	}47	var aliases []string48	var ok bool49	if aliases, ok = req.NetworkAliases[network]; !ok {50		return "", errors.New("the container is does not have an alias in the specified network")51	}52	if len(aliases) == 0 {53		return "", errors.New("the container is does not have an alias in the specified network")54	}55	return aliases[0], nil56}...

NetworkAliases

Using AI Code Generation

1import (2func main() {3	ctx := context.Background()4	req := testcontainers.ContainerRequest{5		ExposedPorts: []string{"80/tcp"},6		WaitingFor:   wait.ForListeningPort("80/tcp"),7		Networks:     []string{"test"},8		NetworkAliases: map[string][]string{9			"test": {"test-nginx"},10		},11	}12	ngnixContainer, _ := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{13	})14	ip, _ := ngnixContainer.Host(ctx)15	fmt.Println(ip)16	port, _ := ngnixContainer.MappedPort(ctx, "80")17	fmt.Println(port.Int())18	name, _ := ngnixContainer.Name(ctx)19	fmt.Println(name)20	id, _ := ngnixContainer.ContainerID(ctx)21	fmt.Println(id)22	state, _ := ngnixContainer.State(ctx)23	fmt.Println(state)24	info, _ := ngnixContainer.Inspect(ctx)25	fmt.Println(info)26	ngnixContainer.Terminate(ctx)27}

NetworkAliases

Using AI Code Generation

1import (2func main() {3	ctx := context.Background()4	req := testcontainers.ContainerRequest{5		ExposedPorts: []string{"8080/tcp"},6		WaitingFor:   wait.ForLog("Started!"),7	}8	ryukContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{9	})10	if err != nil {11		log.Fatalf("Could not start Ryuk container: %s", err)12	}13	defer func() {14		err := ryukContainer.Terminate(ctx)15		if err != nil {16			log.Fatalf("Could not stop Ryuk container: %s", err)17		}18	}()19	ip, err := ryukContainer.Host(ctx)20	if err != nil {21		log.Fatalf("Could not get Ryuk container IP: %s", err)22	}23	port, err := ryukContainer.MappedPort(ctx, "8080/tcp")24	if err != nil {25		log.Fatalf("Could not get Ryuk container port: %s", err)26	}27	fmt.Printf("Ryuk container IP: %s, port: %s", ip, port.Port())28	networkAliases, err := ryukContainer.NetworkAliases(ctx)29	if err != nil {30		log.Fatalf("Could not get Ryuk container network aliases: %s", err)31	}32	fmt.Printf("Ryuk container network aliases: %s", networkAliases)33}

NetworkAliases

Using AI Code Generation

1import (2func main() {3    ctx := context.Background()4    req := testcontainers.ContainerRequest{5        ExposedPorts: []string{"8091/tcp"},6        WaitingFor:   wait.ForLog("The following services are ready: data, index, query, search, eventing, analytics,fts"),7    }8    couchbase, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{9    })10    if err != nil {11        panic(err)12    }13    defer couchbase.Terminate(ctx)14    couchbaseIP, err := couchbase.Host(ctx)15    if err != nil {16        panic(err)17    }18    couchbasePort, err := couchbase.MappedPort(ctx, "8091")19    if err != nil {20        panic(err)21    }22    fmt.Println(couchbaseIP)23    fmt.Println(couchbasePort.Int())24}

NetworkAliases

Using AI Code Generation

1import (2func main() {3	ctx := context.Background()4	req := testcontainers.ContainerRequest{5		ExposedPorts: []string{"80/tcp"},6		WaitingFor:   wait.ForHTTP("/"),7	}8	nginxContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{9	})10	if err != nil {11		panic(err)12	}13	defer nginxContainer.Terminate(ctx)14	ip, err := nginxContainer.Host(ctx)15	if err != nil {16		panic(err)17	}18	port, err := nginxContainer.MappedPort(ctx, "80")19	if err != nil {20		panic(err)21	}22	if err != nil {23		panic(err)24	}25	log.Println(resp.Status)26	port2, err := nginxContainer.MappedPort(ctx, "80")27	if err != nil {28		panic(err)29	}30	if err != nil {31		panic(err)32	}33	log.Println(resp2.Status)34	port3, err := nginxContainer.MappedPort(ctx, "80")35	if err != nil {36		panic(err)37	}38	if err != nil {39		panic(err)40	}41	log.Println(resp3.Status)42	port4, err := nginxContainer.MappedPort(ctx, "80")43	if err != nil {44		panic(err)

NetworkAliases

Using AI Code Generation

1import (2func main() {3	ctx := context.Background()4	req := testcontainers.ContainerRequest{5		Cmd:          []string{"sh", "-c", "while true; do echo hello world; sleep 1; done"},6		ExposedPorts: []string{"80/tcp"},7		WaitingFor:   wait.ForLog("hello world"),8	}9	container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{10		Networks:         []string{"my_network"},11	})12	if err != nil {13		log.Fatalf("Could not start container: %v", err)14	}15	ip, err := container.Host(ctx)16	if err != nil {17		log.Fatalf("Could not get container IP: %v", err)18	}19	fmt.Printf("Container IP: %s20	mappedPort, err := container.MappedPort(ctx, "80")21	if err != nil {22		log.Fatalf("Could not get container port: %v", err)23	}24	fmt.Printf("Container Port: %s25", mappedPort.Port())26", mappedPort.Port())27", mappedPort.Port())

NetworkAliases

Using AI Code Generation

1import (2func main() {3	ctx := context.Background()4	req := testcontainers.ContainerRequest{5		ExposedPorts: []string{"6379/tcp"},6		WaitingFor:   wait.ForListeningPort("6379/tcp"),7		Networks:     []string{"test"},8		NetworkAliases: map[string][]string{9			"test": {"redis"},10		},11	}12	redisContainer, _ := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{13	})14	defer redisContainer.Terminate(ctx)15	ip, _ := redisContainer.Host(ctx)16	port, _ := redisContainer.MappedPort(ctx, "6379/tcp")17	fmt.Println(redisURL)18	os.Exit(0)19}20import (21func main() {22	ctx := context.Background()23	req := testcontainers.ContainerRequest{24		ExposedPorts: []string{"6379/tcp"},25		WaitingFor:   wait.ForListeningPort("6379/tcp"),26		Networks:     []string{"test"},27		NetworkAliases: map[string][]string{28			"test": {"redis"},29		},30	}31	redisContainer, _ := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{32	})33	defer redisContainer.Terminate(ctx)34	ip, _ := redisContainer.Host(ctx)35	port, _ := redisContainer.MappedPort(ctx, "6379/tcp")36	fmt.Println(redisURL)37	os.Exit(0)38}39import (

NetworkAliases

Using AI Code Generation

1import (2func main() {3    ctx := context.Background()4    req := testcontainers.ContainerRequest{5        ExposedPorts: []string{"5432/tcp"},6        Env: map[string]string{7        },8        WaitingFor: wait.ForLog("database system is ready to accept connections").WithStartupTimeout(1 * time.Minute),9    }10    postgresContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{11    })12    if err != nil {13        log.Fatalf("Could not start container: %v", err)14    }15    defer postgresContainer.Terminate(ctx)16    ip, err := postgresContainer.Host(ctx)17    if err != nil {18        log.Fatalf("Could not get container IP: %v", err)19    }20    port, err := postgresContainer.MappedPort(ctx, "5432/tcp")21    if err != nil {22        log.Fatalf("Could not get container port: %v", err)23    }24    postgresContainer.NetworkAliases(ctx, "postgres")25    cmd := exec.Command("psql", "-h", ip, "-p", port.Port(), "postgres", "-U", "postgres")26    cmd.Run()27}28psql (12.5 (Debian 12.5-1.pgdg100+1))29import (30func main()

NetworkAliases

Using AI Code Generation

1func main() {2	ctx := context.Background()3	req := testcontainers.ContainerRequest{4		ExposedPorts: []string{"3306/tcp"},5		WaitingFor:   wait.ForListeningPort("3306/tcp"),6		Networks:     []string{"network-1"},7		NetworkAliases: map[string][]string{8			"network-1": {"mysql"},9		},10		Env: map[string]string{11		},12	}13	mysqlContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{14	})15	if err != nil {16		panic(err)17	}18	defer mysqlContainer.Terminate(ctx)19	ip, _ := mysqlContainer.Host(ctx)20	port, _ := mysqlContainer.MappedPort(ctx, "3306")21	fmt.Println(ip, port.Int())22}

NetworkAliases

Using AI Code Generation

1func TestNetworkAliases(t *testing.T) {2	ctx := context.Background()3	req := testcontainers.ContainerRequest{4		ExposedPorts: []string{"6379/tcp"},5		WaitingFor:   wait.ForListeningPort("6379/tcp"),6	}7	redisContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{8	})9	if err != nil {10		log.Fatal(err)11	}12	defer redisContainer.Terminate(ctx)13	ip, err := redisContainer.Host(ctx)14	if err != nil {15		log.Fatal(err)16	}17	port, err := redisContainer.MappedPort(ctx, "6379")18	if err != nil {19		log.Fatal(err)20	}21	fmt.Printf("Redis is available at %s:%s22", ip, port.Port())23	req = testcontainers.ContainerRequest{24		Cmd:          []string{"nc", ip, port.Port()},25		Networks:     []string{"test"},26		NetworkAliases: map[string][]string{"test": {"redis"}},27		WaitingFor:   wait.ForLog("Connection refused"),28	}29	ncContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{30	})31	if err != nil {32		log.Fatal(err)33	}34	defer ncContainer.Terminate(ctx)35	ip, err = ncContainer.Host(ctx)36	if err != nil {37		log.Fatal(err)38	}39	port, err = ncContainer.MappedPort(ctx, "6379")40	if err != nil {41		log.Fatal(err)42	}43	fmt.Printf("Redis is available at %s:%s44", ip, port.Port())45}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.