How to use Read method of testcontainers Package

Best Testcontainers-go code snippet using testcontainers.Read

cache_integration_test.go

Source:cache_integration_test.go

...29	ctx = context.Background()30	req := testcontainers.ContainerRequest{31		Image:        "redis:latest",32		ExposedPorts: []string{"6379/tcp"},33		WaitingFor:   wait.ForLog("Ready to accept connections"),34	}35	redisC, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{36		ContainerRequest: req,37		Started:          true,38	})39	if err != nil {40		panic(err)41	}42	redisHost, err := redisC.Host(ctx)43	if err != nil {44		panic(err)45	}46	redisPort, err := redisC.MappedPort(ctx, "6379/tcp")47	if err != nil {48		panic(err)49	}50	envVariables.redisURL = fmt.Sprintf("%s:%s", redisHost, redisPort.Port())51	envVariables.expiryInSeconds = 252	redisCacheService = cache.NewRedisCacheService("tcp", envVariables.redisURL, 10, envVariables.expiryInSeconds)53	return redisC54}55func stopContainer(container testcontainers.Container) {56	fmt.Println("Stopping container")57	container.Terminate(ctx)58}59func TestIntegrationRedisCacheService_Create(t *testing.T) {60	Convey("When I create a cached entry", t, func() {61		const topic = "stream:test"62		err := redisCacheService.Create(topic, "{id : 123}", 20)63		Convey("Then the cached entry should be created", func() {64			if err != nil {65				t.Error("Failed: " + err.Error())66			}67		})68	})69}70func TestIntegrationRedisCacheService_Read(t *testing.T) {71	Convey("Given an entry exists in the redis cache sortedSet", t, func() {72		const topic = "stream:test2"73		err := redisCacheService.Create(topic, "{id : 124}", 21)74		if err != nil {75			t.Error("Failed: " + err.Error())76		}77		Convey("When I fetch the cached entries", func() {78			actual, err := redisCacheService.Read(topic, 0)79			if err != nil {80				t.Error("Failed: " + err.Error())81			}82			Convey("Then the cached entries for the given topic should be found", func() {83				So(len(actual), ShouldEqual, 1)84				var expected = [1]string{"{id : 124}"}85				So(actual[0], ShouldEqual, expected[0])86			})87		})88	})89}90func TestIntegrationRedisCacheService_ReadFromAGivenOffset(t *testing.T) {91	Convey("Given an entry exists in the redis cache sortedSet", t, func() {92		const topic = "stream:test3"93		for score := 10; score < 20; score++ {94			delta := fmt.Sprintf("{id : %d}", score)95			err := redisCacheService.Create(topic, delta, int64(score))96			if err != nil {97				t.Error("Failed: " + err.Error())98			}99		}100		Convey("When I fetch the cached entries for a given offset", func() {101			actualArray, err := redisCacheService.Read(topic, 15)102			if err != nil {103				t.Error("Failed: " + err.Error())104			}105			Convey("Then only the cached entries for the given offset should be found", func() {106				So(len(actualArray), ShouldEqual, 5)107				var expected = []string{"{id : 15}", "{id : 16}", "{id : 17}", "{id : 18}", "{id : 19}"}108				for index, actual := range actualArray {109					fmt.Println("Actual: ", index, actual)110					So(actual, ShouldEqual, expected[index])111				}112			})113		})114	})115}116func TestIntegrationRedisCacheService_ReadDoesNotReturnExpiredEntries(t *testing.T) {117	Convey("Given an entry exists in the redis cache sortedSet", t, func() {118		const topic = "stream:test4"119		for score := 10; score < 20; score++ {120			delta := fmt.Sprintf("{id : %d}", score)121			err := redisCacheService.Create(topic, delta, int64(score))122			if err != nil {123				t.Error("Failed: " + err.Error())124			}125		}126		Convey("When the entries become expired", func() {127			fmt.Println("Waiting for cache entries to expire...")128			time.Sleep(time.Duration(envVariables.expiryInSeconds) * time.Second)129			Convey("Then the expired entries for the given offset should not be returned", func() {130				actualArray, err := redisCacheService.Read(topic, 10)131				if err != nil {132					t.Error("Failed: " + err.Error())133				}134				So(len(actualArray), ShouldEqual, 0)135			})136		})137	})138}...

client_test.go

Source:client_test.go

1package influx_test2import (3	"context"4	"errors"5	"fmt"6	"github.com/google/go-cmp/cmp"7	influxdb2 "github.com/influxdata/influxdb-client-go/v2"8	"github.com/paluszkiewiczB/speedtest/internal/core"9	"github.com/paluszkiewiczB/speedtest/internal/influx"10	"github.com/testcontainers/testcontainers-go"11	"github.com/testcontainers/testcontainers-go/wait"12	"strconv"13	"strings"14	"testing"15	"time"16)17const (18	username    = "username"19	password    = "influxdb123"20	org         = "testOrganization"21	bucket      = "testBucket"22	token       = "adminToken"23	mappedPort  = "8086/tcp"24	measurement = "test"25)26var influxEnvs = map[string]string{27	"DOCKER_INFLUXDB_INIT_USERNAME":    username,28	"DOCKER_INFLUXDB_INIT_PASSWORD":    password,29	"DOCKER_INFLUXDB_INIT_ORG":         org,30	"DOCKER_INFLUXDB_INIT_BUCKET":      bucket,31	"DOCKER_INFLUXDB_INIT_ADMIN_TOKEN": token,32	"DOCKER_INFLUXDB_INIT_MODE":        "setup",33}34func TestInflux_Push(t *testing.T) {35	if testing.Short() {36		t.SkipNow()37	}38	ctx := context.Background()39	container, err := prepareContainer(ctx)40	defer terminate(container, ctx)41	if err != nil {42		t.Fatal(err)43	}44	ports, err := container.Ports(ctx)45	if err != nil {46		t.Fatal(err)47	}48	mP := ports[mappedPort][0]49	url := fmt.Sprintf("http://%s:%s", mP.HostIP, strings.Split(mP.HostPort, "/")[0])50	fmt.Printf("InfluxDB url: %s\n", url)51	asyncClient, err := influx.NewClient(influx.Cfg{52		Url:          url,53		Token:        token,54		Organization: org,55		Bucket:       bucket,56		Points: influx.PointsCfg{57			Measurement: measurement,58			Tags: map[string]string{59				"key": "value",60			},61		},62	})63	if err != nil {64		t.Fatal(err)65	}66	client := influx.Retrying(asyncClient, influx.RetryCfg{Times: 20, Wait: 100 * time.Millisecond})67	err = client.Ping(ctx)68	if err != nil {69		t.Fatal(err)70	}71	speed := core.Speed{72		Download:  10.1,73		Upload:    2.51,74		Ping:      14 * time.Second,75		Timestamp: time.Now(),76	}77	err = client.Push(ctx, speed)78	if err != nil {79		t.Fatal(err)80	}81	err = client.Close()82	if err != nil {83		t.Error(err)84	}85	read, err := readSpeed(ctx, url)86	if err != nil {87		t.Fatal(err)88	}89	if cmp.Diff(speed, read) != "" {90		t.Fatalf("read speed differs from written one. expected: %v, actual: %v", speed, read)91	}92}93func prepareContainer(ctx context.Context) (testcontainers.Container, error) {94	req := testcontainers.ContainerRequest{95		FromDockerfile: testcontainers.FromDockerfile{},96		Image:          "influxdb:2.1-alpine",97		ExposedPorts:   []string{mappedPort},98		Env:            influxEnvs,99		WaitingFor:     wait.ForLog("Starting log_id="),100	}101	c, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{102		ContainerRequest: req,103		Started:          true,104	})105	if err != nil {106		return nil, err107	}108	return c, nil109}110func terminate(c testcontainers.Container, ctx context.Context) {111	err := c.Terminate(ctx)112	if err != nil {113		fmt.Printf("error terminating influxdb container: %v\n", err)114	}115}116func readSpeed(ctx context.Context, url string) (core.Speed, error) {117	query := fmt.Sprintf(118		`	from(bucket:"%s")119					|> range(start: -1h)120					|> filter(fn: (r) =>r._measurement == "%s")121					|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")`, bucket, measurement)122	result, err := influxdb2.NewClient(url, token).QueryAPI(org).Query(ctx, query)123	if err != nil {124		return core.InvalidSpeed, err125	}126	if !result.Next() {127		return core.InvalidSpeed, errors.New("speed not found")128	}129	r := result.Record()130	return core.Speed{131		Download:  toFloat(r.ValueByKey("download")),132		Upload:    toFloat(r.ValueByKey("upload")),133		Ping:      time.Duration(toInt(r.ValueByKey("ping")) * time.Millisecond.Nanoseconds()),134		Timestamp: r.Time(),135	}, nil136}137func toFloat(f interface{}) float64 {138	if r, ok := f.(float64); ok {139		return r140	}141	if s, ok := f.(string); ok {142		float, err := strconv.ParseFloat(s, 64)143		if err != nil {144			panic(err)145		}146		return float147	}148	panic(fmt.Sprintf("cannot parse to float: %v", f))149}150func toInt(f interface{}) int64 {151	if r, ok := f.(int64); ok {152		return r153	}154	if s, ok := f.(string); ok {155		parsed, err := strconv.ParseInt(s, 10, 64)156		if err != nil {157			panic(err)158		}159		return parsed160	}161	panic(fmt.Sprintf("cannot parse to int64: %v", f))162}...

customer_dao_test.go

Source:customer_dao_test.go

1package main2import (3	"context"4	"fmt"5	"github.com/docker/go-connections/nat"6	_ "github.com/lib/pq"7	"github.com/testcontainers/testcontainers-go"8	_ "github.com/testcontainers/testcontainers-go"9	"github.com/testcontainers/testcontainers-go/wait"10	_ "github.com/testcontainers/testcontainers-go/wait"11	"os"12	"testing"13	"time"14)15func CreateTestContainer(ctx context.Context, dbname string) (testcontainers.Container, error) {16	user := "user"17	password := "password"18	var env = map[string]string{19		"POSTGRES_PASSWORD": "password",20		"POSTGRES_USER":     "user",21		"POSTGRES_DB":       dbname,22	}23	seedDataPath, err := os.Getwd()24	if err != nil {25		panic(fmt.Sprintf("%v", err))26	}27	mountPath := seedDataPath + "/env/sql"28	var port = "5432/tcp"29	dbURL := func(port nat.Port) string {30		return fmt.Sprintf("postgres://user:password@localhost:%s/%s?sslmode=disable", port.Port(), dbname)31	}32	req := testcontainers.ContainerRequest{33		Image:        "postgres:13.4-alpine",34		ExposedPorts: []string{port},35		Cmd:          []string{"postgres", "-c", "fsync=off"},36		Env:          env,37		BindMounts: map[string]string{38			"/docker-entrypoint-initdb.d/": mountPath,39		},40		WaitingFor: wait.ForSQL(nat.Port(port), "postgres", dbURL).Timeout(time.Second * 5),41		AutoRemove: true,42	}43	container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{44		ContainerRequest: req,45		Started:          true,46	})47	if err != nil {48		return container, fmt.Errorf("failed to start container: %s", err)49	}50	mappedPort, err := container.MappedPort(ctx, nat.Port(port))51	if err != nil {52		return container, fmt.Errorf("failed to get container external port: %s", err)53	}54	os.Setenv("DB_USER", user)55	os.Setenv("DB_PASSWORD", password)56	os.Setenv("DB_PORT", mappedPort.Port())57	os.Setenv("DB_NAME", dbname)58	return container, nil59}60func checkCustomer(t *testing.T, customer Customer) {61	if customer.id <= 0 {62		t.Error("Customer id is not read")63	}64	if customer.version <= 0 {65		t.Error("Customer version is not read")66	}67	if len(customer.firstName) == 0 {68		t.Error("Customer first name is not read")69	}70	if len(customer.lastName) == 0 {71		t.Error("Customer last name is not read")72	}73	if len(customer.address) == 0 {74		t.Error("Customer address is not read")75	}76	if len(customer.email) == 0 {77		t.Error("Customer email is not read")78	}79	if customer.birthday.IsZero() {80		t.Error("Customer birthday is not read")81	}82}83func TestWithPostgreSql(t *testing.T) {84	ctx := context.Background()85	container, err := CreateTestContainer(ctx, "testdb")86	if err != nil {87		panic(err)88	}89	var daoService CustomerDao90	customers, listErr := daoService.list()91	if listErr != nil {92		t.Error("Error during list customers: " + listErr.Error())93	}94	if len(customers) != 3 {95		t.Error("Cannot load predefined customers from database")96	}97	checkCustomer(t, customers[0])98	checkCustomer(t, customers[1])99	checkCustomer(t, customers[2])100	customer := customers[2]101	searchResult, _ := daoService.search(customer.firstName, customer.lastName, Sort.Unordered)102	if len(searchResult) != 1 {103		t.Error("Cannot search customer by first name and last name")104	}105	checkCustomer(t, searchResult[0])106	searchResult, err = daoService.search("111", "222", Sort.Unordered)107	if err != nil {108		t.Error("Search customer error: " + err.Error())109	}110	if len(searchResult) != 0 {111		t.Error("Search customer does not work correctly")112	}113	customerById, _ := daoService.get(customer.id)114	checkCustomer(t, customerById)115	var notExistsCustomer = Customer{}116	updateError := daoService.update(notExistsCustomer)117	if updateError == nil {118		t.Error("No error after updating non-exists customer")119	}120	updateError = daoService.update(customer)121	if updateError != nil {122		t.Error("Cannot update customer")123	}124	updateError = daoService.update(customer)125	if updateError == nil {126		t.Error("Update customer with incorrect version")127	}128	var newCustomer = Customer{129		0,130		"FNAME",131		"LNAME",132		time.Now(),133		"Male",134		"test111@test.ee",135		"qwerty asdfghh zxcvbn",136		0,137	}138	newId, createErr := daoService.create(newCustomer)139	if createErr != nil {140		t.Error("Cannot create customer")141	}142	if newId <= 0 {143		t.Error("Incorrect new customer id")144	}145	defer container.Terminate(ctx)146}...

Read

Using AI Code Generation

1import (2func main() {3    ctx := context.Background()4    req := testcontainers.ContainerRequest{5        ExposedPorts: []string{"5432/tcp"},6        WaitingFor:   wait.ForListeningPort("5432/tcp"),7    }8    postgresContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{9    })10    if err != nil {11        panic(err)12    }13    defer postgresContainer.Terminate(ctx)14    port, err := postgresContainer.MappedPort(ctx, "5432")15    if err != nil {16        panic(err)17    }18    fmt.Println(port.Int())19}

Read

Using AI Code Generation

1import (2func main() {3	ctx := context.Background()4	req := testcontainers.ContainerRequest{5		ExposedPorts: []string{"9092/tcp"},6		WaitingFor:   wait.ForListeningPort("9092/tcp"),7	}8	kafka, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{9	})10	if err != nil {11		panic(err)12	}13	defer kafka.Terminate(ctx)14	ip, err := kafka.Host(ctx)15	if err != nil {16		panic(err)17	}18	mappedPort, err := kafka.MappedPort(ctx, "9092/tcp")19	if err != nil {20		panic(err)21	}22	fmt.Println(ip, mappedPort.Int())23}24import (25func main() {26	ctx := context.Background()27	req := testcontainers.ContainerRequest{28		ExposedPorts: []string{"9092/tcp"},29		WaitingFor:   wait.ForListeningPort("9092/tcp"),30	}31	kafka, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{32	})33	if err != nil {34		panic(err)35	}36	defer kafka.Terminate(ctx)37	err = kafka.Start(ctx)38	if err != nil {39		panic(err)40	}41	ip, err := kafka.Host(ctx)42	if err != nil {43		panic(err)44	}45	mappedPort, err := kafka.MappedPort(ctx, "9092/tcp")46	if err != nil {47		panic(err)48	}49	fmt.Println(ip, mappedPort.Int())50}

Read

Using AI Code Generation

1import (2func main() {3	ctx := context.Background()4	req := testcontainers.ContainerRequest{5		ExposedPorts: []string{"80/tcp"},6		WaitingFor:   wait.ForLog("ready"),7	}8	container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{9	})10	if err != nil {11		log.Fatal(err)12	}13	ip, err := container.Host(ctx)14	if err != nil {15		log.Fatal(err)16	}17	mappedPort, err := container.MappedPort(ctx, "80")18	if err != nil {19		log.Fatal(err)20	}21	containerID, err := container.ContainerID(ctx)22	if err != nil {23		log.Fatal(err)24	}25	containerName, err := container.ContainerName(ctx)26	if err != nil {27		log.Fatal(err)28	}29	containerURL, err := container.URL(ctx)30	if err != nil {31		log.Fatal(err)32	}33	containerState, err := container.State(ctx)34	if err != nil {35		log.Fatal(err)36	}37	fmt.Println(ip, mappedPort, containerID, containerName, containerURL, containerState)38	err = container.Terminate(ctx)39	if err != nil {40		log.Fatal(err)41	}42}

Read

Using AI Code Generation

1import (2func main() {3	ctx := context.Background()4	req := testcontainers.ContainerRequest{5		ExposedPorts: []string{"5432/tcp"},6		WaitingFor:   wait.ForLog("database system is ready to accept connections"),7	}8	postgresContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{9	})10	if err != nil {11		log.Fatalf("Could not start container: %s", err)12	}13	defer postgresContainer.Terminate(ctx)14	ip, err := postgresContainer.Host(ctx)15	if err != nil {16		log.Fatalf("Could not get container IP: %s", err)17	}18	port, err := postgresContainer.MappedPort(ctx, "5432")19	if err != nil {20		log.Fatalf("Could not get container port: %s", err)21	}22	fmt.Printf("Container IP: %s, Port: %s", ip, port.Port())23}24import (25func main() {26	ctx := context.Background()27	req := testcontainers.ContainerRequest{28		ExposedPorts: []string{"5432/tcp"},29		WaitingFor:   wait.ForLog("database system is ready to accept connections"),30	}31	postgresContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{32	})33	if err != nil {34		log.Fatalf("Could not start container: %s", err)35	}36	defer postgresContainer.Terminate(ctx)37	ip, err := postgresContainer.Host(ctx)38	if err != nil {39		log.Fatalf("Could not get container IP: %s", err)40	}41	port, err := postgresContainer.MappedPort(ctx, "5432")42	if err != nil {43		log.Fatalf("Could not get container port: %s", err)44	}45	fmt.Printf("

Read

Using AI Code Generation

1import (2func main() {3    ctx := context.Background()4    req := testcontainers.ContainerRequest{5        ExposedPorts: []string{"5432/tcp"},6        WaitingFor:   wait.ForLog("database system is ready to accept connections"),7    }8    postgresContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{9    })10    if err != nil {11        log.Fatal(err)12    }13    defer postgresContainer.Terminate(ctx)14    ip, err := postgresContainer.Host(ctx)15    if err != nil {16        log.Fatal(err)17    }18    port, err := postgresContainer.MappedPort(ctx, "5432")19    if err != nil {20        log.Fatal(err)21    }22    fmt.Println(ip + ":" + port.Port())23}

Read

Using AI Code Generation

1import (2func main() {3	file, err := os.Open("input.txt")4	if err != nil {5		log.Fatal(err)6	}7	defer file.Close()8	scanner := bufio.NewScanner(file)9	for scanner.Scan() {10		s := strings.Split(scanner.Text(), ",")11		runContainer(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9])12	}13	if err := scanner.Err(); err != nil {14		log.Fatal(err)15	}16}17func runContainer(imageName, imageName1, imageName2, imageName3, imageName4, imageName5, imageName6, imageName7, imageName8, imageName9 string) {18	ctx := context.Background()19	req := testcontainers.ContainerRequest{20		ExposedPorts: []string{"80/tcp"},21		WaitingFor:   wait.ForHTTP("/"),22	}23	req1 := testcontainers.ContainerRequest{24		ExposedPorts: []string{"80/tcp"},25		WaitingFor:   wait.ForHTTP("/"),26	}27	req2 := testcontainers.ContainerRequest{28		ExposedPorts: []string{"80/tcp"},29		WaitingFor:   wait.ForHTTP("/"),30	}31	req3 := testcontainers.ContainerRequest{32		ExposedPorts: []string{"80/tcp"},33		WaitingFor:   wait.ForHTTP("/"),34	}35	req4 := testcontainers.ContainerRequest{36		ExposedPorts: []string{"80/tcp"},37		WaitingFor:   wait.ForHTTP("/"),38	}39	req5 := testcontainers.ContainerRequest{40		ExposedPorts: []string{"80

Read

Using AI Code Generation

1func main() {2    ctx := context.Background()3    req := testcontainers.ContainerRequest{4        ExposedPorts: []string{"9200/tcp"},5        WaitingFor:   wait.ForLog("started"),6    }7    elasticsearch, _ := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{8    })9    defer elasticsearch.Terminate(ctx)10    ip, _ := elasticsearch.Host(ctx)11    port, _ := elasticsearch.MappedPort(ctx, "9200")12    fmt.Printf("Elasticsearch is listening on IP: %s and port: %s", ip, port.Port())13}14require (

Read

Using AI Code Generation

1import (2func main() {3	req := testcontainers.ContainerRequest{4		ExposedPorts: []string{"9092/tcp"},5		WaitingFor:   wait.ForLog("started (kafka.server.KafkaServer)").WithOccurrence(1),6	}7	ctx := context.Background()8	kafka, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{9	})10	if err != nil {11		log.Fatalf("Could not start container: %v", err)12	}13	defer kafka.Terminate(ctx)14	ip, err := kafka.Host(ctx)15	if err != nil {16		log.Fatalf("Could not get container IP: %v", err)17	}18	port, err := kafka.MappedPort(ctx, "9092/tcp")19	if err != nil {20		log.Fatalf("Could not get container port: %v", err)21	}22	fmt.Printf("Kafka is listening on %s:%s23", ip, port.Port())24	file, err := os.Open("test.txt")25	if err != nil {26		log.Fatal(err)27	}28	defer file.Close()29	reader := bufio.NewReader(file)30	for {31		line, err := reader.ReadString('32		if err == io.EOF {33		} else if err != nil {34			log.Fatal(err)35		}36		fmt.Print(line)37	}38}39import (40func main() {41	req := testcontainers.ContainerRequest{42		ExposedPorts: []string{"9092/tcp"},43		WaitingFor:   wait.ForLog("started (kafka.server.KafkaServer)").WithOccurrence(1),44	}45	ctx := context.Background()46	kafka, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{47	})48	if err != nil {

Read

Using AI Code Generation

1import (2func main() {3	ctx := context.Background()4	req := testcontainers.ContainerRequest{5		Cmd:          []string{"tail", "-f", "/dev/null"},6		ExposedPorts: []string{"80/tcp"},7		WaitingFor:   wait.ForHTTP("/"),8	}

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.