I have a script testing websocket messages and even if my test is passed katalon dipslay it as done and when i execute the test suite the status i the report is incomplete.
import org.java_websocket.client.WebSocketClient
import org.java_websocket.handshake.ServerHandshake
import java.net.URI
import groovy.json.JsonSlurper
import internal.GlobalVariable
import groovy.json.JsonOutput
import com.kms.katalon.core.util.KeywordUtil
import com.kms.katalon.core.testdata.TestDataFactory
class MyWebSocketClient extends WebSocketClient {
MyWebSocketClient(URI serverUri) {
super(serverUri) // Ajouter les headers (dont le cookie)
println ('serverUri : '+ serverUri)
}
@Override
void onOpen(ServerHandshake handshakedata) {
println ("Connexion ouverte ")
// Envoyer la requête WebSocket après la connexion
String handShake = '''
{
"protocol": "json",
"version": 1
}
'''.stripIndent().trim() + "\u001E" // Ajouter le caractère de fin de message WebSocket (0x1E)
this.send(handShake)
println "handShake envoyée : $handShake"
String request = '''
{
"protocol": "json",
"version": 1,
"arguments": [{
"debug": true
}],
"invocationId": "0",
"target": "ListFunctions",
"type": 1
}
'''.stripIndent().trim() + "\u001E" // Ajouter le caractère de fin de message WebSocket (0x1E)
this.send(request)
println "Requête listFunctions envoyée : $request"
Thread.sleep(1000)
}
@Override
void onMessage(String message) {
println "Message reçu : " + message
def jsonSlurper = new JsonSlurper()
def response = jsonSlurper.parseText(message)
if (response.type == 1) {
validateResponse(message) // Exécuter la validation uniquement pour type = 1
} else {
println "Message ignoré (type ${response.type})"
}
}
@Override
void onClose(int code, String reason, boolean remote) {
println "Connexion fermée : Code=$code, Raison=${reason ?: 'Aucune raison fournie'}, Fermeture initiée par " + (remote ? "le serveur" : "le client")
}
@Override
void onError(Exception ex) {
println "Erreur : ${ex.message}"
}
void validateResponse(String message) {
def jsonSlurper = new JsonSlurper()
def response = jsonSlurper.parseText(message) // Désérialisation de la réponse JSON
// Chargement des modèles attendus depuis le Data File
def testData = TestDataFactory.findTestData('Data Files/ListFunctions')
def expectedFunctionsMap = [:]
for (int i = 1; i <= testData.getRowNumbers(); i++) {
expectedFunctionsMap[testData.getValue('functionName', i)] = [
functionName: testData.getValue('functionName', i),
description: testData.getValue('description', i),
parameters: testData.getValue('parameters', i)
]
}
def errors = [] // Liste pour stocker les erreurs
if (response.type == 1) {
response.arguments[0].functions.each { function ->
def validationResult = validateFunction(function, expectedFunctionsMap[function.functionName])
if (validationResult) {
errors << validationResult
}
}
if (errors.isEmpty()) {
KeywordUtil.markPassed("All functions are returned correctly")
} else {
KeywordUtil.markFailed("Test failed: ${errors.size()} error(s) detected:\n- " + errors.join("\n- "))
}
}
}
// Fonction de validation d'une function
String validateFunction(function, expectedFunction) {
println ("name : "+ function.functionName)
if (!expectedFunction) {
return "Function inattendu : ${function.functionName}"
}
if (function.functionName != expectedFunction.functionName) {
return "functionName incorrect pour ${function.functionName} : attendu '${expectedFunction.functionName}', reçu '${function.functionName}'"
}
if (function.description.replace("\n", " ").trim() != expectedFunction.description.trim()) {
return "description incorrect pour ${function.functionName} : attendu '${expectedFunction.description.trim()}', reçu '${function.description.trim()}'"
}
// Désérialisation de expectedModel.parameters s'il est stocké sous forme de String
def expectedParameters = expectedFunction.parameters instanceof String ?
new JsonSlurper().parseText(expectedFunction.parameters) : expectedFunction.parameters
// Vérification après transformation en JSON standardisé
if (JsonOutput.toJson(function.parameters) != JsonOutput.toJson(expectedParameters)) {
return "parameters incorrect pour ${function.functionName} : attendu '${JsonOutput.toJson(expectedParameters)}', reçu '${JsonOutput.toJson(function.parameters)}'"
}
return null // Pas d'erreur
}
}
// URL du serveur WebSocket
def serverUri = new URI(GlobalVariable.ws_URI + 'endpoints/v1/assistant')
// Créer une instance du client WebSocket
def client = new MyWebSocketClient(serverUri)
// Connecter au serveur WebSocket
client.connect()
// Attendre que la connexion soit Ă©tablie
while (!client.isOpen()) {
println "En attente de l'ouverture de la connexion..."
Thread.sleep(300)
}
// Attendre un moment pour recevoir des messages
Thread.sleep(5000)
// Fermer la connexion
client.close()
