From 836254a4c6bd5e17b40acbcaf77a83802d44919e Mon Sep 17 00:00:00 2001 From: Evgeny Poberezkin Date: Thu, 2 Jul 2026 12:58:43 +0100 Subject: [PATCH] types: rename name types --- src/Simplex/Messaging/Agent.hs | 4 ++-- src/Simplex/Messaging/Agent/Client.hs | 2 +- src/Simplex/Messaging/Agent/Protocol.hs | 4 ++-- src/Simplex/Messaging/Client.hs | 6 ++--- src/Simplex/Messaging/Protocol.hs | 4 ++-- src/Simplex/Messaging/Server.hs | 4 ++-- src/Simplex/Messaging/Server/Names.hs | 6 ++--- src/Simplex/Messaging/SimplexName.hs | 30 ++++++++++++------------- tests/AgentTests/ResolveNameTests.hs | 18 +++++++-------- tests/RSLVTests.hs | 6 ++--- tests/SMPNamesTests.hs | 8 +++---- tests/XFTPClient.hs | 2 +- 12 files changed, 47 insertions(+), 47 deletions(-) diff --git a/src/Simplex/Messaging/Agent.hs b/src/Simplex/Messaging/Agent.hs index f882ce7af..34e90f127 100644 --- a/src/Simplex/Messaging/Agent.hs +++ b/src/Simplex/Messaging/Agent.hs @@ -445,7 +445,7 @@ getConnShortLink c = withAgentEnv c .:. getConnShortLink' c -- | Resolve a SimpleX name (PFWD RSLV). The agent owns server selection: it -- picks a names-capable server (ServerRoles.names) from the user's nameSrvs, so -- chat clients just pass the parsed domain. -resolveSimplexName :: AgentClient -> NetworkRequestMode -> UserId -> SimplexNameDomain -> AE NameRecord +resolveSimplexName :: AgentClient -> NetworkRequestMode -> UserId -> SimplexDomain -> AE NameRecord resolveSimplexName c nm userId domain = withAgentEnv c $ resolveSimplexName' c nm userId domain {-# INLINE resolveSimplexName #-} @@ -1191,7 +1191,7 @@ getConnShortLink' c nm userId = \case deleteLocalInvShortLink' :: AgentClient -> ConnShortLink 'CMInvitation -> AM () deleteLocalInvShortLink' c (CSLInvitation _ srv linkId _) = withStore' c $ \db -> deleteInvShortLink db srv linkId -resolveSimplexName' :: AgentClient -> NetworkRequestMode -> UserId -> SimplexNameDomain -> AM NameRecord +resolveSimplexName' :: AgentClient -> NetworkRequestMode -> UserId -> SimplexDomain -> AM NameRecord resolveSimplexName' c nm userId domain = do resolverSrv <- getNextNameServer c userId resolveName c nm userId resolverSrv domain diff --git a/src/Simplex/Messaging/Agent/Client.hs b/src/Simplex/Messaging/Agent/Client.hs index 14ba84e9c..bb4f1a950 100644 --- a/src/Simplex/Messaging/Agent/Client.hs +++ b/src/Simplex/Messaging/Agent/Client.hs @@ -1986,7 +1986,7 @@ getQueueLink c nm userId server lnkId = -- resolver) and falls back to a direct send when the proxy is unavailable -- (faster but exposes the client IP). Mode selection is delegated to -- `sendOrProxySMPCommand`, which honours the network config (SPMNever etc.). -resolveName :: AgentClient -> NetworkRequestMode -> UserId -> SMPServer -> SimplexNameDomain -> AM NameRecord +resolveName :: AgentClient -> NetworkRequestMode -> UserId -> SMPServer -> SimplexDomain -> AM NameRecord resolveName c nm userId server domain = snd <$> sendOrProxySMPCommand c nm userId server "" "RSLV" NoEntity resolveViaProxy resolveDirectly where diff --git a/src/Simplex/Messaging/Agent/Protocol.hs b/src/Simplex/Messaging/Agent/Protocol.hs index 87afce2eb..c4310414e 100644 --- a/src/Simplex/Messaging/Agent/Protocol.hs +++ b/src/Simplex/Messaging/Agent/Protocol.hs @@ -123,7 +123,7 @@ module Simplex.Messaging.Agent.Protocol ConnectionLink (..), AConnectionLink (..), SimplexNameInfo (..), - SimplexNameDomain (..), + SimplexDomain (..), SimplexTLD (..), SimplexNameType (..), ConnShortLink (..), @@ -238,7 +238,7 @@ import Simplex.Messaging.Crypto.Ratchet ) import Simplex.Messaging.Encoding import Simplex.Messaging.Encoding.String -import Simplex.Messaging.SimplexName (SimplexNameDomain (..), SimplexNameInfo (..), SimplexNameType (..), SimplexTLD (..), fullDomainName, shortNameInfoStr) +import Simplex.Messaging.SimplexName (SimplexDomain (..), SimplexNameInfo (..), SimplexNameType (..), SimplexTLD (..), fullDomainName, shortNameInfoStr) import Simplex.Messaging.Parsers import Simplex.Messaging.Protocol ( AProtocolType, diff --git a/src/Simplex/Messaging/Client.hs b/src/Simplex/Messaging/Client.hs index 9091db3e1..dc811fa0b 100644 --- a/src/Simplex/Messaging/Client.hs +++ b/src/Simplex/Messaging/Client.hs @@ -166,7 +166,7 @@ import Simplex.Messaging.Parsers (defaultJSON, dropPrefix, enumJSON, sumTypeJSON import Simplex.Messaging.Protocol import Simplex.Messaging.Protocol.Types import Simplex.Messaging.Server.QueueStore.QueueInfo -import Simplex.Messaging.SimplexName (SimplexNameDomain) +import Simplex.Messaging.SimplexName (SimplexDomain) import Simplex.Messaging.TMap (TMap) import qualified Simplex.Messaging.TMap as TM import Simplex.Messaging.Transport @@ -1054,7 +1054,7 @@ proxySMPMessage c nm proxiedRelay spKey sId flags msg = proxyOKSMPCommand c nm p -- through `proxySMPCommand` and pattern-matches the expected RNAME response. -- Version-gated on the destination relay (mirrors `connectSMPProxiedRelay`): -- the client never sends RSLV to a relay that predates names support. -proxyResolveName :: SMPClient -> NetworkRequestMode -> ProxiedRelay -> SimplexNameDomain -> ExceptT SMPClientError IO (Either ProxyClientError NameRecord) +proxyResolveName :: SMPClient -> NetworkRequestMode -> ProxiedRelay -> SimplexDomain -> ExceptT SMPClientError IO (Either ProxyClientError NameRecord) proxyResolveName c nm proxiedRelay name | prVersion proxiedRelay >= namesSMPVersion = proxySMPCommand c nm proxiedRelay Nothing NoEntity (RSLV name) >>= \case @@ -1068,7 +1068,7 @@ proxyResolveName c nm proxiedRelay name -- proxy fallback in the agent. RSLV requires no entity ID or authorization -- (see `noAuthCmd` in Protocol.hs). Version-gated on the session here, not the -- encoder, so an old server never receives RSLV. -directResolveName :: SMPClient -> NetworkRequestMode -> SimplexNameDomain -> ExceptT SMPClientError IO NameRecord +directResolveName :: SMPClient -> NetworkRequestMode -> SimplexDomain -> ExceptT SMPClientError IO NameRecord directResolveName c nm name | thVersion (thParams c) >= namesSMPVersion = sendProtocolCommand c nm Nothing NoEntity (Cmd SResolver (RSLV name)) >>= \case diff --git a/src/Simplex/Messaging/Protocol.hs b/src/Simplex/Messaging/Protocol.hs index 7ebc82fab..8ef5bb04f 100644 --- a/src/Simplex/Messaging/Protocol.hs +++ b/src/Simplex/Messaging/Protocol.hs @@ -270,7 +270,7 @@ import Simplex.Messaging.Parsers import Simplex.Messaging.Protocol.Types import Simplex.Messaging.Server.QueueStore.QueueInfo import Simplex.Messaging.ServiceScheme -import Simplex.Messaging.SimplexName (SimplexNameDomain) +import Simplex.Messaging.SimplexName (SimplexDomain) import Simplex.Messaging.Transport import Simplex.Messaging.Transport.Client (TransportHost, TransportHosts (..)) import Simplex.Messaging.Util (bshow, eitherToMaybe, safeDecodeUtf8, (<$?>)) @@ -608,7 +608,7 @@ data Command (p :: Party) where -- - corrId: unique correlation ID between proxy and relay, also used as a nonce to encrypt forwarded transmission RFWD :: EncFwdTransmission -> Command ProxyService -- use CorrId as CbNonce, proxy to relay -- Resolve SimpleX name. - RSLV :: SimplexNameDomain -> Command Resolver + RSLV :: SimplexDomain -> Command Resolver deriving instance Show (Command p) diff --git a/src/Simplex/Messaging/Server.hs b/src/Simplex/Messaging/Server.hs index a9303f34e..36ac471f9 100644 --- a/src/Simplex/Messaging/Server.hs +++ b/src/Simplex/Messaging/Server.hs @@ -103,7 +103,7 @@ import qualified Simplex.Messaging.Crypto as C import Simplex.Messaging.Encoding import Simplex.Messaging.Encoding.String import Simplex.Messaging.Protocol -import Simplex.Messaging.SimplexName (SimplexNameDomain) +import Simplex.Messaging.SimplexName (SimplexDomain) import Simplex.Messaging.Server.Control import Simplex.Messaging.Server.Env.STM as Env import Simplex.Messaging.Server.Expiration @@ -1497,7 +1497,7 @@ client Just nenv -> pure (Just nenv) -- Runs on a forked thread so RSLV does not block other commands; -- concurrency is limited by serverResolverConcurrency in forkCmd. - resolveNameMsg :: NamesEnv -> SimplexNameDomain -> M s BrokerMsg + resolveNameMsg :: NamesEnv -> SimplexDomain -> M s BrokerMsg resolveNameMsg nenv d = do st <- asks (rslvStats . serverStats) (selector, msg) <- diff --git a/src/Simplex/Messaging/Server/Names.hs b/src/Simplex/Messaging/Server/Names.hs index 896b952ad..19bae15fc 100644 --- a/src/Simplex/Messaging/Server/Names.hs +++ b/src/Simplex/Messaging/Server/Names.hs @@ -30,7 +30,7 @@ import Simplex.Messaging.Server.Names.HttpResolver newResolverEnv, resolveHttp, ) -import Simplex.Messaging.SimplexName (SimplexNameDomain, fullDomainName) +import Simplex.Messaging.SimplexName (SimplexDomain, fullDomainName) import System.Timeout (timeout) data NamesConfig = NamesConfig @@ -58,7 +58,7 @@ pingEndpoint :: NamesEnv -> IO (Either ResolverError ()) pingEndpoint NamesEnv {resolverEnv, config} = fromMaybe (Left ResolverTimeout) <$> timeout (resolverTimeoutMs config * 1000) (healthHttp resolverEnv) -resolveName :: NamesEnv -> SimplexNameDomain -> IO (Either NameErrorType NameRecord) +resolveName :: NamesEnv -> SimplexDomain -> IO (Either NameErrorType NameRecord) resolveName env d = do r <- E.try (timeout (resolverTimeoutMs (config env) * 1000) (fetch env d)) case r of @@ -69,7 +69,7 @@ resolveName env d = do logError $ "[NAMES] resolver fetch raised " <> T.pack (E.displayException e) pure (Left (RESOLVER "resolver error")) -fetch :: NamesEnv -> SimplexNameDomain -> IO (Either NameErrorType NameRecord) +fetch :: NamesEnv -> SimplexDomain -> IO (Either NameErrorType NameRecord) fetch NamesEnv {resolverEnv} d = first mapResolverError <$> resolveHttp resolverEnv (fullDomainName d) diff --git a/src/Simplex/Messaging/SimplexName.hs b/src/Simplex/Messaging/SimplexName.hs index 1178d1f3f..2dd0f8645 100644 --- a/src/Simplex/Messaging/SimplexName.hs +++ b/src/Simplex/Messaging/SimplexName.hs @@ -6,7 +6,7 @@ module Simplex.Messaging.SimplexName ( SimplexNameInfo (..), - SimplexNameDomain (..), + SimplexDomain (..), SimplexTLD (..), SimplexNameType (..), fullDomainName, @@ -33,11 +33,11 @@ import Simplex.Messaging.Util (eitherToMaybe, safeDecodeUtf8, (<$?>)) data SimplexNameInfo = SimplexNameInfo { nameType :: SimplexNameType, - nameDomain :: SimplexNameDomain + nameDomain :: SimplexDomain } deriving (Eq, Show) -data SimplexNameDomain = SimplexNameDomain +data SimplexDomain = SimplexDomain { nameTLD :: SimplexTLD, domain :: Text, subDomain :: [Text] -- parent to child: ["b", "a"] for a.b.domain.simplex @@ -87,9 +87,9 @@ instance StrEncoding SimplexNameInfo where infoP NTPublicGroup = SimplexNameInfo NTPublicGroup <$> (strP <|> bareName) infoP NTContact = SimplexNameInfo NTContact <$> strP bareName = parseBare . safeDecodeUtf8 <$?> boundedNonSpace - parseBare s = (\name -> SimplexNameDomain TLDSimplex (T.toLower name) []) <$> AT.parseOnly (nameLabelP <* AT.endOfInput) s + parseBare s = (\name -> SimplexDomain TLDSimplex (T.toLower name) []) <$> AT.parseOnly (nameLabelP <* AT.endOfInput) s -instance StrEncoding SimplexNameDomain where +instance StrEncoding SimplexDomain where strEncode = encodeUtf8 . fullDomainName strP = parseDomain . safeDecodeUtf8 <$?> boundedNonSpace where @@ -97,18 +97,18 @@ instance StrEncoding SimplexNameDomain where mkDomain labels = case reverse lowered of [] -> Left "empty name" [_] -> Left "domain requires TLD" - "simplex" : name : sub -> Right (SimplexNameDomain TLDSimplex name sub) - "testing" : name : sub -> Right (SimplexNameDomain TLDTesting name sub) - _ -> Right (SimplexNameDomain TLDWeb (T.intercalate "." lowered) []) + "simplex" : name : sub -> Right (SimplexDomain TLDSimplex name sub) + "testing" : name : sub -> Right (SimplexDomain TLDTesting name sub) + _ -> Right (SimplexDomain TLDWeb (T.intercalate "." lowered) []) where lowered = map T.toLower labels -instance Encoding SimplexNameDomain where +instance Encoding SimplexDomain where smpEncode = strEncode smpP = strP -fullDomainName :: SimplexNameDomain -> Text -fullDomainName SimplexNameDomain {nameTLD, domain, subDomain} = T.intercalate "." (reverse subDomain ++ [domain] ++ tld') +fullDomainName :: SimplexDomain -> Text +fullDomainName SimplexDomain {nameTLD, domain, subDomain} = T.intercalate "." (reverse subDomain ++ [domain] ++ tld') where tld' = case nameTLD of TLDSimplex -> ["simplex"] @@ -117,21 +117,21 @@ fullDomainName SimplexNameDomain {nameTLD, domain, subDomain} = T.intercalate ". shortNameInfoStr :: SimplexNameInfo -> Text shortNameInfoStr = \case - SimplexNameInfo {nameType = NTPublicGroup, nameDomain = SimplexNameDomain {nameTLD = TLDSimplex, domain, subDomain = []}} -> "#" <> domain + SimplexNameInfo {nameType = NTPublicGroup, nameDomain = SimplexDomain {nameTLD = TLDSimplex, domain, subDomain = []}} -> "#" <> domain info -> pfx <> fullDomainName (nameDomain info) where pfx = case nameType info of NTPublicGroup -> "#" NTContact -> "@" -instance ToField SimplexNameInfo where toField = toField . decodeLatin1 . strEncode +instance ToField SimplexDomain where toField = toField . decodeLatin1 . strEncode -instance FromField SimplexNameInfo where fromField = fromTextField_ (eitherToMaybe . strDecode . encodeUtf8) +instance FromField SimplexDomain where fromField = fromTextField_ (eitherToMaybe . strDecode . encodeUtf8) $(J.deriveJSON (enumJSON $ dropPrefix "TLD") ''SimplexTLD) $(J.deriveJSON (enumJSON $ dropPrefix "NT") ''SimplexNameType) -$(J.deriveJSON defaultJSON ''SimplexNameDomain) +$(J.deriveJSON defaultJSON ''SimplexDomain) $(J.deriveJSON defaultJSON ''SimplexNameInfo) diff --git a/tests/AgentTests/ResolveNameTests.hs b/tests/AgentTests/ResolveNameTests.hs index 5c97c8c3a..f55faf75f 100644 --- a/tests/AgentTests/ResolveNameTests.hs +++ b/tests/AgentTests/ResolveNameTests.hs @@ -30,7 +30,7 @@ import Simplex.Messaging.Agent.Protocol (AgentErrorType (..)) import Simplex.Messaging.Client (SMPProxyFallback (..), SMPProxyMode (..), pattern NRMInteractive) import Simplex.Messaging.Protocol (SMPServer) import qualified Simplex.Messaging.Protocol as SMP -import Simplex.Messaging.SimplexName (SimplexNameDomain (..), SimplexTLD (..)) +import Simplex.Messaging.SimplexName (SimplexDomain (..), SimplexTLD (..)) import Simplex.Messaging.Transport import Test.Hspec hiding (fit, it) import Util (it) @@ -90,7 +90,7 @@ resolveNameTests = do testDirectNotFound :: HasCallStack => IO () testDirectNotFound = withDirectResolver (status404, "{}") $ \c -> do - r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexNameDomain TLDSimplex "alice" []) + r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" []) case r of Left (SMP _ (SMP.NAME SMP.NOT_FOUND)) -> pure () _ -> expectationFailure $ "expected Left (SMP _ (NAME NOT_FOUND)), got: " <> show r @@ -98,7 +98,7 @@ testDirectNotFound = testProxyNotFound :: HasCallStack => IO () testProxyNotFound = withProxyAndResolver (status404, "{}") $ \c -> do - r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexNameDomain TLDSimplex "alice" []) + r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" []) case r of Left (SMP host (SMP.NAME SMP.NOT_FOUND)) | testPort `isInfixOf` host -> pure () _ -> expectationFailure $ "expected Left (SMP testPort <> "> (NAME NOT_FOUND)), got: " <> show r @@ -106,7 +106,7 @@ testProxyNotFound = testTestingTldNotFound :: HasCallStack => IO () testTestingTldNotFound = withDirectResolver (status404, "{}") $ \c -> do - r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexNameDomain TLDTesting "bob" []) + r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDTesting "bob" []) case r of Left (SMP _ (SMP.NAME SMP.NOT_FOUND)) -> pure () _ -> expectationFailure $ "expected Left (SMP _ (NAME NOT_FOUND)), got: " <> show r @@ -114,7 +114,7 @@ testTestingTldNotFound = testWebTldNotFound :: HasCallStack => IO () testWebTldNotFound = withDirectResolver (status404, "{}") $ \c -> do - r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexNameDomain TLDWeb "example.com" []) + r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDWeb "example.com" []) case r of Left (SMP _ (SMP.NAME SMP.NOT_FOUND)) -> pure () _ -> expectationFailure $ "expected Left (SMP _ (NAME NOT_FOUND)), got: " <> show r @@ -122,7 +122,7 @@ testWebTldNotFound = testNoResolver :: HasCallStack => IO () testNoResolver = withNoResolver $ \c -> do - r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexNameDomain TLDSimplex "alice" []) + r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" []) case r of Left (SMP _ (SMP.NAME SMP.NO_RESOLVER)) -> pure () _ -> expectationFailure $ "expected Left (SMP _ (NAME NO_RESOLVER)), got: " <> show r @@ -130,7 +130,7 @@ testNoResolver = testNoNameServers :: HasCallStack => IO () testNoNameServers = withNoNameServers $ \c -> do - r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexNameDomain TLDSimplex "alice" []) + r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" []) case r of Left NO_NAME_SERVERS -> pure () _ -> expectationFailure $ "expected Left NO_NAME_SERVERS, got: " <> show r @@ -138,7 +138,7 @@ testNoNameServers = testBackendError :: HasCallStack => IO () testBackendError = withDirectResolver (status502, "{}") $ \c -> do - r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexNameDomain TLDSimplex "alice" []) + r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" []) case r of Left (SMP _ (SMP.NAME (SMP.RESOLVER _))) -> pure () _ -> expectationFailure $ "expected Left (SMP _ (NAME (RESOLVER ..))), got: " <> show r @@ -146,7 +146,7 @@ testBackendError = testDirectSuccess :: HasCallStack => IO () testDirectSuccess = withDirectResolver (status200, J.encode testNameRecord) $ \c -> do - r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexNameDomain TLDSimplex "alice" []) + r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" []) case r of Right nr -> nr `shouldBe` testNameRecord _ -> expectationFailure $ "expected Right NameRecord, got: " <> show r diff --git a/tests/RSLVTests.hs b/tests/RSLVTests.hs index 1dcec6444..2416d851e 100644 --- a/tests/RSLVTests.hs +++ b/tests/RSLVTests.hs @@ -43,13 +43,13 @@ import Simplex.Messaging.Protocol tPut, ) import qualified Simplex.Messaging.Protocol as SMP -import Simplex.Messaging.SimplexName (SimplexNameDomain) +import Simplex.Messaging.SimplexName (SimplexDomain) import Simplex.Messaging.Transport import Simplex.Messaging.Version (mkVersionRange) import Test.Hspec hiding (fit, it) import Util (it) -domain :: Text -> SimplexNameDomain +domain :: Text -> SimplexDomain domain = either error id . strDecode . encodeUtf8 withResolverServer :: (Status, LB.ByteString) -> IO a -> IO a @@ -63,7 +63,7 @@ withProxyAndResolver (st, body) runTest = withSmpServerConfigOn (transport @TLS) memProxyCfg testPort $ \_ -> withSmpServerConfigOn (transport @TLS) (withNames port memCfg2) testPort2 (const runTest) -sendRslv :: Transport c => THandleSMP c 'TClient -> B.ByteString -> SimplexNameDomain -> IO (Transmission (Either ErrorType BrokerMsg)) +sendRslv :: Transport c => THandleSMP c 'TClient -> B.ByteString -> SimplexDomain -> IO (Transmission (Either ErrorType BrokerMsg)) sendRslv h@THandle {params} corrId d = do let TransmissionForAuth {tToSend} = encodeTransmissionForAuth params (CorrId corrId, NoEntity, Cmd SResolver (RSLV d)) [Right ()] <- tPut h (Right (Nothing, tToSend) :| []) diff --git a/tests/SMPNamesTests.hs b/tests/SMPNamesTests.hs index 042e086f8..0101a40a7 100644 --- a/tests/SMPNamesTests.hs +++ b/tests/SMPNamesTests.hs @@ -27,7 +27,7 @@ import Simplex.Messaging.Server.Names resolveName, ) import Simplex.Messaging.Server.Names.HttpResolver (ResolverError (..)) -import Simplex.Messaging.SimplexName (SimplexNameDomain (..), SimplexTLD (..)) +import Simplex.Messaging.SimplexName (SimplexDomain (..), SimplexTLD (..)) import Test.Hspec testNameRecord :: NameRecord @@ -51,7 +51,7 @@ smpNamesTests :: Spec smpNamesTests = do describe "NameRecord JSON (Protocol)" nameRecordEncodingSpec describe "ErrorType NAME wire encoding" errorWireSpec - describe "Name parsing (SimplexNameDomain)" parseNameSpec + describe "Name parsing (SimplexDomain)" parseNameSpec describe "HTTP resolver" resolverSpec describe "Resolver health probe" healthSpec describe "resolver_endpoint validation" validateUrlSpec @@ -136,7 +136,7 @@ parseNameSpec = do it "accepts a label of exactly 63 bytes" $ parseN (T.replicate 63 "a" <> ".simplex") `shouldSatisfy` isRight where - parseN :: T.Text -> Either String SimplexNameDomain + parseN :: T.Text -> Either String SimplexDomain parseN = strDecode . encodeUtf8 resolverSpec :: Spec @@ -195,7 +195,7 @@ resolverSpec = do readIORef reqs `shouldReturn` [["resolve", "alice.simplex"]] where - aliceDomain = SimplexNameDomain {nameTLD = TLDSimplex, domain = "alice", subDomain = []} + aliceDomain = SimplexDomain {nameTLD = TLDSimplex, domain = "alice", subDomain = []} healthSpec :: Spec healthSpec = do diff --git a/tests/XFTPClient.hs b/tests/XFTPClient.hs index 276171e21..b306ae39c 100644 --- a/tests/XFTPClient.hs +++ b/tests/XFTPClient.hs @@ -9,7 +9,6 @@ module XFTPClient where import Control.Concurrent (ThreadId, threadDelay) -import Control.Monad (void) import Data.String (fromString) import Data.Time.Clock (getCurrentTime) import Network.Socket (ServiceName) @@ -25,6 +24,7 @@ import Simplex.Messaging.Transport.HTTP2 (httpALPN) import Simplex.Messaging.Transport.Server import Test.Hspec hiding (fit, it) #if defined(dbServerPostgres) +import Control.Monad (void) import qualified Database.PostgreSQL.Simple as PSQL import Database.PostgreSQL.Simple (ConnectInfo (..), defaultConnectInfo) import Simplex.FileTransfer.Server.Store.Postgres.Config (PostgresFileStoreCfg (..), defaultXFTPDBOpts)