handle retry limit

support_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"strings"
+	"testing"
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
@@ -19,36 +20,35 @@ const (
 	retryInterval = 3 * time.Second
 )
 
-type fataler interface {
-	Fatal(...interface{})
-}
-
-func newDB(f fataler, driver string, url string) *sql.DB {
+func newDB(t testing.TB, driver string, url string) *sql.DB {
 	db, err := sql.Open(driver, url)
 	if err != nil {
-		f.Fatal(err)
+		t.Fatal(err)
 	}
 
 	for i := 0; i < retryLimit; i++ {
 		if err := db.Ping(); err != nil {
-			time.Sleep(retryInterval)
-			continue
+			if i < retryLimit {
+				time.Sleep(retryInterval)
+				continue
+			}
+			t.Fatalf("connecting to %s: %w", driver, err)
 		}
 		break
 	}
 
 	return db
 }
 
-func newS3Client(f fataler, region string, endpoint string) *s3.S3 {
+func newS3Client(t testing.TB, region string, endpoint string) *s3.S3 {
 	awsConfig := aws.NewConfig().
 		WithRegion(region).
 		WithDisableSSL(true).
 		WithCredentials(credentials.NewEnvCredentials())
 
 	awsSession, err := session.NewSession(awsConfig)
 	if err != nil {
-		f.Fatal(err)
+		t.Fatal(err)
 	}
 
 	client := s3.New(awsSession)
@@ -57,68 +57,68 @@ func newS3Client(f fataler, region string, endpoint string) *s3.S3 {
 	return client
 }
 
-func exec(f fataler, db *sql.DB, statements string) {
+func exec(t testing.TB, db *sql.DB, statements string) {
 	s := strings.Split(statements, ";\n\n")
 	for _, statement := range s {
 		if _, err := db.Exec(statement); err != nil {
-			f.Fatal(err)
+			t.Fatal(err)
 		}
 	}
 }
 
-func createBucket(f fataler, client *s3.S3, name string) {
+func createBucket(t testing.TB, client *s3.S3, name string) {
 	if _, err := client.CreateBucket(&s3.CreateBucketInput{
 		Bucket: aws.String(name),
 	}); err != nil {
-		f.Fatal(err)
+		t.Fatal(err)
 	}
 }
 
-func deleteBucket(f fataler, client *s3.S3, name string) {
+func deleteBucket(t testing.TB, client *s3.S3, name string) {
 	// we could do this more cleanly with BatchDeleteIterator, but localstack doesn't like batch deletes :shrug:
 	out, err := client.ListObjects(&s3.ListObjectsInput{
 		Bucket: aws.String(name),
 	})
 	if err != nil {
-		f.Fatal(err)
+		t.Fatal(err)
 	}
 
 	for _, o := range out.Contents {
 		if _, err := client.DeleteObject(&s3.DeleteObjectInput{
 			Key:    o.Key,
 			Bucket: aws.String(name),
 		}); err != nil {
-			f.Fatal(err)
+			t.Fatal(err)
 		}
 	}
 
 	if _, err := client.DeleteBucket(&s3.DeleteBucketInput{
 		Bucket: aws.String(name),
 	}); err != nil {
-		f.Fatal(err)
+		t.Fatal(err)
 	}
 }
 
 //nolint deadcode false positive
-func readFile(f fataler, path string) string {
+func readFile(t testing.TB, path string) string {
 	contents, err := ioutil.ReadFile(path)
 	if err != nil {
-		f.Fatal(err)
+		t.Fatal(err)
 	}
 
 	return string(contents)
 }
 
 //nolint deadcode false positive
-func download(f fataler, downloader *s3manager.Downloader, bucket string, key string) string {
+func download(t testing.TB, downloader *s3manager.Downloader, bucket string, key string) string {
 	b := &aws.WriteAtBuffer{}
 	_, err := downloader.Download(b, &s3.GetObjectInput{
 		Bucket: aws.String(bucket),
 		Key:    aws.String(key),
 	})
 	if err != nil {
 		fmt.Println("error:", bucket, key)
-		f.Fatal(err)
+		t.Fatal(err)
 	}
 
 	return string(b.Bytes())