github.com/xmidt-org/webpa-common@v1.11.9/secure/key/resolver_test.go (about)

     1  package key
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/stretchr/testify/mock"
     8  	"github.com/xmidt-org/webpa-common/resource"
     9  	"testing"
    10  )
    11  
    12  func TestSingleResolver(t *testing.T) {
    13  	assert := assert.New(t)
    14  
    15  	loader, err := (&resource.Factory{
    16  		URI: publicKeyFilePath,
    17  	}).NewLoader()
    18  
    19  	if !assert.Nil(err) {
    20  		return
    21  	}
    22  
    23  	expectedData, err := resource.ReadAll(loader)
    24  	assert.NotEmpty(expectedData)
    25  	assert.Nil(err)
    26  
    27  	for _, purpose := range []Purpose{PurposeVerify, PurposeDecrypt, PurposeSign, PurposeEncrypt} {
    28  		t.Logf("purpose: %s", purpose)
    29  
    30  		expectedPair := &MockPair{}
    31  		parser := &MockParser{}
    32  		parser.On("ParseKey", purpose, expectedData).Return(expectedPair, nil).Once()
    33  
    34  		var resolver Resolver = &singleResolver{
    35  			basicResolver: basicResolver{
    36  				parser:  parser,
    37  				purpose: purpose,
    38  			},
    39  
    40  			loader: loader,
    41  		}
    42  
    43  		assert.Contains(fmt.Sprintf("%s", resolver), publicKeyFilePath)
    44  
    45  		pair, err := resolver.ResolveKey("does not matter")
    46  		assert.Equal(expectedPair, pair)
    47  		assert.Nil(err)
    48  
    49  		mock.AssertExpectationsForObjects(t, expectedPair.Mock, parser.Mock)
    50  	}
    51  }
    52  
    53  func TestSingleResolverBadResource(t *testing.T) {
    54  	assert := assert.New(t)
    55  
    56  	var resolver Resolver = &singleResolver{
    57  		basicResolver: basicResolver{
    58  			parser:  DefaultParser,
    59  			purpose: PurposeVerify,
    60  		},
    61  		loader: &resource.File{
    62  			Path: "does not exist",
    63  		},
    64  	}
    65  
    66  	key, err := resolver.ResolveKey("does not matter")
    67  	assert.Nil(key)
    68  	assert.NotNil(err)
    69  }
    70  
    71  func TestMultiResolver(t *testing.T) {
    72  	assert := assert.New(t)
    73  
    74  	expander, err := (&resource.Factory{
    75  		URI: publicKeyFilePathTemplate,
    76  	}).NewExpander()
    77  
    78  	if !assert.Nil(err) {
    79  		return
    80  	}
    81  
    82  	loader, err := expander.Expand(
    83  		map[string]interface{}{KeyIdParameterName: keyId},
    84  	)
    85  
    86  	expectedData, err := resource.ReadAll(loader)
    87  	assert.NotEmpty(expectedData)
    88  	assert.Nil(err)
    89  
    90  	for _, purpose := range []Purpose{PurposeVerify, PurposeDecrypt, PurposeSign, PurposeEncrypt} {
    91  		t.Logf("purpose: %s", purpose)
    92  
    93  		expectedPair := &MockPair{}
    94  		parser := &MockParser{}
    95  		parser.On("ParseKey", purpose, expectedData).Return(expectedPair, nil).Once()
    96  
    97  		var resolver Resolver = &multiResolver{
    98  			basicResolver: basicResolver{
    99  				parser:  parser,
   100  				purpose: purpose,
   101  			},
   102  			expander: expander,
   103  		}
   104  
   105  		assert.Contains(fmt.Sprintf("%s", resolver), publicKeyFilePathTemplate)
   106  
   107  		pair, err := resolver.ResolveKey(keyId)
   108  		assert.Equal(expectedPair, pair)
   109  		assert.Nil(err)
   110  
   111  		mock.AssertExpectationsForObjects(t, expectedPair.Mock, parser.Mock)
   112  	}
   113  }
   114  
   115  func TestMultiResolverBadResource(t *testing.T) {
   116  	assert := assert.New(t)
   117  
   118  	var resolver Resolver = &multiResolver{
   119  		expander: &resource.Template{
   120  			URITemplate: resource.MustParse("/this/does/not/exist/{key}"),
   121  		},
   122  	}
   123  
   124  	key, err := resolver.ResolveKey("this isn't valid")
   125  	assert.Nil(key)
   126  	assert.NotNil(err)
   127  }
   128  
   129  type badExpander struct {
   130  	err error
   131  }
   132  
   133  func (bad *badExpander) Names() []string {
   134  	return []string{}
   135  }
   136  
   137  func (bad *badExpander) Expand(interface{}) (resource.Loader, error) {
   138  	return nil, bad.err
   139  }
   140  
   141  func TestMultiResolverBadExpander(t *testing.T) {
   142  	assert := assert.New(t)
   143  
   144  	expectedError := errors.New("The roof! The roof! The roof is on fire!")
   145  	var resolver Resolver = &multiResolver{
   146  		expander: &badExpander{expectedError},
   147  	}
   148  
   149  	key, err := resolver.ResolveKey("does not matter")
   150  	assert.Nil(key)
   151  	assert.Equal(expectedError, err)
   152  }