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

     1  package key
     2  
     3  import (
     4  	"crypto/rsa"
     5  	"encoding/json"
     6  	"fmt"
     7  	"sync"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/mock"
    13  	"github.com/xmidt-org/webpa-common/resource"
    14  )
    15  
    16  func ExampleSingleKeyConfiguration() {
    17  	jsonConfiguration := fmt.Sprintf(`{
    18  		"uri": "%s",
    19  		"purpose": "verify",
    20  		"header": {
    21  			"Accept": ["text/plain"]
    22  		}
    23  	}`, publicKeyURL)
    24  
    25  	var factory ResolverFactory
    26  	if err := json.Unmarshal([]byte(jsonConfiguration), &factory); err != nil {
    27  		fmt.Println(err)
    28  		return
    29  	}
    30  
    31  	resolver, err := factory.NewResolver()
    32  	if err != nil {
    33  		fmt.Println(err)
    34  		return
    35  	}
    36  
    37  	// althrough we pass a keyId, it doesn't matter
    38  	// the keyId would normally come from a JWT or other source, but
    39  	// this configuration maps all key identifiers onto the same resource
    40  	key, err := resolver.ResolveKey(keyId)
    41  	if err != nil {
    42  		fmt.Println(err)
    43  		return
    44  	}
    45  
    46  	publicKey, ok := key.Public().(*rsa.PublicKey)
    47  	if !ok {
    48  		fmt.Println("Expected a public key")
    49  	}
    50  
    51  	fmt.Printf("%#v", publicKey)
    52  
    53  	// Output:
    54  	// &rsa.PublicKey{N:27943075365309976493653163303797959212418241538912650140443307384472696765226993413692820781465849081859025776428168351053450151991381458393395627926945090025279037554792902370352660829719944448435879538779506598037701785142079839040587119599241554109043386957121126327267661933261531301157240649436180239359321477795441956911062536999488590278721548425004681839069551715529565117581358421070795577996947939534909344145027536788621293233751031126681790089555592380957432236272148722403554429033227913702251021698422165616430378445527162280875770582636410571931829939754369601100687471071175959731316949515587341982201, E:65537}
    55  }
    56  
    57  func ExampleURITemplateConfiguration() {
    58  	jsonConfiguration := fmt.Sprintf(`{
    59  		"uri": "%s",
    60  		"purpose": "verify",
    61  		"header": {
    62  			"Accept": ["text/plain"]
    63  		}
    64  	}`, publicKeyURLTemplate)
    65  
    66  	var factory ResolverFactory
    67  	if err := json.Unmarshal([]byte(jsonConfiguration), &factory); err != nil {
    68  		fmt.Println(err)
    69  		return
    70  	}
    71  
    72  	resolver, err := factory.NewResolver()
    73  	if err != nil {
    74  		fmt.Println(err)
    75  		return
    76  	}
    77  
    78  	key, err := resolver.ResolveKey(keyId)
    79  	if err != nil {
    80  		fmt.Println(err)
    81  		return
    82  	}
    83  
    84  	publicKey, ok := key.Public().(*rsa.PublicKey)
    85  	if !ok {
    86  		fmt.Println("Expected a public key")
    87  	}
    88  
    89  	fmt.Printf("%#v", publicKey)
    90  
    91  	// Output:
    92  	// &rsa.PublicKey{N:27943075365309976493653163303797959212418241538912650140443307384472696765226993413692820781465849081859025776428168351053450151991381458393395627926945090025279037554792902370352660829719944448435879538779506598037701785142079839040587119599241554109043386957121126327267661933261531301157240649436180239359321477795441956911062536999488590278721548425004681839069551715529565117581358421070795577996947939534909344145027536788621293233751031126681790089555592380957432236272148722403554429033227913702251021698422165616430378445527162280875770582636410571931829939754369601100687471071175959731316949515587341982201, E:65537}
    93  }
    94  
    95  func TestBadURITemplates(t *testing.T) {
    96  	assert := assert.New(t)
    97  
    98  	badURITemplates := []string{
    99  		"",
   100  		"badscheme://foo/bar.pem",
   101  		"http://badtemplate.com/{bad",
   102  		"file:///etc/{too}/{many}/{parameters}",
   103  		"http://missing.keyId.com/{someOtherName}",
   104  	}
   105  
   106  	for _, badURITemplate := range badURITemplates {
   107  		t.Logf("badURITemplate: %s", badURITemplate)
   108  
   109  		factory := ResolverFactory{
   110  			Factory: resource.Factory{
   111  				URI: badURITemplate,
   112  			},
   113  		}
   114  
   115  		resolver, err := factory.NewResolver()
   116  		assert.Nil(resolver)
   117  		assert.NotNil(err)
   118  	}
   119  }
   120  
   121  func TestResolverFactoryNewUpdater(t *testing.T) {
   122  	assert := assert.New(t)
   123  
   124  	updateKeysCalled := make(chan struct{})
   125  	runner := func(mock.Arguments) {
   126  		defer func() {
   127  			recover() // ignore panics from multiple closes
   128  		}()
   129  
   130  		close(updateKeysCalled)
   131  	}
   132  
   133  	keyCache := &MockCache{}
   134  	keyCache.On("UpdateKeys").Return(0, nil).Run(runner)
   135  
   136  	resolverFactory := ResolverFactory{
   137  		UpdateInterval: time.Duration(100 * time.Millisecond),
   138  	}
   139  
   140  	if updater := resolverFactory.NewUpdater(keyCache); assert.NotNil(updater) {
   141  		waitGroup := &sync.WaitGroup{}
   142  		shutdown := make(chan struct{})
   143  		updater.Run(waitGroup, shutdown)
   144  
   145  		// we only care that the updater called UpdateKeys() at least once
   146  		<-updateKeysCalled
   147  		close(shutdown)
   148  		waitGroup.Wait()
   149  	}
   150  }
   151  
   152  func TestResolverFactoryDefaultParser(t *testing.T) {
   153  	assert := assert.New(t)
   154  
   155  	parser := &MockParser{}
   156  	resolverFactory := ResolverFactory{
   157  		Factory: resource.Factory{
   158  			URI: publicKeyFilePath,
   159  		},
   160  	}
   161  
   162  	assert.Equal(DefaultParser, resolverFactory.parser())
   163  	mock.AssertExpectationsForObjects(t, parser.Mock)
   164  }
   165  
   166  func TestResolverFactoryCustomParser(t *testing.T) {
   167  	assert := assert.New(t)
   168  
   169  	parser := &MockParser{}
   170  	resolverFactory := ResolverFactory{
   171  		Factory: resource.Factory{
   172  			URI: publicKeyFilePath,
   173  		},
   174  		Parser: parser,
   175  	}
   176  
   177  	assert.Equal(parser, resolverFactory.parser())
   178  	mock.AssertExpectationsForObjects(t, parser.Mock)
   179  }