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

     1  package auth_test
     2  
     3  import (
     4  	"time"
     5  
     6  	"github.com/kyma-incubator/compass/components/director/internal/model"
     7  	"github.com/kyma-incubator/compass/components/director/internal/tokens"
     8  	"github.com/kyma-incubator/compass/components/director/pkg/graphql"
     9  )
    10  
    11  var (
    12  	authUsername     = "user"
    13  	authPassword     = "password"
    14  	authEndpoint     = "url"
    15  	authClientID     = "clientID"
    16  	authClientSecret = "client-secret"
    17  	authCertificate  = "certificate-here"
    18  	authURL          = "http://test.com"
    19  	connectorURL     = "connectorURL"
    20  	modelTokenType   = tokens.ApplicationToken
    21  	gqlTokenType     = graphql.OneTimeTokenTypeApplication
    22  	authMap          = map[string][]string{
    23  		"foo": {"bar", "baz"},
    24  		"too": {"tar", "taz"},
    25  	}
    26  	authMapSerialized            = "{\"foo\":[\"bar\",\"baz\"],\"too\":[\"tar\",\"taz\"]}"
    27  	authHeaders                  = graphql.HTTPHeaders(authMap)
    28  	authHeadersSerialized        = graphql.HTTPHeadersSerialized(authMapSerialized)
    29  	invalidAuthHeadersSerialized = graphql.HTTPHeadersSerialized("invalid")
    30  	authParams                   = graphql.QueryParams(authMap)
    31  	authParamsSerialized         = graphql.QueryParamsSerialized(authMapSerialized)
    32  	invalidAuthParamsSerialized  = graphql.QueryParamsSerialized("invalid")
    33  	accessStrategy               = "testAccessStrategy"
    34  )
    35  
    36  func fixDetailedAuthBasicCredentials() *model.Auth {
    37  	return &model.Auth{
    38  		Credential: model.CredentialData{
    39  			Basic: &model.BasicCredentialData{
    40  				Username: authUsername,
    41  				Password: authPassword,
    42  			},
    43  			Oauth: nil,
    44  		},
    45  		AccessStrategy:        &accessStrategy,
    46  		AdditionalHeaders:     authMap,
    47  		AdditionalQueryParams: authMap,
    48  		RequestAuth: &model.CredentialRequestAuth{
    49  			Csrf: &model.CSRFTokenCredentialRequestAuth{
    50  				TokenEndpointURL: authEndpoint,
    51  				Credential: model.CredentialData{
    52  					Basic: &model.BasicCredentialData{
    53  						Username: authUsername,
    54  						Password: authPassword,
    55  					},
    56  					Oauth: nil,
    57  				},
    58  				AdditionalHeaders:     authMap,
    59  				AdditionalQueryParams: authMap,
    60  			},
    61  		},
    62  	}
    63  }
    64  
    65  func fixDetailedAuthCertificateOAuthCredentials() *model.Auth {
    66  	return &model.Auth{
    67  		Credential: model.CredentialData{
    68  			CertificateOAuth: &model.CertificateOAuthCredentialData{
    69  				ClientID:    authClientID,
    70  				Certificate: authCertificate,
    71  				URL:         authURL,
    72  			},
    73  		},
    74  		AccessStrategy:        &accessStrategy,
    75  		AdditionalHeaders:     authMap,
    76  		AdditionalQueryParams: authMap,
    77  		RequestAuth: &model.CredentialRequestAuth{
    78  			Csrf: &model.CSRFTokenCredentialRequestAuth{
    79  				TokenEndpointURL: authEndpoint,
    80  				Credential: model.CredentialData{
    81  					Basic: &model.BasicCredentialData{
    82  						Username: authUsername,
    83  						Password: authPassword,
    84  					},
    85  					Oauth: nil,
    86  				},
    87  				AdditionalHeaders:     authMap,
    88  				AdditionalQueryParams: authMap,
    89  			},
    90  		},
    91  	}
    92  }
    93  
    94  func fixDetailedOAuthCredentials() *model.Auth {
    95  	return &model.Auth{
    96  		Credential: model.CredentialData{
    97  			Oauth: &model.OAuthCredentialData{
    98  				ClientID:     authClientID,
    99  				ClientSecret: authClientSecret,
   100  				URL:          authURL,
   101  			},
   102  		},
   103  		AccessStrategy:        &accessStrategy,
   104  		AdditionalHeaders:     authMap,
   105  		AdditionalQueryParams: authMap,
   106  		RequestAuth: &model.CredentialRequestAuth{
   107  			Csrf: &model.CSRFTokenCredentialRequestAuth{
   108  				TokenEndpointURL: authEndpoint,
   109  				Credential: model.CredentialData{
   110  					Basic: &model.BasicCredentialData{
   111  						Username: authUsername,
   112  						Password: authPassword,
   113  					},
   114  					Oauth: nil,
   115  				},
   116  				AdditionalHeaders:     authMap,
   117  				AdditionalQueryParams: authMap,
   118  			},
   119  		},
   120  	}
   121  }
   122  
   123  func fixDetailedBasicCredentialsGQLAuth() *graphql.Auth {
   124  	emptyCertCommonName := ""
   125  	return &graphql.Auth{
   126  		Credential: graphql.BasicCredentialData{
   127  			Username: authUsername,
   128  			Password: authPassword,
   129  		},
   130  		AccessStrategy:                  &accessStrategy,
   131  		AdditionalHeaders:               authHeaders,
   132  		AdditionalHeadersSerialized:     &authHeadersSerialized,
   133  		AdditionalQueryParams:           authParams,
   134  		AdditionalQueryParamsSerialized: &authParamsSerialized,
   135  		RequestAuth: &graphql.CredentialRequestAuth{
   136  			Csrf: &graphql.CSRFTokenCredentialRequestAuth{
   137  				TokenEndpointURL: authEndpoint,
   138  				Credential: graphql.BasicCredentialData{
   139  					Username: authUsername,
   140  					Password: authPassword,
   141  				},
   142  				AdditionalHeaders:     authHeaders,
   143  				AdditionalQueryParams: authParams,
   144  			},
   145  		},
   146  		CertCommonName: &emptyCertCommonName,
   147  	}
   148  }
   149  
   150  func fixDetailedCertificateOAuthCredentialsGQLAuth() *graphql.Auth {
   151  	emptyCertCommonName := ""
   152  	return &graphql.Auth{
   153  		Credential: graphql.CertificateOAuthCredentialData{
   154  			ClientID:    authClientID,
   155  			Certificate: authCertificate,
   156  			URL:         authURL,
   157  		},
   158  		AccessStrategy:                  &accessStrategy,
   159  		AdditionalHeaders:               authHeaders,
   160  		AdditionalHeadersSerialized:     &authHeadersSerialized,
   161  		AdditionalQueryParams:           authParams,
   162  		AdditionalQueryParamsSerialized: &authParamsSerialized,
   163  		RequestAuth: &graphql.CredentialRequestAuth{
   164  			Csrf: &graphql.CSRFTokenCredentialRequestAuth{
   165  				TokenEndpointURL: authEndpoint,
   166  				Credential: graphql.BasicCredentialData{
   167  					Username: authUsername,
   168  					Password: authPassword,
   169  				},
   170  				AdditionalHeaders:     authHeaders,
   171  				AdditionalQueryParams: authParams,
   172  			},
   173  		},
   174  		CertCommonName: &emptyCertCommonName,
   175  	}
   176  }
   177  
   178  func fixDetailedOAuthCredentialsGQLAuth() *graphql.Auth {
   179  	emptyCertCommonName := ""
   180  	return &graphql.Auth{
   181  		Credential: graphql.OAuthCredentialData{
   182  			ClientID:     authClientID,
   183  			ClientSecret: authClientSecret,
   184  			URL:          authURL,
   185  		},
   186  		AccessStrategy:                  &accessStrategy,
   187  		AdditionalHeaders:               authHeaders,
   188  		AdditionalHeadersSerialized:     &authHeadersSerialized,
   189  		AdditionalQueryParams:           authParams,
   190  		AdditionalQueryParamsSerialized: &authParamsSerialized,
   191  		RequestAuth: &graphql.CredentialRequestAuth{
   192  			Csrf: &graphql.CSRFTokenCredentialRequestAuth{
   193  				TokenEndpointURL: authEndpoint,
   194  				Credential: graphql.BasicCredentialData{
   195  					Username: authUsername,
   196  					Password: authPassword,
   197  				},
   198  				AdditionalHeaders:     authHeaders,
   199  				AdditionalQueryParams: authParams,
   200  			},
   201  		},
   202  		CertCommonName: &emptyCertCommonName,
   203  	}
   204  }
   205  
   206  func fixDetailedBasicCredentialAuthInput() *model.AuthInput {
   207  	return &model.AuthInput{
   208  		Credential: &model.CredentialDataInput{
   209  			Basic: &model.BasicCredentialDataInput{
   210  				Username: authUsername,
   211  				Password: authPassword,
   212  			},
   213  			Oauth: nil,
   214  		},
   215  		AccessStrategy:        &accessStrategy,
   216  		AdditionalHeaders:     authMap,
   217  		AdditionalQueryParams: authMap,
   218  		RequestAuth: &model.CredentialRequestAuthInput{
   219  			Csrf: &model.CSRFTokenCredentialRequestAuthInput{
   220  				TokenEndpointURL: authEndpoint,
   221  				Credential: &model.CredentialDataInput{
   222  					Basic: &model.BasicCredentialDataInput{
   223  						Username: authUsername,
   224  						Password: authPassword,
   225  					},
   226  					Oauth: nil,
   227  				},
   228  				AdditionalHeaders:     authMap,
   229  				AdditionalQueryParams: authMap,
   230  			},
   231  		},
   232  	}
   233  }
   234  
   235  func fixDetailedCertificateOAuthAuthInput() *model.AuthInput {
   236  	return &model.AuthInput{
   237  		Credential: &model.CredentialDataInput{
   238  			CertificateOAuth: &model.CertificateOAuthCredentialDataInput{
   239  				ClientID:    authClientID,
   240  				Certificate: authCertificate,
   241  				URL:         authURL,
   242  			},
   243  		},
   244  		AccessStrategy:        &accessStrategy,
   245  		AdditionalHeaders:     authMap,
   246  		AdditionalQueryParams: authMap,
   247  		RequestAuth: &model.CredentialRequestAuthInput{
   248  			Csrf: &model.CSRFTokenCredentialRequestAuthInput{
   249  				TokenEndpointURL: authEndpoint,
   250  				Credential: &model.CredentialDataInput{
   251  					Basic: &model.BasicCredentialDataInput{
   252  						Username: authUsername,
   253  						Password: authPassword,
   254  					},
   255  					Oauth: nil,
   256  				},
   257  				AdditionalHeaders:     authMap,
   258  				AdditionalQueryParams: authMap,
   259  			},
   260  		},
   261  	}
   262  }
   263  
   264  func fixDetailedBasicCredentialGQLAuthInput() *graphql.AuthInput {
   265  	return &graphql.AuthInput{
   266  		Credential: &graphql.CredentialDataInput{
   267  			Basic: &graphql.BasicCredentialDataInput{
   268  				Username: authUsername,
   269  				Password: authPassword,
   270  			},
   271  			Oauth: nil,
   272  		},
   273  		AccessStrategy:                  &accessStrategy,
   274  		AdditionalHeadersSerialized:     &authHeadersSerialized,
   275  		AdditionalQueryParamsSerialized: &authParamsSerialized,
   276  		RequestAuth: &graphql.CredentialRequestAuthInput{
   277  			Csrf: &graphql.CSRFTokenCredentialRequestAuthInput{
   278  				TokenEndpointURL: authEndpoint,
   279  				Credential: &graphql.CredentialDataInput{
   280  					Basic: &graphql.BasicCredentialDataInput{
   281  						Username: authUsername,
   282  						Password: authPassword,
   283  					},
   284  					Oauth: nil,
   285  				},
   286  				AdditionalHeadersSerialized:     &authHeadersSerialized,
   287  				AdditionalQueryParamsSerialized: &authParamsSerialized,
   288  			},
   289  		},
   290  	}
   291  }
   292  
   293  func fixDetailedCertificateOAuthGQLAuthInput() *graphql.AuthInput {
   294  	return &graphql.AuthInput{
   295  		Credential: &graphql.CredentialDataInput{
   296  			CertificateOAuth: &graphql.CertificateOAuthCredentialDataInput{
   297  				ClientID:    authClientID,
   298  				Certificate: authCertificate,
   299  				URL:         authURL,
   300  			},
   301  		},
   302  		AccessStrategy:                  &accessStrategy,
   303  		AdditionalHeadersSerialized:     &authHeadersSerialized,
   304  		AdditionalQueryParamsSerialized: &authParamsSerialized,
   305  		RequestAuth: &graphql.CredentialRequestAuthInput{
   306  			Csrf: &graphql.CSRFTokenCredentialRequestAuthInput{
   307  				TokenEndpointURL: authEndpoint,
   308  				Credential: &graphql.CredentialDataInput{
   309  					Basic: &graphql.BasicCredentialDataInput{
   310  						Username: authUsername,
   311  						Password: authPassword,
   312  					},
   313  					Oauth: nil,
   314  				},
   315  				AdditionalHeadersSerialized:     &authHeadersSerialized,
   316  				AdditionalQueryParamsSerialized: &authParamsSerialized,
   317  			},
   318  		},
   319  	}
   320  }
   321  
   322  func fixDetailedGQLAuthInputDeprecated() *graphql.AuthInput {
   323  	return &graphql.AuthInput{
   324  		Credential: &graphql.CredentialDataInput{
   325  			Basic: &graphql.BasicCredentialDataInput{
   326  				Username: authUsername,
   327  				Password: authPassword,
   328  			},
   329  			Oauth: nil,
   330  		},
   331  		AccessStrategy:        &accessStrategy,
   332  		AdditionalHeaders:     authHeaders,
   333  		AdditionalQueryParams: authParams,
   334  		RequestAuth: &graphql.CredentialRequestAuthInput{
   335  			Csrf: &graphql.CSRFTokenCredentialRequestAuthInput{
   336  				TokenEndpointURL: authEndpoint,
   337  				Credential: &graphql.CredentialDataInput{
   338  					Basic: &graphql.BasicCredentialDataInput{
   339  						Username: authUsername,
   340  						Password: authPassword,
   341  					},
   342  					Oauth: nil,
   343  				},
   344  				AdditionalHeaders:     authHeaders,
   345  				AdditionalQueryParams: authParams,
   346  			},
   347  		},
   348  	}
   349  }
   350  
   351  func fixOneTimeTokenInput() *model.OneTimeToken {
   352  	return &model.OneTimeToken{
   353  		Token:        "token",
   354  		ConnectorURL: connectorURL,
   355  		Used:         false,
   356  		Type:         modelTokenType,
   357  		CreatedAt:    time.Time{},
   358  		ExpiresAt:    time.Time{},
   359  		UsedAt:       time.Time{},
   360  	}
   361  }
   362  
   363  func fixOneTimeTokenGQLInput() *graphql.OneTimeTokenInput {
   364  	return &graphql.OneTimeTokenInput{
   365  		Token:        "token",
   366  		ConnectorURL: &connectorURL,
   367  		Used:         false,
   368  		Type:         &gqlTokenType,
   369  		CreatedAt:    graphql.Timestamp{},
   370  		ExpiresAt:    graphql.Timestamp{},
   371  		UsedAt:       graphql.Timestamp{},
   372  	}
   373  }