Вступление
Всем привет. Меня зовут Ирек, и я в профессиональном IT с 2012 года. Прошел путь от специалиста службы поддержки до разработчика. На данный момент занимаюсь автоматизацией тестирования в компании РТК ИТ.
В статье хочу рассказать о своём опыте автоматизации тестирования websocket. О том какие грабли собрал и какой в итоге велосипед изобрёл.
На один из проектов разрабы завезли websoket и нужно было автоматизировать процесс тестирования. Бэк написан на Spring, фронт на React и оба они успешно используют библиотеку SockJS на которой и построена вся функциональность связанная с ws.
Автотесты мы пишем на нативной Java без использования Spring в отдельном от основного проекта репозитории.
Первое знакомство
Так получилось, что раньше эта тема меня обходила стороной. Поэтому для таких же как я постараюсь дать краткую вводную.
WebSocket — протокол связи поверх TCP-соединения, предназначенный для обмена сообщениями между браузером и веб-сервером, используя постоянное соединение.
Чуть подробнее вот тут.
STOMP (Simple Text Oriented Messaging Protocol) - текстово-ориентированный протокол, который может работать поверх websocket. Дело в том, что сам ws не определяет содержимое сообщений обмена и для согласованности принято использовать суб-протоколы.
Про STOMP понятно написано вот тут.
SockJS — это JavaScript библиотека, которая обеспечивает двусторонний междоменный канал связи между клиентом и сервером.
Про SockJS и как он работает в связке Spring, есть хорошая статья на хабре.
Как это выглядит в браузере
Открываем страничку, где используются ws.
Идем в DevTools или нажимаем F12, переходим во вкладку Network.
После ищем запрос со статусом 101.
Далее в самом запросе можно посмотреть на сообщения.
Ответы от сервера имеют определенные префиксы. На скрине они хорошо видны.
Из статьи приведенной выше мы узнаем, что для поддержания совместимости с Websocket Api SockJS использует кастомный протокол обмена сообщениями:
o — (open frame) отправляется каждый раз при открытии новой сессии.
c — (close frame) отправляется когда клиент запрашивает закрытие соединения.
h — (heartbeat frame) проверка доступности соединения.
a — (data frame) Массив json сообщений. К примеру: a["message"].
SockJS для тестирования
Если у нас на бэке и на фронте используется SockJS, то логично поискать и для тестирования подобную библиотеку.
На страничке в Github SockJS мы узнаем, что для Java существует клиент внутри Spring Framework, Atmosphere Framework и некая библиотека vert.x.
Потратил кучу времени на vert.x, но так и не смог заставить ее работать.
Решение №1. Нативный
Мы построим свой SockJS с асинхронкой и тестировщицами.
Немного покопался и нашел замечательное видео с которого и начал погружаться в ws. Сначала повторил все вслед за спикером и тестовым примером, а потом пробовал адаптировать под себя. Получилось не сразу, но всё же заработало.
Описание класса клиента будет выглядеть следующим образом
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.drafts.Draft;
import org.java_websocket.handshake.ServerHandshake;
import java.net.URI;
import java.nio.ByteBuffer;
public class Client extends WebSocketClient {
public Client(URI serverUri, Draft draft) {
super(serverUri, draft);
}
public Client(URI serverURI) {
super(serverURI);
}
@Override
public void onOpen(ServerHandshake handshakedata) {
System.out.println("new connection is opened");
}
@Override
public void onClose(int code, String reason, boolean remote) {
System.out.println("closed with exit code " + code + " additional info: " + reason);
}
@Override
public void onMessage(String message) {
System.out.println("received <- " + message);
}
@Override
public void onMessage(ByteBuffer message) {
System.out.println("received ByteBuffer");
}
@Override
public void onError(Exception ex) {
System.err.println("an error occurred:" + ex);
}
@Override
public void send(String text) {
System.out.println("send -> " + text);
super.send(text);
}
}Вариант использования будет таким
// Создаем экземпляр клиента
WebSocketClient ws = new Client(new URI("wss://myhost.rt.ru/websocket/tracker/666/autotest/websocket"));
// Подключаемся к хосту
ws.connectBlocking();
// Отправляем сообщение о подключении
ws.send("[\"CONNECT\\naccept-version:1.2,1.1,1.0\\nheart-beat:10000,10000\\n\\n\\u0000\"]");
sleep(2000);
// Подписываемся на редактирование заголовка
ws.send("[\"SUBSCRIBE\\nid:23051/title/edit\\ndestination:/topic/articles/23051/title/edit\\n\\n\\u0000\"]");
sleep(2000);
// Отправляем сообщение с новым заголовком статьи
ws.send("[\"SEND\\ndestination:/kernel/articles/23051/title/edit\\ncontent-length:22\\n\\n{\\\"title\\\":\\\"Hello Habr\\\"}\\u0000\"]");
sleep(2000);Соответственно в выводе увидим следующее
new connection is opened
send -> ["CONNECT\naccept-version:1.2,1.1,1.0\nheart-beat:10000,10000\n\n\u0000"]
received <- o
received <- a["CONNECTED\nversion:1.2\nheart-beat:0,0\n\n\u0000"]
send -> ["SUBSCRIBE\nid:23051/title/edit\ndestination:/topic/articles/23051/title/edit\n\n\u0000"]
send -> ["SEND\ndestination:/kernel/articles/23051/title/edit\ncontent-length:22\n\n{\"title\":\"Hello Habr\"}\u0000"]
received <- a["MESSAGE\ndestination:/topic/articles/23051/title/edit\ncontent-type:application/json\nsubscription:23051/title/edit\nmessage-id:autotest-79\ncontent-length:22\n\n{\"title\":\"Hello Habr\"}\u0000"]
received <- hНемного про то откуда берется странная ссылка wss://myhost.rt.ru/websocket/tracker/666/autotest/websocket
Дело в том, что SockJs для формирования ссылки использует следующий шаблон wss://host:port/myApp/myEndpoint/{server-id}/{session-id}/{transport}
где
{server-id} — случайный параметр от 000 до 999, единственное назначение которого упростить балансировку на серверной стороне.
{session-id} — сопоставляет HTTP-запросы, принадлежащие сессии SockJs.
{transport} — указывает на транспортный протокол «websocket», «xhr-streaming», и т.д.
Поэтому в качестве server-id решили выбрать счастливое число 666, а в качестве session-id указали autotest вместо рандомного id, чтобы легче следить по логам.
Решение №2. Тащим Spring к себе в тесты
Сначала я очень сопротивлялся, но теперь думаю что зря.
Решение будет немного лаконичнее за счет еще одного уровня абстракции.
Для начала нужно определить класс управления сессией
import org.springframework.messaging.simp.stomp.StompHeaders;
import org.springframework.messaging.simp.stomp.StompSession;
import org.springframework.messaging.simp.stomp.StompSessionHandlerAdapter;
public class StompSessionHandler extends StompSessionHandlerAdapter {
// Описываем действия с подключением к вебсокету
@Override
public void afterConnected(StompSession session, StompHeaders connectedHeaders) {
// Выводим в консоль, что подключение есть
System.out.println("new connection is opened");
}
}Далее описываем хендлер для STOMP фреймов
import org.springframework.messaging.simp.stomp.StompFrameHandler;
import org.springframework.messaging.simp.stomp.StompHeaders;
import java.lang.reflect.Type;
import java.util.Map;
import java.util.Queue;
public class CustomStompFrameHandler implements StompFrameHandler {
Queue<Map<String, Object>> queue;
public CustomStompFrameHandler(Queue<Map<String, Object>> queue) {
this.queue = queue;
}
@Override
public Type getPayloadType(StompHeaders headers) {
// WS запрашивает у нас тип для Payload
return Map.class;
}
@Override
@SuppressWarnings("unchecked")
public void handleFrame(StompHeaders headers, Object payload) {
// Получен ответ от WS
if (payload != null) {
// Выведем ответ в консоль для отладки
System.out.println("received <- " + payload);
System.out.println(" headers:");
for (String key : headers.keySet()) {
System.out.println(" " + key + ":" + headers.get(key));
}
}
if (payload instanceof Map) {
queue.add((Map<String, Object>) payload);
}
}
}Теперь у нас есть всё, чтобы написать клиент
import org.json.JSONObject;
import org.springframework.messaging.converter.MappingJackson2MessageConverter;
import org.springframework.messaging.simp.stomp.StompSession;
import org.springframework.web.socket.client.standard.StandardWebSocketClient;
import org.springframework.web.socket.messaging.WebSocketStompClient;
import org.springframework.web.socket.sockjs.client.SockJsClient;
import org.springframework.web.socket.sockjs.client.WebSocketTransport;
import java.util.Collections;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await;
public class Client {
private static final String TOPIC = "/topic";
private static final String KERNEL = "/kernel";
private WebSocketStompClient stompClient;
private StompSession session = null;
private Queue<Map<String, Object>> queue = new ConcurrentLinkedQueue<>();
private String websocketURI;
public Client(String websocketURI) {
this.websocketURI = websocketURI;
stompClient = new WebSocketStompClient(new SockJsClient(
Collections.singletonList(new WebSocketTransport(new StandardWebSocketClient()))));
stompClient.setMessageConverter(new MappingJackson2MessageConverter());
}
public void connect() {
try {
session = stompClient.connectAsync(
websocketURI,
new StompSessionHandler())
.get(1, SECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
throw new RuntimeException(e);
}
}
public void disconnect() {
if (session.isConnected()) {
session.disconnect();
}
}
public void subscribe(String destination, String id) {
if (!session.isConnected()) {
connect();
}
session.subscribe(destination.formatted(TOPIC, id),
new CustomStompFrameHandler(queue));
}
public void send(String destination, JSONObject json, String id) {
if (!session.isConnected()) {
connect();
}
Map<String, Object> payload = json.toMap();
System.out.println("send -> " + payload);
session.send(destination.formatted(KERNEL, id), payload);
await().atMost(1, SECONDS)
.untilAsserted(() -> assertThat(queue).contains(payload));
}
}Вариант использования будет таким
// Создаем экземпляр клиента
Client ws = new Client("wss://myhost.rt.ru/websocket/tracker");
// Подключаемся к хосту
ws.connect();
// Подписываемся на редактирование заголовка статьи
ws.subscribe("%s/articles/%s/title/edit", "23051");
// Отправляем сообщение с новым заголовком статьи
ws.send("%s/articles/%s/title/edit",
new JSONObject().put("title", "Hello Habr"),
"23051");Вывод будет следующим
new connection is opened
send -> {title=Hello Habr}
received <- {title=Hello Habr}
headers:
destination:[/topic/articles/23051/title/edit]
content-type:[application/json]
subscription:[0]
message-id:[6fe34d3531c14e3d8289168fcf0f6488-111]
content-length:[22]А если нужна нагрузка?
Для нагрузочных тестов использовал Gatling. Это было первое знакомство, поэтому мог нагородить лишнего. Если что поправьте в комментариях.
import io.gatling.http.Predef._
import io.gatling.core.Predef._
import io.gatling.core.structure.ChainBuilder
object ArticleCase {
val subscribeTitle = "[\"SUBSCRIBE\\nid:173920/title/edit\\ndestination:/topic/articles/173920/title/edit\\n\\n\\u0000\"]"
val sendTextTitle = "[\"SEND\\ndestination:/kernel/articles/173920/block/edit\\ncontent-length:170\\n\\n{\\\"blockId\\\":\\\"a5fb646f-8386-42bc-8070-1d40d135fc02\\\",\\\"currentUser\\\":\\\"80bc7774-e00a-4455-85dd-527499c5012a\\\",\\\"payload\\\":{\\\"type\\\":\\\"ROOT\\\",\\\"title\\\":\\\"WebSocket Load Testing is WORK\\\"}}\\u0000\"]"
val updateArticleTitle: ChainBuilder = exec(
ws("Подключение к Websocket").connect("/websocket/tracker/666/autotest/websocket"),
pause(2),
ws("Подписка на события заголовка").sendText(subscribeTitle),
pause(1),
ws("Отправка сообщения с новым заголовком").sendText(sendTextTitle),
pause(2),
ws("Закрытие канала Websocket").close
)
}Подведем итоги
На этом всё. Надеюсь кто-то найдет себе что-то новое, а кто-то сэкономит немножко времени, когда столкнётся с подобным случаем на практике.
В целом работа с ws довольно приятная и интересная, особенно в череде однотипных задач по автоматизации rest api.
Еще немного полезных ссылок, если нужно чуть глубже погрузиться: