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

     1  package bundleinstanceauth_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  
     8  	"github.com/kyma-incubator/compass/components/director/internal/domain/bundleinstanceauth"
     9  	"github.com/kyma-incubator/compass/components/director/internal/domain/bundleinstanceauth/automock"
    10  	"github.com/kyma-incubator/compass/components/director/internal/model"
    11  	"github.com/kyma-incubator/compass/components/director/pkg/graphql"
    12  	"github.com/stretchr/testify/mock"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  var (
    17  	testJSON = graphql.JSON("test")
    18  	testStr  = "test"
    19  
    20  	authInputModel = fixModelAuthInput()
    21  	authInputGQL   = fixGQLAuthInput()
    22  )
    23  
    24  func TestConverter_ToGraphQL(t *testing.T) {
    25  	// GIVEN
    26  	authModel := fixModelAuth()
    27  	authGQL := fixGQLAuth()
    28  
    29  	piaModel := fixModelBundleInstanceAuth(testID, testBundleID, testTenant, authModel, fixModelStatusSucceeded(), &testRuntimeID)
    30  	piaGQL := fixGQLBundleInstanceAuth(testID, authGQL, fixGQLStatusSucceeded(), &testRuntimeID)
    31  
    32  	testCases := []struct {
    33  		Name            string
    34  		AuthConverterFn func() *automock.AuthConverter
    35  		Input           *model.BundleInstanceAuth
    36  		Expected        *graphql.BundleInstanceAuth
    37  	}{
    38  		{
    39  			Name: "Success when nil",
    40  			AuthConverterFn: func() *automock.AuthConverter {
    41  				conv := &automock.AuthConverter{}
    42  				return conv
    43  			},
    44  			Input:    nil,
    45  			Expected: nil,
    46  		},
    47  		{
    48  			Name: "Success",
    49  			AuthConverterFn: func() *automock.AuthConverter {
    50  				conv := &automock.AuthConverter{}
    51  				conv.On("ToGraphQL", piaModel.Auth).Return(piaGQL.Auth, nil).Once()
    52  				return conv
    53  			},
    54  			Input:    piaModel,
    55  			Expected: piaGQL,
    56  		},
    57  		{
    58  			Name: "Success when context and input params empty",
    59  			AuthConverterFn: func() *automock.AuthConverter {
    60  				conv := &automock.AuthConverter{}
    61  				conv.On("ToGraphQL", (*model.Auth)(nil)).Return(nil, nil).Once()
    62  				return conv
    63  			},
    64  			Input:    fixModelBundleInstanceAuthWithoutContextAndInputParams(testID, testBundleID, testTenant, nil, fixModelStatusPending(), nil),
    65  			Expected: fixGQLBundleInstanceAuthWithoutContextAndInputParams(testID, nil, fixGQLStatusPending(), nil),
    66  		},
    67  		{
    68  			Name: "Success when context and input params empty",
    69  			AuthConverterFn: func() *automock.AuthConverter {
    70  				conv := &automock.AuthConverter{}
    71  				conv.On("ToGraphQL", (*model.Auth)(nil)).Return(nil, nil).Once()
    72  				return conv
    73  			},
    74  			Input:    fixModelBundleInstanceAuthWithoutContextAndInputParams(testID, testBundleID, testTenant, nil, nil, nil),
    75  			Expected: fixGQLBundleInstanceAuthWithoutContextAndInputParams(testID, nil, nil, nil),
    76  		},
    77  	}
    78  
    79  	for _, testCase := range testCases {
    80  		t.Run(testCase.Name, func(t *testing.T) {
    81  			authConv := testCase.AuthConverterFn()
    82  
    83  			conv := bundleinstanceauth.NewConverter(authConv)
    84  			// WHEN
    85  			result, err := conv.ToGraphQL(testCase.Input)
    86  
    87  			// THEN
    88  			require.NoError(t, err)
    89  			require.Equal(t, testCase.Expected, result)
    90  
    91  			mock.AssertExpectationsForObjects(t, authConv)
    92  		})
    93  	}
    94  }
    95  
    96  func TestConverter_MultipleToGraphQL(t *testing.T) {
    97  	// GIVEN
    98  	piaModels := []*model.BundleInstanceAuth{
    99  		fixModelBundleInstanceAuth("foo", testBundleID, testTenant, fixModelAuth(), fixModelStatusSucceeded(), nil),
   100  		fixModelBundleInstanceAuth("bar", testBundleID, testTenant, nil, fixModelStatusPending(), &testRuntimeID),
   101  		nil,
   102  	}
   103  
   104  	piaGQLs := []*graphql.BundleInstanceAuth{
   105  		fixGQLBundleInstanceAuth("foo", fixGQLAuth(), fixGQLStatusSucceeded(), nil),
   106  		fixGQLBundleInstanceAuth("bar", nil, fixGQLStatusPending(), &testRuntimeID),
   107  	}
   108  
   109  	testCases := []struct {
   110  		Name            string
   111  		AuthConverterFn func() *automock.AuthConverter
   112  		Input           []*model.BundleInstanceAuth
   113  		Expected        []*graphql.BundleInstanceAuth
   114  	}{
   115  		{
   116  			Name: "Success when nil",
   117  			AuthConverterFn: func() *automock.AuthConverter {
   118  				conv := &automock.AuthConverter{}
   119  				return conv
   120  			},
   121  			Input:    nil,
   122  			Expected: []*graphql.BundleInstanceAuth{},
   123  		},
   124  		{
   125  			Name: "Success",
   126  			AuthConverterFn: func() *automock.AuthConverter {
   127  				conv := &automock.AuthConverter{}
   128  				conv.On("ToGraphQL", piaModels[0].Auth).Return(piaGQLs[0].Auth, nil).Once()
   129  				conv.On("ToGraphQL", piaModels[1].Auth).Return(piaGQLs[1].Auth, nil).Once()
   130  				return conv
   131  			},
   132  			Input:    piaModels,
   133  			Expected: piaGQLs,
   134  		},
   135  	}
   136  
   137  	for _, testCase := range testCases {
   138  		t.Run(testCase.Name, func(t *testing.T) {
   139  			authConv := testCase.AuthConverterFn()
   140  
   141  			conv := bundleinstanceauth.NewConverter(authConv)
   142  			// WHEN
   143  			result, err := conv.MultipleToGraphQL(testCase.Input)
   144  
   145  			// THEN
   146  			require.NoError(t, err)
   147  			require.Equal(t, testCase.Expected, result)
   148  
   149  			mock.AssertExpectationsForObjects(t, authConv)
   150  		})
   151  	}
   152  }
   153  
   154  func TestConverter_RequestInputFromGraphQL(t *testing.T) {
   155  	// GIVEN
   156  	testCases := []struct {
   157  		Name     string
   158  		Input    graphql.BundleInstanceAuthRequestInput
   159  		Expected model.BundleInstanceAuthRequestInput
   160  	}{
   161  		{
   162  			Name: "Success when nil",
   163  			Input: graphql.BundleInstanceAuthRequestInput{
   164  				Context:     nil,
   165  				InputParams: nil,
   166  			},
   167  			Expected: model.BundleInstanceAuthRequestInput{
   168  				Context:     nil,
   169  				InputParams: nil,
   170  			},
   171  		},
   172  		{
   173  			Name: "Success when not nil",
   174  			Input: graphql.BundleInstanceAuthRequestInput{
   175  				Context:     &testJSON,
   176  				InputParams: &testJSON,
   177  			},
   178  			Expected: model.BundleInstanceAuthRequestInput{
   179  				Context:     &testStr,
   180  				InputParams: &testStr,
   181  			},
   182  		},
   183  	}
   184  
   185  	for _, testCase := range testCases {
   186  		t.Run(testCase.Name, func(t *testing.T) {
   187  			conv := bundleinstanceauth.NewConverter(nil)
   188  
   189  			// WHEN
   190  			result := conv.RequestInputFromGraphQL(testCase.Input)
   191  
   192  			// THEN
   193  			require.Equal(t, testCase.Expected, result)
   194  		})
   195  	}
   196  }
   197  
   198  func TestConverter_CreateInputFromGraphQL(t *testing.T) {
   199  	// GIVEN
   200  	testCases := []struct {
   201  		Name             string
   202  		AuthConverterFn  func() *automock.AuthConverter
   203  		Input            graphql.BundleInstanceAuthCreateInput
   204  		ExpectedOutput   model.BundleInstanceAuthCreateInput
   205  		ExpectedErrorMsg string
   206  	}{
   207  		{
   208  			Name: "Success",
   209  			AuthConverterFn: func() *automock.AuthConverter {
   210  				conv := &automock.AuthConverter{}
   211  				conv.On("InputFromGraphQL", authInputGQL).Return(authInputModel, nil).Once()
   212  				return conv
   213  			},
   214  			Input: graphql.BundleInstanceAuthCreateInput{
   215  				Context:     &testJSON,
   216  				InputParams: &testJSON,
   217  				Auth:        authInputGQL,
   218  				RuntimeID:   &testStr,
   219  			},
   220  			ExpectedOutput: model.BundleInstanceAuthCreateInput{
   221  				Context:     &testStr,
   222  				InputParams: &testStr,
   223  				Auth:        authInputModel,
   224  				RuntimeID:   &testStr,
   225  			},
   226  		},
   227  		{
   228  			Name: "Returns error when can't convert auth",
   229  			AuthConverterFn: func() *automock.AuthConverter {
   230  				conv := &automock.AuthConverter{}
   231  				conv.On("InputFromGraphQL", authInputGQL).Return(nil, testError).Once()
   232  				return conv
   233  			},
   234  			Input: graphql.BundleInstanceAuthCreateInput{
   235  				Context:     &testJSON,
   236  				InputParams: &testJSON,
   237  				Auth:        authInputGQL,
   238  				RuntimeID:   &testStr,
   239  			},
   240  			ExpectedErrorMsg: "while converting Auth",
   241  		},
   242  	}
   243  
   244  	for _, testCase := range testCases {
   245  		t.Run(testCase.Name, func(t *testing.T) {
   246  			authConv := testCase.AuthConverterFn()
   247  
   248  			conv := bundleinstanceauth.NewConverter(authConv)
   249  
   250  			// WHEN
   251  			result, err := conv.CreateInputFromGraphQL(testCase.Input)
   252  
   253  			// THEN
   254  			if testCase.ExpectedErrorMsg == "" {
   255  				require.Equal(t, testCase.ExpectedOutput, result)
   256  				require.Nil(t, err)
   257  			} else {
   258  				require.Contains(t, err.Error(), testCase.ExpectedErrorMsg)
   259  			}
   260  
   261  			authConv.AssertExpectations(t)
   262  		})
   263  	}
   264  }
   265  
   266  func TestConverter_UpdateInputFromGraphQL(t *testing.T) {
   267  	// GIVEN
   268  	testCases := []struct {
   269  		Name             string
   270  		AuthConverterFn  func() *automock.AuthConverter
   271  		Input            graphql.BundleInstanceAuthUpdateInput
   272  		ExpectedOutput   model.BundleInstanceAuthUpdateInput
   273  		ExpectedErrorMsg string
   274  	}{
   275  		{
   276  			Name: "Success",
   277  			AuthConverterFn: func() *automock.AuthConverter {
   278  				conv := &automock.AuthConverter{}
   279  				conv.On("InputFromGraphQL", authInputGQL).Return(authInputModel, nil).Once()
   280  				return conv
   281  			},
   282  			Input: graphql.BundleInstanceAuthUpdateInput{
   283  				Context:     &testJSON,
   284  				InputParams: &testJSON,
   285  				Auth:        authInputGQL,
   286  			},
   287  			ExpectedOutput: model.BundleInstanceAuthUpdateInput{
   288  				Context:     &testStr,
   289  				InputParams: &testStr,
   290  				Auth:        authInputModel,
   291  			},
   292  		},
   293  		{
   294  			Name: "Returns error when can't convert auth",
   295  			AuthConverterFn: func() *automock.AuthConverter {
   296  				conv := &automock.AuthConverter{}
   297  				conv.On("InputFromGraphQL", authInputGQL).Return(nil, testError).Once()
   298  				return conv
   299  			},
   300  			Input: graphql.BundleInstanceAuthUpdateInput{
   301  				Context:     &testJSON,
   302  				InputParams: &testJSON,
   303  				Auth:        authInputGQL,
   304  			},
   305  			ExpectedErrorMsg: "while converting Auth",
   306  		},
   307  	}
   308  
   309  	for _, testCase := range testCases {
   310  		t.Run(testCase.Name, func(t *testing.T) {
   311  			authConv := testCase.AuthConverterFn()
   312  
   313  			conv := bundleinstanceauth.NewConverter(authConv)
   314  
   315  			// WHEN
   316  			result, err := conv.UpdateInputFromGraphQL(testCase.Input)
   317  
   318  			// THEN
   319  			if testCase.ExpectedErrorMsg == "" {
   320  				require.Equal(t, testCase.ExpectedOutput, result)
   321  				require.Nil(t, err)
   322  			} else {
   323  				require.Contains(t, err.Error(), testCase.ExpectedErrorMsg)
   324  			}
   325  
   326  			authConv.AssertExpectations(t)
   327  		})
   328  	}
   329  }
   330  
   331  func TestConverter_SetInputFromGraphQL(t *testing.T) {
   332  	// GIVEN
   333  	testCases := []struct {
   334  		Name            string
   335  		AuthConverterFn func() *automock.AuthConverter
   336  		Input           graphql.BundleInstanceAuthSetInput
   337  		Expected        model.BundleInstanceAuthSetInput
   338  	}{
   339  		{
   340  			Name: "Success",
   341  			AuthConverterFn: func() *automock.AuthConverter {
   342  				conv := &automock.AuthConverter{}
   343  				conv.On("InputFromGraphQL", authInputGQL).Return(authInputModel, nil).Once()
   344  				return conv
   345  			},
   346  			Input: graphql.BundleInstanceAuthSetInput{
   347  				Auth:   authInputGQL,
   348  				Status: fixGQLStatusInput(graphql.BundleInstanceAuthSetStatusConditionInputSucceeded, "foo", "bar"),
   349  			},
   350  			Expected: model.BundleInstanceAuthSetInput{
   351  				Auth:   authInputModel,
   352  				Status: fixModelStatusInput(model.BundleInstanceAuthSetStatusConditionInputSucceeded, "foo", "bar"),
   353  			},
   354  		},
   355  		{
   356  			Name: "Success when no status",
   357  			AuthConverterFn: func() *automock.AuthConverter {
   358  				conv := &automock.AuthConverter{}
   359  				conv.On("InputFromGraphQL", authInputGQL).Return(authInputModel, nil).Once()
   360  				return conv
   361  			},
   362  			Input: graphql.BundleInstanceAuthSetInput{
   363  				Auth:   authInputGQL,
   364  				Status: nil,
   365  			},
   366  			Expected: model.BundleInstanceAuthSetInput{
   367  				Auth:   authInputModel,
   368  				Status: nil,
   369  			},
   370  		},
   371  		{
   372  			Name: "Success when no auth",
   373  			AuthConverterFn: func() *automock.AuthConverter {
   374  				conv := &automock.AuthConverter{}
   375  				conv.On("InputFromGraphQL", (*graphql.AuthInput)(nil)).Return(nil, nil).Once()
   376  				return conv
   377  			},
   378  			Input: graphql.BundleInstanceAuthSetInput{
   379  				Auth:   nil,
   380  				Status: fixGQLStatusInput(graphql.BundleInstanceAuthSetStatusConditionInputFailed, "foo", "bar"),
   381  			},
   382  			Expected: model.BundleInstanceAuthSetInput{
   383  				Auth:   nil,
   384  				Status: fixModelStatusInput(model.BundleInstanceAuthSetStatusConditionInputFailed, "foo", "bar"),
   385  			},
   386  		},
   387  	}
   388  
   389  	for _, testCase := range testCases {
   390  		t.Run(testCase.Name, func(t *testing.T) {
   391  			authConv := testCase.AuthConverterFn()
   392  
   393  			conv := bundleinstanceauth.NewConverter(authConv)
   394  			// WHEN
   395  			result, err := conv.SetInputFromGraphQL(testCase.Input)
   396  
   397  			// THEN
   398  			require.NoError(t, err)
   399  			require.Equal(t, testCase.Expected, result)
   400  
   401  			mock.AssertExpectationsForObjects(t, authConv)
   402  		})
   403  	}
   404  }
   405  
   406  func TestConverter_ToEntity(t *testing.T) {
   407  	t.Run("Success all nullable properties filled", func(t *testing.T) {
   408  		// GIVEN
   409  		piaModel := fixModelBundleInstanceAuth(testID, testBundleID, testTenant, fixModelAuth(), fixModelStatusSucceeded(), &testRuntimeID)
   410  		piaEntity := fixEntityBundleInstanceAuth(t, testID, testBundleID, testTenant, fixModelAuth(), fixModelStatusSucceeded(), &testRuntimeID)
   411  
   412  		conv := bundleinstanceauth.NewConverter(nil)
   413  
   414  		// WHEN
   415  		entity, err := conv.ToEntity(piaModel)
   416  
   417  		// THEN
   418  		require.NoError(t, err)
   419  		assert.Equal(t, piaEntity, entity)
   420  	})
   421  
   422  	t.Run("Success all nullable properties empty", func(t *testing.T) {
   423  		// GIVEN
   424  		piaModel := fixModelBundleInstanceAuthWithoutContextAndInputParams(testID, testBundleID, testTenant, nil, nil, nil)
   425  		piaEntity := fixEntityBundleInstanceAuthWithoutContextAndInputParams(t, testID, testBundleID, testTenant, nil, nil, nil)
   426  
   427  		conv := bundleinstanceauth.NewConverter(nil)
   428  
   429  		// WHEN
   430  		entity, err := conv.ToEntity(piaModel)
   431  
   432  		// THEN
   433  		require.NoError(t, err)
   434  		assert.Equal(t, piaEntity, entity)
   435  	})
   436  }
   437  
   438  func TestConverter_FromEntity(t *testing.T) {
   439  	t.Run("Success all nullable properties filled", func(t *testing.T) {
   440  		// GIVEN
   441  		piaModel := fixModelBundleInstanceAuth(testID, testBundleID, testTenant, fixModelAuth(), fixModelStatusSucceeded(), &testRuntimeID)
   442  		piaEntity := fixEntityBundleInstanceAuth(t, testID, testBundleID, testTenant, fixModelAuth(), fixModelStatusSucceeded(), &testRuntimeID)
   443  
   444  		conv := bundleinstanceauth.NewConverter(nil)
   445  
   446  		// WHEN
   447  		result, err := conv.FromEntity(piaEntity)
   448  
   449  		// THEN
   450  		require.NoError(t, err)
   451  		assert.Equal(t, piaModel, result)
   452  	})
   453  
   454  	t.Run("Success all nullable properties empty", func(t *testing.T) {
   455  		// GIVEN
   456  		piaModel := fixModelBundleInstanceAuthWithoutContextAndInputParams(testID, testBundleID, testTenant, nil, fixModelStatusPending(), nil)
   457  		piaEntity := fixEntityBundleInstanceAuthWithoutContextAndInputParams(t, testID, testBundleID, testTenant, nil, fixModelStatusPending(), nil)
   458  
   459  		conv := bundleinstanceauth.NewConverter(nil)
   460  
   461  		// WHEN
   462  		result, err := conv.FromEntity(piaEntity)
   463  
   464  		// THEN
   465  		require.NoError(t, err)
   466  		assert.Equal(t, piaModel, result)
   467  	})
   468  }