github.com/bkosm/gompose/v2@v2.3.1/helpers_test.go (about)

     1  package gompose
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"io"
     7  	"net/http"
     8  	"os"
     9  	"os/exec"
    10  	"syscall"
    11  	"testing"
    12  	"time"
    13  )
    14  
    15  const (
    16  	expectedLogLine   = "server is listening"
    17  	customServiceName = "echo"
    18  	containerPort     = 5678
    19  )
    20  
    21  var customFileOpt = CustomFile("./testdata/docker-compose.yml")
    22  
    23  func testUp(t *testing.T) {
    24  	t.Helper()
    25  	_, err := run(*exec.Command("docker-compose", "-f", "./testdata/docker-compose.yml", "up", "-d"))
    26  	if err != nil {
    27  		t.Fatal(err)
    28  	}
    29  }
    30  
    31  func testDown(t *testing.T) {
    32  	t.Helper()
    33  	_, err := run(*exec.Command("docker-compose", "-f", "./testdata/docker-compose.yml", "down"))
    34  	if err != nil {
    35  		t.Fatal(err)
    36  	}
    37  }
    38  
    39  func pingService() error {
    40  	resp, err := http.Get(fmt.Sprintf("http://localhost:%d", containerPort))
    41  	if err != nil {
    42  		return err
    43  	}
    44  
    45  	defer func(Body io.ReadCloser) {
    46  		_ = Body.Close()
    47  	}(resp.Body)
    48  
    49  	if resp.StatusCode != http.StatusOK {
    50  		return errors.New("ping status code was not 200")
    51  	}
    52  	return nil
    53  }
    54  
    55  func serviceIsUp() bool {
    56  	err := pingService()
    57  	return err == nil
    58  }
    59  
    60  func assertServiceIsUp(t *testing.T) {
    61  	t.Helper()
    62  	err := pingService()
    63  	if err != nil {
    64  		t.Fatal("expected service to be up, got", err)
    65  	}
    66  }
    67  
    68  func serviceIsDown() bool {
    69  	err := pingService()
    70  	return err != nil
    71  }
    72  
    73  func assertServiceIsDown(t *testing.T) {
    74  	t.Helper()
    75  	err := pingService()
    76  	if err == nil {
    77  		t.Fatal("service is up")
    78  	}
    79  }
    80  
    81  func goIntoTestDataDir(t *testing.T) func() {
    82  	t.Helper()
    83  	startDir, err := os.Getwd()
    84  	if err != nil {
    85  		t.Fatal(err)
    86  	}
    87  
    88  	err = os.Chdir(fmt.Sprintf("%s/testdata", startDir))
    89  	if err != nil {
    90  		t.Fatal(err)
    91  	}
    92  
    93  	return func() {
    94  		err = os.Chdir(startDir)
    95  		if err != nil {
    96  			t.Fatal(err)
    97  		}
    98  	}
    99  }
   100  
   101  func doSignal(t *testing.T, s syscall.Signal) {
   102  	t.Helper()
   103  	err := syscall.Kill(syscall.Getpid(), s)
   104  	if err != nil {
   105  		t.Fatal(err)
   106  	}
   107  }
   108  
   109  func validRequest(t *testing.T) http.Request {
   110  	t.Helper()
   111  
   112  	req := MustT[*http.Request](t)(http.NewRequest(
   113  		http.MethodGet,
   114  		fmt.Sprintf("http://localhost:%d", containerPort),
   115  		nil,
   116  	))
   117  	return *req
   118  }
   119  
   120  // assertEventually is a helper function copied from stretchr/testify
   121  func assertEventually(t *testing.T, condition func() bool, waitFor time.Duration, tick time.Duration) {
   122  	t.Helper()
   123  
   124  	ch := make(chan bool, 1)
   125  
   126  	timer := time.NewTimer(waitFor)
   127  	defer timer.Stop()
   128  
   129  	ticker := time.NewTicker(tick)
   130  	defer ticker.Stop()
   131  
   132  	for tick := ticker.C; ; {
   133  		select {
   134  		case <-timer.C:
   135  			t.Fatal("eventual condition not satisfied")
   136  			return
   137  		case <-tick:
   138  			tick = nil
   139  			go func() { ch <- condition() }()
   140  		case v := <-ch:
   141  			if v {
   142  				return
   143  			}
   144  			tick = ticker.C
   145  		}
   146  	}
   147  }
   148  
   149  func assertError(t *testing.T, errs ...error) {
   150  	t.Helper()
   151  	l := len(errs)
   152  	switch l {
   153  	case 0:
   154  		return
   155  	case 1:
   156  		if errs[0] == nil {
   157  			t.Fatal("expected error, got nil")
   158  		}
   159  	default:
   160  		expected := errs[l-1]
   161  		for _, err := range errs[:l-1] {
   162  			if err == nil || !errors.Is(err, expected) {
   163  				t.Fatalf("expected error of %v but got %v instead", expected, err)
   164  			}
   165  		}
   166  	}
   167  }
   168  
   169  func assertNoError(t *testing.T, err error) {
   170  	t.Helper()
   171  	if err != nil {
   172  		t.Fatal("expected no error, got", err)
   173  	}
   174  }