Move lookupEntityAliasId() to the entity package

internal/consts/consts.go

@@ -32,6 +32,7 @@ const (
 	FieldLocal                    = "local"
 	FieldSealWrap                 = "seal_wrap"
 	FieldExternalEntropyAccess    = "external_entropy_access"
+	FieldMountAccessor            = "mount_accessor"
 
 	/*
 		common environment variables

internal/identity/entity/entity.go

@@ -113,3 +113,42 @@ func JoinAliasID(id string) string {
 func JoinEntityID(id string) string {
 	return fmt.Sprintf("%s/%s", RootEntityIDPath, id)
 }
+
+// LookupEntityAlias for the given FindAliasParams.
+func LookupEntityAlias(client *api.Client, params *FindAliasParams) (*Alias, error) {
+	if params.Name == "" {
+		return nil, fmt.Errorf("alias name cannot be empty params=%#v", params)
+	}
+
+	if params.MountAccessor == "" {
+		return nil, fmt.Errorf("alias mount_accessor cannot be empty params=%#v", params)
+	}
+
+	resp, err := client.Logical().Write(LookupPath, map[string]interface{}{
+		"alias_name":           params.Name,
+		"alias_mount_accessor": params.MountAccessor,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if resp == nil {
+		return nil, nil
+	}
+
+	var a Alias
+	if aliases, ok := resp.Data["aliases"]; ok && aliases != nil {
+		for _, alias := range aliases.([]interface{}) {
+			v := alias.(map[string]interface{})
+			if err := mapstructure.Decode(v, &a); err != nil {
+				return nil, err
+			}
+
+			if a.Name == params.Name {
+				return &a, nil
+			}
+		}
+	}
+
+	return nil, nil
+}

internal/identity/entity/entity_test.go

@@ -3,6 +3,7 @@ package entity
 import (
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"net/http"
 	"reflect"
 	"regexp"
@@ -15,7 +16,6 @@ import (
 
 type testFindAliasHandler struct {
 	requests      int
-	retryStatus   int
 	wantErrOnList bool
 	wantErrOnRead bool
 	entities      []*Entity
@@ -279,3 +279,214 @@ func TestFindAliases(t *testing.T) {
 		})
 	}
 }
+
+type testLookupEntityAliasHandler struct {
+	requests      int
+	wantErrOnRead bool
+	entities      []*Entity
+}
+
+func (t *testLookupEntityAliasHandler) handler() http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		t.requests++
+
+		if req.Method != http.MethodPut {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+
+		wantPath := "/v1/" + LookupPath
+		if wantPath != req.URL.Path {
+			w.WriteHeader(http.StatusNotImplemented)
+			return
+
+		}
+
+		if t.wantErrOnRead {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		b, err := ioutil.ReadAll(req.Body)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		type reqParams struct {
+			Name               string `json:"name,omitempty"`
+			ID                 string `json:"id,omitempty"`
+			AliasID            string `json:"alias_id,omitempty"`
+			AliasName          string `json:"alias_name,omitempty"`
+			AliasMountAccessor string `json:"alias_mount_accessor,omitempty"`
+		}
+
+		var reqData reqParams
+		if err := json.Unmarshal(b, &reqData); err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		var data map[string]interface{}
+		for _, e := range t.entities {
+			for _, a := range e.Aliases {
+				if a.Name == reqData.AliasName && a.MountAccessor == reqData.AliasMountAccessor {
+					b, err := json.Marshal(e)
+					if err != nil {
+						w.WriteHeader(http.StatusInternalServerError)
+						return
+					}
+					if err := json.Unmarshal(b, &data); err != nil {
+						w.WriteHeader(http.StatusInternalServerError)
+						return
+					}
+					break
+				}
+			}
+		}
+
+		m, err := json.Marshal(
+			&api.Secret{
+				Data: data,
+			},
+		)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		w.WriteHeader(http.StatusOK)
+		w.Write(m)
+	}
+}
+
+func TestLookupEntityAlias(t *testing.T) {
+	t.Parallel()
+
+	aliasBob := &Alias{
+		Name:          "bob",
+		MountAccessor: "CC417368-0C63-407A-93AD-2D76A72F58E2",
+	}
+
+	aliasAlice := &Alias{
+		Name:          "alice",
+		MountAccessor: "CC417368-0C63-407A-93AD-2D76A72F58E3",
+	}
+
+	defaultEntities := []*Entity{
+		{
+			ID: "C6D3410E-86AF-4A10-9282-4B1E9773932A",
+			Aliases: []*Alias{
+				aliasBob,
+			},
+		},
+		{
+			ID: "C6D3410E-86AF-4A10-9282-4B1E9773932B",
+			Aliases: []*Alias{
+				aliasAlice,
+			},
+		},
+	}
+
+	tests := []struct {
+		name        string
+		params      *FindAliasParams
+		want        *Alias
+		findHandler *testLookupEntityAliasHandler
+		wantErr     bool
+	}{
+		{
+			name: "alice",
+			params: &FindAliasParams{
+				Name:          aliasAlice.Name,
+				MountAccessor: aliasAlice.MountAccessor,
+			},
+			findHandler: &testLookupEntityAliasHandler{
+				entities: defaultEntities,
+			},
+			want:    aliasAlice,
+			wantErr: false,
+		},
+		{
+			name: "bob",
+			params: &FindAliasParams{
+				Name:          aliasBob.Name,
+				MountAccessor: aliasBob.MountAccessor,
+			},
+			findHandler: &testLookupEntityAliasHandler{
+				entities: defaultEntities,
+			},
+			want:    aliasBob,
+			wantErr: false,
+		},
+		{
+			name: "none",
+			params: &FindAliasParams{
+				Name:          "other",
+				MountAccessor: "other_accesor",
+			},
+			findHandler: &testLookupEntityAliasHandler{
+				entities: defaultEntities,
+			},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name: "error-empty-name",
+			params: &FindAliasParams{
+				MountAccessor: aliasBob.MountAccessor,
+			},
+			findHandler: &testLookupEntityAliasHandler{
+				entities: defaultEntities,
+			},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "error-empty-mount-accessor",
+			params: &FindAliasParams{
+				Name: aliasBob.Name,
+			},
+			findHandler: &testLookupEntityAliasHandler{
+				entities: defaultEntities,
+			},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "error-on-read",
+			params: &FindAliasParams{
+				Name: aliasBob.Name,
+			},
+			findHandler: &testLookupEntityAliasHandler{
+				entities:      defaultEntities,
+				wantErrOnRead: true,
+			},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := tt.findHandler
+
+			config, ln := testutil.TestHTTPServer(t, r.handler())
+			defer ln.Close()
+
+			config.Address = fmt.Sprintf("http://%s", ln.Addr())
+			c, err := api.NewClient(config)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			got, err := LookupEntityAlias(c, tt.params)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("LookupEntityAlias() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("LookupEntityAlias() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

vault/data_identity_entity.go

@@ -6,10 +6,11 @@ import (
 	"log"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/vault/api"
+
 	"github.com/hashicorp/terraform-provider-vault/internal/consts"
 	"github.com/hashicorp/terraform-provider-vault/internal/identity/entity"
 	"github.com/hashicorp/terraform-provider-vault/internal/provider"
-	"github.com/hashicorp/vault/api"
 )
 
 var (
@@ -33,7 +34,7 @@ var (
 		"last_update_time",
 		"merged_from_canonical_ids",
 		"metadata",
-		"mount_accessor",
+		consts.FieldMountAccessor,
 		"mount_path",
 		"mount_type",
 		"name",
@@ -67,7 +68,7 @@ var (
 			Type:     schema.TypeMap,
 			Computed: true,
 		},
-		"mount_accessor": {
+		consts.FieldMountAccessor: {
 			Type:     schema.TypeString,
 			Computed: true,
 		},

vault/data_identity_group.go

@@ -34,7 +34,7 @@ var (
 		"last_update_time",
 		"merged_from_canonical_ids",
 		"metadata",
-		"mount_accessor",
+		consts.FieldMountAccessor,
 		"mount_path",
 		"mount_type",
 		"name",