{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.Transfer.TestIdentityProvider
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- If the @IdentityProviderType@ of a file transfer protocol-enabled server
-- is @AWS_DIRECTORY_SERVICE@ or @API_Gateway@, tests whether your identity
-- provider is set up successfully. We highly recommend that you call this
-- operation to test your authentication method as soon as you create your
-- server. By doing so, you can troubleshoot issues with the identity
-- provider integration to ensure that your users can successfully use the
-- service.
--
-- The @ServerId@ and @UserName@ parameters are required. The
-- @ServerProtocol@, @SourceIp@, and @UserPassword@ are all optional.
--
-- You cannot use @TestIdentityProvider@ if the @IdentityProviderType@ of
-- your server is @SERVICE_MANAGED@.
--
-- -   If you provide any incorrect values for any parameters, the
--     @Response@ field is empty.
--
-- -   If you provide a server ID for a server that uses service-managed
--     users, you get an error:
--
--     @ An error occurred (InvalidRequestException) when calling the TestIdentityProvider operation: s-@/@server-ID@/@ not configured for external auth @
--
-- -   If you enter a Server ID for the @--server-id@ parameter that does
--     not identify an actual Transfer server, you receive the following
--     error:
--
--     @An error occurred (ResourceNotFoundException) when calling the TestIdentityProvider operation: Unknown server@
module Amazonka.Transfer.TestIdentityProvider
  ( -- * Creating a Request
    TestIdentityProvider (..),
    newTestIdentityProvider,

    -- * Request Lenses
    testIdentityProvider_serverProtocol,
    testIdentityProvider_sourceIp,
    testIdentityProvider_userPassword,
    testIdentityProvider_serverId,
    testIdentityProvider_userName,

    -- * Destructuring the Response
    TestIdentityProviderResponse (..),
    newTestIdentityProviderResponse,

    -- * Response Lenses
    testIdentityProviderResponse_message,
    testIdentityProviderResponse_response,
    testIdentityProviderResponse_httpStatus,
    testIdentityProviderResponse_statusCode,
    testIdentityProviderResponse_url,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.Transfer.Types

-- | /See:/ 'newTestIdentityProvider' smart constructor.
data TestIdentityProvider = TestIdentityProvider'
  { -- | The type of file transfer protocol to be tested.
    --
    -- The available protocols are:
    --
    -- -   Secure Shell (SSH) File Transfer Protocol (SFTP)
    --
    -- -   File Transfer Protocol Secure (FTPS)
    --
    -- -   File Transfer Protocol (FTP)
    TestIdentityProvider -> Maybe Protocol
serverProtocol :: Prelude.Maybe Protocol,
    -- | The source IP address of the user account to be tested.
    TestIdentityProvider -> Maybe Text
sourceIp :: Prelude.Maybe Prelude.Text,
    -- | The password of the user account to be tested.
    TestIdentityProvider -> Maybe (Sensitive Text)
userPassword :: Prelude.Maybe (Data.Sensitive Prelude.Text),
    -- | A system-assigned identifier for a specific server. That server\'s user
    -- authentication method is tested with a user name and password.
    TestIdentityProvider -> Text
serverId :: Prelude.Text,
    -- | The name of the user account to be tested.
    TestIdentityProvider -> Text
userName :: Prelude.Text
  }
  deriving (TestIdentityProvider -> TestIdentityProvider -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TestIdentityProvider -> TestIdentityProvider -> Bool
$c/= :: TestIdentityProvider -> TestIdentityProvider -> Bool
== :: TestIdentityProvider -> TestIdentityProvider -> Bool
$c== :: TestIdentityProvider -> TestIdentityProvider -> Bool
Prelude.Eq, Int -> TestIdentityProvider -> ShowS
[TestIdentityProvider] -> ShowS
TestIdentityProvider -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TestIdentityProvider] -> ShowS
$cshowList :: [TestIdentityProvider] -> ShowS
show :: TestIdentityProvider -> String
$cshow :: TestIdentityProvider -> String
showsPrec :: Int -> TestIdentityProvider -> ShowS
$cshowsPrec :: Int -> TestIdentityProvider -> ShowS
Prelude.Show, forall x. Rep TestIdentityProvider x -> TestIdentityProvider
forall x. TestIdentityProvider -> Rep TestIdentityProvider x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TestIdentityProvider x -> TestIdentityProvider
$cfrom :: forall x. TestIdentityProvider -> Rep TestIdentityProvider x
Prelude.Generic)

-- |
-- Create a value of 'TestIdentityProvider' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'serverProtocol', 'testIdentityProvider_serverProtocol' - The type of file transfer protocol to be tested.
--
-- The available protocols are:
--
-- -   Secure Shell (SSH) File Transfer Protocol (SFTP)
--
-- -   File Transfer Protocol Secure (FTPS)
--
-- -   File Transfer Protocol (FTP)
--
-- 'sourceIp', 'testIdentityProvider_sourceIp' - The source IP address of the user account to be tested.
--
-- 'userPassword', 'testIdentityProvider_userPassword' - The password of the user account to be tested.
--
-- 'serverId', 'testIdentityProvider_serverId' - A system-assigned identifier for a specific server. That server\'s user
-- authentication method is tested with a user name and password.
--
-- 'userName', 'testIdentityProvider_userName' - The name of the user account to be tested.
newTestIdentityProvider ::
  -- | 'serverId'
  Prelude.Text ->
  -- | 'userName'
  Prelude.Text ->
  TestIdentityProvider
newTestIdentityProvider :: Text -> Text -> TestIdentityProvider
newTestIdentityProvider Text
pServerId_ Text
pUserName_ =
  TestIdentityProvider'
    { $sel:serverProtocol:TestIdentityProvider' :: Maybe Protocol
serverProtocol =
        forall a. Maybe a
Prelude.Nothing,
      $sel:sourceIp:TestIdentityProvider' :: Maybe Text
sourceIp = forall a. Maybe a
Prelude.Nothing,
      $sel:userPassword:TestIdentityProvider' :: Maybe (Sensitive Text)
userPassword = forall a. Maybe a
Prelude.Nothing,
      $sel:serverId:TestIdentityProvider' :: Text
serverId = Text
pServerId_,
      $sel:userName:TestIdentityProvider' :: Text
userName = Text
pUserName_
    }

-- | The type of file transfer protocol to be tested.
--
-- The available protocols are:
--
-- -   Secure Shell (SSH) File Transfer Protocol (SFTP)
--
-- -   File Transfer Protocol Secure (FTPS)
--
-- -   File Transfer Protocol (FTP)
testIdentityProvider_serverProtocol :: Lens.Lens' TestIdentityProvider (Prelude.Maybe Protocol)
testIdentityProvider_serverProtocol :: Lens' TestIdentityProvider (Maybe Protocol)
testIdentityProvider_serverProtocol = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TestIdentityProvider' {Maybe Protocol
serverProtocol :: Maybe Protocol
$sel:serverProtocol:TestIdentityProvider' :: TestIdentityProvider -> Maybe Protocol
serverProtocol} -> Maybe Protocol
serverProtocol) (\s :: TestIdentityProvider
s@TestIdentityProvider' {} Maybe Protocol
a -> TestIdentityProvider
s {$sel:serverProtocol:TestIdentityProvider' :: Maybe Protocol
serverProtocol = Maybe Protocol
a} :: TestIdentityProvider)

-- | The source IP address of the user account to be tested.
testIdentityProvider_sourceIp :: Lens.Lens' TestIdentityProvider (Prelude.Maybe Prelude.Text)
testIdentityProvider_sourceIp :: Lens' TestIdentityProvider (Maybe Text)
testIdentityProvider_sourceIp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TestIdentityProvider' {Maybe Text
sourceIp :: Maybe Text
$sel:sourceIp:TestIdentityProvider' :: TestIdentityProvider -> Maybe Text
sourceIp} -> Maybe Text
sourceIp) (\s :: TestIdentityProvider
s@TestIdentityProvider' {} Maybe Text
a -> TestIdentityProvider
s {$sel:sourceIp:TestIdentityProvider' :: Maybe Text
sourceIp = Maybe Text
a} :: TestIdentityProvider)

-- | The password of the user account to be tested.
testIdentityProvider_userPassword :: Lens.Lens' TestIdentityProvider (Prelude.Maybe Prelude.Text)
testIdentityProvider_userPassword :: Lens' TestIdentityProvider (Maybe Text)
testIdentityProvider_userPassword = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TestIdentityProvider' {Maybe (Sensitive Text)
userPassword :: Maybe (Sensitive Text)
$sel:userPassword:TestIdentityProvider' :: TestIdentityProvider -> Maybe (Sensitive Text)
userPassword} -> Maybe (Sensitive Text)
userPassword) (\s :: TestIdentityProvider
s@TestIdentityProvider' {} Maybe (Sensitive Text)
a -> TestIdentityProvider
s {$sel:userPassword:TestIdentityProvider' :: Maybe (Sensitive Text)
userPassword = Maybe (Sensitive Text)
a} :: TestIdentityProvider) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall a. Iso' (Sensitive a) a
Data._Sensitive

-- | A system-assigned identifier for a specific server. That server\'s user
-- authentication method is tested with a user name and password.
testIdentityProvider_serverId :: Lens.Lens' TestIdentityProvider Prelude.Text
testIdentityProvider_serverId :: Lens' TestIdentityProvider Text
testIdentityProvider_serverId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TestIdentityProvider' {Text
serverId :: Text
$sel:serverId:TestIdentityProvider' :: TestIdentityProvider -> Text
serverId} -> Text
serverId) (\s :: TestIdentityProvider
s@TestIdentityProvider' {} Text
a -> TestIdentityProvider
s {$sel:serverId:TestIdentityProvider' :: Text
serverId = Text
a} :: TestIdentityProvider)

-- | The name of the user account to be tested.
testIdentityProvider_userName :: Lens.Lens' TestIdentityProvider Prelude.Text
testIdentityProvider_userName :: Lens' TestIdentityProvider Text
testIdentityProvider_userName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TestIdentityProvider' {Text
userName :: Text
$sel:userName:TestIdentityProvider' :: TestIdentityProvider -> Text
userName} -> Text
userName) (\s :: TestIdentityProvider
s@TestIdentityProvider' {} Text
a -> TestIdentityProvider
s {$sel:userName:TestIdentityProvider' :: Text
userName = Text
a} :: TestIdentityProvider)

instance Core.AWSRequest TestIdentityProvider where
  type
    AWSResponse TestIdentityProvider =
      TestIdentityProviderResponse
  request :: (Service -> Service)
-> TestIdentityProvider -> Request TestIdentityProvider
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy TestIdentityProvider
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse TestIdentityProvider)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Maybe Text -> Int -> Int -> Text -> TestIdentityProviderResponse
TestIdentityProviderResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Message")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Response")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"StatusCode")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"Url")
      )

instance Prelude.Hashable TestIdentityProvider where
  hashWithSalt :: Int -> TestIdentityProvider -> Int
hashWithSalt Int
_salt TestIdentityProvider' {Maybe Text
Maybe (Sensitive Text)
Maybe Protocol
Text
userName :: Text
serverId :: Text
userPassword :: Maybe (Sensitive Text)
sourceIp :: Maybe Text
serverProtocol :: Maybe Protocol
$sel:userName:TestIdentityProvider' :: TestIdentityProvider -> Text
$sel:serverId:TestIdentityProvider' :: TestIdentityProvider -> Text
$sel:userPassword:TestIdentityProvider' :: TestIdentityProvider -> Maybe (Sensitive Text)
$sel:sourceIp:TestIdentityProvider' :: TestIdentityProvider -> Maybe Text
$sel:serverProtocol:TestIdentityProvider' :: TestIdentityProvider -> Maybe Protocol
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Protocol
serverProtocol
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
sourceIp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (Sensitive Text)
userPassword
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
serverId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
userName

instance Prelude.NFData TestIdentityProvider where
  rnf :: TestIdentityProvider -> ()
rnf TestIdentityProvider' {Maybe Text
Maybe (Sensitive Text)
Maybe Protocol
Text
userName :: Text
serverId :: Text
userPassword :: Maybe (Sensitive Text)
sourceIp :: Maybe Text
serverProtocol :: Maybe Protocol
$sel:userName:TestIdentityProvider' :: TestIdentityProvider -> Text
$sel:serverId:TestIdentityProvider' :: TestIdentityProvider -> Text
$sel:userPassword:TestIdentityProvider' :: TestIdentityProvider -> Maybe (Sensitive Text)
$sel:sourceIp:TestIdentityProvider' :: TestIdentityProvider -> Maybe Text
$sel:serverProtocol:TestIdentityProvider' :: TestIdentityProvider -> Maybe Protocol
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Protocol
serverProtocol
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
sourceIp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive Text)
userPassword
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
serverId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
userName

instance Data.ToHeaders TestIdentityProvider where
  toHeaders :: TestIdentityProvider -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"TransferService.TestIdentityProvider" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON TestIdentityProvider where
  toJSON :: TestIdentityProvider -> Value
toJSON TestIdentityProvider' {Maybe Text
Maybe (Sensitive Text)
Maybe Protocol
Text
userName :: Text
serverId :: Text
userPassword :: Maybe (Sensitive Text)
sourceIp :: Maybe Text
serverProtocol :: Maybe Protocol
$sel:userName:TestIdentityProvider' :: TestIdentityProvider -> Text
$sel:serverId:TestIdentityProvider' :: TestIdentityProvider -> Text
$sel:userPassword:TestIdentityProvider' :: TestIdentityProvider -> Maybe (Sensitive Text)
$sel:sourceIp:TestIdentityProvider' :: TestIdentityProvider -> Maybe Text
$sel:serverProtocol:TestIdentityProvider' :: TestIdentityProvider -> Maybe Protocol
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ServerProtocol" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Protocol
serverProtocol,
            (Key
"SourceIp" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
sourceIp,
            (Key
"UserPassword" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (Sensitive Text)
userPassword,
            forall a. a -> Maybe a
Prelude.Just (Key
"ServerId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
serverId),
            forall a. a -> Maybe a
Prelude.Just (Key
"UserName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
userName)
          ]
      )

instance Data.ToPath TestIdentityProvider where
  toPath :: TestIdentityProvider -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery TestIdentityProvider where
  toQuery :: TestIdentityProvider -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newTestIdentityProviderResponse' smart constructor.
data TestIdentityProviderResponse = TestIdentityProviderResponse'
  { -- | A message that indicates whether the test was successful or not.
    --
    -- If an empty string is returned, the most likely cause is that the
    -- authentication failed due to an incorrect username or password.
    TestIdentityProviderResponse -> Maybe Text
message :: Prelude.Maybe Prelude.Text,
    -- | The response that is returned from your API Gateway.
    TestIdentityProviderResponse -> Maybe Text
response :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    TestIdentityProviderResponse -> Int
httpStatus :: Prelude.Int,
    -- | The HTTP status code that is the response from your API Gateway.
    TestIdentityProviderResponse -> Int
statusCode :: Prelude.Int,
    -- | The endpoint of the service used to authenticate a user.
    TestIdentityProviderResponse -> Text
url :: Prelude.Text
  }
  deriving (TestIdentityProviderResponse
-> TestIdentityProviderResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TestIdentityProviderResponse
-> TestIdentityProviderResponse -> Bool
$c/= :: TestIdentityProviderResponse
-> TestIdentityProviderResponse -> Bool
== :: TestIdentityProviderResponse
-> TestIdentityProviderResponse -> Bool
$c== :: TestIdentityProviderResponse
-> TestIdentityProviderResponse -> Bool
Prelude.Eq, ReadPrec [TestIdentityProviderResponse]
ReadPrec TestIdentityProviderResponse
Int -> ReadS TestIdentityProviderResponse
ReadS [TestIdentityProviderResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TestIdentityProviderResponse]
$creadListPrec :: ReadPrec [TestIdentityProviderResponse]
readPrec :: ReadPrec TestIdentityProviderResponse
$creadPrec :: ReadPrec TestIdentityProviderResponse
readList :: ReadS [TestIdentityProviderResponse]
$creadList :: ReadS [TestIdentityProviderResponse]
readsPrec :: Int -> ReadS TestIdentityProviderResponse
$creadsPrec :: Int -> ReadS TestIdentityProviderResponse
Prelude.Read, Int -> TestIdentityProviderResponse -> ShowS
[TestIdentityProviderResponse] -> ShowS
TestIdentityProviderResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TestIdentityProviderResponse] -> ShowS
$cshowList :: [TestIdentityProviderResponse] -> ShowS
show :: TestIdentityProviderResponse -> String
$cshow :: TestIdentityProviderResponse -> String
showsPrec :: Int -> TestIdentityProviderResponse -> ShowS
$cshowsPrec :: Int -> TestIdentityProviderResponse -> ShowS
Prelude.Show, forall x.
Rep TestIdentityProviderResponse x -> TestIdentityProviderResponse
forall x.
TestIdentityProviderResponse -> Rep TestIdentityProviderResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep TestIdentityProviderResponse x -> TestIdentityProviderResponse
$cfrom :: forall x.
TestIdentityProviderResponse -> Rep TestIdentityProviderResponse x
Prelude.Generic)

-- |
-- Create a value of 'TestIdentityProviderResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'message', 'testIdentityProviderResponse_message' - A message that indicates whether the test was successful or not.
--
-- If an empty string is returned, the most likely cause is that the
-- authentication failed due to an incorrect username or password.
--
-- 'response', 'testIdentityProviderResponse_response' - The response that is returned from your API Gateway.
--
-- 'httpStatus', 'testIdentityProviderResponse_httpStatus' - The response's http status code.
--
-- 'statusCode', 'testIdentityProviderResponse_statusCode' - The HTTP status code that is the response from your API Gateway.
--
-- 'url', 'testIdentityProviderResponse_url' - The endpoint of the service used to authenticate a user.
newTestIdentityProviderResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'statusCode'
  Prelude.Int ->
  -- | 'url'
  Prelude.Text ->
  TestIdentityProviderResponse
newTestIdentityProviderResponse :: Int -> Int -> Text -> TestIdentityProviderResponse
newTestIdentityProviderResponse
  Int
pHttpStatus_
  Int
pStatusCode_
  Text
pUrl_ =
    TestIdentityProviderResponse'
      { $sel:message:TestIdentityProviderResponse' :: Maybe Text
message =
          forall a. Maybe a
Prelude.Nothing,
        $sel:response:TestIdentityProviderResponse' :: Maybe Text
response = forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:TestIdentityProviderResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:statusCode:TestIdentityProviderResponse' :: Int
statusCode = Int
pStatusCode_,
        $sel:url:TestIdentityProviderResponse' :: Text
url = Text
pUrl_
      }

-- | A message that indicates whether the test was successful or not.
--
-- If an empty string is returned, the most likely cause is that the
-- authentication failed due to an incorrect username or password.
testIdentityProviderResponse_message :: Lens.Lens' TestIdentityProviderResponse (Prelude.Maybe Prelude.Text)
testIdentityProviderResponse_message :: Lens' TestIdentityProviderResponse (Maybe Text)
testIdentityProviderResponse_message = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TestIdentityProviderResponse' {Maybe Text
message :: Maybe Text
$sel:message:TestIdentityProviderResponse' :: TestIdentityProviderResponse -> Maybe Text
message} -> Maybe Text
message) (\s :: TestIdentityProviderResponse
s@TestIdentityProviderResponse' {} Maybe Text
a -> TestIdentityProviderResponse
s {$sel:message:TestIdentityProviderResponse' :: Maybe Text
message = Maybe Text
a} :: TestIdentityProviderResponse)

-- | The response that is returned from your API Gateway.
testIdentityProviderResponse_response :: Lens.Lens' TestIdentityProviderResponse (Prelude.Maybe Prelude.Text)
testIdentityProviderResponse_response :: Lens' TestIdentityProviderResponse (Maybe Text)
testIdentityProviderResponse_response = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TestIdentityProviderResponse' {Maybe Text
response :: Maybe Text
$sel:response:TestIdentityProviderResponse' :: TestIdentityProviderResponse -> Maybe Text
response} -> Maybe Text
response) (\s :: TestIdentityProviderResponse
s@TestIdentityProviderResponse' {} Maybe Text
a -> TestIdentityProviderResponse
s {$sel:response:TestIdentityProviderResponse' :: Maybe Text
response = Maybe Text
a} :: TestIdentityProviderResponse)

-- | The response's http status code.
testIdentityProviderResponse_httpStatus :: Lens.Lens' TestIdentityProviderResponse Prelude.Int
testIdentityProviderResponse_httpStatus :: Lens' TestIdentityProviderResponse Int
testIdentityProviderResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TestIdentityProviderResponse' {Int
httpStatus :: Int
$sel:httpStatus:TestIdentityProviderResponse' :: TestIdentityProviderResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: TestIdentityProviderResponse
s@TestIdentityProviderResponse' {} Int
a -> TestIdentityProviderResponse
s {$sel:httpStatus:TestIdentityProviderResponse' :: Int
httpStatus = Int
a} :: TestIdentityProviderResponse)

-- | The HTTP status code that is the response from your API Gateway.
testIdentityProviderResponse_statusCode :: Lens.Lens' TestIdentityProviderResponse Prelude.Int
testIdentityProviderResponse_statusCode :: Lens' TestIdentityProviderResponse Int
testIdentityProviderResponse_statusCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TestIdentityProviderResponse' {Int
statusCode :: Int
$sel:statusCode:TestIdentityProviderResponse' :: TestIdentityProviderResponse -> Int
statusCode} -> Int
statusCode) (\s :: TestIdentityProviderResponse
s@TestIdentityProviderResponse' {} Int
a -> TestIdentityProviderResponse
s {$sel:statusCode:TestIdentityProviderResponse' :: Int
statusCode = Int
a} :: TestIdentityProviderResponse)

-- | The endpoint of the service used to authenticate a user.
testIdentityProviderResponse_url :: Lens.Lens' TestIdentityProviderResponse Prelude.Text
testIdentityProviderResponse_url :: Lens' TestIdentityProviderResponse Text
testIdentityProviderResponse_url = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TestIdentityProviderResponse' {Text
url :: Text
$sel:url:TestIdentityProviderResponse' :: TestIdentityProviderResponse -> Text
url} -> Text
url) (\s :: TestIdentityProviderResponse
s@TestIdentityProviderResponse' {} Text
a -> TestIdentityProviderResponse
s {$sel:url:TestIdentityProviderResponse' :: Text
url = Text
a} :: TestIdentityProviderResponse)

instance Prelude.NFData TestIdentityProviderResponse where
  rnf :: TestIdentityProviderResponse -> ()
rnf TestIdentityProviderResponse' {Int
Maybe Text
Text
url :: Text
statusCode :: Int
httpStatus :: Int
response :: Maybe Text
message :: Maybe Text
$sel:url:TestIdentityProviderResponse' :: TestIdentityProviderResponse -> Text
$sel:statusCode:TestIdentityProviderResponse' :: TestIdentityProviderResponse -> Int
$sel:httpStatus:TestIdentityProviderResponse' :: TestIdentityProviderResponse -> Int
$sel:response:TestIdentityProviderResponse' :: TestIdentityProviderResponse -> Maybe Text
$sel:message:TestIdentityProviderResponse' :: TestIdentityProviderResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
message
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
response
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
statusCode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
url