github.com/kubeshop/testkube@v1.17.23/pkg/cloud/data/result/result_test.go (about)

     1  package result
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/golang/mock/gomock"
    10  	"github.com/stretchr/testify/assert"
    11  
    12  	"github.com/kubeshop/testkube/pkg/api/v1/testkube"
    13  	"github.com/kubeshop/testkube/pkg/cloud/data/executor"
    14  )
    15  
    16  var ctx = context.Background()
    17  
    18  func TestCloudResultRepository_GetNextExecutionNumber(t *testing.T) {
    19  	t.Parallel()
    20  
    21  	ctrl := gomock.NewController(t)
    22  	defer ctrl.Finish()
    23  
    24  	mockExecutor := executor.NewMockExecutor(ctrl)
    25  
    26  	testName := "test-1"
    27  	var testNumber int32 = 3
    28  
    29  	// Setup expectations for the mockedExecutor.Execute method
    30  	expectedReq := NextExecutionNumberRequest{TestName: testName}
    31  	expectedResponse, _ := json.Marshal(&NextExecutionNumberResponse{TestNumber: testNumber})
    32  	mockExecutor.EXPECT().Execute(gomock.Any(), CmdResultGetNextExecutionNumber, expectedReq).Return(expectedResponse, nil)
    33  
    34  	r := &CloudRepository{executor: mockExecutor}
    35  
    36  	result, err := r.GetNextExecutionNumber(ctx, testName)
    37  	assert.NoError(t, err)
    38  	assert.Equal(t, testNumber, result)
    39  }
    40  
    41  func TestCloudResultRepository_Get(t *testing.T) {
    42  	t.Parallel()
    43  
    44  	mockCtrl := gomock.NewController(t)
    45  	defer mockCtrl.Finish()
    46  
    47  	mockExecutor := executor.NewMockExecutor(mockCtrl)
    48  	repo := &CloudRepository{executor: mockExecutor}
    49  
    50  	expectedExecution := testkube.Execution{Id: "id"}
    51  	expectedResponse := GetResponse{Execution: expectedExecution}
    52  	expectedResponseBytes, _ := json.Marshal(expectedResponse)
    53  
    54  	mockExecutor.EXPECT().Execute(ctx, CmdResultGet, GetRequest{ID: "id"}).Return(expectedResponseBytes, nil)
    55  
    56  	actualExecution, err := repo.Get(ctx, "id")
    57  	if err != nil {
    58  		t.Fatalf("unexpected error: %v", err)
    59  	}
    60  
    61  	assert.Equal(t, expectedExecution.Id, actualExecution.Id)
    62  }
    63  
    64  func TestCloudResultRepository_GetByNameAndTest(t *testing.T) {
    65  	t.Parallel()
    66  
    67  	mockCtrl := gomock.NewController(t)
    68  	defer mockCtrl.Finish()
    69  
    70  	mockExecutor := executor.NewMockExecutor(mockCtrl)
    71  	repo := &CloudRepository{executor: mockExecutor}
    72  
    73  	expectedName := "name"
    74  	expectedTestName := "testName"
    75  	expectedExecution := testkube.Execution{Name: expectedName, TestName: expectedTestName}
    76  	expectedResponse := GetByNameAndTestResponse{Execution: expectedExecution}
    77  	expectedResponseBytes, _ := json.Marshal(expectedResponse)
    78  
    79  	mockExecutor.
    80  		EXPECT().
    81  		Execute(ctx, CmdResultGetByNameAndTest, GetByNameAndTestRequest{Name: expectedName, TestName: expectedTestName}).
    82  		Return(expectedResponseBytes, nil)
    83  
    84  	actualExecution, err := repo.GetByNameAndTest(ctx, expectedName, expectedTestName)
    85  	if err != nil {
    86  		t.Fatalf("unexpected error: %v", err)
    87  	}
    88  
    89  	assert.Equal(t, expectedExecution.Name, actualExecution.Name)
    90  	assert.Equal(t, expectedExecution.TestName, actualExecution.TestName)
    91  }
    92  
    93  func TestCloudResultRepository_GetLatestByTest(t *testing.T) {
    94  	t.Parallel()
    95  
    96  	mockCtrl := gomock.NewController(t)
    97  	defer mockCtrl.Finish()
    98  
    99  	mockExecutor := executor.NewMockExecutor(mockCtrl)
   100  	repo := &CloudRepository{executor: mockExecutor}
   101  
   102  	testName := "test_name"
   103  	prevDate := time.Date(2023, 5, 5, 0, 0, 0, 0, time.UTC)
   104  	nextDate := prevDate.Add(time.Hour)
   105  
   106  	startExecution := testkube.Execution{Id: "id1", StartTime: prevDate}
   107  	endExecution := testkube.Execution{Id: "id2", StartTime: prevDate, EndTime: nextDate}
   108  
   109  	startReq := GetLatestByTestRequest{TestName: testName, SortField: "starttime"}
   110  	startResponse := GetLatestByTestResponse{Execution: startExecution}
   111  	startResponseBytes, _ := json.Marshal(startResponse)
   112  	endReq := GetLatestByTestRequest{TestName: testName, SortField: "endtime"}
   113  	endResponse := GetLatestByTestResponse{Execution: endExecution}
   114  	endResponseBytes, _ := json.Marshal(endResponse)
   115  	mockExecutor.EXPECT().Execute(gomock.Any(), CmdResultGetLatestByTest, startReq).Return(startResponseBytes, nil)
   116  	mockExecutor.EXPECT().Execute(gomock.Any(), CmdResultGetLatestByTest, endReq).Return(endResponseBytes, nil)
   117  
   118  	result, err := repo.GetLatestByTest(ctx, testName)
   119  	assert.NoError(t, err)
   120  	assert.Equal(t, &endExecution, result)
   121  }
   122  
   123  func TestCloudResultRepository_Insert(t *testing.T) {
   124  	t.Parallel()
   125  
   126  	mockCtrl := gomock.NewController(t)
   127  	defer mockCtrl.Finish()
   128  
   129  	mockExecutor := executor.NewMockExecutor(mockCtrl)
   130  	repo := &CloudRepository{executor: mockExecutor}
   131  	result := testkube.Execution{Id: "id", Name: "name", TestName: "testName"}
   132  	req := InsertRequest{Result: result}
   133  
   134  	mockExecutor.EXPECT().Execute(ctx, CmdResultInsert, req).Return(nil, nil)
   135  
   136  	err := repo.Insert(ctx, result)
   137  
   138  	assert.NoError(t, err)
   139  }
   140  
   141  func TestCloudResultRepository_Update(t *testing.T) {
   142  	t.Parallel()
   143  
   144  	mockCtrl := gomock.NewController(t)
   145  	defer mockCtrl.Finish()
   146  
   147  	mockExecutor := executor.NewMockExecutor(mockCtrl)
   148  	repo := &CloudRepository{executor: mockExecutor}
   149  	result := testkube.Execution{Id: "id", Name: "name", TestName: "testName"}
   150  	req := UpdateRequest{Result: result}
   151  
   152  	mockExecutor.EXPECT().Execute(ctx, CmdResultUpdate, req).Return(nil, nil)
   153  
   154  	err := repo.Update(ctx, result)
   155  
   156  	assert.NoError(t, err)
   157  }