Skip to content
This repository has been archived by the owner on Jul 27, 2023. It is now read-only.

Fix failing tests and run them all in travis #297

Merged
merged 8 commits into from
Jan 31, 2018
Merged

Fix failing tests and run them all in travis #297

Show file tree
Hide file tree
Changes from 7 commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
aef153d
Play all unit tests
yfouquet Jan 29, 2018
a830185
Fix CheckTest tests
yfouquet Jan 29, 2018
912e5d8
Update KeyValueTests
yfouquet Jan 30, 2018
643e3e1
Fix SessionClient tests
yfouquet Jan 30, 2018
7b8c73f
Fix ConsulCacheTest
yfouquet Jan 30, 2018
eb901f2
Fix CustomBuilderTest
yfouquet Jan 30, 2018
3a9da15
Fix ConsulCacheTest tests using DebugConfig
yfouquet Jan 29, 2018
34a9690
Adjust ConsulCacheTest
yfouquet Jan 31, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 0 additions & 5 deletions pom.xml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -255,11 +255,6 @@
<version>2.19.1</version>
</dependency>
</dependencies>
<configuration>
<includes>
<include>**/*Tests.java</include>
</includes>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
Expand Down
62 changes: 35 additions & 27 deletions src/test/java/com/orbitz/consul/KeyValueTests.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -259,17 +259,19 @@ public void acquireAndReleaseLock() throws Exception {
String key = UUID.randomUUID().toString();
String value = "session_" + UUID.randomUUID().toString();
SessionCreatedResponse response = sessionClient.createSession(ImmutableSession.builder().name(value).build());

String sessionId = response.getId();

assertTrue(keyValueClient.acquireLock(key, value, sessionId));
assertTrue(keyValueClient.acquireLock(key, value, sessionId)); // No ideas why there was an assertFalse

assertTrue("SessionId must be present.", keyValueClient.getValue(key).get().getSession().isPresent());
assertTrue(keyValueClient.releaseLock(key, sessionId));
assertFalse("SessionId in the key value should be absent.", keyValueClient.getValue(key).get().getSession().isPresent());
keyValueClient.deleteKey(key);

try {
assertTrue(keyValueClient.acquireLock(key, value, sessionId));
assertTrue(keyValueClient.acquireLock(key, value, sessionId)); // No ideas why there was an assertFalse

assertTrue("SessionId must be present.", keyValueClient.getValue(key).get().getSession().isPresent());
assertTrue(keyValueClient.releaseLock(key, sessionId));
assertFalse("SessionId in the key value should be absent.", keyValueClient.getValue(key).get().getSession().isPresent());
keyValueClient.deleteKey(key);
} finally {
sessionClient.destroySession(sessionId);
}
}

@Test
Expand All @@ -285,13 +287,15 @@ public void testGetSession() throws Exception {

String sessionValue = "session_" + UUID.randomUUID().toString();
SessionCreatedResponse response = sessionClient.createSession(ImmutableSession.builder().name(sessionValue).build());

String sessionId = response.getId();

assertTrue(keyValueClient.acquireLock(key, sessionValue, sessionId));
assertTrue(keyValueClient.acquireLock(key, sessionValue, sessionId)); // No ideas why there was an assertFalse
assertEquals(sessionId, keyValueClient.getSession(key).get());

try {
assertTrue(keyValueClient.acquireLock(key, sessionValue, sessionId));
assertTrue(keyValueClient.acquireLock(key, sessionValue, sessionId)); // No ideas why there was an assertFalse
assertEquals(sessionId, keyValueClient.getSession(key).get());
} finally {
sessionClient.destroySession(sessionId);
}
}

@Test
Expand Down Expand Up @@ -326,19 +330,23 @@ public void testAcquireLock() throws Exception {
SessionCreatedResponse response2 = sessionClient.createSession(ImmutableSession.builder().name(sessionValue).build());
String sessionId2 = response2.getId();

assertTrue(keyValueClient.acquireLock(key, sessionValue, sessionId));
// session-2 can't acquire the lock
assertFalse(keyValueClient.acquireLock(key, sessionValue2, sessionId2));
assertEquals(sessionId, keyValueClient.getSession(key).get());

keyValueClient.releaseLock(key, sessionId);

// session-2 now can acquire the lock
assertTrue(keyValueClient.acquireLock(key, sessionValue2, sessionId2));
// session-1 can't acquire the lock anymore
assertFalse(keyValueClient.acquireLock(key, sessionValue, sessionId));
assertEquals(sessionId2, keyValueClient.getSession(key).get());

try {
assertTrue(keyValueClient.acquireLock(key, sessionValue, sessionId));
// session-2 can't acquire the lock
assertFalse(keyValueClient.acquireLock(key, sessionValue2, sessionId2));
assertEquals(sessionId, keyValueClient.getSession(key).get());

keyValueClient.releaseLock(key, sessionId);

// session-2 now can acquire the lock
assertTrue(keyValueClient.acquireLock(key, sessionValue2, sessionId2));
// session-1 can't acquire the lock anymore
assertFalse(keyValueClient.acquireLock(key, sessionValue, sessionId));
assertEquals(sessionId2, keyValueClient.getSession(key).get());
} finally {
sessionClient.destroySession(sessionId);
sessionClient.destroySession(sessionId2);
}
}

@Test
Expand Down
142 changes: 112 additions & 30 deletions src/test/java/com/orbitz/consul/SessionClientTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,6 +4,7 @@
import com.orbitz.consul.model.session.Session;
import com.orbitz.consul.model.session.SessionCreatedResponse;
import com.orbitz.consul.model.session.SessionInfo;
import org.junit.Before;
import org.junit.Test;

import java.util.List;
Expand All @@ -16,71 +17,152 @@

public class SessionClientTest extends BaseIntegrationTest {

private KeyValueClient keyValueClient;
private SessionClient sessionClient;

@Before
public void setUp() {
keyValueClient = client.keyValueClient();
sessionClient = client.sessionClient();
}

@Test
public void testCreateAndDestroySession() throws Exception {
SessionClient sessionClient = client.sessionClient();
final Session value = ImmutableSession.builder().name("session_" + UUID.randomUUID().toString()).build();

SessionCreatedResponse session = sessionClient.createSession(value);

assertNotNull(session);

sessionClient.destroySession(session.getId());
}

@Test
public void testCreateEmptySession() throws Exception {
SessionClient sessionClient = client.sessionClient();
SessionCreatedResponse session = sessionClient.createSession(ImmutableSession.builder().build());

assertNotNull(session);
sessionClient.destroySession(session.getId());
}

@Test(expected = ConsulException.class)
@Test
public void testRenewSession() throws Exception {
SessionClient sessionClient = client.sessionClient();
final Session value = ImmutableSession.builder().name("session_" + UUID.randomUUID().toString()).build();

SessionCreatedResponse session = sessionClient.createSession(value);

assertNotNull(session);

SessionInfo info = sessionClient.renewSession(session.getId()).get();
try {
SessionInfo info = sessionClient.renewSession(session.getId()).get();
assertEquals(session.getId(), info.getId());
} finally {
sessionClient.destroySession(session.getId());
}

assertEquals(session.getId(), info.getId());
}

@Test
public void testGetSessionInfo() throws Exception {
KeyValueClient keyValueClient = client.keyValueClient();
SessionClient sessionClient = client.sessionClient();
public void testAcquireLock() {
String key = UUID.randomUUID().toString();

final Session value = ImmutableSession.builder().name("session_" + UUID.randomUUID().toString()).build();
Session value = ImmutableSession.builder().name("session_" + UUID.randomUUID().toString()).build();
String sessionId = sessionClient.createSession(value).getId();
String valueName = value.getName().get();

try {
assertTrue("Should succeed to acquire a lock",
keyValueClient.acquireLock(key, valueName, sessionId));
assertEquals(sessionId, keyValueClient.getSession(key).get());
} finally {
keyValueClient.releaseLock(key, sessionId);
keyValueClient.deleteKey(key);
sessionClient.destroySession(sessionId);
}
}

assertTrue(keyValueClient.acquireLock(key, value.getName().get(), sessionId));
assertFalse(keyValueClient.acquireLock(key, value.getName().get(), sessionId));
assertEquals(sessionId, keyValueClient.getSession(key).get());
@Test
public void testAcquireLockTwiceFromSameSession() {
String key = UUID.randomUUID().toString();

SessionInfo sessionInfo = sessionClient.getSessionInfo(sessionId).orElse(null);
assertNotNull(sessionInfo);
assertEquals(sessionId, sessionInfo.getId());
Session value = ImmutableSession.builder().name("session_" + UUID.randomUUID().toString()).build();
String sessionId = sessionClient.createSession(value).getId();
String valueName = value.getName().get();

try {
assertTrue("Should succeed to acquire a lock - first time",
keyValueClient.acquireLock(key, valueName, sessionId));
assertTrue("Should succeed to acquire a lock - second time",
keyValueClient.acquireLock(key, valueName, sessionId));
assertEquals(sessionId, keyValueClient.getSession(key).get());
} finally {
keyValueClient.releaseLock(key, sessionId);
keyValueClient.deleteKey(key);
sessionClient.destroySession(sessionId);
}
}

@Test
public void testListSessions() throws Exception {
KeyValueClient keyValueClient = client.keyValueClient();
SessionClient sessionClient = client.sessionClient();
public void testAcquireLockTwiceFromDifferentSessions() {
String key = UUID.randomUUID().toString();

final Session value = ImmutableSession.builder().name("session_" + UUID.randomUUID().toString()).build();
Session firstSessionValue = ImmutableSession.builder().name("session_" + UUID.randomUUID().toString()).build();
String firstSessionId = sessionClient.createSession(firstSessionValue).getId();
String firstSessionValueContent = firstSessionValue.getName().get();

Session secondSessionValue = ImmutableSession.builder().name("session_" + UUID.randomUUID().toString()).build();
String secondSessionId = sessionClient.createSession(secondSessionValue).getId();
String secondSessionValueNameContent = secondSessionValue.getName().get();

try {
assertTrue("Should succeed to acquire a lock - first session",
keyValueClient.acquireLock(key, firstSessionValueContent, firstSessionId));
assertFalse("Should fail to acquire a lock - second session",
keyValueClient.acquireLock(key, secondSessionValueNameContent, secondSessionId));

assertEquals(firstSessionId, keyValueClient.getSession(key).get());
} finally {
keyValueClient.releaseLock(key, firstSessionId);
keyValueClient.deleteKey(key);
sessionClient.destroySession(firstSessionId);
sessionClient.destroySession(secondSessionId);
}
}

@Test
public void testGetSessionInfo() throws Exception {
String key = UUID.randomUUID().toString();

Session value = ImmutableSession.builder().name("session_" + UUID.randomUUID().toString()).build();
String sessionId = sessionClient.createSession(value).getId();
String valueName = value.getName().get();

try {
assertTrue("Should succeed to acquire a lock",
keyValueClient.acquireLock(key, valueName, sessionId));

SessionInfo sessionInfo = sessionClient.getSessionInfo(sessionId).orElse(null);
assertNotNull(sessionInfo);
assertEquals(sessionId, sessionInfo.getId());
} finally {
keyValueClient.releaseLock(key, sessionId);
keyValueClient.deleteKey(key);
sessionClient.destroySession(sessionId);
}
}

assertTrue(keyValueClient.acquireLock(key, value.getName().get(), sessionId));
assertFalse(keyValueClient.acquireLock(key, value.getName().get(), sessionId));
assertEquals(sessionId, keyValueClient.getSession(key).get());
@Test
public void testListSessions() throws Exception {
String key = UUID.randomUUID().toString();

Session value = ImmutableSession.builder().name("session_" + UUID.randomUUID().toString()).build();
String sessionId = sessionClient.createSession(value).getId();

List<SessionInfo> result = sessionClient.listSessions();
try {
assertTrue(keyValueClient.acquireLock(key, value.getName().get(), sessionId));
List<SessionInfo> result = sessionClient.listSessions();

assertEquals(sessionId, result.get(0).getId());
assertTrue(result.stream().anyMatch(sessionInfo -> sessionId.equals(sessionInfo.getId())));
} finally {
keyValueClient.releaseLock(key, sessionId);
keyValueClient.deleteKey(key);
sessionClient.destroySession(sessionId);
}
}
}
}
Loading