github.com/hashicorp/vault/sdk@v0.11.0/helper/pluginidentityutil/fields_test.go (about)

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: MPL-2.0
     3  
     4  package pluginidentityutil
     5  
     6  import (
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  
    12  	"github.com/hashicorp/vault/sdk/framework"
    13  )
    14  
    15  const (
    16  	fieldIDTokenTTL      = "identity_token_ttl"
    17  	fieldIDTokenAudience = "identity_token_audience"
    18  )
    19  
    20  func identityTokenFieldData(raw map[string]interface{}) *framework.FieldData {
    21  	return &framework.FieldData{
    22  		Raw: raw,
    23  		Schema: map[string]*framework.FieldSchema{
    24  			fieldIDTokenTTL: {
    25  				Type: framework.TypeDurationSecond,
    26  			},
    27  			fieldIDTokenAudience: {
    28  				Type: framework.TypeString,
    29  			},
    30  		},
    31  	}
    32  }
    33  
    34  func TestParsePluginIdentityTokenFields(t *testing.T) {
    35  	testcases := []struct {
    36  		name    string
    37  		d       *framework.FieldData
    38  		wantErr bool
    39  		want    map[string]interface{}
    40  	}{
    41  		{
    42  			name: "all input",
    43  			d: identityTokenFieldData(map[string]interface{}{
    44  				fieldIDTokenTTL:      10,
    45  				fieldIDTokenAudience: "test-aud",
    46  			}),
    47  			want: map[string]interface{}{
    48  				fieldIDTokenTTL:      time.Duration(10) * time.Second,
    49  				fieldIDTokenAudience: "test-aud",
    50  			},
    51  		},
    52  		{
    53  			name: "empty ttl",
    54  			d: identityTokenFieldData(map[string]interface{}{
    55  				fieldIDTokenAudience: "test-aud",
    56  			}),
    57  			want: map[string]interface{}{
    58  				fieldIDTokenTTL:      time.Duration(0),
    59  				fieldIDTokenAudience: "test-aud",
    60  			},
    61  		},
    62  		{
    63  			name: "empty audience",
    64  			d: identityTokenFieldData(map[string]interface{}{
    65  				fieldIDTokenTTL: 10,
    66  			}),
    67  			want: map[string]interface{}{
    68  				fieldIDTokenTTL:      time.Duration(10) * time.Second,
    69  				fieldIDTokenAudience: "",
    70  			},
    71  		},
    72  	}
    73  
    74  	for _, tt := range testcases {
    75  		t.Run(tt.name, func(t *testing.T) {
    76  			p := new(PluginIdentityTokenParams)
    77  			err := p.ParsePluginIdentityTokenFields(tt.d)
    78  			if tt.wantErr {
    79  				assert.Error(t, err)
    80  				return
    81  			}
    82  			got := map[string]interface{}{
    83  				fieldIDTokenTTL:      p.IdentityTokenTTL,
    84  				fieldIDTokenAudience: p.IdentityTokenAudience,
    85  			}
    86  			assert.Equal(t, tt.want, got)
    87  		})
    88  	}
    89  }
    90  
    91  func TestPopulatePluginIdentityTokenData(t *testing.T) {
    92  	testcases := []struct {
    93  		name string
    94  		p    *PluginIdentityTokenParams
    95  		want map[string]interface{}
    96  	}{
    97  		{
    98  			name: "basic",
    99  			p: &PluginIdentityTokenParams{
   100  				IdentityTokenAudience: "test-aud",
   101  				IdentityTokenTTL:      time.Duration(10) * time.Second,
   102  			},
   103  			want: map[string]interface{}{
   104  				fieldIDTokenTTL:      int64(10),
   105  				fieldIDTokenAudience: "test-aud",
   106  			},
   107  		},
   108  	}
   109  
   110  	for _, tt := range testcases {
   111  		t.Run(tt.name, func(t *testing.T) {
   112  			got := make(map[string]interface{})
   113  			tt.p.PopulatePluginIdentityTokenData(got)
   114  			assert.Equal(t, tt.want, got)
   115  		})
   116  	}
   117  }
   118  
   119  func TestAddPluginIdentityTokenFields(t *testing.T) {
   120  	testcases := []struct {
   121  		name  string
   122  		input map[string]*framework.FieldSchema
   123  		want  map[string]*framework.FieldSchema
   124  	}{
   125  		{
   126  			name:  "basic",
   127  			input: map[string]*framework.FieldSchema{},
   128  			want: map[string]*framework.FieldSchema{
   129  				fieldIDTokenAudience: {
   130  					Type:        framework.TypeString,
   131  					Description: "Audience of plugin identity tokens",
   132  					Default:     "",
   133  				},
   134  				fieldIDTokenTTL: {
   135  					Type:        framework.TypeDurationSecond,
   136  					Description: "Time-to-live of plugin identity tokens",
   137  					Default:     3600,
   138  				},
   139  			},
   140  		},
   141  		{
   142  			name: "additional-fields",
   143  			input: map[string]*framework.FieldSchema{
   144  				"test": {
   145  					Type:        framework.TypeString,
   146  					Description: "Test description",
   147  					Default:     "default",
   148  				},
   149  			},
   150  			want: map[string]*framework.FieldSchema{
   151  				fieldIDTokenAudience: {
   152  					Type:        framework.TypeString,
   153  					Description: "Audience of plugin identity tokens",
   154  					Default:     "",
   155  				},
   156  				fieldIDTokenTTL: {
   157  					Type:        framework.TypeDurationSecond,
   158  					Description: "Time-to-live of plugin identity tokens",
   159  					Default:     3600,
   160  				},
   161  				"test": {
   162  					Type:        framework.TypeString,
   163  					Description: "Test description",
   164  					Default:     "default",
   165  				},
   166  			},
   167  		},
   168  	}
   169  
   170  	for _, tt := range testcases {
   171  		t.Run(tt.name, func(t *testing.T) {
   172  			got := tt.input
   173  			AddPluginIdentityTokenFields(got)
   174  			assert.Equal(t, tt.want, got)
   175  		})
   176  	}
   177  }