github.com/kyma-incubator/compass/components/director@v0.0.0-20230623144113-d764f56ff805/internal/domain/apptemplate/converter_test.go (about)

     1  package apptemplate_test
     2  
     3  import (
     4  	"database/sql"
     5  	"testing"
     6  
     7  	"github.com/pkg/errors"
     8  
     9  	"github.com/kyma-incubator/compass/components/director/internal/domain/apptemplate/automock"
    10  
    11  	"github.com/kyma-incubator/compass/components/director/pkg/graphql"
    12  
    13  	"github.com/kyma-incubator/compass/components/director/internal/domain/apptemplate"
    14  	"github.com/kyma-incubator/compass/components/director/internal/model"
    15  	"github.com/stretchr/testify/assert"
    16  	"github.com/stretchr/testify/require"
    17  )
    18  
    19  var mockedError = errors.New("test-error")
    20  
    21  func TestConverter_ToGraphQL(t *testing.T) {
    22  	// GIVEN
    23  	appConv := &automock.AppConverter{}
    24  	modelWebhooks := fixModelApplicationWebhooks(testWebhookID, testID)
    25  	GQLWebhooks := fixGQLApplicationWebhooks(testWebhookID, testID)
    26  
    27  	testCases := []struct {
    28  		Name               string
    29  		Input              *model.ApplicationTemplate
    30  		Expected           *graphql.ApplicationTemplate
    31  		ExpectedError      bool
    32  		WebhookConverterFn func() *automock.WebhookConverter
    33  	}{
    34  		{
    35  			Name:          "All properties given",
    36  			Input:         fixModelApplicationTemplate(testID, testName, modelWebhooks),
    37  			Expected:      fixGQLAppTemplate(testID, testName, GQLWebhooks),
    38  			ExpectedError: false,
    39  			WebhookConverterFn: func() *automock.WebhookConverter {
    40  				conv := &automock.WebhookConverter{}
    41  				conv.On("MultipleToGraphQL", modelWebhooks).Return(GQLWebhooks, nil)
    42  				return conv
    43  			},
    44  		},
    45  		{
    46  			Name: "Error when graphqlising Application Create Input",
    47  			Input: &model.ApplicationTemplate{
    48  				ID:                   testID,
    49  				Name:                 testName,
    50  				ApplicationInputJSON: "{abc",
    51  			},
    52  			Expected:      nil,
    53  			ExpectedError: true,
    54  			WebhookConverterFn: func() *automock.WebhookConverter {
    55  				conv := &automock.WebhookConverter{}
    56  				conv.On("MultipleToGraphQL", modelWebhooks).Return(GQLWebhooks, nil)
    57  				return conv
    58  			},
    59  		},
    60  		{
    61  			Name:          "Error when converting Webhooks",
    62  			Input:         fixModelApplicationTemplate(testID, testName, modelWebhooks),
    63  			Expected:      nil,
    64  			ExpectedError: true,
    65  			WebhookConverterFn: func() *automock.WebhookConverter {
    66  				conv := &automock.WebhookConverter{}
    67  				conv.On("MultipleToGraphQL", modelWebhooks).Return(nil, mockedError)
    68  				return conv
    69  			},
    70  		},
    71  		{
    72  			Name:          "Empty",
    73  			Input:         &model.ApplicationTemplate{},
    74  			Expected:      nil,
    75  			ExpectedError: true,
    76  			WebhookConverterFn: func() *automock.WebhookConverter {
    77  				conv := &automock.WebhookConverter{}
    78  				conv.On("MultipleToGraphQL", modelWebhooks).Return(GQLWebhooks, nil)
    79  				return conv
    80  			},
    81  		},
    82  		{
    83  			Name:          "Nil",
    84  			Input:         nil,
    85  			Expected:      nil,
    86  			ExpectedError: false,
    87  			WebhookConverterFn: func() *automock.WebhookConverter {
    88  				conv := &automock.WebhookConverter{}
    89  				conv.On("MultipleToGraphQL", modelWebhooks).Return(GQLWebhooks, nil)
    90  				return conv
    91  			},
    92  		},
    93  	}
    94  
    95  	for _, testCase := range testCases {
    96  		t.Run(testCase.Name, func(t *testing.T) {
    97  			// WHEN
    98  			webhookConverter := testCase.WebhookConverterFn()
    99  			converter := apptemplate.NewConverter(appConv, webhookConverter)
   100  
   101  			res, err := converter.ToGraphQL(testCase.Input)
   102  			if testCase.ExpectedError {
   103  				require.Error(t, err)
   104  			} else {
   105  				require.NoError(t, err)
   106  			}
   107  
   108  			// THEN
   109  			assert.Equal(t, testCase.Expected, res)
   110  		})
   111  	}
   112  }
   113  
   114  func TestConverter_MultipleToGraphQL(t *testing.T) {
   115  	// GIVEN
   116  	modelWebhooks := [][]*model.Webhook{
   117  		fixModelApplicationTemplateWebhooks("webhook-id-1", "id1"),
   118  		fixModelApplicationTemplateWebhooks("webhook-id-2", "id2"),
   119  	}
   120  	GQLWebhooks := [][]*graphql.Webhook{
   121  		fixGQLApplicationTemplateWebhooks("webhook-id-1", "id1"),
   122  		fixGQLApplicationTemplateWebhooks("webhook-id-2", "id2"),
   123  	}
   124  
   125  	testCases := []struct {
   126  		Name               string
   127  		Input              []*model.ApplicationTemplate
   128  		Expected           []*graphql.ApplicationTemplate
   129  		ExpectedError      bool
   130  		WebhookConverterFn func() *automock.WebhookConverter
   131  	}{
   132  		{
   133  			Name: "All properties given",
   134  			Input: []*model.ApplicationTemplate{
   135  				fixModelApplicationTemplate("id1", "name1", modelWebhooks[0]),
   136  				fixModelApplicationTemplate("id2", "name2", modelWebhooks[1]),
   137  				nil,
   138  			},
   139  			Expected: []*graphql.ApplicationTemplate{
   140  				fixGQLAppTemplate("id1", "name1", GQLWebhooks[0]),
   141  				fixGQLAppTemplate("id2", "name2", GQLWebhooks[1]),
   142  			},
   143  			ExpectedError: false,
   144  			WebhookConverterFn: func() *automock.WebhookConverter {
   145  				conv := &automock.WebhookConverter{}
   146  				conv.On("MultipleToGraphQL", modelWebhooks[0]).Return(GQLWebhooks[0], nil)
   147  				conv.On("MultipleToGraphQL", modelWebhooks[1]).Return(GQLWebhooks[1], nil)
   148  				return conv
   149  			},
   150  		},
   151  		{
   152  			Name: "Error when application input is empty",
   153  			Input: []*model.ApplicationTemplate{
   154  				fixModelApplicationTemplate("id1", "name1", modelWebhooks[0]),
   155  				{
   156  					ID:                   testID,
   157  					Name:                 testName,
   158  					ApplicationInputJSON: "",
   159  				},
   160  			},
   161  			Expected:      nil,
   162  			ExpectedError: true,
   163  			WebhookConverterFn: func() *automock.WebhookConverter {
   164  				conv := &automock.WebhookConverter{}
   165  				conv.On("MultipleToGraphQL", modelWebhooks[0]).Return(GQLWebhooks[0], nil)
   166  				return conv
   167  			},
   168  		},
   169  		{
   170  			Name: "Error when converting application template",
   171  			Input: []*model.ApplicationTemplate{
   172  				fixModelApplicationTemplate("id1", "name1", modelWebhooks[0]),
   173  				{
   174  					ID:                   testID,
   175  					Name:                 testName,
   176  					ApplicationInputJSON: "{abc",
   177  				},
   178  			},
   179  			Expected:      nil,
   180  			ExpectedError: true,
   181  			WebhookConverterFn: func() *automock.WebhookConverter {
   182  				conv := &automock.WebhookConverter{}
   183  				conv.On("MultipleToGraphQL", modelWebhooks[0]).Return(GQLWebhooks[0], nil)
   184  				return conv
   185  			},
   186  		},
   187  	}
   188  
   189  	for _, testCase := range testCases {
   190  		t.Run(testCase.Name, func(t *testing.T) {
   191  			// WHEN
   192  			webhookConverter := testCase.WebhookConverterFn()
   193  			converter := apptemplate.NewConverter(nil, webhookConverter)
   194  			res, err := converter.MultipleToGraphQL(testCase.Input)
   195  			if testCase.ExpectedError {
   196  				require.Error(t, err)
   197  			} else {
   198  				require.NoError(t, err)
   199  			}
   200  
   201  			// THEN
   202  			assert.Equal(t, testCase.Expected, res)
   203  		})
   204  	}
   205  }
   206  
   207  func TestConverter_InputFromGraphQL(t *testing.T) {
   208  	// GIVEN
   209  	appTemplateInputGQL := fixGQLAppTemplateInput(testName)
   210  	appTemplateInputModel := fixModelAppTemplateInput(testName, "{\"name\":\"foo\",\"description\":\"Lorem ipsum\"}")
   211  
   212  	testCases := []struct {
   213  		Name               string
   214  		AppConverterFn     func() *automock.AppConverter
   215  		WebhookConverterFn func() *automock.WebhookConverter
   216  		Input              graphql.ApplicationTemplateInput
   217  		Expected           model.ApplicationTemplateInput
   218  		ExpectedError      error
   219  	}{
   220  		{
   221  			Name: "All properties given",
   222  			AppConverterFn: func() *automock.AppConverter {
   223  				appConverter := automock.AppConverter{}
   224  				appConverter.On("CreateJSONInputGQLToJSON", appTemplateInputGQL.ApplicationInput).Return(appTemplateInputModel.ApplicationInputJSON, nil).Once()
   225  				return &appConverter
   226  			},
   227  			WebhookConverterFn: func() *automock.WebhookConverter {
   228  				conv := &automock.WebhookConverter{}
   229  				conv.On("MultipleInputFromGraphQL", []*graphql.WebhookInput(nil)).Return([]*model.WebhookInput(nil), nil)
   230  				return conv
   231  			},
   232  			Input:         *appTemplateInputGQL,
   233  			Expected:      *appTemplateInputModel,
   234  			ExpectedError: nil,
   235  		},
   236  		{
   237  			Name: "Error when converting Webhook",
   238  			AppConverterFn: func() *automock.AppConverter {
   239  				appConverter := automock.AppConverter{}
   240  				appConverter.On("CreateJSONInputGQLToJSON", appTemplateInputGQL.ApplicationInput).Return(appTemplateInputModel.ApplicationInputJSON, nil).Once()
   241  				return &appConverter
   242  			},
   243  			WebhookConverterFn: func() *automock.WebhookConverter {
   244  				conv := &automock.WebhookConverter{}
   245  				conv.On("MultipleInputFromGraphQL", []*graphql.WebhookInput(nil)).Return(nil, mockedError)
   246  				return conv
   247  			},
   248  			Input:         *appTemplateInputGQL,
   249  			ExpectedError: mockedError,
   250  		},
   251  		{
   252  			Name: "Empty",
   253  			AppConverterFn: func() *automock.AppConverter {
   254  				appConverter := automock.AppConverter{}
   255  				return &appConverter
   256  			},
   257  			WebhookConverterFn: func() *automock.WebhookConverter {
   258  				conv := &automock.WebhookConverter{}
   259  				conv.On("MultipleInputFromGraphQL", []*graphql.WebhookInput(nil)).Return([]*model.WebhookInput(nil), nil)
   260  				return conv
   261  			},
   262  			Input: graphql.ApplicationTemplateInput{},
   263  			Expected: model.ApplicationTemplateInput{
   264  				Placeholders: []model.ApplicationTemplatePlaceholder{},
   265  			},
   266  			ExpectedError: nil,
   267  		},
   268  		{
   269  			Name: "Error when converting",
   270  			AppConverterFn: func() *automock.AppConverter {
   271  				appConverter := automock.AppConverter{}
   272  				appConverter.On("CreateJSONInputGQLToJSON", appTemplateInputGQL.ApplicationInput).Return("", testError).Once()
   273  				return &appConverter
   274  			},
   275  			WebhookConverterFn: func() *automock.WebhookConverter {
   276  				conv := &automock.WebhookConverter{}
   277  				conv.On("MultipleInputFromGraphQL", []*graphql.WebhookInput(nil)).Return([]*model.WebhookInput(nil), nil)
   278  				return conv
   279  			},
   280  			Input:         *appTemplateInputGQL,
   281  			ExpectedError: testError,
   282  		},
   283  	}
   284  
   285  	for _, testCase := range testCases {
   286  		t.Run(testCase.Name, func(t *testing.T) {
   287  			appConv := testCase.AppConverterFn()
   288  			webhookConv := testCase.WebhookConverterFn()
   289  			converter := apptemplate.NewConverter(appConv, webhookConv)
   290  			// WHEN
   291  			res, err := converter.InputFromGraphQL(testCase.Input)
   292  
   293  			// THEN
   294  			if testCase.ExpectedError == nil {
   295  				require.NoError(t, err)
   296  				assert.Equal(t, testCase.Expected, res)
   297  			} else {
   298  				require.Error(t, err)
   299  			}
   300  
   301  			appConv.AssertExpectations(t)
   302  		})
   303  	}
   304  }
   305  
   306  func TestConverter_UpdateInputFromGraphQL(t *testing.T) {
   307  	// GIVEN
   308  	appTemplateInputGQL := fixGQLAppTemplateUpdateInput(testName)
   309  	appTemplateInputModel := fixModelAppTemplateUpdateInputWithLabels(testName, "{\"name\":\"foo\",\"description\":\"Lorem ipsum\"}", newTestLabels)
   310  
   311  	testCases := []struct {
   312  		Name               string
   313  		AppConverterFn     func() *automock.AppConverter
   314  		WebhookConverterFn func() *automock.WebhookConverter
   315  		Input              graphql.ApplicationTemplateUpdateInput
   316  		Expected           model.ApplicationTemplateUpdateInput
   317  		ExpectedError      error
   318  	}{
   319  		{
   320  			Name: "All properties given",
   321  			AppConverterFn: func() *automock.AppConverter {
   322  				appConverter := automock.AppConverter{}
   323  				appConverter.On("CreateJSONInputGQLToJSON", appTemplateInputGQL.ApplicationInput).Return(appTemplateInputModel.ApplicationInputJSON, nil).Once()
   324  				return &appConverter
   325  			},
   326  			WebhookConverterFn: func() *automock.WebhookConverter {
   327  				conv := &automock.WebhookConverter{}
   328  				conv.On("MultipleInputFromGraphQL", []*graphql.WebhookInput(nil)).Return([]*model.WebhookInput(nil), nil)
   329  				return conv
   330  			},
   331  			Input:         *appTemplateInputGQL,
   332  			Expected:      *appTemplateInputModel,
   333  			ExpectedError: nil,
   334  		},
   335  		{
   336  			Name: "Error when converting Webhook",
   337  			AppConverterFn: func() *automock.AppConverter {
   338  				appConverter := automock.AppConverter{}
   339  				appConverter.On("CreateJSONInputGQLToJSON", appTemplateInputGQL.ApplicationInput).Return(appTemplateInputModel.ApplicationInputJSON, nil).Once()
   340  				return &appConverter
   341  			},
   342  			WebhookConverterFn: func() *automock.WebhookConverter {
   343  				conv := &automock.WebhookConverter{}
   344  				conv.On("MultipleInputFromGraphQL", []*graphql.WebhookInput(nil)).Return(nil, mockedError)
   345  				return conv
   346  			},
   347  			Input:         *appTemplateInputGQL,
   348  			ExpectedError: mockedError,
   349  		},
   350  		{
   351  			Name: "Empty",
   352  			AppConverterFn: func() *automock.AppConverter {
   353  				appConverter := automock.AppConverter{}
   354  				return &appConverter
   355  			},
   356  			WebhookConverterFn: func() *automock.WebhookConverter {
   357  				conv := &automock.WebhookConverter{}
   358  				conv.On("MultipleInputFromGraphQL", []*graphql.WebhookInput(nil)).Return([]*model.WebhookInput(nil), nil)
   359  				return conv
   360  			},
   361  			Input: graphql.ApplicationTemplateUpdateInput{},
   362  			Expected: model.ApplicationTemplateUpdateInput{
   363  				Placeholders: []model.ApplicationTemplatePlaceholder{},
   364  			},
   365  			ExpectedError: nil,
   366  		},
   367  		{
   368  			Name: "Error when converting app",
   369  			AppConverterFn: func() *automock.AppConverter {
   370  				appConverter := automock.AppConverter{}
   371  				appConverter.On("CreateJSONInputGQLToJSON", appTemplateInputGQL.ApplicationInput).Return("", testError).Once()
   372  				return &appConverter
   373  			},
   374  			WebhookConverterFn: func() *automock.WebhookConverter {
   375  				conv := &automock.WebhookConverter{}
   376  				conv.On("MultipleInputFromGraphQL", []*graphql.WebhookInput(nil)).Return([]*model.WebhookInput(nil), nil)
   377  				return conv
   378  			},
   379  			Input:         *appTemplateInputGQL,
   380  			ExpectedError: testError,
   381  		},
   382  	}
   383  
   384  	for _, testCase := range testCases {
   385  		t.Run(testCase.Name, func(t *testing.T) {
   386  			appConv := testCase.AppConverterFn()
   387  			webhookConv := testCase.WebhookConverterFn()
   388  			converter := apptemplate.NewConverter(appConv, webhookConv)
   389  			// WHEN
   390  			res, err := converter.UpdateInputFromGraphQL(testCase.Input)
   391  
   392  			// THEN
   393  			if testCase.ExpectedError == nil {
   394  				require.NoError(t, err)
   395  				assert.Equal(t, testCase.Expected, res)
   396  			} else {
   397  				require.Error(t, err)
   398  			}
   399  
   400  			appConv.AssertExpectations(t)
   401  		})
   402  	}
   403  }
   404  
   405  func TestConverter_ApplicationFromTemplateInputFromGraphQL(t *testing.T) {
   406  	// GIVEN
   407  	conv := apptemplate.NewConverter(nil, nil)
   408  	appTemplateModel := fixModelApplicationTemplate(testID, testName, fixModelApplicationTemplateWebhooks("webhook-id-1", testID))
   409  
   410  	in := fixGQLApplicationFromTemplateInput(testName)
   411  	expected := fixModelApplicationFromTemplateInput(testName)
   412  
   413  	// WHEN
   414  	result, err := conv.ApplicationFromTemplateInputFromGraphQL(appTemplateModel, in)
   415  
   416  	// THEN
   417  	require.NoError(t, err)
   418  	assert.Equal(t, expected, result)
   419  }
   420  
   421  func TestConverter_ApplicationFromTemplateInputFromGraphQLWithPlaceholderPayload(t *testing.T) {
   422  	// GIVEN
   423  	conv := apptemplate.NewConverter(nil, nil)
   424  	appTemplateModel := fixModelApplicationTemplateWithPlaceholdersPayload(testID, testName, fixModelApplicationTemplateWebhooks("webhook-id-1", testID))
   425  
   426  	in := fixGQLApplicationFromTemplateInputWithPlaceholderPayload(testName)
   427  	expected := fixModelApplicationFromTemplateInputWithPlaceholderPayload(testName)
   428  
   429  	// WHEN
   430  	result, err := conv.ApplicationFromTemplateInputFromGraphQL(appTemplateModel, in)
   431  
   432  	// THEN
   433  	require.NoError(t, err)
   434  	assert.Equal(t, expected, result)
   435  }
   436  
   437  func TestConverter_ToEntity(t *testing.T) {
   438  	// GIVEN
   439  	appTemplateModel := fixModelApplicationTemplate(testID, testName, fixModelApplicationTemplateWebhooks("webhook-id-1", testID))
   440  	appTemplateEntity := fixEntityApplicationTemplate(t, testID, testName)
   441  
   442  	testCases := []struct {
   443  		Name     string
   444  		Input    *model.ApplicationTemplate
   445  		Expected *apptemplate.Entity
   446  	}{
   447  		{
   448  			Name:     "All properties given",
   449  			Input:    appTemplateModel,
   450  			Expected: appTemplateEntity,
   451  		},
   452  		{
   453  			Name:     "Empty",
   454  			Input:    &model.ApplicationTemplate{},
   455  			Expected: &apptemplate.Entity{},
   456  		},
   457  		{
   458  			Name:     "Nil",
   459  			Input:    nil,
   460  			Expected: nil,
   461  		},
   462  	}
   463  
   464  	for _, testCase := range testCases {
   465  		t.Run(testCase.Name, func(t *testing.T) {
   466  			conv := apptemplate.NewConverter(nil, nil)
   467  
   468  			// WHEN
   469  			res, err := conv.ToEntity(testCase.Input)
   470  
   471  			// then
   472  			require.NoError(t, err)
   473  			assert.Equal(t, testCase.Expected, res)
   474  		})
   475  	}
   476  }
   477  
   478  func TestConverter_FromEntity(t *testing.T) {
   479  	// GIVEN
   480  	id := "foo"
   481  	name := "bar"
   482  
   483  	appTemplateEntity := fixEntityApplicationTemplate(t, id, name)
   484  	appTemplateModel := fixModelApplicationTemplate(id, name, nil)
   485  
   486  	testCases := []struct {
   487  		Name               string
   488  		Input              *apptemplate.Entity
   489  		Expected           *model.ApplicationTemplate
   490  		ExpectedErrMessage string
   491  	}{
   492  		{
   493  			Name:               "All properties given",
   494  			Input:              appTemplateEntity,
   495  			Expected:           appTemplateModel,
   496  			ExpectedErrMessage: "",
   497  		},
   498  		{
   499  			Name:               "Empty",
   500  			Input:              &apptemplate.Entity{},
   501  			Expected:           &model.ApplicationTemplate{},
   502  			ExpectedErrMessage: "",
   503  		},
   504  		{
   505  			Name:               "Nil",
   506  			Input:              nil,
   507  			Expected:           nil,
   508  			ExpectedErrMessage: "",
   509  		},
   510  		{
   511  			Name: "PlaceholdersJSON Unmarshall Error",
   512  			Input: &apptemplate.Entity{
   513  				PlaceholdersJSON: sql.NullString{
   514  					String: "{dasdd",
   515  					Valid:  true,
   516  				},
   517  			},
   518  			ExpectedErrMessage: "while converting placeholders from JSON to model: invalid character 'd' looking for beginning of object key string",
   519  		},
   520  	}
   521  
   522  	for _, testCase := range testCases {
   523  		t.Run(testCase.Name, func(t *testing.T) {
   524  			conv := apptemplate.NewConverter(nil, nil)
   525  
   526  			// WHEN
   527  			res, err := conv.FromEntity(testCase.Input)
   528  
   529  			if testCase.ExpectedErrMessage != "" {
   530  				require.Error(t, err)
   531  				assert.Equal(t, testCase.ExpectedErrMessage, err.Error())
   532  			} else {
   533  				require.Nil(t, err)
   534  			}
   535  
   536  			// then
   537  			assert.Equal(t, testCase.Expected, res)
   538  		})
   539  	}
   540  }