github.com/kubeshop/testkube@v1.17.23/internal/graphql/resolvers/executors_resolver_test.go (about)

     1  package resolvers
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/golang/mock/gomock"
     8  	"github.com/pkg/errors"
     9  	"github.com/stretchr/testify/assert"
    10  
    11  	"github.com/kubeshop/testkube/pkg/api/v1/testkube"
    12  )
    13  
    14  var (
    15  	sample = testkube.ExecutorDetails{
    16  		Name: "sample",
    17  		Executor: &testkube.Executor{
    18  			ExecutorType:         "job",
    19  			Image:                "",
    20  			ImagePullSecrets:     nil,
    21  			Command:              nil,
    22  			Args:                 nil,
    23  			Types:                []string{"curl/test"},
    24  			Uri:                  "",
    25  			ContentTypes:         nil,
    26  			JobTemplate:          "",
    27  			JobTemplateReference: "",
    28  			Labels:               map[string]string{"label-name": "label-value"},
    29  			Features:             nil,
    30  			Meta:                 nil,
    31  		},
    32  	}
    33  )
    34  
    35  func TestExecutorsResolver_Query_Executors(t *testing.T) {
    36  	t.Run("should default selector to empty string", func(t *testing.T) {
    37  		c := NewTestClient(t)
    38  		defer c.Finish()
    39  
    40  		q := `query { executors { name } }`
    41  		c.ExecutorsService.EXPECT().List("").Return([]testkube.ExecutorDetails{}, nil)
    42  		var resp interface{}
    43  		c.Client.MustPost(q, &resp)
    44  	})
    45  
    46  	t.Run("should pass the selector as an argument", func(t *testing.T) {
    47  		c := NewTestClient(t)
    48  		defer c.Finish()
    49  
    50  		q := `query { executors(selector: "label=value") { name } }`
    51  		c.ExecutorsService.EXPECT().List("label=value").Return([]testkube.ExecutorDetails{}, nil)
    52  		var resp interface{}
    53  		c.Client.MustPost(q, &resp)
    54  	})
    55  
    56  	t.Run("should throw client error", func(t *testing.T) {
    57  		c := NewTestClient(t)
    58  		defer c.Finish()
    59  
    60  		q := `query { executors { name } }`
    61  		c.ExecutorsService.EXPECT().List("").Return(nil, errors.New("some error"))
    62  
    63  		var resp interface{}
    64  		e := c.Client.Post(q, &resp)
    65  		assert.Error(t, e)
    66  	})
    67  
    68  	t.Run("should return back the executors", func(t *testing.T) {
    69  		c := NewTestClient(t)
    70  		defer c.Finish()
    71  
    72  		q := `query { executors { name } }`
    73  		c.ExecutorsService.EXPECT().List("").Return([]testkube.ExecutorDetails{sample}, nil)
    74  		var resp struct{ Executors []struct{ Name string } }
    75  		c.Client.MustPost(q, &resp)
    76  		assert.Len(t, resp.Executors, 1)
    77  		assert.Equal(t, resp.Executors[0].Name, sample.Name)
    78  	})
    79  }
    80  
    81  func TestExecutorsResolver_Subscription_Executors(t *testing.T) {
    82  	t.Run("should default selector to empty string", func(t *testing.T) {
    83  		c := NewTestClient(t)
    84  		defer c.Finish()
    85  
    86  		input := make(chan []testkube.ExecutorDetails, 1)
    87  		input <- []testkube.ExecutorDetails{}
    88  		close(input)
    89  
    90  		q := `subscription { executors { name } }`
    91  		c.ExecutorsService.EXPECT().SubscribeList(gomock.Any(), "").Return(input, nil)
    92  		var resp interface{}
    93  		c.Client.WebsocketOnce(q, &resp)
    94  	})
    95  
    96  	t.Run("should pass the selector as an argument", func(t *testing.T) {
    97  		c := NewTestClient(t)
    98  		defer c.Finish()
    99  
   100  		input := make(chan []testkube.ExecutorDetails, 1)
   101  		input <- []testkube.ExecutorDetails{}
   102  		close(input)
   103  
   104  		q := `subscription { executors(selector: "label=value") { name } }`
   105  		c.ExecutorsService.EXPECT().SubscribeList(gomock.Any(), "label=value").Return(input, nil)
   106  		var resp interface{}
   107  		assert.NoError(t, c.Client.WebsocketOnce(q, &resp))
   108  	})
   109  
   110  	t.Run("should throw client error", func(t *testing.T) {
   111  		c := NewTestClient(t)
   112  		defer c.Finish()
   113  
   114  		q := `subscription { executors { name } }`
   115  		c.ExecutorsService.EXPECT().SubscribeList(gomock.Any(), "").Return(nil, errors.New("some error"))
   116  
   117  		var resp interface{}
   118  		e := c.Client.WebsocketOnce(q, &resp)
   119  		assert.Error(t, e)
   120  	})
   121  
   122  	t.Run("should return back the executors", func(t *testing.T) {
   123  		c := NewTestClient(t)
   124  		defer c.Finish()
   125  
   126  		input := make(chan []testkube.ExecutorDetails, 1)
   127  		input <- []testkube.ExecutorDetails{}
   128  		go func() {
   129  			time.Sleep(10 * time.Millisecond)
   130  			input <- []testkube.ExecutorDetails{sample}
   131  			close(input)
   132  		}()
   133  
   134  		q := `subscription { executors { name } }`
   135  		c.ExecutorsService.EXPECT().SubscribeList(gomock.Any(), "").Return(input, nil)
   136  		var resp struct{ Executors []struct{ Name string } }
   137  		s := c.Client.Websocket(q)
   138  
   139  		assert.NoError(t, s.Next(&resp))
   140  		assert.Len(t, resp.Executors, 0)
   141  
   142  		assert.NoError(t, s.Next(&resp))
   143  		assert.Len(t, resp.Executors, 1)
   144  		assert.Equal(t, resp.Executors[0].Name, sample.Name)
   145  	})
   146  }