package org.lttng.ust.agent.integration.client;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
import org.lttng.tools.ILttngSession;
import org.lttng.tools.LttngToolsHelper;
import org.lttng.ust.agent.ILttngAgent;
import org.lttng.ust.agent.session.LogLevelSelector.LogLevelType;
import org.lttng.ust.agent.utils.EventRuleFactory;
import org.lttng.ust.agent.utils.ILogLevelStrings;
-import org.lttng.ust.agent.utils.TestPrintRunner;
+import org.lttng.ust.agent.utils.TestPrintExtension;
/**
* Tests for the TCP client only, without using an agent.
*
* @author Alexandre Montplaisir
*/
-@RunWith(TestPrintRunner.class)
+@ExtendWith(TestPrintExtension.class)
public class TcpClientIT {
// ------------------------------------------------------------------------
/* Test configuration */
private static final int DOMAIN_VALUE = ILttngAgent.Domain.JUL.value();
private static final ILttngSession.Domain SESSION_DOMAIN = ILttngSession.Domain.JUL;
- private static final boolean ROOT_SESSIOND = true;
private static TcpClientDebugListener clientListener;
private static LttngTcpSessiondClient client;
private static Thread clientThread;
+ private static EventRuleFactory eventRuleFactory = new EventRuleFactory(SESSION_DOMAIN);
+
private ILttngSession session;
// ------------------------------------------------------------------------
/**
* Class setup
*/
- @BeforeClass
+ @BeforeAll
public static void setupClass() {
LttngToolsHelper.destroyAllSessions();
clientListener = new TcpClientDebugListener();
- client = new LttngTcpSessiondClient(clientListener, DOMAIN_VALUE, ROOT_SESSIOND);
+ /* Try connecting to a root sessiond first */
+ client = new LttngTcpSessiondClient(clientListener, DOMAIN_VALUE, true);
+ clientThread = new Thread(client);
+ clientThread.start();
+
+ if (client.waitForConnection(5)) {
+ return;
+ }
+
+ /* Connection was not established, try a user sessiond instead */
+ client.close();
+ try {
+ clientThread.join();
+ } catch (InterruptedException e) {
+ fail(e.getMessage());
+ }
+
+ client = new LttngTcpSessiondClient(clientListener, DOMAIN_VALUE, false);
clientThread = new Thread(client);
clientThread.start();
- assumeTrue("Timed out waiting for root sessiond", client.waitForConnection(5));
+ assertTrue(client.waitForConnection(5), "Timed out waiting for a sessiond");
}
/**
* Class teardown
*/
- @AfterClass
+ @AfterAll
public static void teardownClass() {
if (client != null) {
client.close();
/**
* Test setup
*/
- @Before
+ @BeforeEach
public void setup() {
session = ILttngSession.createSession(null, SESSION_DOMAIN);
clientListener.clearAllCommands();
/**
* Test teardown
*/
- @After
+ @AfterEach
public void teardown() {
session.close();
}
session.enableEvent(EVENT_NAME_A, null, false, null);
List<EventRule> expectedCommands = Collections.singletonList(
- EventRuleFactory.createRule(EVENT_NAME_A));
+ eventRuleFactory.createRule(EVENT_NAME_A));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.enableAllEvents();
List<EventRule> expectedCommands = Collections.singletonList(
- EventRuleFactory.createRuleAllEvents());
+ eventRuleFactory.createRuleAllEvents());
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.disableEvents(EVENT_NAME_A);
List<EventRule> expectedEnableCommands = Collections.singletonList(
- EventRuleFactory.createRule(EVENT_NAME_A));
+ eventRuleFactory.createRule(EVENT_NAME_A));
List<String> expectedDisableCommands = Collections.singletonList(EVENT_NAME_A);
assertEquals(expectedEnableCommands, clientListener.getEnabledEventCommands());
session.disableAllEvents();
List<EventRule> expectedEnableCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A),
- EventRuleFactory.createRule(EVENT_NAME_B),
- EventRuleFactory.createRule(EVENT_NAME_C));
+ eventRuleFactory.createRule(EVENT_NAME_A),
+ eventRuleFactory.createRule(EVENT_NAME_B),
+ eventRuleFactory.createRule(EVENT_NAME_C));
/*
* A "disable-event -a" will send one command for each enabled event.
* The order may be different though.
session.enableAllEvents();
session.disableAllEvents();
- List<EventRule> expectedEnableCommands = Arrays.asList(EventRuleFactory.createRuleAllEvents());
+ List<EventRule> expectedEnableCommands = Arrays.asList(eventRuleFactory.createRuleAllEvents());
List<String> expectedDisableCommands = Arrays.asList(EventRuleFactory.EVENT_NAME_ALL);
assertEquals(expectedEnableCommands, clientListener.getEnabledEventCommands());
session2.enableEvent(EVENT_NAME_B, null, false, null);
} // close(), aka destroy the session, sending "disable event" messages
- List<EventRule> expectedEnabledCommands = Arrays.asList(EventRuleFactory.createRule(EVENT_NAME_A), EventRuleFactory.createRule(EVENT_NAME_B));
+ List<EventRule> expectedEnabledCommands = Arrays.asList(eventRuleFactory.createRule(EVENT_NAME_A), eventRuleFactory.createRule(EVENT_NAME_B));
List<String> expectedDisabledCommands = Arrays.asList(EVENT_NAME_A, EVENT_NAME_B);
assertEquals(expectedEnabledCommands, clientListener.getEnabledEventCommands());
session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, null);
List<EventRule> expectedCommands = Collections.singletonList(
- EventRuleFactory.createRule(EVENT_NAME_A, lls));
+ eventRuleFactory.createRule(EVENT_NAME_A, lls));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), true, null);
List<EventRule> expectedCommands = Collections.singletonList(
- EventRuleFactory.createRule(EVENT_NAME_A, lls));
+ eventRuleFactory.createRule(EVENT_NAME_A, lls));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), true, null);
List<EventRule> expectedCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A, lls1),
- EventRuleFactory.createRule(EVENT_NAME_A, lls2)
+ eventRuleFactory.createRule(EVENT_NAME_A, lls1),
+ eventRuleFactory.createRule(EVENT_NAME_A, lls2)
);
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, null);
List<EventRule> expectedCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A, lls1),
- EventRuleFactory.createRule(EVENT_NAME_A, lls2)
+ eventRuleFactory.createRule(EVENT_NAME_A, lls1),
+ eventRuleFactory.createRule(EVENT_NAME_A, lls2)
);
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
session2.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), true, null);
List<EventRule> expectedCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A, lls1),
- EventRuleFactory.createRule(EVENT_NAME_A, lls2));
+ eventRuleFactory.createRule(EVENT_NAME_A, lls1),
+ eventRuleFactory.createRule(EVENT_NAME_A, lls2));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.enableEvent(EVENT_NAME_A, null, false, filter2);
List<EventRule> expectedCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A),
- EventRuleFactory.createRule(EVENT_NAME_A, EventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter1),
- EventRuleFactory.createRule(EVENT_NAME_A, EventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter2));
+ eventRuleFactory.createRule(EVENT_NAME_A),
+ eventRuleFactory.createRule(EVENT_NAME_A, eventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter1),
+ eventRuleFactory.createRule(EVENT_NAME_A, eventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter2));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, filter);
List<EventRule> expectedCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A),
- EventRuleFactory.createRule(EVENT_NAME_A, lls),
- EventRuleFactory.createRule(EVENT_NAME_A, EventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter),
- EventRuleFactory.createRule(EVENT_NAME_A, lls, filter));
+ eventRuleFactory.createRule(EVENT_NAME_A),
+ eventRuleFactory.createRule(EVENT_NAME_A, lls),
+ eventRuleFactory.createRule(EVENT_NAME_A, eventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter),
+ eventRuleFactory.createRule(EVENT_NAME_A, lls, filter));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);