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