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

     1  package model
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/kyma-incubator/compass/components/director/pkg/str"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  func TestBundleInstanceAuthRequestInput_ToBundleInstanceAuth(t *testing.T) {
    15  	// GIVEN
    16  	timestamp := time.Now()
    17  	testID := "foo"
    18  	testBundleID := "bar"
    19  	testTenant := "baz"
    20  	runtimeID := "d05fb90c-3084-4349-9deb-af23a4ce76be"
    21  
    22  	input := BundleInstanceAuthRequestInput{
    23  		ID:          str.Ptr(`"foo"'`),
    24  		Context:     str.Ptr(`"test"`),
    25  		InputParams: str.Ptr(`"test"`),
    26  	}
    27  	inputStatus := BundleInstanceAuthStatus{
    28  		Condition: BundleInstanceAuthStatusConditionPending,
    29  		Timestamp: timestamp,
    30  		Message:   "Credentials were not yet provided.",
    31  		Reason:    "CredentialsNotProvided",
    32  	}
    33  	inputAuth := Auth{
    34  		Credential: CredentialData{
    35  			Basic: &BasicCredentialData{
    36  				Username: "foo",
    37  				Password: "bar",
    38  			},
    39  		},
    40  	}
    41  
    42  	expected := BundleInstanceAuth{
    43  		ID:               testID,
    44  		BundleID:         testBundleID,
    45  		RuntimeContextID: nil,
    46  		Owner:            testTenant,
    47  		Context:          str.Ptr(`"test"`),
    48  		InputParams:      str.Ptr(`"test"`),
    49  		Auth:             &inputAuth,
    50  		Status:           &inputStatus,
    51  	}
    52  
    53  	t.Run("Success when have runtimeID", func(t *testing.T) {
    54  		// GIVEN
    55  		expected.RuntimeID = &runtimeID
    56  
    57  		// WHEN
    58  		result := input.ToBundleInstanceAuth(testID, testBundleID, testTenant, &inputAuth, &inputStatus, &runtimeID, nil)
    59  
    60  		// THEN
    61  		require.Equal(t, expected, result)
    62  	})
    63  
    64  	t.Run("Success when missing runtimeID", func(t *testing.T) {
    65  		// GIVEN
    66  		expected.RuntimeID = nil
    67  
    68  		// WHEN
    69  		result := input.ToBundleInstanceAuth(testID, testBundleID, testTenant, &inputAuth, &inputStatus, nil, nil)
    70  
    71  		// THEN
    72  		require.Equal(t, expected, result)
    73  	})
    74  }
    75  
    76  func TestBundleInstanceAuthStatusInput_ToBundleInstanceAuthStatus(t *testing.T) {
    77  	// GIVEN
    78  	timestamp := time.Now()
    79  
    80  	testCases := []struct {
    81  		Name     string
    82  		Input    *BundleInstanceAuthStatusInput
    83  		Expected *BundleInstanceAuthStatus
    84  	}{
    85  		{
    86  			Name:     "Success when nil",
    87  			Input:    nil,
    88  			Expected: nil,
    89  		},
    90  		{
    91  			Name: "Success",
    92  			Input: &BundleInstanceAuthStatusInput{
    93  				Condition: BundleInstanceAuthSetStatusConditionInputSucceeded,
    94  				Message:   "foo",
    95  				Reason:    "bar",
    96  			},
    97  			Expected: &BundleInstanceAuthStatus{
    98  				Condition: BundleInstanceAuthStatusConditionSucceeded,
    99  				Timestamp: timestamp,
   100  				Message:   "foo",
   101  				Reason:    "bar",
   102  			},
   103  		},
   104  	}
   105  
   106  	for _, testCase := range testCases {
   107  		t.Run(testCase.Name, func(t *testing.T) {
   108  			// WHEN
   109  			result := testCase.Input.ToBundleInstanceAuthStatus(timestamp)
   110  			// THEN
   111  			require.Equal(t, testCase.Expected, result)
   112  		})
   113  	}
   114  }
   115  
   116  func TestBundleInstanceAuth_SetDefaultStatus(t *testing.T) {
   117  	// GIVEN
   118  	timestamp := time.Now()
   119  
   120  	testCases := []struct {
   121  		Name            string
   122  		InputCondition  BundleInstanceAuthStatusCondition
   123  		ExpectedReason  string
   124  		ExpectedMessage string
   125  		ExpectedError   error
   126  	}{
   127  		{
   128  			Name:            "Success when succeeded",
   129  			InputCondition:  BundleInstanceAuthStatusConditionSucceeded,
   130  			ExpectedReason:  "CredentialsProvided",
   131  			ExpectedMessage: "Credentials were provided.",
   132  			ExpectedError:   nil,
   133  		},
   134  		{
   135  			Name:            "Success when pending",
   136  			InputCondition:  BundleInstanceAuthStatusConditionPending,
   137  			ExpectedReason:  "CredentialsNotProvided",
   138  			ExpectedMessage: "Credentials were not yet provided.",
   139  			ExpectedError:   nil,
   140  		},
   141  		{
   142  			Name:            "Success when unused",
   143  			InputCondition:  BundleInstanceAuthStatusConditionUnused,
   144  			ExpectedReason:  "PendingDeletion",
   145  			ExpectedMessage: "Credentials for given Bundle Instance Auth are ready for being deleted by Application or Integration System.",
   146  			ExpectedError:   nil,
   147  		},
   148  		{
   149  			Name:           "Error when unknown status condition",
   150  			InputCondition: "INVALID",
   151  			ExpectedError:  errors.New("invalid status condition"),
   152  		},
   153  	}
   154  
   155  	for _, testCase := range testCases {
   156  		t.Run(testCase.Name, func(t *testing.T) {
   157  			instanceAuth := BundleInstanceAuth{}
   158  
   159  			// WHEN
   160  			err := instanceAuth.SetDefaultStatus(testCase.InputCondition, timestamp)
   161  
   162  			// THEN
   163  			if testCase.ExpectedError == nil {
   164  				require.NoError(t, err)
   165  				assert.Equal(t, &BundleInstanceAuthStatus{
   166  					Condition: testCase.InputCondition,
   167  					Timestamp: timestamp,
   168  					Message:   testCase.ExpectedMessage,
   169  					Reason:    testCase.ExpectedReason,
   170  				}, instanceAuth.Status)
   171  			} else {
   172  				require.Error(t, err)
   173  				assert.Contains(t, err.Error(), testCase.ExpectedError.Error())
   174  			}
   175  		})
   176  	}
   177  
   178  	t.Run("Success if nil", func(t *testing.T) {
   179  		var instanceAuth *BundleInstanceAuth
   180  
   181  		// WHEN
   182  		err := instanceAuth.SetDefaultStatus(BundleInstanceAuthStatusConditionSucceeded, timestamp)
   183  
   184  		// THEN
   185  		require.NoError(t, err)
   186  		assert.Nil(t, instanceAuth)
   187  	})
   188  }