feat(k6):Add remote test scripts

modules/k6/k6.go

@@ -3,8 +3,12 @@ package k6
 import (
 	"context"
 	"fmt"
+	"io"
+	"net/http"
 	"os"
+	"path"
 	"path/filepath"
+	"time"
 
 	"github.com/docker/docker/api/types/mount"
 
@@ -17,17 +21,78 @@ type K6Container struct {
 	testcontainers.Container
 }
 
+type RemoteTestFileDescription struct{
+
+	Uri string
+	DownloadDir string
+	User string
+	Password string
+}
+
+func ( d *RemoteTestFileDescription) getDownloadPath() string{
+	baseName := path.Base(d.Uri)
+	return path.Join(d.DownloadDir,baseName)
+
+}
+
+func downloadFileFromDescription(d RemoteTestFileDescription) error{
+
+	client := http.Client{Timeout: time.Second*60}
+	// Set up HTTPS request with basic authorization.
+	req, err := http.NewRequest(http.MethodGet, d.Uri, nil)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "text/javascript")
+	if d.User != "" && d.Password != ""{
+		req.SetBasicAuth(d.User, d.Password)
+	}	
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+
+
+	out, err := os.Create(d.getDownloadPath())
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	// Write the body to file
+	_, err = io.Copy(out, resp.Body)
+	return err
+
+
+
+}
+
+
 // WithTestScript mounts the given script into the ./test directory in the container
 // and passes it to k6 as the test to run.
 // The path to the script must be an absolute path
 func WithTestScript(scriptPath string) testcontainers.CustomizeRequestOption {
-	return func(req *testcontainers.GenericContainerRequest) {
-		script := filepath.Base(scriptPath)
-		target := "/home/k6x/" + script
+
+		scriptBaseName := filepath.Base(scriptPath)
+		f, err := os.Open(scriptPath)
+		if err != nil {
+			panic("Cannot create reader for test file ")
+		}
+		return WithTestScriptReader(f,scriptBaseName)
+
+}
+
+// Copies files into the Container using the Reader API
+func WithTestScriptReader(reader io.Reader, scriptBaseName string) testcontainers.CustomizeRequestOption {
+	opt := func(req *testcontainers.GenericContainerRequest) {
+		target := "/home/k6x/" + scriptBaseName
 		req.Files = append(
 			req.Files,
 			testcontainers.ContainerFile{
-				HostFilePath:      scriptPath,
+				HostFilePath:      "",
+				Reader: reader,
 				ContainerFilePath: target,
 				FileMode:          0o644,
 			},
@@ -36,6 +101,19 @@ func WithTestScript(scriptPath string) testcontainers.CustomizeRequestOption {
 		// add script to the k6 run command
 		req.Cmd = append(req.Cmd, target)
 	}
+	return opt
+}
+
+func WithRemoteTestScript(d RemoteTestFileDescription) testcontainers.CustomizeRequestOption {
+
+
+
+	err := downloadFileFromDescription(d)
+	if err != nil {
+		panic("Not able to download required test script")
+	}
+
+	return WithTestScript(d.getDownloadPath())
 }
 
 // WithCmdOptions pass the given options to the k6 run command

modules/k6/k6_test.go

@@ -3,11 +3,14 @@ package k6_test
 import (
 	"context"
 	"path/filepath"
+	"strings"
 	"testing"
 
+	"github.com/testcontainers/testcontainers-go"
 	"github.com/testcontainers/testcontainers-go/modules/k6"
 )
 
+
 func TestK6(t *testing.T) {
 	testCases := []struct {
 		title  string
@@ -24,19 +27,35 @@ func TestK6(t *testing.T) {
 			script: "fail.js",
 			expect: 108,
 		},
+		{
+			title:  "Passing remote test",
+			script: "https://raw.githubusercontent.com/testcontainers/testcontainers-go/main/modules/k6/scripts/pass.js",
+			expect: 0,
+		},
+
 	}
 
 	for _, tc := range testCases {
 		tc := tc
 		t.Run(tc.title, func(t *testing.T) {
 			ctx := context.Background()
 
-			absPath, err := filepath.Abs(filepath.Join("scripts", tc.script))
-			if err != nil {
-				t.Fatal(err)
+			var options testcontainers.CustomizeRequestOption
+			if !strings.HasPrefix(tc.script, "http"){
+				absPath, err := filepath.Abs(filepath.Join("scripts", tc.script))
+				if err != nil {
+					t.Fatal(err)
+				}
+				options = k6.WithTestScript(absPath)
+			}else{
+
+				desc := k6.RemoteTestFileDescription{Uri : tc.script,DownloadDir:t.TempDir() }
+				options = k6.WithRemoteTestScript(desc)
 			}
 
-			container, err := k6.RunContainer(ctx, k6.WithCache(), k6.WithTestScript(absPath))
+
+
+			container, err := k6.RunContainer(ctx, k6.WithCache(),options )
 			if err != nil {
 				t.Fatal(err)
 			}