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

     1  package certsubjectmapping_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/kyma-incubator/compass/components/director/internal/domain/certsubjectmapping"
     7  	"github.com/kyma-incubator/compass/components/director/internal/model"
     8  	"github.com/kyma-incubator/compass/components/director/pkg/graphql"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  var converter = certsubjectmapping.NewConverter()
    13  
    14  func TestConverter_ToGraphQL(t *testing.T) {
    15  	testCases := []struct {
    16  		Name           string
    17  		Input          *model.CertSubjectMapping
    18  		Expected       *graphql.CertificateSubjectMapping
    19  		ExpectedErrMsg string
    20  	}{
    21  		{
    22  			Name:     "Success",
    23  			Input:    CertSubjectMappingModel,
    24  			Expected: CertSubjectMappingGQLModel,
    25  		},
    26  		{
    27  			Name:     "Success when input is nil",
    28  			Input:    nil,
    29  			Expected: nil,
    30  		},
    31  	}
    32  
    33  	for _, testCase := range testCases {
    34  		t.Run(testCase.Name, func(t *testing.T) {
    35  			// WHEN
    36  			r := converter.ToGraphQL(testCase.Input)
    37  
    38  			// THEN
    39  			require.Equal(t, r, testCase.Expected)
    40  		})
    41  	}
    42  }
    43  
    44  func TestConverter_FromGraphql(t *testing.T) {
    45  	testCases := []struct {
    46  		Name           string
    47  		Input          graphql.CertificateSubjectMappingInput
    48  		Expected       *model.CertSubjectMapping
    49  		ExpectedErrMsg string
    50  	}{
    51  		{
    52  			Name:     "Success",
    53  			Input:    CertSubjectMappingGQLModelInput,
    54  			Expected: CertSubjectMappingModel,
    55  		},
    56  	}
    57  
    58  	for _, testCase := range testCases {
    59  		t.Run(testCase.Name, func(t *testing.T) {
    60  			// WHEN
    61  			r := converter.FromGraphql(TestID, testCase.Input)
    62  
    63  			// THEN
    64  			require.Equal(t, r, testCase.Expected)
    65  		})
    66  	}
    67  }
    68  
    69  func TestConverter_MultipleToGraphQL(t *testing.T) {
    70  	testCases := []struct {
    71  		Name           string
    72  		Input          []*model.CertSubjectMapping
    73  		Expected       []*graphql.CertificateSubjectMapping
    74  		ExpectedErrMsg string
    75  	}{
    76  		{
    77  			Name:     "Success",
    78  			Input:    []*model.CertSubjectMapping{CertSubjectMappingModel},
    79  			Expected: []*graphql.CertificateSubjectMapping{CertSubjectMappingGQLModel},
    80  		},
    81  		{
    82  			Name:     "Success when input is nil",
    83  			Input:    nil,
    84  			Expected: nil,
    85  		},
    86  		{
    87  			Name:     "Success when in the input slice there is a nil element",
    88  			Input:    []*model.CertSubjectMapping{nil},
    89  			Expected: []*graphql.CertificateSubjectMapping{},
    90  		},
    91  	}
    92  
    93  	for _, testCase := range testCases {
    94  		t.Run(testCase.Name, func(t *testing.T) {
    95  			// WHEN
    96  			r := converter.MultipleToGraphQL(testCase.Input)
    97  
    98  			// THEN
    99  			require.Equal(t, r, testCase.Expected)
   100  		})
   101  	}
   102  }
   103  
   104  func TestConverter_ToEntity(t *testing.T) {
   105  	testCases := []struct {
   106  		Name           string
   107  		Input          *model.CertSubjectMapping
   108  		Expected       *certsubjectmapping.Entity
   109  		ExpectedErrMsg string
   110  	}{
   111  		{
   112  			Name:     "Success",
   113  			Input:    CertSubjectMappingModel,
   114  			Expected: CertSubjectMappingEntity,
   115  		},
   116  		{
   117  			Name:     "Success when input is nil",
   118  			Input:    nil,
   119  			Expected: nil,
   120  		},
   121  	}
   122  
   123  	for _, testCase := range testCases {
   124  		t.Run(testCase.Name, func(t *testing.T) {
   125  			// WHEN
   126  			r, err := converter.ToEntity(testCase.Input)
   127  
   128  			if testCase.ExpectedErrMsg != "" {
   129  				require.Error(t, err)
   130  				require.Contains(t, err.Error(), testCase.ExpectedErrMsg)
   131  			} else {
   132  				require.NoError(t, err)
   133  			}
   134  
   135  			// THEN
   136  			require.Equal(t, r, testCase.Expected)
   137  		})
   138  	}
   139  }
   140  
   141  func TestConverter_FromEntity(t *testing.T) {
   142  	testCases := []struct {
   143  		Name           string
   144  		Input          *certsubjectmapping.Entity
   145  		Expected       *model.CertSubjectMapping
   146  		ExpectedErrMsg string
   147  	}{
   148  		{
   149  			Name:     "Success",
   150  			Input:    CertSubjectMappingEntity,
   151  			Expected: CertSubjectMappingModel,
   152  		},
   153  		{
   154  			Name:     "Success when input is nil",
   155  			Input:    nil,
   156  			Expected: nil,
   157  		},
   158  		{
   159  			Name:           "Error when unmarhalling fails",
   160  			Input:          CertSubjectMappingEntityInvalidTntAccessLevels,
   161  			Expected:       nil,
   162  			ExpectedErrMsg: "while unmarshalling tenant access levels",
   163  		},
   164  	}
   165  
   166  	for _, testCase := range testCases {
   167  		t.Run(testCase.Name, func(t *testing.T) {
   168  			// WHEN
   169  			r, err := converter.FromEntity(testCase.Input)
   170  
   171  			if testCase.ExpectedErrMsg != "" {
   172  				require.Error(t, err)
   173  				require.Contains(t, err.Error(), testCase.ExpectedErrMsg)
   174  			} else {
   175  				require.NoError(t, err)
   176  			}
   177  
   178  			// THEN
   179  			require.Equal(t, r, testCase.Expected)
   180  		})
   181  	}
   182  }