github.com/kubeshop/testkube@v1.17.23/contrib/executor/k6/pkg/runner/runner_integration_test.go (about)

     1  package runner
     2  
     3  import (
     4  	"context"
     5  	"os"
     6  	"path/filepath"
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  
    11  	"github.com/kubeshop/testkube/pkg/api/v1/testkube"
    12  	"github.com/kubeshop/testkube/pkg/envs"
    13  	"github.com/kubeshop/testkube/pkg/utils/test"
    14  )
    15  
    16  func TestRunFiles_Integration(t *testing.T) {
    17  	test.IntegrationTest(t)
    18  	t.Parallel()
    19  
    20  	ctx := context.Background()
    21  
    22  	t.Run("Run k6 with simple script", func(t *testing.T) {
    23  		t.Parallel()
    24  
    25  		tempDir, err := os.MkdirTemp("", "*")
    26  		assert.NoErrorf(t, err, "failed to create temp dir: %v", err)
    27  		defer os.RemoveAll(tempDir)
    28  
    29  		params := envs.Params{DataDir: tempDir}
    30  		runner, err := NewRunner(context.Background(), params)
    31  		assert.NoError(t, err)
    32  
    33  		execution := testkube.NewQueuedExecution()
    34  		execution.Content = testkube.NewStringTestContent("")
    35  		execution.TestType = "k6/script"
    36  		execution.Command = []string{
    37  			"k6",
    38  		}
    39  		execution.Args = []string{
    40  			"<k6Command>",
    41  			"<envVars>",
    42  			"<runPath>",
    43  		}
    44  		writeTestContent(t, tempDir, "../../examples/k6-test-script.js")
    45  
    46  		// when
    47  		result, err := runner.Run(ctx, *execution)
    48  
    49  		// then
    50  		assert.NoError(t, err)
    51  		assert.Equal(t, testkube.ExecutionStatusPassed, result.Status)
    52  		assert.Len(t, result.Steps, 1)
    53  	})
    54  
    55  	t.Run("Run k6 with simple failing script", func(t *testing.T) {
    56  		t.Parallel()
    57  
    58  		tempDir, err := os.MkdirTemp("", "*")
    59  		assert.NoErrorf(t, err, "failed to create temp dir: %v", err)
    60  		defer os.RemoveAll(tempDir)
    61  
    62  		params := envs.Params{DataDir: tempDir}
    63  		runner, err := NewRunner(context.Background(), params)
    64  		assert.NoError(t, err)
    65  
    66  		execution := testkube.NewQueuedExecution()
    67  		execution.Content = testkube.NewStringTestContent("")
    68  		execution.TestType = "k6/script"
    69  		execution.Command = []string{
    70  			"k6",
    71  		}
    72  		execution.Args = []string{
    73  			"<k6Command>",
    74  			"<envVars>",
    75  			"<runPath>",
    76  		}
    77  		writeTestContent(t, tempDir, "../../examples/k6-test-failing-script.js")
    78  
    79  		// when
    80  		result, err := runner.Run(ctx, *execution)
    81  
    82  		// then
    83  		assert.NoError(t, err)
    84  		assert.Equal(t, testkube.ExecutionStatusFailed, result.Status)
    85  		assert.Len(t, result.Steps, 1)
    86  	})
    87  
    88  	t.Run("Run k6 with arguments and simple script", func(t *testing.T) {
    89  		t.Parallel()
    90  
    91  		tempDir, err := os.MkdirTemp("", "*")
    92  		assert.NoErrorf(t, err, "failed to create temp dir: %v", err)
    93  		defer os.RemoveAll(tempDir)
    94  
    95  		params := envs.Params{DataDir: tempDir}
    96  		runner, err := NewRunner(context.Background(), params)
    97  		assert.NoError(t, err)
    98  
    99  		execution := testkube.NewQueuedExecution()
   100  		execution.Content = testkube.NewStringTestContent("")
   101  		execution.TestType = "k6/run"
   102  		execution.Command = []string{
   103  			"k6",
   104  		}
   105  		execution.Args = []string{
   106  			"<k6Command>",
   107  			"<envVars>",
   108  			"<runPath>",
   109  			"--vus",
   110  			"2",
   111  			"--duration",
   112  			"1s",
   113  		}
   114  		writeTestContent(t, tempDir, "../../examples/k6-test-script.js")
   115  
   116  		// when
   117  		result, err := runner.Run(ctx, *execution)
   118  
   119  		// then
   120  		assert.NoError(t, err)
   121  		assert.Equal(t, testkube.ExecutionStatusPassed, result.Status)
   122  		assert.Len(t, result.Steps, 1)
   123  	})
   124  
   125  	t.Run("Run k6 with ENV variables and script", func(t *testing.T) {
   126  		t.Parallel()
   127  
   128  		tempDir, err := os.MkdirTemp("", "*")
   129  		assert.NoErrorf(t, err, "failed to create temp dir: %v", err)
   130  		defer os.RemoveAll(tempDir)
   131  
   132  		params := envs.Params{DataDir: tempDir}
   133  		runner, err := NewRunner(context.Background(), params)
   134  		assert.NoError(t, err)
   135  
   136  		execution := testkube.NewQueuedExecution()
   137  		execution.Content = testkube.NewStringTestContent("")
   138  		execution.TestType = "k6/script"
   139  		execution.Command = []string{
   140  			"k6",
   141  		}
   142  		execution.Args = []string{
   143  			"<k6Command>",
   144  			"<envVars>",
   145  			"<runPath>",
   146  		}
   147  		execution.Envs = map[string]string{"TARGET_HOSTNAME": "kubeshop.github.io"}
   148  		writeTestContent(t, tempDir, "../../examples/k6-test-environment.js")
   149  
   150  		// when
   151  		result, err := runner.Run(ctx, *execution)
   152  
   153  		// then
   154  		assert.NoError(t, err)
   155  		assert.Equal(t, testkube.ExecutionStatusPassed, result.Status)
   156  		assert.Len(t, result.Steps, 1)
   157  	})
   158  }
   159  
   160  func TestRunAdvanced_Integration(t *testing.T) {
   161  	test.IntegrationTest(t)
   162  	t.Parallel()
   163  
   164  	ctx := context.Background()
   165  
   166  	t.Run("Run k6 with scenarios", func(t *testing.T) {
   167  		t.Parallel()
   168  
   169  		tempDir, err := os.MkdirTemp("", "*")
   170  		assert.NoErrorf(t, err, "failed to create temp dir: %v", err)
   171  		defer os.RemoveAll(tempDir)
   172  
   173  		params := envs.Params{DataDir: tempDir}
   174  		runner, err := NewRunner(context.Background(), params)
   175  		assert.NoError(t, err)
   176  
   177  		execution := testkube.NewQueuedExecution()
   178  		execution.Content = testkube.NewStringTestContent("")
   179  		execution.TestType = "k6/run"
   180  		execution.Command = []string{
   181  			"k6",
   182  		}
   183  		execution.Args = []string{
   184  			"<k6Command>",
   185  			"<envVars>",
   186  			"<runPath>",
   187  		}
   188  		writeTestContent(t, tempDir, "../../examples/k6-test-scenarios.js")
   189  
   190  		// when
   191  		result, err := runner.Run(ctx, *execution)
   192  
   193  		// then
   194  		assert.NoError(t, err)
   195  		assert.Equal(t, testkube.ExecutionStatusPassed, result.Status)
   196  		assert.Len(t, result.Steps, 2)
   197  	})
   198  
   199  	t.Run("Run k6 with checks and thresholds", func(t *testing.T) {
   200  		t.Parallel()
   201  
   202  		tempDir, err := os.MkdirTemp("", "*")
   203  		assert.NoErrorf(t, err, "failed to create temp dir: %v", err)
   204  		defer os.RemoveAll(tempDir)
   205  
   206  		params := envs.Params{DataDir: tempDir}
   207  		runner, err := NewRunner(context.Background(), params)
   208  		assert.NoError(t, err)
   209  
   210  		execution := testkube.NewQueuedExecution()
   211  		execution.Content = testkube.NewStringTestContent("")
   212  		execution.TestType = "k6/script"
   213  		execution.Command = []string{
   214  			"k6",
   215  		}
   216  		execution.Args = []string{
   217  			"<k6Command>",
   218  			"<envVars>",
   219  			"<runPath>",
   220  		}
   221  		writeTestContent(t, tempDir, "../../examples/k6-test-thresholds.js")
   222  
   223  		// when
   224  		result, err := runner.Run(ctx, *execution)
   225  
   226  		// then
   227  		assert.NoError(t, err)
   228  		assert.Equal(t, "some thresholds have failed", result.ErrorMessage)
   229  		assert.Equal(t, testkube.ExecutionStatusFailed, result.Status)
   230  		assert.Len(t, result.Steps, 1)
   231  	})
   232  }
   233  
   234  func TestRunDirs_Integtaion(t *testing.T) {
   235  	test.IntegrationTest(t)
   236  	t.Parallel()
   237  
   238  	ctx := context.Background()
   239  	// setup
   240  	tempDir, err := os.MkdirTemp("", "*")
   241  	assert.NoErrorf(t, err, "failed to create temp dir: %v", err)
   242  	defer os.RemoveAll(tempDir)
   243  
   244  	repoDir := filepath.Join(tempDir, "repo")
   245  	assert.NoError(t, os.Mkdir(repoDir, 0755))
   246  
   247  	k6Script, err := os.ReadFile("../../examples/k6-test-script.js")
   248  	if err != nil {
   249  		assert.FailNow(t, "Unable to read k6 test script")
   250  	}
   251  
   252  	err = os.WriteFile(filepath.Join(repoDir, "k6-test-script.js"), k6Script, 0644)
   253  	if err != nil {
   254  		assert.FailNow(t, "Unable to write k6 runner test content file")
   255  	}
   256  
   257  	t.Run("Run k6 from directory with script argument", func(t *testing.T) {
   258  		params := envs.Params{DataDir: tempDir}
   259  		runner, err := NewRunner(context.Background(), params)
   260  		assert.NoError(t, err)
   261  
   262  		execution := testkube.NewQueuedExecution()
   263  		execution.Content = &testkube.TestContent{
   264  			Type_: string(testkube.TestContentTypeGitDir),
   265  			Repository: &testkube.Repository{
   266  				Uri:    "https://github.com/kubeshop/testkube-executor-k6.git",
   267  				Branch: "main",
   268  			},
   269  		}
   270  		execution.TestType = "k6/script"
   271  		execution.Command = []string{
   272  			"k6",
   273  		}
   274  		execution.Args = []string{
   275  			"<k6Command>",
   276  			"<envVars>",
   277  			"<runPath>",
   278  			"--duration",
   279  			"1s",
   280  			"k6-test-script.js",
   281  		}
   282  
   283  		// when
   284  		result, err := runner.Run(ctx, *execution)
   285  
   286  		// then
   287  		assert.NoError(t, err)
   288  		assert.Equal(t, testkube.ExecutionStatusPassed, result.Status)
   289  		assert.Len(t, result.Steps, 1)
   290  	})
   291  }
   292  
   293  func TestRunErrors_Integration(t *testing.T) {
   294  	test.IntegrationTest(t)
   295  	t.Parallel()
   296  
   297  	ctx := context.Background()
   298  
   299  	t.Run("Run k6 with no script", func(t *testing.T) {
   300  		t.Parallel()
   301  
   302  		tempDir, err := os.MkdirTemp("", "*")
   303  		assert.NoErrorf(t, err, "failed to create temp dir: %v", err)
   304  		defer os.RemoveAll(tempDir)
   305  
   306  		params := envs.Params{DataDir: tempDir}
   307  		runner, err := NewRunner(context.Background(), params)
   308  		assert.NoError(t, err)
   309  
   310  		execution := testkube.NewQueuedExecution()
   311  		execution.Content = testkube.NewStringTestContent("")
   312  		execution.TestType = "k6/script"
   313  		execution.Command = []string{
   314  			"k6",
   315  		}
   316  		execution.Args = []string{
   317  			"<k6Command>",
   318  			"<envVars>",
   319  			"<runPath>",
   320  		}
   321  
   322  		// when
   323  		result, err := runner.Run(ctx, *execution)
   324  
   325  		// then
   326  		assert.NoError(t, err)
   327  		assert.Equal(t, testkube.ExecutionStatusFailed, result.Status)
   328  		assert.Contains(t, result.ErrorMessage, "255")
   329  	})
   330  
   331  	t.Run("Run k6 with invalid arguments", func(t *testing.T) {
   332  		t.Parallel()
   333  
   334  		tempDir, err := os.MkdirTemp("", "*")
   335  		assert.NoErrorf(t, err, "failed to create temp dir: %v", err)
   336  		defer os.RemoveAll(tempDir)
   337  
   338  		params := envs.Params{DataDir: tempDir}
   339  		runner, err := NewRunner(context.Background(), params)
   340  		assert.NoError(t, err)
   341  
   342  		execution := testkube.NewQueuedExecution()
   343  		execution.Content = testkube.NewStringTestContent("")
   344  		execution.TestType = "k6/script"
   345  		execution.Command = []string{
   346  			"k6",
   347  		}
   348  		execution.Args = []string{
   349  			"<k6Command>",
   350  			"<envVars>",
   351  			"<runPath>",
   352  			"--vues",
   353  			"2",
   354  			"--duration",
   355  			"5",
   356  		}
   357  
   358  		// when
   359  		result, err := runner.Run(ctx, *execution)
   360  
   361  		// then
   362  		assert.NoError(t, err)
   363  		assert.Equal(t, testkube.ExecutionStatusFailed, result.Status)
   364  		assert.Contains(t, result.ErrorMessage, "255")
   365  	})
   366  
   367  	t.Run("Run k6 from directory with missing script arg", func(t *testing.T) {
   368  		t.Parallel()
   369  
   370  		tempDir, err := os.MkdirTemp("", "*")
   371  		assert.NoErrorf(t, err, "failed to create temp dir: %v", err)
   372  		defer os.RemoveAll(tempDir)
   373  
   374  		params := envs.Params{DataDir: tempDir}
   375  		runner, err := NewRunner(context.Background(), params)
   376  		assert.NoError(t, err)
   377  
   378  		execution := testkube.NewQueuedExecution()
   379  		execution.Content = &testkube.TestContent{
   380  			Type_: string(testkube.TestContentTypeGitDir),
   381  			Repository: &testkube.Repository{
   382  				Uri:    "https://github.com/kubeshop/testkube-executor-k6.git",
   383  				Branch: "main",
   384  				Path:   "examples",
   385  			},
   386  		}
   387  		execution.TestType = "k6/script"
   388  		execution.Command = []string{
   389  			"k6",
   390  		}
   391  		execution.Args = []string{
   392  			"<k6Command>",
   393  			"<envVars>",
   394  			"<runPath>",
   395  		}
   396  
   397  		// when
   398  		result, err := runner.Run(ctx, *execution)
   399  
   400  		// then
   401  		assert.NoError(t, err)
   402  		assert.Equal(t, testkube.ExecutionStatusFailed, result.Status)
   403  		assert.Contains(t, result.ErrorMessage, "not found")
   404  	})
   405  }
   406  
   407  func writeTestContent(t *testing.T, dir string, testScript string) {
   408  	k6Script, err := os.ReadFile(testScript)
   409  	if err != nil {
   410  		assert.FailNow(t, "Unable to read k6 test script")
   411  	}
   412  
   413  	err = os.WriteFile(filepath.Join(dir, "test-content"), k6Script, 0644)
   414  	if err != nil {
   415  		assert.FailNow(t, "Unable to write k6 runner test content file")
   416  	}
   417  }