Speed up openbao unit tests by allowing connectionTimeout override #826

merged

opened by

evan.jarrett.net 3 weeks ago targeting master from evan.jarrett.net/core: openbao-tests

Current runtime for the unit tests is about 25-30 seconds depending on hardware. the openbao secrets tests are over 20 seconds by themselves when waiting for 10 second timeouts.

This adds an override for the unit tests.

options

unified split

Changed files

+20 -9

spindle

secrets

openbao.go

openbao_test.go

+15 -7

spindle/secrets/openbao.go

···

       13
       13
        
       )

     

       14
       14
        
       

     

       15
       15
        
       type OpenBaoManager struct {

     

       16
       16
       -
       	client    *vault.Client

     

       17
       17
       -
       	mountPath string

     

       18
       18
       -
       	logger    *slog.Logger

     

       16
       16
       +
       	client            *vault.Client

     

       17
       17
       +
       	mountPath         string

     

       18
       18
       +
       	logger            *slog.Logger

     

       19
       19
       +
       	connectionTimeout time.Duration

     

       19
       20
        
       }

     

       20
       21
        
       

     

       21
       22
        
       type OpenBaoManagerOpt func(*OpenBaoManager)

     
···

       26
       27
        
       	}

     

       27
       28
        
       }

     

       28
       29
        
       

     

       30
       30
       +
       func WithConnectionTimeout(timeout time.Duration) OpenBaoManagerOpt {

     

       31
       31
       +
       	return func(v *OpenBaoManager) {

     

       32
       32
       +
       		v.connectionTimeout = timeout

     

       33
       33
       +
       	}

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       29
       36
        
       // NewOpenBaoManager creates a new OpenBao manager that connects to a Bao Proxy

     

       30
       37
        
       // The proxyAddress should point to the local Bao Proxy (e.g., "http://127.0.0.1:8200")

     

       31
       38
        
       // The proxy handles all authentication automatically via Auto-Auth

     
···

       43
       50
        
       	}

     

       44
       51
        
       

     

       45
       52
        
       	manager := &OpenBaoManager{

     

       46
       46
       -
       		client:    client,

     

       47
       47
       -
       		mountPath: "spindle", // default KV v2 mount path

     

       48
       48
       -
       		logger:    logger,

     

       53
       53
       +
       		client:            client,

     

       54
       54
       +
       		mountPath:         "spindle",        // default KV v2 mount path

     

       55
       55
       +
       		logger:            logger,

     

       56
       56
       +
       		connectionTimeout: 10 * time.Second, // default connection timeout

     

       49
       57
        
       	}

     

       50
       58
        
       

     

       51
       59
        
       	for _, opt := range opts {

     
···

       62
       70
        
       

     

       63
       71
        
       // testConnection verifies that we can connect to the proxy

     

       64
       72
        
       func (v *OpenBaoManager) testConnection() error {

     

       65
       65
       -
       	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)

     

       73
       73
       +
       	ctx, cancel := context.WithTimeout(context.Background(), v.connectionTimeout)

     

       66
       74
        
       	defer cancel()

     

       67
       75
        
       

     

       68
       76
        
       	// try token self-lookup as a quick way to verify proxy works

+5 -2

spindle/secrets/openbao_test.go

···

       152
       152
        
       	for _, tt := range tests {

     

       153
       153
        
       		t.Run(tt.name, func(t *testing.T) {

     

       154
       154
        
       			logger := slog.New(slog.NewTextHandler(os.Stderr, nil))

     

       155
       155
       -
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, tt.opts...)

     

       155
       155
       +
       			// Use shorter timeout for tests to avoid long waits

     

       156
       156
       +
       			opts := append(tt.opts, WithConnectionTimeout(1*time.Second))

     

       157
       157
       +
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, opts...)

     

       156
       158
        
       

     

       157
       159
        
       			if tt.expectError {

     

       158
       160
        
       				assert.Error(t, err)

     
···

       596
       598
        
       

     

       597
       599
        
       			// All these will fail because no real proxy is running

     

       598
       600
        
       			// but we can test that the configuration is properly accepted

     

       599
       599
       -
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger)

     

       601
       601
       +
       			// Use shorter timeout for tests to avoid long waits

     

       602
       602
       +
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, WithConnectionTimeout(1*time.Second))

     

       600
       603
        
       			assert.Error(t, err) // Expected because no real proxy

     

       601
       604
        
       			assert.Nil(t, manager)

     

       602
       605
        
       			assert.Contains(t, err.Error(), "failed to connect to bao proxy")