typo in shutdown not shudown

Also added test for CredentialProviderSelector shutdown

Sources/SotoCore/Credential/CredentialProviderSelector.swift

@@ -17,6 +17,20 @@ import NIO
 import NIOConcurrencyHelpers
 import SotoSignerV4
 
+/// Protocol for CredentialProvider that uses an internal CredentialProvider
+///
+/// When conforming to this protocol once you ahve the internal provider it should be supplying to
+/// the startupPromise and you should set `internalProvider` when the setupPromise
+/// result is available.
+/// ```
+/// init(providers: [CredentialProviderFactory], context: CredentialProviderFactory.Context) {
+///    self.startupPromise = context.eventLoop.makePromise(of: CredentialProvider.self)
+///    self.startupPromise.futureResult.whenSuccess { result in
+///        self.internalProvider = result
+///    }
+///    self.setupInternalProvider(providers: providers, context: context)
+///}
+/// ```
 protocol CredentialProviderSelector: CredentialProvider, AnyObject {
     /// promise to find a credential provider
     var startupPromise: EventLoopPromise<CredentialProvider> { get }
@@ -39,7 +53,7 @@ extension CredentialProviderSelector {
         }
     }
 
-    func shudown(on eventLoop: EventLoop) -> EventLoopFuture<Void> {
+    func shutdown(on eventLoop: EventLoop) -> EventLoopFuture<Void> {
         return self.startupPromise.futureResult.flatMap { provider in
             provider.shutdown(on: eventLoop)
         }.hop(to: eventLoop)

Tests/SotoCoreTests/Credential/CredentialProviderTests.swift

@@ -15,6 +15,7 @@
 import AsyncHTTPClient
 import Logging
 import NIO
+import NIOConcurrencyHelpers
 @testable import SotoCore
 import SotoTestUtils
 import XCTest
@@ -100,4 +101,41 @@ class CredentialProviderTests: XCTestCase {
             XCTAssertEqual(error as? CredentialProviderError, .noProvider)
         }
     }
+
+    func testCredentialSelectorShutdown() {
+        class TestCredentialProvider: CredentialProvider {
+            var active = true
+
+            func getCredential(on eventLoop: EventLoop, logger: Logger) -> EventLoopFuture<Credential> {
+                return eventLoop.makeSucceededFuture(StaticCredential(accessKeyId: "", secretAccessKey: ""))
+            }
+
+            func shutdown(on eventLoop: EventLoop) -> EventLoopFuture<Void> {
+                self.active = false
+                return eventLoop.makeSucceededFuture(())
+            }
+
+            deinit {
+                XCTAssertEqual(active, false)
+            }
+        }
+        class CredentialProviderOwner: CredentialProviderSelector {
+            /// promise to find a credential provider
+            let startupPromise: EventLoopPromise<CredentialProvider>
+            let lock = Lock()
+            var _internalProvider: CredentialProvider?
+
+            init(eventLoop: EventLoop) {
+                self.startupPromise = eventLoop.makePromise(of: CredentialProvider.self)
+                self.startupPromise.futureResult.whenSuccess { result in
+                    self.internalProvider = result
+                }
+                self.startupPromise.succeed(TestCredentialProvider())
+            }
+        }
+        let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        defer { XCTAssertNoThrow(try elg.syncShutdownGracefully())}
+        let provider = CredentialProviderOwner(eventLoop: elg.next())
+        XCTAssertNoThrow(try provider.shutdown(on: elg.next()).wait())
+    }
 }