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 }