{-# OPTIONS -Wno-ambiguous-fields #-}

-- This file is part of the Wire Server implementation.
--
-- Copyright (C) 2025 Wire Swiss GmbH <opensource@wire.com>
--
-- This program is free software: you can redistribute it and/or modify it under
-- the terms of the GNU Affero General Public License as published by the Free
-- Software Foundation, either version 3 of the License, or (at your option) any
-- later version.
--
-- This program is distributed in the hope that it will be useful, but WITHOUT
-- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-- FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-- details.
--
-- You should have received a copy of the GNU Affero General Public License along
-- with this program. If not, see <https://www.gnu.org/licenses/>.

module Test.EJPD
  ( testEJPDRequest,
    testEJPDRequestRemote,
  )
where

import API.Brig
import qualified API.BrigInternal as BI
import API.Galley
import API.Gundeck
import Control.Lens hiding ((.=))
import Control.Monad.Reader
import qualified Data.Aeson as A
import Data.Aeson.Lens
import Data.String.Conversions (cs)
import qualified Data.UUID as UUID
import qualified Data.UUID.V4 as UUID
import qualified Network.Wreq as Wreq
import SetupHelpers
import Testlib.JSON
import Testlib.Prelude

-- | Create some teams & users, and return their expected ejpd response values.
setupEJPD :: (HasCallStack) => App (A.Value, A.Value, A.Value, A.Value, A.Value)
setupEJPD :: HasCallStack => App (Value, Value, Value, Value, Value)
setupEJPD =
  do
    (owner1, tid1, [usr1, usr2]) <- Domain -> Int -> App (Value, String, [Value])
forall domain.
(HasCallStack, MakesValue domain) =>
domain -> Int -> App (Value, String, [Value])
createTeam Domain
OwnDomain Int
3
    handle1 <- liftIO $ UUID.nextRandom <&> ("usr1-handle-" <>) . UUID.toString
    handle2 <- liftIO $ UUID.nextRandom <&> ("usr2-handle-" <>) . UUID.toString
    owner1Handle <- liftIO $ UUID.nextRandom <&> ("owner1-handle-" <>) . UUID.toString
    void $ putHandle usr1 handle1
    void $ putHandle usr2 handle2
    void $ putHandle owner1 owner1Handle
    email3 <- liftIO $ UUID.nextRandom <&> \UUID
uuid -> String
"usr3-" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> UUID -> String
UUID.toString UUID
uuid String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"@example.com"
    email4 <- liftIO $ UUID.nextRandom <&> \UUID
uuid -> String
"usr4-" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> UUID -> String
UUID.toString UUID
uuid String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"@example.com"
    email5 <- liftIO $ UUID.nextRandom <&> \UUID
uuid -> String
"usr5-" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> UUID -> String
UUID.toString UUID
uuid String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"@example.com"
    usr3 <- randomUser OwnDomain def {BI.email = Just email3, BI.name = Just "usr3"}
    usr4 <- randomUser OwnDomain def {BI.email = Just email4, BI.name = Just "usr4"}
    usr5 <- randomUser OwnDomain def {BI.email = Just email5, BI.name = Just "usr5"}
    usrRemote <- randomUser OtherDomain def {BI.email = Nothing, BI.name = Just "usrRemote"}
    handle3 <- liftIO $ UUID.nextRandom <&> ("usr3-handle-" <>) . UUID.toString
    handle4 <- liftIO $ UUID.nextRandom <&> ("usr4-handle-" <>) . UUID.toString
    handle5 <- liftIO $ UUID.nextRandom <&> ("usr5-handle-" <>) . UUID.toString
    void $ putHandle usr3 handle3
    void $ putHandle usr4 handle4
    void $ putHandle usr5 handle5

    connectTwoUsers usr3 usr5
    connectUsers [usr2, usr4, usr5, usrRemote]

    toks1 <- do
      cl11 <- objId $ addClient (usr1 %. "qualified_id") def >>= getJSON 201
      bindResponse (generateAndPostPushToken usr1 cl11 def) $ \Response
resp -> do
        Response
resp.status Int -> Int -> App ()
forall a. (MakesValue a, HasCallStack) => a -> Int -> App ()
`shouldMatchInt` Int
201
        tok <- Response
resp.json App Value -> String -> App Value
forall a. (HasCallStack, MakesValue a) => a -> String -> App Value
%. String
"token" App Value -> (App Value -> App String) -> App String
forall a b. a -> (a -> b) -> b
& App Value -> App String
forall a. (HasCallStack, MakesValue a) => a -> App String
asString
        pure [tok]
    toks2 <- do
      cl21 <- objId $ addClient (usr2 %. "qualified_id") def >>= getJSON 201
      cl22 <- objId $ addClient (usr2 %. "qualified_id") def >>= getJSON 201
      t1 <- bindResponse (generateAndPostPushToken usr2 cl21 def) $ \Response
resp -> do
        Response
resp.status Int -> Int -> App ()
forall a. (MakesValue a, HasCallStack) => a -> Int -> App ()
`shouldMatchInt` Int
201
        Response
resp.json App Value -> String -> App Value
forall a. (HasCallStack, MakesValue a) => a -> String -> App Value
%. String
"token" App Value -> (App Value -> App String) -> App String
forall a b. a -> (a -> b) -> b
& App Value -> App String
forall a. (HasCallStack, MakesValue a) => a -> App String
asString
      t2 <- bindResponse (generateAndPostPushToken usr2 cl22 def) $ \Response
resp -> do
        Response
resp.status Int -> Int -> App ()
forall a. (MakesValue a, HasCallStack) => a -> Int -> App ()
`shouldMatchInt` Int
201
        Response
resp.json App Value -> String -> App Value
forall a. (HasCallStack, MakesValue a) => a -> String -> App Value
%. String
"token" App Value -> (App Value -> App String) -> App String
forall a b. a -> (a -> b) -> b
& App Value -> App String
forall a. (HasCallStack, MakesValue a) => a -> App String
asString
      pure [t1, t2]
    toks4 <- do
      cl41 <- objId $ addClient (usr4 %. "qualified_id") def >>= getJSON 201
      bindResponse (generateAndPostPushToken usr4 cl41 def) $ \Response
resp -> do
        Response
resp.status Int -> Int -> App ()
forall a. (MakesValue a, HasCallStack) => a -> Int -> App ()
`shouldMatchInt` Int
201
        tok <- Response
resp.json App Value -> String -> App Value
forall a. (HasCallStack, MakesValue a) => a -> String -> App Value
%. String
"token" App Value -> (App Value -> App String) -> App String
forall a b. a -> (a -> b) -> b
& App Value -> App String
forall a. (HasCallStack, MakesValue a) => a -> App String
asString
        pure [tok]

    assets1 <- do
      a1 <- uploadDownloadProfilePicture usr1
      a2 <- uploadDownloadProfilePicture usr1
      pure $ snd <$> [a1, a2]
    assets2 <- (: []) . snd <$> uploadDownloadProfilePicture usr2
    assets3 <- (: []) . snd <$> uploadDownloadProfilePicture usr3
    assets4 <- (: []) . snd <$> uploadDownloadProfilePicture usr4

    (convs1, convs2, convs3, convs4, convs5) <- do
      let parse :: Response -> App Value
          parse Response
resp =
            HasCallStack => Int -> Response -> App Value
Int -> Response -> App Value
getJSON Int
201 Response
resp App Value -> (Value -> Value) -> App Value
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Value
val ->
              [Pair] -> Value
object
                [ String
"conv_name" String -> Text -> Pair
forall a. ToJSON a => String -> a -> Pair
.= do Value
val Value -> Getting (Endo Text) Value Text -> Text
forall s a. HasCallStack => s -> Getting (Endo a) s a -> a
^?! Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"name") ((Value -> Const (Endo Text) Value)
 -> Value -> Const (Endo Text) Value)
-> Getting (Endo Text) Value Text -> Getting (Endo Text) Value Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Endo Text) Value Text
forall t. AsValue t => Prism' t Text
Prism' Value Text
_String,
                  String
"conv_id" String -> KeyMap Value -> Pair
forall a. ToJSON a => String -> a -> Pair
.= do Value
val Value
-> Getting (Endo (KeyMap Value)) Value (KeyMap Value)
-> KeyMap Value
forall s a. HasCallStack => s -> Getting (Endo a) s a -> a
^?! Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"qualified_id") ((Value -> Const (Endo (KeyMap Value)) Value)
 -> Value -> Const (Endo (KeyMap Value)) Value)
-> Getting (Endo (KeyMap Value)) Value (KeyMap Value)
-> Getting (Endo (KeyMap Value)) Value (KeyMap Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Endo (KeyMap Value)) Value (KeyMap Value)
forall t. AsValue t => Prism' t (KeyMap Value)
Prism' Value (KeyMap Value)
_Object
                ]

      conv1 <-
        parse
          =<< postConversation usr1 do
            defMLS {name = Just "11", qualifiedUsers = [], team = Just tid1}
      conv12 <-
        parse
          =<< postConversation usr1 do
            defProteus {name = Just "12", qualifiedUsers = [usr2], team = Just tid1}
      conv35 <-
        parse
          =<< postConversation
            usr3
            do defProteus {name = Just "35", qualifiedUsers = [usr5]}
      conv524 <-
        parse
          =<< postConversation usr5 do
            defProteus {name = Just "524", qualifiedUsers = [usr2, usr4]}
      pure (Just ([conv1, conv12]), Just ([conv12, conv524]), Just [conv35], Just [conv524], Just [conv35, conv524])

    assertSuccess =<< postConversation usrRemote do
      defProteus {name = Just "remote245", qualifiedUsers = [usr2, usr4, usr5]}

    let usr2contacts = [(Value, String)] -> Maybe [(Value, String)]
forall a. a -> Maybe a
Just ([(Value, String)] -> Maybe [(Value, String)])
-> [(Value, String)] -> Maybe [(Value, String)]
forall a b. (a -> b) -> a -> b
$ (,String
"accepted") (Value -> (Value, String)) -> [Value] -> [(Value, String)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Value
ejpd4, Value
ejpd5]
        usr3contacts = [(Value, String)] -> Maybe [(Value, String)]
forall a. a -> Maybe a
Just ([(Value, String)] -> Maybe [(Value, String)])
-> [(Value, String)] -> Maybe [(Value, String)]
forall a b. (a -> b) -> a -> b
$ (,String
"accepted") (Value -> (Value, String)) -> [Value] -> [(Value, String)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Value
ejpd5]
        usr4contacts = [(Value, String)] -> Maybe [(Value, String)]
forall a. a -> Maybe a
Just ([(Value, String)] -> Maybe [(Value, String)])
-> [(Value, String)] -> Maybe [(Value, String)]
forall a b. (a -> b) -> a -> b
$ (,String
"accepted") (Value -> (Value, String)) -> [Value] -> [(Value, String)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Value
ejpd2, Value
ejpd5]
        usr5contacts = [(Value, String)] -> Maybe [(Value, String)]
forall a. a -> Maybe a
Just ([(Value, String)] -> Maybe [(Value, String)])
-> [(Value, String)] -> Maybe [(Value, String)]
forall a b. (a -> b) -> a -> b
$ (,String
"accepted") (Value -> (Value, String)) -> [Value] -> [(Value, String)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Value
ejpd2, Value
ejpd3, Value
ejpd4]

        ejpd0 = HasCallStack =>
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
mkUsr Value
owner1 (String -> Maybe String
forall a. a -> Maybe a
Just String
owner1Handle) [] Maybe [(Value, String)]
forall a. Maybe a
Nothing (([Value], String) -> Maybe ([Value], String)
forall a. a -> Maybe a
Just ([Value
ejpd1, Value
ejpd2], String
"list_complete")) Maybe [Value]
forall a. Maybe a
Nothing Maybe [String]
forall a. Maybe a
Nothing
        ejpd1 = HasCallStack =>
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
mkUsr Value
usr1 (String -> Maybe String
forall a. a -> Maybe a
Just String
handle1) [String]
toks1 Maybe [(Value, String)]
forall a. Maybe a
Nothing (([Value], String) -> Maybe ([Value], String)
forall a. a -> Maybe a
Just ([Value
ejpd0, Value
ejpd2], String
"list_complete")) Maybe [Value]
convs1 ([String] -> Maybe [String]
forall a. a -> Maybe a
Just [String]
assets1)
        ejpd2 = HasCallStack =>
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
mkUsr Value
usr2 (String -> Maybe String
forall a. a -> Maybe a
Just String
handle2) [String]
toks2 Maybe [(Value, String)]
usr2contacts (([Value], String) -> Maybe ([Value], String)
forall a. a -> Maybe a
Just ([Value
ejpd0, Value
ejpd1], String
"list_complete")) Maybe [Value]
convs2 ([String] -> Maybe [String]
forall a. a -> Maybe a
Just [String]
assets2)
        ejpd3 = HasCallStack =>
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
mkUsr Value
usr3 (String -> Maybe String
forall a. a -> Maybe a
Just String
handle3) [] Maybe [(Value, String)]
usr3contacts Maybe ([Value], String)
forall a. Maybe a
Nothing Maybe [Value]
convs3 ([String] -> Maybe [String]
forall a. a -> Maybe a
Just [String]
assets3)
        ejpd4 = HasCallStack =>
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
mkUsr Value
usr4 (String -> Maybe String
forall a. a -> Maybe a
Just String
handle4) [String]
toks4 Maybe [(Value, String)]
usr4contacts Maybe ([Value], String)
forall a. Maybe a
Nothing Maybe [Value]
convs4 ([String] -> Maybe [String]
forall a. a -> Maybe a
Just [String]
assets4)
        ejpd5 = HasCallStack =>
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
mkUsr Value
usr5 (String -> Maybe String
forall a. a -> Maybe a
Just String
handle5) [] Maybe [(Value, String)]
usr5contacts Maybe ([Value], String)
forall a. Maybe a
Nothing Maybe [Value]
convs5 Maybe [String]
forall a. Maybe a
Nothing

    pure (ejpd1, ejpd2, ejpd3, ejpd4, ejpd5)
  where
    -- Return value is a 'EJPDResponseItem'.
    mkUsr ::
      (HasCallStack) =>
      A.Value {- user -} ->
      Maybe String {- handle (in case usr is not up to date, we pass this separately) -} ->
      [String {- push tokens -}] ->
      -- contacts
      Maybe [(A.Value {- ejpd response item of contact -}, String {- relation -})] ->
      -- team contacts
      Maybe ([A.Value {- ejpd response item -}], String {- pagination flag -}) ->
      -- conversations
      Maybe [A.Value] ->
      Maybe [String {- asset url -}] ->
      A.Value
    mkUsr :: HasCallStack =>
Value
-> Maybe String
-> [String]
-> Maybe [(Value, String)]
-> Maybe ([Value], String)
-> Maybe [Value]
-> Maybe [String]
-> Value
mkUsr Value
usr Maybe String
hdl [String]
toks Maybe [(Value, String)]
contacts Maybe ([Value], String)
teamContacts Maybe [Value]
convs Maybe [String]
assets = Value
result
      where
        result :: Value
result =
          [Pair] -> Value
object
            [ -- (We know we have "id", but using ^? instead of ^. avoids the need for a Monoid instance for Value.)
              String
"UserId" String -> Maybe Value -> Pair
forall a. ToJSON a => String -> a -> Pair
.= (Value
usr Value -> Getting (First Value) Value Value -> Maybe Value
forall s a. s -> Getting (First a) s a -> Maybe a
^? Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"qualified_id")),
              String
"TeamId" String -> Maybe Value -> Pair
forall a. ToJSON a => String -> a -> Pair
.= (Value
usr Value -> Getting (First Value) Value Value -> Maybe Value
forall s a. s -> Getting (First a) s a -> Maybe a
^? Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"team")),
              String
"Name" String -> Maybe Value -> Pair
forall a. ToJSON a => String -> a -> Pair
.= (Value
usr Value -> Getting (First Value) Value Value -> Maybe Value
forall s a. s -> Getting (First a) s a -> Maybe a
^? Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"name")),
              String
"Handle" String -> Maybe String -> Pair
forall a. ToJSON a => String -> a -> Pair
.= Maybe String
hdl,
              String
"Email" String -> Maybe Value -> Pair
forall a. ToJSON a => String -> a -> Pair
.= (Value
usr Value -> Getting (First Value) Value Value -> Maybe Value
forall s a. s -> Getting (First a) s a -> Maybe a
^? Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"email")),
              String
"Phone" String -> Maybe Value -> Pair
forall a. ToJSON a => String -> a -> Pair
.= (Value
usr Value -> Getting (First Value) Value Value -> Maybe Value
forall s a. s -> Getting (First a) s a -> Maybe a
^? Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"phone")),
              String
"PushTokens" String -> [String] -> Pair
forall a. ToJSON a => String -> a -> Pair
.= [String]
toks,
              String
"Contacts"
                String -> Maybe [Value] -> Pair
forall a. ToJSON a => String -> a -> Pair
.= let f :: (a, a) -> Value
f (a
item, a
relation) = [Pair] -> Value
object [String
"contact_item" String -> a -> Pair
forall a. ToJSON a => String -> a -> Pair
.= a
item, String
"contact_relation" String -> a -> Pair
forall a. ToJSON a => String -> a -> Pair
.= a
relation]
                    in (((Value, String) -> Value) -> [(Value, String)] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
map ((Value, String) -> Value
forall {a} {a}. (ToJSON a, ToJSON a) => (a, a) -> Value
f ((Value, String) -> Value)
-> ((Value, String) -> (Value, String)) -> (Value, String) -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' (Value, String) Value -> (Value, String) -> (Value, String)
forall x. Lens' x Value -> x -> x
trimContact (Value -> f Value) -> (Value, String) -> f (Value, String)
forall s t a b. Field1 s t a b => Lens s t a b
Lens' (Value, String) Value
_1) ([(Value, String)] -> [Value])
-> Maybe [(Value, String)] -> Maybe [Value]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [(Value, String)]
contacts),
              String
"TeamContacts"
                String -> Value -> Pair
forall a. ToJSON a => String -> a -> Pair
.= ( Maybe ([Value], String)
teamContacts
                       Maybe ([Value], String)
-> (Maybe ([Value], String) -> Value) -> Value
forall a b. a -> (a -> b) -> b
& Value
-> (([Value], String) -> Value) -> Maybe ([Value], String) -> Value
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
                         Value
Null
                         ( \([Value]
tcs, String
ltyp) ->
                             [Pair] -> Value
object
                               [ String
"TeamContacts" String -> [Value] -> Pair
forall a. ToJSON a => String -> a -> Pair
.= (Lens' Value Value -> Value -> Value
forall x. Lens' x Value -> x -> x
trimContact (Value -> f Value) -> Value -> f Value
forall a. a -> a
Lens' Value Value
id (Value -> Value) -> [Value] -> [Value]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Value]
tcs),
                                 String
"ListType" String -> String -> Pair
forall a. ToJSON a => String -> a -> Pair
.= String
ltyp
                               ]
                         )
                   ),
              String
"Conversations" String -> Maybe [Value] -> Pair
forall a. ToJSON a => String -> a -> Pair
.= Maybe [Value]
convs,
              String
"Assets" String -> Maybe [String] -> Pair
forall a. ToJSON a => String -> a -> Pair
.= Maybe [String]
assets
            ]

    trimContact :: forall x. Lens' x A.Value -> x -> x
    trimContact :: forall x. Lens' x Value -> x -> x
trimContact Lens' x Value
lns =
      (Value -> Identity Value) -> x -> Identity x
Lens' x Value
lns ((Value -> Identity Value) -> x -> Identity x)
-> (Value -> Value) -> x -> x
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ \case
        trimmable :: Value
trimmable@(A.Object KeyMap Value
_) -> Value -> Value
trimItem Value
trimmable
        Value
other -> String -> Value
forall a. HasCallStack => String -> a
error (String -> Value) -> String -> Value
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
other

    trimItem :: A.Value -> A.Value
    trimItem :: Value -> Value
trimItem =
      (Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"Contacts") ((Value -> Identity Value) -> Value -> Identity Value)
-> Value -> Value -> Value
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Value
A.Null)
        (Value -> Value) -> (Value -> Value) -> Value -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"TeamContacts") ((Value -> Identity Value) -> Value -> Identity Value)
-> Value -> Value -> Value
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Value
A.Null)
        (Value -> Value) -> (Value -> Value) -> Value -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"Conversations") ((Value -> Identity Value) -> Value -> Identity Value)
-> Value -> Value -> Value
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Value
A.Null)

testEJPDRequest :: (HasCallStack) => App ()
testEJPDRequest :: HasCallStack => App ()
testEJPDRequest = do
  (usr1, usr2, usr3, usr4, usr5) <- App (Value, Value, Value, Value, Value)
HasCallStack => App (Value, Value, Value, Value, Value)
setupEJPD

  let check :: (HasCallStack) => [A.Value] -> App ()
      check [Value]
want = do
        let handle :: Value -> String
handle = Text -> String
forall a b. ConvertibleStrings a b => a -> b
cs (Text -> String) -> (Value -> Text) -> Value -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value -> Getting (Endo Text) Value Text -> Text
forall s a. HasCallStack => s -> Getting (Endo a) s a -> a
^?! (Key -> Traversal' Value Value
forall t. AsValue t => Key -> Traversal' t Value
key (String -> Key
forall a. IsString a => String -> a
fromString String
"Handle") ((Value -> Const (Endo Text) Value)
 -> Value -> Const (Endo Text) Value)
-> Getting (Endo Text) Value Text -> Getting (Endo Text) Value Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Endo Text) Value Text
forall t. AsValue t => Prism' t Text
Prism' Value Text
_String))
        have <- Domain -> [String] -> String -> App Response
forall dom.
(HasCallStack, MakesValue dom) =>
dom -> [String] -> String -> App Response
BI.getEJPDInfo Domain
OwnDomain (Value -> String
handle (Value -> String) -> [Value] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Value]
want) String
"include_contacts"
        have.json `shouldMatchSpecial` object ["EJPDResponse" .= want]

      shouldMatchSpecial :: (MakesValue a, MakesValue b, HasCallStack) => a -> b -> App ()
      shouldMatchSpecial = [LenientMatchRule]
-> (Value -> App (Maybe Value)) -> a -> b -> App ()
forall a b.
(MakesValue a, MakesValue b, HasCallStack) =>
[LenientMatchRule]
-> (Value -> App (Maybe Value)) -> a -> b -> App ()
shouldMatchWithRules [LenientMatchRule
forall a. Bounded a => a
minBound ..] Value -> App (Maybe Value)
resolveAssetLinks

      -- query params and even the uuid in the path of asset urls may differ between actual
      -- and expected value because they are re-generated non-deterministically.  so we fetch
      -- the actual content.
      resolveAssetLinks :: A.Value -> App (Maybe A.Value)
      resolveAssetLinks = \case
        (A.String (Text -> String
forall a b. ConvertibleStrings a b => a -> b
cs -> String
url)) | String -> Bool
isProbablyAssetUrl String
url -> (Value -> Maybe Value
forall a. a -> Maybe a
Just (Value -> Maybe Value)
-> (String -> Value) -> String -> Maybe Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Value
forall a. ToJSON a => a -> Value
toJSON) (String -> Maybe Value) -> App String -> App (Maybe Value)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> App String
fetchIt String
url
        Value
_ -> Maybe Value -> App (Maybe Value)
forall a. a -> App a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Value
forall a. Maybe a
Nothing
        where
          isProbablyAssetUrl :: String -> Bool
          isProbablyAssetUrl :: String -> Bool
isProbablyAssetUrl String
url = (String -> Bool) -> [String] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isInfixOf` String
url) [String
"http", String
"://", String
"/dummy-bucket/v3/persistent/"]

          fetchIt :: String -> App String
          fetchIt :: String -> App String
fetchIt String
url = IO String -> App String
forall a. IO a -> App a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> App String) -> IO String -> App String
forall a b. (a -> b) -> a -> b
$ (ByteString -> String
forall a b. ConvertibleStrings a b => a -> b
cs (ByteString -> String)
-> (Response ByteString -> ByteString)
-> Response ByteString
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting ByteString (Response ByteString) ByteString
-> Response ByteString -> ByteString
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ByteString (Response ByteString) ByteString
forall body0 body1 (f :: * -> *).
Functor f =>
(body0 -> f body1) -> Response body0 -> f (Response body1)
Wreq.responseBody) (Response ByteString -> String)
-> IO (Response ByteString) -> IO String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> IO (Response ByteString)
Wreq.get String
url

  check [usr1]
  check [usr2]
  check [usr3]
  check [usr4, usr5]

testEJPDRequestRemote :: (HasCallStack) => App ()
testEJPDRequestRemote :: HasCallStack => App ()
testEJPDRequestRemote = do
  usrRemote <- Domain -> CreateUser -> App Value
forall domain.
(HasCallStack, MakesValue domain) =>
domain -> CreateUser -> App Value
randomUser Domain
OtherDomain CreateUser
forall a. Default a => a
def {BI.email = Nothing, BI.name = Just "usrRemote"}
  handleRemote <- liftIO $ UUID.nextRandom <&> UUID.toString
  assertSuccess =<< putHandle usrRemote handleRemote

  have <- BI.getEJPDInfo OwnDomain [handleRemote] "include_contacts"
  shouldBeEmpty $ have.json %. "EJPDResponse"