Fixes unsupported AST kind *ast.InterfaceType on the custon AuthProperties type (#143)

Signed-off-by: Spolti <filippespolti@gmail.com>

Author: spolti

hack/deepcopy-gen.sh

@@ -41,7 +41,7 @@ if [ "${GENS}" = "all" ] || grep -qw "deepcopy" <<<"${GENS}"; then
   echo "Generating deepcopy funcs"
   export GO111MODULE=on
   # for debug purposes, increase the log level by updating the -v flag to higher numbers, e.g. -v 4
-  "${GOPATH}/bin/deepcopy-gen" -v 2 \
+  "${GOPATH}/bin/deepcopy-gen" -v 1 \
       --input-dirs ./model -O zz_generated.deepcopy \
       --go-header-file "${SCRIPT_ROOT}/hack/boilerplate.txt" \
       "$@"

model/auth.go

@@ -17,6 +17,7 @@ package model
 import (
 	"encoding/json"
 	"fmt"
+	"strings"
 )
 
 // AuthType ...
@@ -43,18 +44,6 @@ const (
 	GrantTypeTokenExchange GrantType = "tokenExchange"
 )
 
-func getAuthProperties(authType AuthType) (AuthProperties, bool) {
-	switch authType {
-	case AuthTypeBasic:
-		return &BasicAuthProperties{}, true
-	case AuthTypeBearer:
-		return &BearerAuthProperties{}, true
-	case AuthTypeOAuth2:
-		return &OAuth2AuthProperties{}, true
-	}
-	return nil, false
-}
-
 // Auth ...
 type Auth struct {
 	// Name Unique auth definition name
@@ -90,74 +79,73 @@ func (a *Auth) UnmarshalJSON(data []byte) error {
 	if len(a.Scheme) == 0 {
 		a.Scheme = AuthTypeBasic
 	}
-	authProperties, ok := getAuthProperties(a.Scheme)
-	if !ok {
-		return fmt.Errorf("authentication scheme %s not supported", a.Scheme)
-	}
 
-	// we take the type we want to unmarshal based on the scheme
-	if err := unmarshalKey("properties", auth, authProperties); err != nil {
-		return err
-	}
+	switch a.Scheme {
+	case AuthTypeBasic:
+		authProperties := &BasicAuthProperties{}
 
-	a.Properties = authProperties
-	return nil
-}
+		if err := unmarshalKey("properties", auth, authProperties); err != nil {
+			return err
+		}
+		a.Properties.Basic = authProperties
 
-// AuthProperties ...
-type AuthProperties interface {
-	// GetMetadata ...
-	GetMetadata() *Metadata
-	// GetSecret ...
-	GetSecret() string
-	// DeepCopyAuthProperties fixes in.Properties.DeepCopyAuthProperties undefined (type AuthProperties has no
-	// field or method DeepCopyAuthProperties)
-	DeepCopyAuthProperties() AuthProperties
-}
+		return nil
 
-// BaseAuthProperties ...
-type BaseAuthProperties struct {
-	Common `json:",inline"`
-	// Secret Expression referencing a workflow secret that contains all needed auth info
-	Secret string `json:"secret,omitempty"`
-}
+	case AuthTypeBearer:
+		authProperties := &BearerAuthProperties{}
+		if err := unmarshalKey("properties", auth, authProperties); err != nil {
+			return err
+		}
+		a.Properties.Bearer = authProperties
+		return nil
 
-// UnmarshalJSON ...
-func (b *BaseAuthProperties) UnmarshalJSON(data []byte) error {
-	properties := make(map[string]json.RawMessage)
-	if err := json.Unmarshal(data, &properties); err != nil {
-		b.Secret, err = unmarshalString(data)
-		if err != nil {
+	case AuthTypeOAuth2:
+		authProperties := &OAuth2AuthProperties{}
+		if err := unmarshalKey("properties", auth, authProperties); err != nil {
 			return err
 		}
+		a.Properties.OAuth2 = authProperties
 		return nil
-	}
-	if err := unmarshalKey("metadata", properties, &b.Metadata); err != nil {
-		return err
-	}
-	if err := unmarshalKey("secret", properties, &b.Secret); err != nil {
-		return err
-	}
-	return nil
-}
 
-// GetMetadata ...
-func (b *BaseAuthProperties) GetMetadata() *Metadata {
-	return &b.Metadata
+	default:
+		return fmt.Errorf("failed to parse auth properties")
+	}
 }
 
-// GetSecret ...
-func (b *BaseAuthProperties) GetSecret() string {
-	return b.Secret
+func (a *Auth) MarshalJSON() ([]byte, error) {
+	custom, err := json.Marshal(&struct {
+		Name       string         `json:"name" validate:"required"`
+		Scheme     AuthType       `json:"scheme,omitempty" validate:"omitempty,min=1"`
+		Properties AuthProperties `json:"properties" validate:"required"`
+	}{
+		Name:       a.Name,
+		Scheme:     a.Scheme,
+		Properties: a.Properties,
+	})
+	if err != nil {
+		fmt.Println(err)
+	}
+	st := strings.Replace(string(custom), "null,", "", 1)
+	st = strings.Replace(st, "\"Basic\":", "", 1)
+	st = strings.Replace(st, "\"Oauth2\":", "", 1)
+	st = strings.Replace(st, "\"Bearer\":", "", 1)
+	st = strings.Replace(st, "{{", "{", 1)
+	st = strings.TrimSuffix(st, "}")
+	return []byte(st), nil
 }
 
-func (b *BasicAuthProperties) DeepCopyAuthProperties() AuthProperties {
-	return b
+// AuthProperties ...
+type AuthProperties struct {
+	Basic  *BasicAuthProperties  `json:",omitempty"`
+	Bearer *BearerAuthProperties `json:",omitempty"`
+	OAuth2 *OAuth2AuthProperties `json:",omitempty"`
 }
 
 // BasicAuthProperties Basic Auth Info
 type BasicAuthProperties struct {
-	BaseAuthProperties `json:",inline"`
+	Common `json:",inline"`
+	// Secret Expression referencing a workflow secret that contains all needed auth info
+	Secret string `json:"secret,omitempty"`
 	// Username String or a workflow expression. Contains the username
 	Username string `json:"username" validate:"required"`
 	// Password String or a workflow expression. Contains the user password
@@ -168,11 +156,7 @@ type BasicAuthProperties struct {
 func (b *BasicAuthProperties) UnmarshalJSON(data []byte) error {
 	properties := make(map[string]json.RawMessage)
 	if err := json.Unmarshal(data, &properties); err != nil {
-		err = json.Unmarshal(data, &b.BaseAuthProperties)
-		if err != nil {
-			return err
-		}
-		return nil
+		return err
 	}
 	if err := unmarshalKey("username", properties, &b.Username); err != nil {
 		return err
@@ -183,42 +167,44 @@ func (b *BasicAuthProperties) UnmarshalJSON(data []byte) error {
 	if err := unmarshalKey("metadata", properties, &b.Metadata); err != nil {
 		return err
 	}
+	if err := unmarshalKey("secret", properties, &b.Secret); err != nil {
+		return err
+	}
 	return nil
 }
 
 // BearerAuthProperties Bearer auth information
 type BearerAuthProperties struct {
-	BaseAuthProperties `json:",inline"`
+	Common `json:",inline"`
+	// Secret Expression referencing a workflow secret that contains all needed auth info
+	Secret string `json:"secret,omitempty"`
 	// Token String or a workflow expression. Contains the token
 	Token string `json:"token" validate:"required"`
 }
 
-func (b *BearerAuthProperties) DeepCopyAuthProperties() AuthProperties {
-	return b
-}
-
 // UnmarshalJSON ...
 func (b *BearerAuthProperties) UnmarshalJSON(data []byte) error {
 	properties := make(map[string]json.RawMessage)
 	if err := json.Unmarshal(data, &properties); err != nil {
-		err = json.Unmarshal(data, &b.BaseAuthProperties)
-		if err != nil {
-			return err
-		}
-		return nil
+		return err
 	}
 	if err := unmarshalKey("token", properties, &b.Token); err != nil {
 		return err
 	}
 	if err := unmarshalKey("metadata", properties, &b.Metadata); err != nil {
 		return err
 	}
+	if err := unmarshalKey("secret", properties, &b.Secret); err != nil {
+		return err
+	}
 	return nil
 }
 
 // OAuth2AuthProperties OAuth2 information
 type OAuth2AuthProperties struct {
-	BaseAuthProperties `json:",inline"`
+	Common `json:",inline"`
+	// Secret Expression referencing a workflow secret that contains all needed auth info
+	Secret string `json:"secret,omitempty"`
 	// Authority String or a workflow expression. Contains the authority information
 	Authority string `json:"authority,omitempty" validate:"omitempty,min=1"`
 	// GrantType Defines the grant type
@@ -243,21 +229,13 @@ type OAuth2AuthProperties struct {
 	RequestedIssuer string `json:"requestedIssuer,omitempty" validate:"omitempty,min=1"`
 }
 
-func (b *OAuth2AuthProperties) DeepCopyAuthProperties() AuthProperties {
-	return b
-}
-
 // TODO: use reflection to unmarshal the keys and think on a generic approach to handle them
 
 // UnmarshalJSON ...
 func (b *OAuth2AuthProperties) UnmarshalJSON(data []byte) error {
 	properties := make(map[string]json.RawMessage)
 	if err := json.Unmarshal(data, &properties); err != nil {
-		err = json.Unmarshal(data, &b.BaseAuthProperties)
-		if err != nil {
-			return err
-		}
-		return nil
+		return err
 	}
 	if err := unmarshalKey("authority", properties, &b.Authority); err != nil {
 		return err
@@ -295,5 +273,8 @@ func (b *OAuth2AuthProperties) UnmarshalJSON(data []byte) error {
 	if err := unmarshalKey("metadata", properties, &b.Metadata); err != nil {
 		return err
 	}
+	if err := unmarshalKey("secret", properties, &b.Secret); err != nil {
+		return err
+	}
 	return nil
 }

model/auth_test.go

@@ -46,8 +46,8 @@ func TestUnmarshalJSONMultipleAuthProperties(t *testing.T) {
 		err = json.Unmarshal([]byte(a2JSON), &a2)
 		assert.NoError(t, err)
 
-		a1Properties := a1.Properties.(*BearerAuthProperties)
-		a2Properties := a2.Properties.(*BearerAuthProperties)
+		a1Properties := a1.Properties.Bearer
+		a2Properties := a2.Properties.Bearer
 
 		assert.Equal(t, "token1", a1Properties.Token)
 		assert.Equal(t, "token2", a2Properties.Token)
@@ -79,8 +79,8 @@ func TestUnmarshalJSONMultipleAuthProperties(t *testing.T) {
 		err = json.Unmarshal([]byte(a2JSON), &a2)
 		assert.NoError(t, err)
 
-		a1Properties := a1.Properties.(*OAuth2AuthProperties)
-		a2Properties := a2.Properties.(*OAuth2AuthProperties)
+		a1Properties := a1.Properties.OAuth2
+		a2Properties := a2.Properties.OAuth2
 
 		assert.Equal(t, "secret1", a1Properties.ClientSecret)
 		assert.Equal(t, "secret2", a2Properties.ClientSecret)

model/zz_generated.deepcopy.go

@@ -181,7 +181,7 @@ func TestFromFile(t *testing.T) {
 				assert.Equal(t, len(auth), 1)
 				assert.Equal(t, "testAuth", auth[0].Name)
 				assert.Equal(t, model.AuthTypeBearer, auth[0].Scheme)
-				bearerProperties := auth[0].Properties.(*model.BearerAuthProperties).Token
+				bearerProperties := auth[0].Properties.Bearer.Token
 				assert.Equal(t, "test_token", bearerProperties)
 			},
 		}, {
@@ -204,16 +204,16 @@ func TestFromFile(t *testing.T) {
 				assert.Equal(t, len(auth), 2)
 				assert.Equal(t, "testAuth", auth[0].Name)
 				assert.Equal(t, model.AuthTypeBearer, auth[0].Scheme)
-				bearerProperties := auth[0].Properties.(*model.BearerAuthProperties).Token
+				bearerProperties := auth[0].Properties.Bearer.Token
 				assert.Equal(t, "test_token", bearerProperties)
 				assert.Equal(t, "testAuth2", auth[1].Name)
 				assert.Equal(t, model.AuthTypeBasic, auth[1].Scheme)
-				basicProperties := auth[1].Properties.(*model.BasicAuthProperties)
+				basicProperties := auth[1].Properties.Basic
 				assert.Equal(t, "test_user", basicProperties.Username)
 				assert.Equal(t, "test_pwd", basicProperties.Password)
 				// metadata
 				assert.Equal(t, model.Metadata{"metadata1": model.FromString("metadata1"), "metadata2": model.FromString("metadata2")}, w.Metadata)
-				assert.Equal(t, &model.Metadata{"auth1": model.FromString("auth1"), "auth2": model.FromString("auth2")}, auth[0].Properties.GetMetadata())
+				assert.Equal(t, model.Metadata{"auth1": model.FromString("auth1"), "auth2": model.FromString("auth2")}, auth[0].Properties.Bearer.Metadata)
 			},
 		}, {
 			"./testdata/workflows/applicationrequest.rp.json", func(t *testing.T, w *model.Workflow) {