Spring/spring-boot
Spring/spring-boot
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-boot.git synced 2024-08-29 03:06:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Use AssertJ in spring-boot-devtools

Browse Source 
See gh-5083
This commit is contained in:
Phillip Webb 2016-02-06 14:52:48 -08:00
parent 94677b35f8
commit 7f9358f4d8
51 changed files with 359 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/RemoteUrlPropertyExtractorTests.java
View File

@ -27,10 +27,7 @@ import org.springframework.boot.SpringApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Configuration;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link RemoteUrlPropertyExtractor}.
@ -73,17 +70,17 @@ public class RemoteUrlPropertyExtractorTests {
@Test
public void validUrl() throws Exception {
ApplicationContext context = doTest("http://localhost:8080");
assertThat(context.getEnvironment().getProperty("remoteUrl"),
equalTo("http://localhost:8080"));
assertThat(context.getEnvironment().getProperty("spring.thymeleaf.cache"),
is(nullValue()));
assertThat(context.getEnvironment().getProperty("remoteUrl"))
.isEqualTo("http://localhost:8080");
assertThat(context.getEnvironment().getProperty("spring.thymeleaf.cache"))
.isNull();
}
@Test
public void cleanValidUrl() throws Exception {
ApplicationContext context = doTest("http://localhost:8080/");
assertThat(context.getEnvironment().getProperty("remoteUrl"),
equalTo("http://localhost:8080"));
assertThat(context.getEnvironment().getProperty("remoteUrl"))
.isEqualTo("http://localhost:8080");
}
private ApplicationContext doTest(String... args) {

17
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/autoconfigure/DevToolsPropertiesTests.java
View File

@ -18,8 +18,7 @@ package org.springframework.boot.devtools.autoconfigure;
import org.junit.Test;
import static org.hamcrest.Matchers.arrayContaining;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link DevToolsProperties}.
@ -34,11 +33,10 @@ public class DevToolsPropertiesTests {
public void additionalExcludeKeepsDefaults() {
DevToolsProperties.Restart restart = this.devToolsProperties.getRestart();
restart.setAdditionalExclude("foo/**,bar/**");
assertThat(restart.getAllExclude(),
arrayContaining("META-INF/maven/**", "META-INF/resources/**",
"resources/**", "static/**", "public/**", "templates/**",
"**/*Test.class", "**/*Tests.class", "git.properties", "foo/**",
"bar/**"));
assertThat(restart.getAllExclude()).containsOnly("META-INF/maven/**",
"META-INF/resources/**", "resources/**", "static/**", "public/**",
"templates/**", "**/*Test.class", "**/*Tests.class", "git.properties",
"foo/**", "bar/**");
}
@Test
@ -46,7 +44,7 @@ public class DevToolsPropertiesTests {
DevToolsProperties.Restart restart = this.devToolsProperties.getRestart();
restart.setExclude("");
restart.setAdditionalExclude("foo/**,bar/**");
assertThat(restart.getAllExclude(), arrayContaining("foo/**", "bar/**"));
assertThat(restart.getAllExclude()).containsOnly("foo/**", "bar/**");
}
@Test
@ -54,8 +52,7 @@ public class DevToolsPropertiesTests {
DevToolsProperties.Restart restart = this.devToolsProperties.getRestart();
restart.setExclude("biz/**");
restart.setAdditionalExclude("foo/**,bar/**");
assertThat(restart.getAllExclude(),
arrayContaining("biz/**", "foo/**", "bar/**"));
assertThat(restart.getAllExclude()).containsOnly("biz/**", "foo/**", "bar/**");
}
}

43
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/autoconfigure/LocalDevToolsAutoConfigurationTests.java Executable file → Normal file
View File

@ -51,12 +51,7 @@ import org.springframework.session.ExpiringSession;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.util.SocketUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.hasKey;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
@ -94,7 +89,7 @@ public class LocalDevToolsAutoConfigurationTests {
this.context = initializeAndRun(Config.class);
TemplateResolver resolver = this.context.getBean(TemplateResolver.class);
resolver.initialize();
assertThat(resolver.isCacheable(), equalTo(false));
assertThat(resolver.isCacheable()).isFalse();
}
@Test
@ -102,7 +97,7 @@ public class LocalDevToolsAutoConfigurationTests {
this.context = initializeAndRun(Config.class, "--spring.thymeleaf.cache=true");
TemplateResolver resolver = this.context.getBean(TemplateResolver.class);
resolver.initialize();
assertThat(resolver.isCacheable(), equalTo(true));
assertThat(resolver.isCacheable()).isTrue();
}
@Test
@ -114,7 +109,7 @@ public class LocalDevToolsAutoConfigurationTests {
this.context = initializeAndRun(Config.class);
TemplateResolver resolver = this.context.getBean(TemplateResolver.class);
resolver.initialize();
assertThat(resolver.isCacheable(), equalTo(true));
assertThat(resolver.isCacheable()).isTrue();
}
finally {
System.setProperty("user.home", userHome);
@ -125,14 +120,14 @@ public class LocalDevToolsAutoConfigurationTests {
public void resourceCachePeriodIsZero() throws Exception {
this.context = initializeAndRun(WebResourcesConfig.class);
ResourceProperties properties = this.context.getBean(ResourceProperties.class);
assertThat(properties.getCachePeriod(), equalTo(0));
assertThat(properties.getCachePeriod()).isEqualTo(0);
}
@Test
public void liveReloadServer() throws Exception {
this.context = initializeAndRun(Config.class);
LiveReloadServer server = this.context.getBean(LiveReloadServer.class);
assertThat(server.isStarted(), equalTo(true));
assertThat(server.isStarted()).isTrue();
}
@Test
@ -198,7 +193,7 @@ public class LocalDevToolsAutoConfigurationTests {
this.context = initializeAndRun(Config.class);
ClassPathFileSystemWatcher watcher = this.context
.getBean(ClassPathFileSystemWatcher.class);
assertThat(watcher, notNullValue());
assertThat(watcher).isNotNull();
}
@Test
@ -220,7 +215,7 @@ public class LocalDevToolsAutoConfigurationTests {
Object watcher = ReflectionTestUtils.getField(classPathWatcher,
"fileSystemWatcher");
Object filter = ReflectionTestUtils.getField(watcher, "triggerFilter");
assertThat(filter, instanceOf(TriggerFileFilter.class));
assertThat(filter).isInstanceOf(TriggerFileFilter.class);
}
@Test
@ -236,9 +231,9 @@ public class LocalDevToolsAutoConfigurationTests {
@SuppressWarnings("unchecked")
Map<File, Object> folders = (Map<File, Object>) ReflectionTestUtils
.getField(watcher, "folders");
assertThat(folders.size(), is(equalTo(2)));
assertThat(folders, hasKey(new File("src/main/java").getAbsoluteFile()));
assertThat(folders, hasKey(new File("src/test/java").getAbsoluteFile()));
assertThat(folders).hasSize(2)
.containsKey(new File("src/main/java").getAbsoluteFile())
.containsKey(new File("src/test/java").getAbsoluteFile());
}
@Test
@ -263,14 +258,14 @@ public class LocalDevToolsAutoConfigurationTests {
this.context = application.run();
RedisTemplate<?, ?> redisTemplate = this.context.getBean("sessionRedisTemplate",
RedisTemplate.class);
assertThat(redisTemplate.getHashKeySerializer(),
is(instanceOf(RestartCompatibleRedisSerializer.class)));
assertThat(redisTemplate.getHashValueSerializer(),
is(instanceOf(RestartCompatibleRedisSerializer.class)));
assertThat(redisTemplate.getKeySerializer(),
is(instanceOf(RestartCompatibleRedisSerializer.class)));
assertThat(redisTemplate.getValueSerializer(),
is(instanceOf(RestartCompatibleRedisSerializer.class)));
assertThat(redisTemplate.getHashKeySerializer())
.isInstanceOf(RestartCompatibleRedisSerializer.class);
assertThat(redisTemplate.getHashValueSerializer())
.isInstanceOf(RestartCompatibleRedisSerializer.class);
assertThat(redisTemplate.getKeySerializer())
.isInstanceOf(RestartCompatibleRedisSerializer.class);
assertThat(redisTemplate.getValueSerializer())
.isInstanceOf(RestartCompatibleRedisSerializer.class);
}
private ConfigurableApplicationContext initializeAndRun(Class<?> config,

15
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/autoconfigure/RemoteDevToolsAutoConfigurationTests.java
View File

@ -47,8 +47,7 @@ import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.mock.web.MockServletContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@ -204,7 +203,7 @@ public class RemoteDevToolsAutoConfigurationTests {
this.request.addHeader(DEFAULT_SECRET_HEADER_NAME, "supersecret");
this.response.setStatus(500);
filter.doFilter(this.request, this.response, this.chain);
assertThat(this.response.getStatus(), equalTo(200));
assertThat(this.response.getStatus()).isEqualTo(200);
}
@Test
@ -216,17 +215,17 @@ public class RemoteDevToolsAutoConfigurationTests {
this.request.addHeader(DEFAULT_SECRET_HEADER_NAME, "supersecret");
this.response.setStatus(500);
filter.doFilter(this.request, this.response, this.chain);
assertThat(this.response.getStatus(), equalTo(200));
assertThat(this.response.getStatus()).isEqualTo(200);
}
private void assertTunnelInvoked(boolean value) {
assertThat(this.context.getBean(MockHttpTunnelServer.class).invoked,
equalTo(value));
assertThat(this.context.getBean(MockHttpTunnelServer.class).invoked)
.isEqualTo(value);
}
private void assertRestartInvoked(boolean value) {
assertThat(this.context.getBean(MockHttpRestartServer.class).invoked,
equalTo(value));
assertThat(this.context.getBean(MockHttpRestartServer.class).invoked)
.isEqualTo(value);
}
private void loadContext(String... properties) {

7
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/autoconfigure/TriggerFileFilterTests.java
View File

@ -23,8 +23,7 @@ import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link TriggerFileFilter}.
@ -49,13 +48,13 @@ public class TriggerFileFilterTests {
@Test
public void acceptNameMatch() throws Exception {
File file = this.temp.newFile("thefile.txt");
assertThat(new TriggerFileFilter("thefile.txt").accept(file), equalTo(true));
assertThat(new TriggerFileFilter("thefile.txt").accept(file)).isTrue();
}
@Test
public void doesNotAcceptNameMismatch() throws Exception {
File file = this.temp.newFile("notthefile.txt");
assertThat(new TriggerFileFilter("thefile.txt").accept(file), equalTo(false));
assertThat(new TriggerFileFilter("thefile.txt").accept(file)).isFalse();
}
}

10
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/classpath/ClassPathChangedEventTests.java
View File

@ -25,9 +25,7 @@ import org.junit.rules.ExpectedException;
import org.springframework.boot.devtools.filewatch.ChangedFiles;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.sameInstance;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ClassPathChangedEvent}.
@ -53,7 +51,7 @@ public class ClassPathChangedEventTests {
Set<ChangedFiles> changeSet = new LinkedHashSet<ChangedFiles>();
ClassPathChangedEvent event = new ClassPathChangedEvent(this.source, changeSet,
false);
assertThat(event.getChangeSet(), sameInstance(changeSet));
assertThat(event.getChangeSet()).isSameAs(changeSet);
}
@Test
@ -61,9 +59,9 @@ public class ClassPathChangedEventTests {
Set<ChangedFiles> changeSet = new LinkedHashSet<ChangedFiles>();
ClassPathChangedEvent event;
event = new ClassPathChangedEvent(this.source, changeSet, false);
assertThat(event.isRestartRequired(), equalTo(false));
assertThat(event.isRestartRequired()).isFalse();
event = new ClassPathChangedEvent(this.source, changeSet, true);
assertThat(event.isRestartRequired(), equalTo(true));
assertThat(event.isRestartRequired()).isTrue();
}
}

7
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/classpath/ClassPathFileChangeListenerTests.java
View File

@ -36,8 +36,7 @@ import org.springframework.boot.devtools.filewatch.FileSystemWatcher;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationEventPublisher;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
@ -116,8 +115,8 @@ public class ClassPathFileChangeListenerTests {
verify(this.eventPublisher).publishEvent(this.eventCaptor.capture());
ClassPathChangedEvent actualEvent = (ClassPathChangedEvent) this.eventCaptor
.getValue();
assertThat(actualEvent.getChangeSet(), equalTo(changeSet));
assertThat(actualEvent.isRestartRequired(), equalTo(restart));
assertThat(actualEvent.getChangeSet()).isEqualTo(changeSet);
assertThat(actualEvent.isRestartRequired()).isEqualTo(restart);
}
}

7
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/classpath/ClassPathFileSystemWatcherTests.java
View File

@ -40,8 +40,7 @@ import org.springframework.core.env.Environment;
import org.springframework.core.env.MapPropertySource;
import org.springframework.util.FileCopyUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@ -84,9 +83,9 @@ public class ClassPathFileSystemWatcherTests {
FileCopyUtils.copy("file".getBytes(), classFile);
Thread.sleep(1100);
List<ClassPathChangedEvent> events = context.getBean(Listener.class).getEvents();
assertThat(events.size(), equalTo(1));
assertThat(events.size()).isEqualTo(1);
assertThat(events.get(0).getChangeSet().iterator().next().getFiles().iterator()
.next().getFile(), equalTo(classFile));
.next().getFile()).isEqualTo(classFile);
context.close();
}

6
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/classpath/PatternClassPathRestartStrategyTests.java
View File

@ -23,8 +23,7 @@ import org.junit.Test;
import org.springframework.boot.devtools.filewatch.ChangedFile;
import org.springframework.boot.devtools.filewatch.ChangedFile.Type;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link PatternClassPathRestartStrategy}.
@ -90,7 +89,8 @@ public class PatternClassPathRestartStrategyTests {
private void assertRestartRequired(ClassPathRestartStrategy strategy,
String relativeName, boolean expected) {
assertThat(strategy.isRestartRequired(mockFile(relativeName)), equalTo(expected));
assertThat(strategy.isRestartRequired(mockFile(relativeName)))
.isEqualTo(expected);
}
private ChangedFile mockFile(String relativeName) {

8
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/env/DevToolsHomePropertiesPostProcessorTests.java vendored
View File

@ -30,9 +30,7 @@ import org.junit.rules.TemporaryFolder;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.mock.env.MockEnvironment;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link DevToolsHomePropertiesPostProcessor}.
@ -63,7 +61,7 @@ public class DevToolsHomePropertiesPostProcessorTests {
ConfigurableEnvironment environment = new MockEnvironment();
MockDevToolHomePropertiesPostProcessor postProcessor = new MockDevToolHomePropertiesPostProcessor();
postProcessor.postProcessEnvironment(environment, null);
assertThat(environment.getProperty("abc"), equalTo("def"));
assertThat(environment.getProperty("abc")).isEqualTo("def");
}
@Test
@ -71,7 +69,7 @@ public class DevToolsHomePropertiesPostProcessorTests {
ConfigurableEnvironment environment = new MockEnvironment();
MockDevToolHomePropertiesPostProcessor postProcessor = new MockDevToolHomePropertiesPostProcessor();
postProcessor.postProcessEnvironment(environment, null);
assertThat(environment.getProperty("abc"), nullValue());
assertThat(environment.getProperty("abc")).isNull();
}
private class MockDevToolHomePropertiesPostProcessor

9
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/filewatch/ChangedFileTests.java
View File

@ -25,8 +25,7 @@ import org.junit.rules.TemporaryFolder;
import org.springframework.boot.devtools.filewatch.ChangedFile.Type;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ChangedFile}.
@ -66,14 +65,14 @@ public class ChangedFileTests {
public void getFile() throws Exception {
File file = this.temp.newFile();
ChangedFile changedFile = new ChangedFile(this.temp.newFolder(), file, Type.ADD);
assertThat(changedFile.getFile(), equalTo(file));
assertThat(changedFile.getFile()).isEqualTo(file);
}
@Test
public void getType() throws Exception {
ChangedFile changedFile = new ChangedFile(this.temp.newFolder(),
this.temp.newFile(), Type.DELETE);
assertThat(changedFile.getType(), equalTo(Type.DELETE));
assertThat(changedFile.getType()).isEqualTo(Type.DELETE);
}
@Test
@ -82,7 +81,7 @@ public class ChangedFileTests {
File subFolder = new File(folder, "A");
File file = new File(subFolder, "B.txt");
ChangedFile changedFile = new ChangedFile(folder, file, Type.ADD);
assertThat(changedFile.getRelativeName(), equalTo("A/B.txt"));
assertThat(changedFile.getRelativeName()).isEqualTo("A/B.txt");
}
}

14
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/filewatch/FileSnapshotTests.java
View File

@ -28,9 +28,7 @@ import org.junit.rules.TemporaryFolder;
import org.springframework.util.FileCopyUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link FileSnapshot}.
@ -70,8 +68,8 @@ public class FileSnapshotTests {
File fileCopy = new File(file, "x").getParentFile();
FileSnapshot snapshot1 = new FileSnapshot(file);
FileSnapshot snapshot2 = new FileSnapshot(fileCopy);
assertThat(snapshot1, equalTo(snapshot2));
assertThat(snapshot1.hashCode(), equalTo(snapshot2.hashCode()));
assertThat(snapshot1).isEqualTo(snapshot2);
assertThat(snapshot1.hashCode()).isEqualTo(snapshot2.hashCode());
}
@Test
@ -79,7 +77,7 @@ public class FileSnapshotTests {
File file = createNewFile("abc", MODIFIED);
FileSnapshot snapshot1 = new FileSnapshot(file);
file.delete();
assertThat(snapshot1, not(equalTo(new FileSnapshot(file))));
assertThat(snapshot1).isNotEqualTo(new FileSnapshot(file));
}
@Test
@ -87,7 +85,7 @@ public class FileSnapshotTests {
File file = createNewFile("abc", MODIFIED);
FileSnapshot snapshot1 = new FileSnapshot(file);
setupFile(file, "abcd", MODIFIED);
assertThat(snapshot1, not(equalTo(new FileSnapshot(file))));
assertThat(snapshot1).isNotEqualTo(new FileSnapshot(file));
}
@Test
@ -95,7 +93,7 @@ public class FileSnapshotTests {
File file = createNewFile("abc", MODIFIED);
FileSnapshot snapshot1 = new FileSnapshot(file);
setupFile(file, "abc", MODIFIED + TWO_MINS);
assertThat(snapshot1, not(equalTo(new FileSnapshot(file))));
assertThat(snapshot1).isNotEqualTo(new FileSnapshot(file));
}
private File createNewFile(String content, long lastModified) throws IOException {

43
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/filewatch/FileSystemWatcherTests.java
View File

@ -22,7 +22,6 @@ import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
@ -37,11 +36,7 @@ import org.junit.rules.TemporaryFolder;
import org.springframework.boot.devtools.filewatch.ChangedFile.Type;
import org.springframework.util.FileCopyUtils;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@ -112,7 +107,7 @@ public class FileSystemWatcherTests {
@Test
public void sourceFolderMustExist() throws Exception {
File folder = new File("does/not/exist");
assertThat(folder.exists(), is(false));
assertThat(folder.exists()).isFalse();
this.thrown.expect(IllegalArgumentException.class);
this.thrown.expectMessage(
"Folder '" + folder + "' must exist and must be a directory");
@ -122,7 +117,7 @@ public class FileSystemWatcherTests {
@Test
public void sourceFolderMustBeADirectory() throws Exception {
File folder = new File("pom.xml");
assertThat(folder.isFile(), is(true));
assertThat(folder.isFile()).isTrue();
this.thrown.expect(IllegalArgumentException.class);
this.thrown.expectMessage("Folder 'pom.xml' must exist and must be a directory");
this.watcher.addSourceFolder(new File("pom.xml"));
@ -143,7 +138,7 @@ public class FileSystemWatcherTests {
this.watcher.stopAfter(1);
ChangedFiles changedFiles = getSingleChangedFiles();
ChangedFile expected = new ChangedFile(folder, file, Type.ADD);
assertThat(changedFiles.getFiles(), contains(expected));
assertThat(changedFiles.getFiles()).contains(expected);
}
@Test
@ -153,7 +148,7 @@ public class FileSystemWatcherTests {
this.watcher.stopAfter(1);
ChangedFiles changedFiles = getSingleChangedFiles();
ChangedFile expected = new ChangedFile(folder, file, Type.ADD);
assertThat(changedFiles.getFiles(), contains(expected));
assertThat(changedFiles.getFiles()).contains(expected);
}
@Test
@ -165,7 +160,7 @@ public class FileSystemWatcherTests {
Thread.sleep(200);
touch(new File(folder, "test2.txt"));
this.watcher.stopAfter(1);
assertThat(this.changes.size(), equalTo(2));
assertThat(this.changes.size()).isEqualTo(2);
}
@Test
@ -178,7 +173,7 @@ public class FileSystemWatcherTests {
}
this.watcher.stopAfter(1);
ChangedFiles changedFiles = getSingleChangedFiles();
assertThat(changedFiles.getFiles().size(), equalTo(10));
assertThat(changedFiles.getFiles().size()).isEqualTo(10);
}
@Test
@ -191,7 +186,7 @@ public class FileSystemWatcherTests {
this.watcher.stopAfter(1);
ChangedFiles changedFiles = getSingleChangedFiles();
ChangedFile expected = new ChangedFile(folder, file, Type.ADD);
assertThat(changedFiles.getFiles(), contains(expected));
assertThat(changedFiles.getFiles()).contains(expected);
}
@Test
@ -205,17 +200,15 @@ public class FileSystemWatcherTests {
File file2 = touch(new File(folder2, "test.txt"));
this.watcher.stopAfter(1);
Set<ChangedFiles> change = getSingleOnChange();
assertThat(change.size(), equalTo(2));
assertThat(change.size()).isEqualTo(2);
for (ChangedFiles changedFiles : change) {
if (changedFiles.getSourceFolder().equals(folder1)) {
ChangedFile file = new ChangedFile(folder1, file1, Type.ADD);
assertEquals(new HashSet<ChangedFile>(Arrays.asList(file)),
changedFiles.getFiles());
assertThat(changedFiles.getFiles()).containsOnly(file);
}
else {
ChangedFile file = new ChangedFile(folder2, file2, Type.ADD);
assertEquals(new HashSet<ChangedFile>(Arrays.asList(file)),
changedFiles.getFiles());
assertThat(changedFiles.getFiles()).containsOnly(file);
}
}
}
@ -236,8 +229,8 @@ public class FileSystemWatcherTests {
this.watcher.stopAfter(1);
ChangedFiles changedFiles = getSingleChangedFiles();
ChangedFile expected = new ChangedFile(folder, file, Type.ADD);
assertThat(changedFiles.getFiles(), contains(expected));
assertEquals(this.changes.get(0), listener2Changes);
assertThat(changedFiles.getFiles()).contains(expected);
assertThat(listener2Changes).isEqualTo(this.changes.get(0));
}
@Test
@ -257,7 +250,7 @@ public class FileSystemWatcherTests {
expected.add(new ChangedFile(folder, modify, Type.MODIFY));
expected.add(new ChangedFile(folder, delete, Type.DELETE));
expected.add(new ChangedFile(folder, add, Type.ADD));
assertEquals(expected, actual);
assertThat(actual).isEqualTo(expected);
}
@Test
@ -277,14 +270,14 @@ public class FileSystemWatcherTests {
this.watcher.start();
FileCopyUtils.copy("abc".getBytes(), file);
Thread.sleep(100);
assertThat(this.changes.size(), equalTo(0));
assertThat(this.changes.size()).isEqualTo(0);
FileCopyUtils.copy("abc".getBytes(), trigger);
this.watcher.stopAfter(1);
ChangedFiles changedFiles = getSingleChangedFiles();
Set<ChangedFile> actual = changedFiles.getFiles();
Set<ChangedFile> expected = new HashSet<ChangedFile>();
expected.add(new ChangedFile(folder, file, Type.MODIFY));
assertEquals(expected, actual);
assertThat(actual).isEqualTo(expected);
}
private void setupWatcher(long pollingInterval, long quietPeriod) {
@ -306,12 +299,12 @@ public class FileSystemWatcherTests {
private ChangedFiles getSingleChangedFiles() {
Set<ChangedFiles> singleChange = getSingleOnChange();
assertThat(singleChange.size(), equalTo(1));
assertThat(singleChange.size()).isEqualTo(1);
return singleChange.iterator().next();
}
private Set<ChangedFiles> getSingleOnChange() {
assertThat(this.changes.size(), equalTo(1));
assertThat(this.changes.size()).isEqualTo(1);
return this.changes.get(0);
}

22
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/filewatch/FolderSnapshotTests.java
View File

@ -28,9 +28,7 @@ import org.junit.rules.TemporaryFolder;
import org.springframework.boot.devtools.filewatch.ChangedFile.Type;
import org.springframework.util.FileCopyUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link FolderSnapshot}.
@ -72,22 +70,22 @@ public class FolderSnapshotTests {
@Test
public void equalsWhenNothingHasChanged() throws Exception {
FolderSnapshot updatedSnapshot = new FolderSnapshot(this.folder);
assertThat(this.initialSnapshot, equalTo(updatedSnapshot));
assertThat(this.initialSnapshot.hashCode(), equalTo(updatedSnapshot.hashCode()));
assertThat(this.initialSnapshot).isEqualTo(updatedSnapshot);
assertThat(this.initialSnapshot.hashCode()).isEqualTo(updatedSnapshot.hashCode());
}
@Test
public void notEqualsWhenAFileIsAdded() throws Exception {
new File(new File(this.folder, "folder1"), "newfile").createNewFile();
FolderSnapshot updatedSnapshot = new FolderSnapshot(this.folder);
assertThat(this.initialSnapshot, not(equalTo(updatedSnapshot)));
assertThat(this.initialSnapshot).isNotEqualTo(updatedSnapshot);
}
@Test
public void notEqualsWhenAFileIsDeleted() throws Exception {
new File(new File(this.folder, "folder1"), "file1").delete();
FolderSnapshot updatedSnapshot = new FolderSnapshot(this.folder);
assertThat(this.initialSnapshot, not(equalTo(updatedSnapshot)));
assertThat(this.initialSnapshot).isNotEqualTo(updatedSnapshot);
}
@Test
@ -95,7 +93,7 @@ public class FolderSnapshotTests {
File file1 = new File(new File(this.folder, "folder1"), "file1");
FileCopyUtils.copy("updatedcontent".getBytes(), file1);
FolderSnapshot updatedSnapshot = new FolderSnapshot(this.folder);
assertThat(this.initialSnapshot, not(equalTo(updatedSnapshot)));
assertThat(this.initialSnapshot).isNotEqualTo(updatedSnapshot);
}
@Test
@ -131,10 +129,10 @@ public class FolderSnapshotTests {
FolderSnapshot updatedSnapshot = new FolderSnapshot(this.folder);
ChangedFiles changedFiles = this.initialSnapshot.getChangedFiles(updatedSnapshot,
null);
assertThat(changedFiles.getSourceFolder(), equalTo(this.folder));
assertThat(getChangedFile(changedFiles, file1).getType(), equalTo(Type.MODIFY));
assertThat(getChangedFile(changedFiles, file2).getType(), equalTo(Type.DELETE));
assertThat(getChangedFile(changedFiles, newFile).getType(), equalTo(Type.ADD));
assertThat(changedFiles.getSourceFolder()).isEqualTo(this.folder);
assertThat(getChangedFile(changedFiles, file1).getType()).isEqualTo(Type.MODIFY);
assertThat(getChangedFile(changedFiles, file2).getType()).isEqualTo(Type.DELETE);
assertThat(getChangedFile(changedFiles, newFile).getType()).isEqualTo(Type.ADD);
}
private ChangedFile getChangedFile(ChangedFiles changedFiles, File file) {

10
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/integrationtest/HttpTunnelIntegrationTests.java Executable file → Normal file
View File

@ -54,7 +54,7 @@ import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Simple integration tests for HTTP tunneling.
@ -74,8 +74,8 @@ public class HttpTunnelIntegrationTests {
String url = "http://localhost:" + this.config.httpServerPort + "/hello";
ResponseEntity<String> entity = new TestRestTemplate().getForEntity(url,
String.class);
assertEquals(HttpStatus.OK, entity.getStatusCode());
assertEquals("Hello World", entity.getBody());
assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(entity.getBody()).isEqualTo("Hello World");
}
@Test
@ -83,8 +83,8 @@ public class HttpTunnelIntegrationTests {
String url = "http://localhost:" + this.config.clientPort + "/hello";
ResponseEntity<String> entity = new TestRestTemplate().getForEntity(url,
String.class);
assertEquals(HttpStatus.OK, entity.getStatusCode());
assertEquals("Hello World", entity.getBody());
assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(entity.getBody()).isEqualTo("Hello World");
}
@Configuration

7
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/livereload/ConnectionInputStreamTests.java
View File

@ -25,8 +25,7 @@ import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ConnectionInputStream}.
@ -51,7 +50,7 @@ public class ConnectionInputStreamTests {
String data = header + "\r\n\r\n" + "content\r\n";
ConnectionInputStream inputStream = new ConnectionInputStream(
new ByteArrayInputStream(data.getBytes()));
assertThat(inputStream.readHeader(), equalTo(header));
assertThat(inputStream.readHeader()).isEqualTo(header);
}
@Test
@ -62,7 +61,7 @@ public class ConnectionInputStreamTests {
ConnectionInputStream inputStream = new ConnectionInputStream(source);
byte[] buffer = new byte[bytes.length];
inputStream.readFully(buffer, 0, buffer.length);
assertThat(buffer, equalTo(bytes));
assertThat(buffer).isEqualTo(bytes);
}
@Test

7
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/livereload/ConnectionOutputStreamTests.java
View File

@ -22,8 +22,7 @@ import java.io.OutputStream;
import org.junit.Test;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@ -55,7 +54,7 @@ public class ConnectionOutputStreamTests {
expected += "Content-Length: 2\r\n";
expected += "Connection: close\r\n\r\n";
expected += "hi";
assertThat(out.toString(), equalTo(expected));
assertThat(out.toString()).isEqualTo(expected);
}
@Test
@ -67,7 +66,7 @@ public class ConnectionOutputStreamTests {
String expected = "";
expected += "A: a\r\n";
expected += "B: b\r\n\r\n";
assertThat(out.toString(), equalTo(expected));
assertThat(out.toString()).isEqualTo(expected);
}
}

49
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/livereload/FrameTests.java
View File

@ -24,8 +24,7 @@ import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link Frame}.
@ -54,15 +53,15 @@ public class FrameTests {
@Test
public void textPayload() throws Exception {
Frame frame = new Frame("abc");
assertThat(frame.getType(), equalTo(Frame.Type.TEXT));
assertThat(frame.getPayload(), equalTo("abc".getBytes()));
assertThat(frame.getType()).isEqualTo(Frame.Type.TEXT);
assertThat(frame.getPayload()).isEqualTo("abc".getBytes());
}
@Test
public void typedPayload() throws Exception {
Frame frame = new Frame(Frame.Type.CLOSE);
assertThat(frame.getType(), equalTo(Frame.Type.CLOSE));
assertThat(frame.getPayload(), equalTo(new byte[] {}));
assertThat(frame.getType()).isEqualTo(Frame.Type.CLOSE);
assertThat(frame.getPayload()).isEqualTo(new byte[] {});
}
@Test
@ -71,7 +70,7 @@ public class FrameTests {
Frame frame = new Frame(payload);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
frame.write(bos);
assertThat(bos.toByteArray(), equalTo(new byte[] { (byte) 0x81, 0x01, 0x41 }));
assertThat(bos.toByteArray()).isEqualTo(new byte[] { (byte) 0x81, 0x01, 0x41 });
}
@Test
@ -81,13 +80,13 @@ public class FrameTests {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
frame.write(bos);
byte[] bytes = bos.toByteArray();
assertThat(bytes.length, equalTo(130));
assertThat(bytes[0], equalTo((byte) 0x81));
assertThat(bytes[1], equalTo((byte) 0x7E));
assertThat(bytes[2], equalTo((byte) 0x00));
assertThat(bytes[3], equalTo((byte) 126));
assertThat(bytes[4], equalTo((byte) 0x41));
assertThat(bytes[5], equalTo((byte) 0x41));
assertThat(bytes.length).isEqualTo(130);
assertThat(bytes[0]).isEqualTo((byte) 0x81);
assertThat(bytes[1]).isEqualTo((byte) 0x7E);
assertThat(bytes[2]).isEqualTo((byte) 0x00);
assertThat(bytes[3]).isEqualTo((byte) 126);
assertThat(bytes[4]).isEqualTo((byte) 0x41);
assertThat(bytes[5]).isEqualTo((byte) 0x41);
}
@Test
@ -110,8 +109,8 @@ public class FrameTests {
public void readSmallTextFrame() throws Exception {
byte[] bytes = new byte[] { (byte) 0x81, (byte) 0x02, 0x41, 0x41 };
Frame frame = Frame.read(newConnectionInputStream(bytes));
assertThat(frame.getType(), equalTo(Frame.Type.TEXT));
assertThat(frame.getPayload(), equalTo(new byte[] { 0x41, 0x41 }));
assertThat(frame.getType()).isEqualTo(Frame.Type.TEXT);
assertThat(frame.getPayload()).isEqualTo(new byte[] { 0x41, 0x41 });
}
@Test
@ -119,8 +118,8 @@ public class FrameTests {
byte[] bytes = new byte[] { (byte) 0x81, (byte) 0x82, 0x0F, 0x0F, 0x0F, 0x0F,
0x4E, 0x4E };
Frame frame = Frame.read(newConnectionInputStream(bytes));
assertThat(frame.getType(), equalTo(Frame.Type.TEXT));
assertThat(frame.getPayload(), equalTo(new byte[] { 0x41, 0x41 }));
assertThat(frame.getType()).isEqualTo(Frame.Type.TEXT);
assertThat(frame.getPayload()).isEqualTo(new byte[] { 0x41, 0x41 });
}
@Test
@ -136,43 +135,43 @@ public class FrameTests {
bytes[6] = 0x0F;
bytes[7] = 0x0F;
Frame frame = Frame.read(newConnectionInputStream(bytes));
assertThat(frame.getType(), equalTo(Frame.Type.TEXT));
assertThat(frame.getPayload(), equalTo(createString(126).getBytes()));
assertThat(frame.getType()).isEqualTo(Frame.Type.TEXT);
assertThat(frame.getPayload()).isEqualTo(createString(126).getBytes());
}
@Test
public void readContinuation() throws Exception {
byte[] bytes = new byte[] { (byte) 0x80, (byte) 0x00 };
Frame frame = Frame.read(newConnectionInputStream(bytes));
assertThat(frame.getType(), equalTo(Frame.Type.CONTINUATION));
assertThat(frame.getType()).isEqualTo(Frame.Type.CONTINUATION);
}
@Test
public void readBinary() throws Exception {
byte[] bytes = new byte[] { (byte) 0x82, (byte) 0x00 };
Frame frame = Frame.read(newConnectionInputStream(bytes));
assertThat(frame.getType(), equalTo(Frame.Type.BINARY));
assertThat(frame.getType()).isEqualTo(Frame.Type.BINARY);
}
@Test
public void readClose() throws Exception {
byte[] bytes = new byte[] { (byte) 0x88, (byte) 0x00 };
Frame frame = Frame.read(newConnectionInputStream(bytes));
assertThat(frame.getType(), equalTo(Frame.Type.CLOSE));
assertThat(frame.getType()).isEqualTo(Frame.Type.CLOSE);
}
@Test
public void readPing() throws Exception {
byte[] bytes = new byte[] { (byte) 0x89, (byte) 0x00 };
Frame frame = Frame.read(newConnectionInputStream(bytes));
assertThat(frame.getType(), equalTo(Frame.Type.PING));
assertThat(frame.getType()).isEqualTo(Frame.Type.PING);
}
@Test
public void readPong() throws Exception {
byte[] bytes = new byte[] { (byte) 0x8A, (byte) 0x00 };
Frame frame = Frame.read(newConnectionInputStream(bytes));
assertThat(frame.getType(), equalTo(Frame.Type.PONG));
assertThat(frame.getType()).isEqualTo(Frame.Type.PONG);
}
private ConnectionInputStream newConnectionInputStream(byte[] bytes) {

19
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/livereload/LiveReloadServerTests.java
View File

@ -40,10 +40,7 @@ import org.junit.Test;
import org.springframework.util.SocketUtils;
import org.springframework.web.client.RestTemplate;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link LiveReloadServer}.
@ -78,7 +75,7 @@ public class LiveReloadServerTests {
RestTemplate template = new RestTemplate();
URI uri = new URI("http://localhost:" + this.port + "/livereload.js");
String script = template.getForObject(uri, String.class);
assertThat(script, containsString("livereload.com/protocols/official-7"));
assertThat(script).contains("livereload.com/protocols/official-7");
}
@Test
@ -89,9 +86,9 @@ public class LiveReloadServerTests {
this.server.triggerReload();
Thread.sleep(500);
this.server.stop();
assertThat(socket.getMessages(0),
containsString("http://livereload.com/protocols/official-7"));
assertThat(socket.getMessages(1), containsString("command\":\"reload\""));
assertThat(socket.getMessages(0))
.contains("http://livereload.com/protocols/official-7");
assertThat(socket.getMessages(1)).contains("command\":\"reload\"");
}
finally {
client.stop();
@ -107,7 +104,7 @@ public class LiveReloadServerTests {
socket.getRemote().sendPing(NO_DATA);
Thread.sleep(200);
this.server.stop();
assertThat(driver.getPongCount(), equalTo(1));
assertThat(driver.getPongCount()).isEqualTo(1);
}
finally {
client.stop();
@ -125,7 +122,7 @@ public class LiveReloadServerTests {
client.stop();
}
awaitClosedException();
assertThat(this.server.getClosedExceptions().size(), greaterThan(0));
assertThat(this.server.getClosedExceptions().size()).isGreaterThan(0);
}
private void awaitClosedException() throws InterruptedException {
@ -144,7 +141,7 @@ public class LiveReloadServerTests {
Thread.sleep(200);
this.server.stop();
Thread.sleep(200);
assertThat(socket.getCloseStatus(), equalTo(1006));
assertThat(socket.getCloseStatus()).isEqualTo(1006);
}
finally {
client.stop();

15
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/client/ClassPathChangeUploaderTests.java
View File

@ -44,8 +44,7 @@ import org.springframework.http.HttpStatus;
import org.springframework.mock.http.client.MockClientHttpRequest;
import org.springframework.util.FileCopyUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ClassPathChangeUploader}.
@ -117,20 +116,20 @@ public class ClassPathChangeUploaderTests {
MockClientHttpRequest request = this.requestFactory.getExecutedRequests().get(0);
ClassLoaderFiles classLoaderFiles = deserialize(request.getBodyAsBytes());
Collection<SourceFolder> sourceFolders = classLoaderFiles.getSourceFolders();
assertThat(sourceFolders.size(), equalTo(1));
assertThat(sourceFolders.size()).isEqualTo(1);
SourceFolder classSourceFolder = sourceFolders.iterator().next();
assertThat(classSourceFolder.getName(), equalTo(sourceFolder.getAbsolutePath()));
assertThat(classSourceFolder.getName()).isEqualTo(sourceFolder.getAbsolutePath());
Iterator<ClassLoaderFile> classFiles = classSourceFolder.getFiles().iterator();
assertClassFile(classFiles.next(), "File1", ClassLoaderFile.Kind.ADDED);
assertClassFile(classFiles.next(), "File2", ClassLoaderFile.Kind.MODIFIED);
assertClassFile(classFiles.next(), null, ClassLoaderFile.Kind.DELETED);
assertThat(classFiles.hasNext(), equalTo(false));
assertThat(classFiles.hasNext()).isFalse();
}
private void assertClassFile(ClassLoaderFile file, String content, Kind kind) {
assertThat(file.getContents(),
equalTo(content == null ? null : content.getBytes()));
assertThat(file.getKind(), equalTo(kind));
assertThat(file.getContents())
.isEqualTo(content == null ? null : content.getBytes());
assertThat(file.getKind()).isEqualTo(kind);
}
private File createFile(File sourceFolder, String name) throws IOException {

5
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/client/DelayedLiveReloadTriggerTests.java
View File

@ -33,8 +33,7 @@ import org.springframework.http.client.ClientHttpRequest;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpResponse;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
@ -119,7 +118,7 @@ public class DelayedLiveReloadTriggerTests {
long startTime = System.currentTimeMillis();
this.trigger.setTimings(10, 200, 30000);
this.trigger.run();
assertThat(System.currentTimeMillis() - startTime, greaterThan(300L));
assertThat(System.currentTimeMillis() - startTime).isGreaterThan(300L);
verify(this.liveReloadServer).triggerReload();
}

7
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/client/HttpHeaderInterceptorTests.java
View File

@ -32,8 +32,7 @@ import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.mock.web.MockHttpServletRequest;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
/**
@ -109,8 +108,8 @@ public class HttpHeaderInterceptorTests {
public void intercept() throws IOException {
ClientHttpResponse result = this.interceptor.intercept(this.request, this.body,
this.execution);
assertThat(this.request.getHeaders().getFirst(this.name), equalTo(this.value));
assertThat(result, equalTo(this.response));
assertThat(this.request.getHeaders().getFirst(this.name)).isEqualTo(this.value);
assertThat(result).isEqualTo(this.response);
}
}

11
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/client/LocalDebugPortAvailableConditionTests.java
View File

@ -28,8 +28,7 @@ import org.springframework.context.annotation.ConditionContext;
import org.springframework.mock.env.MockEnvironment;
import org.springframework.util.SocketUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@ -47,8 +46,8 @@ public class LocalDebugPortAvailableConditionTests {
@Test
public void portAvailable() throws Exception {
ConditionOutcome outcome = getOutcome();
assertThat(outcome.isMatch(), equalTo(true));
assertThat(outcome.getMessage(), equalTo("Local debug port available"));
assertThat(outcome.isMatch()).isTrue();
assertThat(outcome.getMessage()).isEqualTo("Local debug port available");
}
@Test
@ -57,8 +56,8 @@ public class LocalDebugPortAvailableConditionTests {
.createServerSocket(this.port);
ConditionOutcome outcome = getOutcome();
serverSocket.close();
assertThat(outcome.isMatch(), equalTo(false));
assertThat(outcome.getMessage(), equalTo("Local debug port unavailable"));
assertThat(outcome.isMatch()).isFalse();
assertThat(outcome.getMessage()).isEqualTo("Local debug port unavailable");
}
private ConditionOutcome getOutcome() {

12
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/client/RemoteClientConfigurationTests.java
View File

@ -49,9 +49,7 @@ import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.util.SocketUtils;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
@ -88,20 +86,20 @@ public class RemoteClientConfigurationTests {
public void warnIfDebugAndRestartDisabled() throws Exception {
configure("spring.devtools.remote.debug.enabled:false",
"spring.devtools.remote.restart.enabled:false");
assertThat(this.output.toString(),
containsString("Remote restart and debug are both disabled"));
assertThat(this.output.toString())
.contains("Remote restart and debug are both disabled");
}
@Test
public void warnIfNotHttps() throws Exception {
configure("http://localhost", true);
assertThat(this.output.toString(), containsString("is insecure"));
assertThat(this.output.toString()).contains("is insecure");
}
@Test
public void doesntWarnIfUsingHttps() throws Exception {
configure("https://localhost", true);
assertThat(this.output.toString(), not(containsString("is insecure")));
assertThat(this.output.toString()).doesNotContain("is insecure");
}
@Test

7
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/server/DispatcherFilterTests.java
View File

@ -38,8 +38,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.willReturn;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
@ -114,8 +113,8 @@ public class DispatcherFilterTests {
ServletServerHttpRequest actualRequest = (ServletServerHttpRequest) dispatcherRequest;
ServerHttpResponse dispatcherResponse = this.serverResponseCaptor.getValue();
ServletServerHttpResponse actualResponse = (ServletServerHttpResponse) dispatcherResponse;
assertThat(actualRequest.getServletRequest(), equalTo(request));
assertThat(actualResponse.getServletResponse(), equalTo(response));
assertThat(actualRequest.getServletRequest()).isEqualTo(request);
assertThat(actualResponse.getServletResponse()).isEqualTo(response);
}
}

5
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/server/DispatcherTests.java
View File

@ -36,8 +36,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.inOrder;
@ -101,7 +100,7 @@ public class DispatcherTests {
Collections.singleton(mapper));
dispatcher.handle(this.serverRequest, this.serverResponse);
verifyZeroInteractions(handler);
assertThat(this.response.getStatus(), equalTo(403));
assertThat(this.response.getStatus()).isEqualTo(403);
}
@Test

11
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/server/HttpHeaderAccessManagerTests.java
View File

@ -25,8 +25,7 @@ import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.mock.web.MockHttpServletRequest;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link HttpHeaderAccessManager}.
@ -87,24 +86,24 @@ public class HttpHeaderAccessManagerTests {
@Test
public void allowsMatching() throws Exception {
this.request.addHeader(HEADER, SECRET);
assertThat(this.manager.isAllowed(this.serverRequest), equalTo(true));
assertThat(this.manager.isAllowed(this.serverRequest)).isTrue();
}
@Test
public void disallowsWrongSecret() throws Exception {
this.request.addHeader(HEADER, "wrong");
assertThat(this.manager.isAllowed(this.serverRequest), equalTo(false));
assertThat(this.manager.isAllowed(this.serverRequest)).isFalse();
}
@Test
public void disallowsNoSecret() throws Exception {
assertThat(this.manager.isAllowed(this.serverRequest), equalTo(false));
assertThat(this.manager.isAllowed(this.serverRequest)).isFalse();
}
@Test
public void disallowsWrongHeader() throws Exception {
this.request.addHeader("X-WRONG", SECRET);
assertThat(this.manager.isAllowed(this.serverRequest), equalTo(false));
assertThat(this.manager.isAllowed(this.serverRequest)).isFalse();
}
}

7
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/server/HttpStatusHandlerTests.java
View File

@ -29,8 +29,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link HttpStatusHandler}.
@ -69,14 +68,14 @@ public class HttpStatusHandlerTests {
public void respondsOk() throws Exception {
HttpStatusHandler handler = new HttpStatusHandler();
handler.handle(this.request, this.response);
assertThat(this.servletResponse.getStatus(), equalTo(200));
assertThat(this.servletResponse.getStatus()).isEqualTo(200);
}
@Test
public void respondsWithStatus() throws Exception {
HttpStatusHandler handler = new HttpStatusHandler(HttpStatus.I_AM_A_TEAPOT);
handler.handle(this.request, this.response);
assertThat(this.servletResponse.getStatus(), equalTo(418));
assertThat(this.servletResponse.getStatus()).isEqualTo(418);
}
}

8
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/server/UrlHandlerMapperTests.java
View File

@ -26,9 +26,7 @@ import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.mock.web.MockHttpServletRequest;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@ -70,7 +68,7 @@ public class UrlHandlerMapperTests {
UrlHandlerMapper mapper = new UrlHandlerMapper("/tunnel", this.handler);
HttpServletRequest servletRequest = new MockHttpServletRequest("GET", "/tunnel");
ServerHttpRequest request = new ServletServerHttpRequest(servletRequest);
assertThat(mapper.getHandler(request), equalTo(this.handler));
assertThat(mapper.getHandler(request)).isEqualTo(this.handler);
}
@Test
@ -79,7 +77,7 @@ public class UrlHandlerMapperTests {
HttpServletRequest servletRequest = new MockHttpServletRequest("GET",
"/tunnel/other");
ServerHttpRequest request = new ServletServerHttpRequest(servletRequest);
assertThat(mapper.getHandler(request), nullValue());
assertThat(mapper.getHandler(request)).isNull();
}
}

11
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/ChangeableUrlsTests.java
View File

@ -24,8 +24,7 @@ import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ChangeableUrls}.
@ -40,19 +39,19 @@ public class ChangeableUrlsTests {
@Test
public void folderUrl() throws Exception {
URL url = makeUrl("myproject");
assertThat(ChangeableUrls.fromUrls(url).size(), equalTo(1));
assertThat(ChangeableUrls.fromUrls(url).size()).isEqualTo(1);
}
@Test
public void fileUrl() throws Exception {
URL url = this.temporaryFolder.newFile().toURI().toURL();
assertThat(ChangeableUrls.fromUrls(url).size(), equalTo(0));
assertThat(ChangeableUrls.fromUrls(url).size()).isEqualTo(0);
}
@Test
public void httpUrl() throws Exception {
URL url = new URL("http://spring.io");
assertThat(ChangeableUrls.fromUrls(url).size(), equalTo(0));
assertThat(ChangeableUrls.fromUrls(url).size()).isEqualTo(0);
}
@Test
@ -61,7 +60,7 @@ public class ChangeableUrlsTests {
makeUrl("spring-boot-autoconfigure"), makeUrl("spring-boot-actuator"),
makeUrl("spring-boot-starter"),
makeUrl("spring-boot-starter-some-thing"));
assertThat(urls.size(), equalTo(0));
assertThat(urls.size()).isEqualTo(0);
}
private URL makeUrl(String name) throws IOException {

20
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/DefaultRestartInitializerTests.java
View File

@ -20,10 +20,8 @@ import java.net.URL;
import org.junit.Test;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.not;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
/**
* Tests for {@link DefaultRestartInitializer}.
@ -35,7 +33,7 @@ public class DefaultRestartInitializerTests {
@Test
public void nullForTests() throws Exception {
MockRestartInitializer initializer = new MockRestartInitializer(true);
assertThat(initializer.getInitialUrls(Thread.currentThread()), nullValue());
assertThat(initializer.getInitialUrls(Thread.currentThread())).isNull();
}
@Test
@ -45,8 +43,8 @@ public class DefaultRestartInitializerTests {
Thread thread = new Thread();
thread.setName("main");
thread.setContextClassLoader(classLoader);
assertThat(initializer.isMain(thread), equalTo(true));
assertThat(initializer.getInitialUrls(thread), not(nullValue()));
assertThat(initializer.isMain(thread)).isTrue();
assertThat(initializer.getInitialUrls(thread)).isNotEqualTo(nullValue());
}
@Test
@ -56,8 +54,8 @@ public class DefaultRestartInitializerTests {
Thread thread = new Thread();
thread.setName("buscuit");
thread.setContextClassLoader(classLoader);
assertThat(initializer.isMain(thread), equalTo(false));
assertThat(initializer.getInitialUrls(thread), nullValue());
assertThat(initializer.isMain(thread)).isFalse();
assertThat(initializer.getInitialUrls(thread)).isNull();
}
@Test
@ -68,8 +66,8 @@ public class DefaultRestartInitializerTests {
Thread thread = new Thread();
thread.setName("main");
thread.setContextClassLoader(classLoader);
assertThat(initializer.isMain(thread), equalTo(false));
assertThat(initializer.getInitialUrls(thread), nullValue());
assertThat(initializer.isMain(thread)).isFalse();
assertThat(initializer.getInitialUrls(thread)).isNull();
}
@Test
@ -86,7 +84,7 @@ public class DefaultRestartInitializerTests {
MockRestartInitializer initializer = new MockRestartInitializer(true);
StackTraceElement element = new StackTraceElement(className, "someMethod",
"someFile", 123);
assertThat(initializer.isSkippedStackElement(element), equalTo(expected));
assertThat(initializer.isSkippedStackElement(element)).isEqualTo(expected);
}
private static class MockAppClassLoader extends ClassLoader {

9
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/MainMethodTests.java
View File

@ -25,8 +25,7 @@ import org.junit.rules.ExpectedException;
import org.springframework.util.ReflectionUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link MainMethod}.
@ -62,9 +61,9 @@ public class MainMethodTests {
Valid.main();
}
}).test();
assertThat(method.getMethod(), equalTo(this.actualMain));
assertThat(method.getDeclaringClassName(),
equalTo(this.actualMain.getDeclaringClass().getName()));
assertThat(method.getMethod()).isEqualTo(this.actualMain);
assertThat(method.getDeclaringClassName())
.isEqualTo(this.actualMain.getDeclaringClass().getName());
}
@Test

9
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/OnInitializedRestarterConditionTests.java
View File

@ -27,8 +27,7 @@ import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
@ -53,7 +52,7 @@ public class OnInitializedRestarterConditionTests {
Restarter.clearInstance();
ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(
Config.class);
assertThat(context.containsBean("bean"), equalTo(false));
assertThat(context.containsBean("bean")).isFalse();
context.close();
}
@ -62,7 +61,7 @@ public class OnInitializedRestarterConditionTests {
Restarter.initialize(new String[0], false, RestartInitializer.NONE);
ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(
Config.class);
assertThat(context.containsBean("bean"), equalTo(false));
assertThat(context.containsBean("bean")).isFalse();
context.close();
}
@ -90,7 +89,7 @@ public class OnInitializedRestarterConditionTests {
Restarter.initialize(new String[0], false, initializer);
ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(
Config.class);
assertThat(context.containsBean("bean"), equalTo(true));
assertThat(context.containsBean("bean")).isTrue();
context.close();
synchronized (wait) {
wait.notify();

28
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/RestartApplicationListenerTests.java
View File

@ -28,10 +28,8 @@ import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.Ordered;
import org.springframework.test.util.ReflectionTestUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.not;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
/**
@ -54,32 +52,32 @@ public class RestartApplicationListenerTests {
@Test
public void isHighestPriority() throws Exception {
assertThat(new RestartApplicationListener().getOrder(),
equalTo(Ordered.HIGHEST_PRECEDENCE));
assertThat(new RestartApplicationListener().getOrder())
.isEqualTo(Ordered.HIGHEST_PRECEDENCE);
}
@Test
public void initializeWithReady() throws Exception {
testInitialize(false);
assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "args"),
equalTo((Object) ARGS));
assertThat(Restarter.getInstance().isFinished(), equalTo(true));
assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "args"))
.isEqualTo(ARGS);
assertThat(Restarter.getInstance().isFinished()).isTrue();
}
@Test
public void initializeWithFail() throws Exception {
testInitialize(true);
assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "args"),
equalTo((Object) ARGS));
assertThat(Restarter.getInstance().isFinished(), equalTo(true));
assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "args"))
.isEqualTo(ARGS);
assertThat(Restarter.getInstance().isFinished()).isTrue();
}
@Test
public void disableWithSystemProperty() throws Exception {
System.setProperty(ENABLED_PROPERTY, "false");
testInitialize(false);
assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "enabled"),
equalTo((Object) false));
assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "enabled"))
.isEqualTo(false);
}
private void testInitialize(boolean failed) {
@ -89,8 +87,8 @@ public class RestartApplicationListenerTests {
ConfigurableApplicationContext context = mock(
ConfigurableApplicationContext.class);
listener.onApplicationEvent(new ApplicationStartedEvent(application, ARGS));
assertThat(Restarter.getInstance(), not(nullValue()));
assertThat(Restarter.getInstance().isFinished(), equalTo(false));
assertThat(Restarter.getInstance()).isNotEqualTo(nullValue());
assertThat(Restarter.getInstance().isFinished()).isFalse();
if (failed) {
listener.onApplicationEvent(new ApplicationFailedEvent(application, ARGS,
context, new RuntimeException()));

7
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/RestartScopeInitializerTests.java
View File

@ -27,8 +27,7 @@ import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link RestartScopeInitializer}.
@ -49,8 +48,8 @@ public class RestartScopeInitializerTests {
context.close();
context = runApplication();
context.close();
assertThat(createCount.get(), equalTo(1));
assertThat(refreshCount.get(), equalTo(2));
assertThat(createCount.get()).isEqualTo(1);
assertThat(refreshCount.get()).isEqualTo(2);
}
private ConfigurableApplicationContext runApplication() {

26
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/RestarterTests.java
View File

@ -41,9 +41,7 @@ import org.springframework.stereotype.Component;
import org.springframework.util.FileCopyUtils;
import org.springframework.util.StringUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
@ -94,9 +92,9 @@ public class RestarterTests {
thread.start();
Thread.sleep(2600);
String output = this.out.toString();
assertThat(StringUtils.countOccurrencesOf(output, "Tick 0"), greaterThan(1));
assertThat(StringUtils.countOccurrencesOf(output, "Tick 1"), greaterThan(1));
assertThat(TestRestartListener.restarts, greaterThan(0));
assertThat(StringUtils.countOccurrencesOf(output, "Tick 0")).isGreaterThan(1);
assertThat(StringUtils.countOccurrencesOf(output, "Tick 1")).isGreaterThan(1);
assertThat(TestRestartListener.restarts).isGreaterThan(0);
}
@Test
@ -105,7 +103,7 @@ public class RestarterTests {
ObjectFactory objectFactory = mock(ObjectFactory.class);
given(objectFactory.getObject()).willReturn("abc");
Object attribute = Restarter.getInstance().getOrAddAttribute("x", objectFactory);
assertThat(attribute, equalTo((Object) "abc"));
assertThat(attribute).isEqualTo("abc");
}
public void addUrlsMustNotBeNull() throws Exception {
@ -123,7 +121,7 @@ public class RestarterTests {
restarter.restart();
ClassLoader classLoader = ((TestableRestarter) restarter)
.getRelaunchClassLoader();
assertThat(((URLClassLoader) classLoader).getURLs()[0], equalTo(url));
assertThat(((URLClassLoader) classLoader).getURLs()[0]).isEqualTo(url);
}
@Test
@ -142,8 +140,8 @@ public class RestarterTests {
restarter.restart();
ClassLoader classLoader = ((TestableRestarter) restarter)
.getRelaunchClassLoader();
assertThat(FileCopyUtils.copyToByteArray(classLoader.getResourceAsStream("f")),
equalTo("abc".getBytes()));
assertThat(FileCopyUtils.copyToByteArray(classLoader.getResourceAsStream("f")))
.isEqualTo("abc".getBytes());
}
@Test
@ -157,7 +155,7 @@ public class RestarterTests {
});
ObjectFactory objectFactory = mock(ObjectFactory.class);
Object attribute = Restarter.getInstance().getOrAddAttribute("x", objectFactory);
assertThat(attribute, equalTo((Object) "abc"));
assertThat(attribute).isEqualTo("abc");
verifyZeroInteractions(objectFactory);
}
@ -173,9 +171,9 @@ public class RestarterTests {
ThreadFactory factory = Restarter.getInstance().getThreadFactory();
Thread viaFactory = factory.newThread(runnable);
// Regular threads will inherit the current thread
assertThat(regular.getContextClassLoader(), equalTo(contextClassLoader));
assertThat(regular.getContextClassLoader()).isEqualTo(contextClassLoader);
// Factory threads should should inherit from the initial thread
assertThat(viaFactory.getContextClassLoader(), equalTo(parentLoader));
assertThat(viaFactory.getContextClassLoader()).isEqualTo(parentLoader);
};
};
thread.setContextClassLoader(contextClassLoader);
@ -190,7 +188,7 @@ public class RestarterTests {
URL[] urls = new URL[] { new URL("file:/proj/module-a.jar!/") };
given(initializer.getInitialUrls(any(Thread.class))).willReturn(urls);
Restarter.initialize(new String[0], false, initializer, false);
assertThat(Restarter.getInstance().getInitialUrls(), equalTo(urls));
assertThat(Restarter.getInstance().getInitialUrls()).isEqualTo(urls);
}
@Component

8
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/SilentExitExceptionHandlerTests.java
View File

@ -18,9 +18,7 @@ package org.springframework.boot.devtools.restart;
import org.junit.Test;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
/**
@ -41,7 +39,7 @@ public class SilentExitExceptionHandlerTests {
};
SilentExitExceptionHandler.setup(testThread);
testThread.startAndJoin();
assertThat(testThread.getThrown(), nullValue());
assertThat(testThread.getThrown()).isNull();
}
@Test
@ -54,7 +52,7 @@ public class SilentExitExceptionHandlerTests {
};
SilentExitExceptionHandler.setup(testThread);
testThread.startAndJoin();
assertThat(testThread.getThrown().getMessage(), equalTo("Expected"));
assertThat(testThread.getThrown().getMessage()).isEqualTo("Expected");
}
private static abstract class TestThread extends Thread {

16
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/classloader/ClassLoaderFileTests.java
View File

@ -22,9 +22,7 @@ import org.junit.rules.ExpectedException;
import org.springframework.boot.devtools.restart.classloader.ClassLoaderFile.Kind;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ClassLoaderFile}.
@ -69,22 +67,22 @@ public class ClassLoaderFileTests {
@Test
public void added() throws Exception {
ClassLoaderFile file = new ClassLoaderFile(Kind.ADDED, BYTES);
assertThat(file.getKind(), equalTo(ClassLoaderFile.Kind.ADDED));
assertThat(file.getContents(), equalTo(BYTES));
assertThat(file.getKind()).isEqualTo(ClassLoaderFile.Kind.ADDED);
assertThat(file.getContents()).isEqualTo(BYTES);
}
@Test
public void modified() throws Exception {
ClassLoaderFile file = new ClassLoaderFile(Kind.MODIFIED, BYTES);
assertThat(file.getKind(), equalTo(ClassLoaderFile.Kind.MODIFIED));
assertThat(file.getContents(), equalTo(BYTES));
assertThat(file.getKind()).isEqualTo(ClassLoaderFile.Kind.MODIFIED);
assertThat(file.getContents()).isEqualTo(BYTES);
}
@Test
public void deleted() throws Exception {
ClassLoaderFile file = new ClassLoaderFile(Kind.DELETED, null);
assertThat(file.getKind(), equalTo(ClassLoaderFile.Kind.DELETED));
assertThat(file.getContents(), nullValue());
assertThat(file.getKind()).isEqualTo(ClassLoaderFile.Kind.DELETED);
assertThat(file.getContents()).isNull();
}
}

52
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/classloader/ClassLoaderFilesTests.java
View File

@ -20,8 +20,6 @@ import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import org.junit.Rule;
@ -31,10 +29,7 @@ import org.junit.rules.ExpectedException;
import org.springframework.boot.devtools.restart.classloader.ClassLoaderFile.Kind;
import org.springframework.boot.devtools.restart.classloader.ClassLoaderFiles.SourceFolder;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@ -65,19 +60,19 @@ public class ClassLoaderFilesTests {
@Test
public void getFileWithNullName() throws Exception {
assertThat(this.files.getFile(null), nullValue());
assertThat(this.files.getFile(null)).isNull();
}
@Test
public void addAndGet() throws Exception {
ClassLoaderFile file = new ClassLoaderFile(Kind.ADDED, new byte[10]);
this.files.addFile("myfile", file);
assertThat(this.files.getFile("myfile"), equalTo(file));
assertThat(this.files.getFile("myfile")).isEqualTo(file);
}
@Test
public void getMissing() throws Exception {
assertThat(this.files.getFile("missing"), nullValue());
assertThat(this.files.getFile("missing")).isNull();
}
@Test
@ -86,7 +81,7 @@ public class ClassLoaderFilesTests {
ClassLoaderFile file2 = new ClassLoaderFile(Kind.MODIFIED, new byte[10]);
this.files.addFile("myfile", file1);
this.files.addFile("myfile", file2);
assertThat(this.files.getFile("myfile"), equalTo(file2));
assertThat(this.files.getFile("myfile")).isEqualTo(file2);
}
@Test
@ -95,9 +90,11 @@ public class ClassLoaderFilesTests {
ClassLoaderFile file2 = new ClassLoaderFile(Kind.MODIFIED, new byte[10]);
this.files.addFile("a", "myfile", file1);
this.files.addFile("b", "myfile", file2);
assertThat(this.files.getFile("myfile"), equalTo(file2));
assertThat(this.files.getOrCreateSourceFolder("a").getFiles().size(), equalTo(0));
assertThat(this.files.getOrCreateSourceFolder("b").getFiles().size(), equalTo(1));
assertThat(this.files.getFile("myfile")).isEqualTo(file2);
assertThat(this.files.getOrCreateSourceFolder("a").getFiles().size())
.isEqualTo(0);
assertThat(this.files.getOrCreateSourceFolder("b").getFiles().size())
.isEqualTo(1);
}
@Test
@ -113,13 +110,11 @@ public class ClassLoaderFilesTests {
Iterator<SourceFolder> sourceFolders = this.files.getSourceFolders().iterator();
SourceFolder sourceFolder1 = sourceFolders.next();
SourceFolder sourceFolder2 = sourceFolders.next();
assertThat(sourceFolders.hasNext(), equalTo(false));
assertThat(sourceFolder1.getName(), equalTo("a"));
assertThat(sourceFolder2.getName(), equalTo("b"));
assertThat(new ArrayList<ClassLoaderFile>(sourceFolder1.getFiles()),
equalTo(Arrays.asList(file1, file2)));
assertThat(new ArrayList<ClassLoaderFile>(sourceFolder2.getFiles()),
equalTo(Arrays.asList(file3, file4)));
assertThat(sourceFolders.hasNext()).isFalse();
assertThat(sourceFolder1.getName()).isEqualTo("a");
assertThat(sourceFolder2.getName()).isEqualTo("b");
assertThat(sourceFolder1.getFiles()).containsOnly(file1, file2);
assertThat(sourceFolder2.getFiles()).containsOnly(file3, file4);
}
@Test
@ -133,7 +128,7 @@ public class ClassLoaderFilesTests {
ObjectInputStream ois = new ObjectInputStream(
new ByteArrayInputStream(bos.toByteArray()));
ClassLoaderFiles readObject = (ClassLoaderFiles) ois.readObject();
assertThat(readObject.getFile("myfile"), notNullValue());
assertThat(readObject.getFile("myfile")).isNotNull();
}
@Test
@ -149,11 +144,10 @@ public class ClassLoaderFilesTests {
Iterator<SourceFolder> sourceFolders = this.files.getSourceFolders().iterator();
SourceFolder sourceFolder1 = sourceFolders.next();
SourceFolder sourceFolder2 = sourceFolders.next();
assertThat(sourceFolders.hasNext(), equalTo(false));
assertThat(sourceFolder1.getName(), equalTo("a"));
assertThat(sourceFolder2.getName(), equalTo("b"));
assertThat(new ArrayList<ClassLoaderFile>(sourceFolder1.getFiles()),
equalTo(Arrays.asList(file1, file2)));
assertThat(sourceFolders.hasNext()).isFalse();
assertThat(sourceFolder1.getName()).isEqualTo("a");
assertThat(sourceFolder2.getName()).isEqualTo("b");
assertThat(sourceFolder1.getFiles()).containsOnly(file1, file2);
}
@Test
@ -162,7 +156,7 @@ public class ClassLoaderFilesTests {
this.files.addFile("s1", "n2", mock(ClassLoaderFile.class));
this.files.addFile("s2", "n3", mock(ClassLoaderFile.class));
this.files.addFile("s2", "n1", mock(ClassLoaderFile.class));
assertThat(this.files.size(), equalTo(3));
assertThat(this.files.size()).isEqualTo(3);
}
@Test
@ -178,8 +172,8 @@ public class ClassLoaderFilesTests {
this.files.addFile("s1", "n2", mock(ClassLoaderFile.class));
ClassLoaderFiles copy = new ClassLoaderFiles(this.files);
this.files.addFile("s2", "n3", mock(ClassLoaderFile.class));
assertThat(this.files.size(), equalTo(3));
assertThat(copy.size(), equalTo(2));
assertThat(this.files.size()).isEqualTo(3);
assertThat(copy.size()).isEqualTo(2);
}
}

30
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/classloader/RestartClassLoaderTests.java
View File

@ -39,9 +39,7 @@ import org.springframework.boot.devtools.restart.classloader.ClassLoaderFile.Kin
import org.springframework.util.FileCopyUtils;
import org.springframework.util.StreamUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link RestartClassLoader}.
@ -115,48 +113,47 @@ public class RestartClassLoaderTests {
public void getResourceFromReloadableUrl() throws Exception {
String content = readString(
this.reloadClassLoader.getResourceAsStream(PACKAGE_PATH + "/Sample.txt"));
assertThat(content, startsWith("fromchild"));
assertThat(content).startsWith("fromchild");
}
@Test
public void getResourceFromParent() throws Exception {
String content = readString(
this.reloadClassLoader.getResourceAsStream(PACKAGE_PATH + "/Parent.txt"));
assertThat(content, startsWith("fromparent"));
assertThat(content).startsWith("fromparent");
}
@Test
public void getResourcesFiltersDuplicates() throws Exception {
List<URL> resources = toList(
this.reloadClassLoader.getResources(PACKAGE_PATH + "/Sample.txt"));
assertThat(resources.size(), equalTo(1));
assertThat(resources.size()).isEqualTo(1);
}
@Test
public void loadClassFromReloadableUrl() throws Exception {
Class<?> loaded = this.reloadClassLoader.loadClass(PACKAGE + ".Sample");
assertThat(loaded.getClassLoader(),
equalTo((ClassLoader) this.reloadClassLoader));
assertThat(loaded.getClassLoader()).isEqualTo(this.reloadClassLoader);
}
@Test
public void loadClassFromParent() throws Exception {
Class<?> loaded = this.reloadClassLoader.loadClass(PACKAGE + ".SampleParent");
assertThat(loaded.getClassLoader(), equalTo(getClass().getClassLoader()));
assertThat(loaded.getClassLoader()).isEqualTo(getClass().getClassLoader());
}
@Test
public void getDeletedResource() throws Exception {
String name = PACKAGE_PATH + "/Sample.txt";
this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.DELETED, null));
assertThat(this.reloadClassLoader.getResource(name), equalTo(null));
assertThat(this.reloadClassLoader.getResource(name)).isEqualTo(null);
}
@Test
public void getDeletedResourceAsStream() throws Exception {
String name = PACKAGE_PATH + "/Sample.txt";
this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.DELETED, null));
assertThat(this.reloadClassLoader.getResourceAsStream(name), equalTo(null));
assertThat(this.reloadClassLoader.getResourceAsStream(name)).isEqualTo(null);
}
@Test
@ -165,7 +162,7 @@ public class RestartClassLoaderTests {
byte[] bytes = "abc".getBytes();
this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.MODIFIED, bytes));
URL resource = this.reloadClassLoader.getResource(name);
assertThat(FileCopyUtils.copyToByteArray(resource.openStream()), equalTo(bytes));
assertThat(FileCopyUtils.copyToByteArray(resource.openStream())).isEqualTo(bytes);
}
@Test
@ -173,7 +170,7 @@ public class RestartClassLoaderTests {
String name = PACKAGE_PATH + "/Sample.txt";
this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.DELETED, null));
List<URL> resources = toList(this.reloadClassLoader.getResources(name));
assertThat(resources.size(), equalTo(0));
assertThat(resources.size()).isEqualTo(0);
}
@Test
@ -182,8 +179,8 @@ public class RestartClassLoaderTests {
byte[] bytes = "abc".getBytes();
this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.MODIFIED, bytes));
List<URL> resources = toList(this.reloadClassLoader.getResources(name));
assertThat(FileCopyUtils.copyToByteArray(resources.get(0).openStream()),
equalTo(bytes));
assertThat(FileCopyUtils.copyToByteArray(resources.get(0).openStream()))
.isEqualTo(bytes);
}
@Test
@ -209,8 +206,7 @@ public class RestartClassLoaderTests {
.copyToByteArray(getClass().getResourceAsStream("SampleParent.class"));
this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.ADDED, bytes));
Class<?> loaded = this.reloadClassLoader.loadClass(PACKAGE + ".SampleParent");
assertThat(loaded.getClassLoader(),
equalTo((ClassLoader) this.reloadClassLoader));
assertThat(loaded.getClassLoader()).isEqualTo(this.reloadClassLoader);
}
private String readString(InputStream in) throws IOException {

12
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/server/DefaultSourceFolderUrlFilterTests.java
View File

@ -24,8 +24,7 @@ import java.util.List;
import org.junit.Test;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link DefaultSourceFolderUrlFilter}.
@ -76,14 +75,14 @@ public class DefaultSourceFolderUrlFilterTests {
+ "spring-boot-sample-devtools";
URL jarUrl = new URL("jar:file:/Users/me/tmp/"
+ "spring-boot-sample-devtools-1.3.0.BUILD-SNAPSHOT.jar!/");
assertThat(this.filter.isMatch(sourceFolder, jarUrl), equalTo(true));
assertThat(this.filter.isMatch(sourceFolder, jarUrl)).isTrue();
URL nestedJarUrl = new URL("jar:file:/Users/me/tmp/"
+ "spring-boot-sample-devtools-1.3.0.BUILD-SNAPSHOT.jar!/"
+ "lib/spring-boot-1.3.0.BUILD-SNAPSHOT.jar!/");
assertThat(this.filter.isMatch(sourceFolder, nestedJarUrl), equalTo(false));
assertThat(this.filter.isMatch(sourceFolder, nestedJarUrl)).isFalse();
URL fileUrl = new URL("file:/Users/me/tmp/"
+ "spring-boot-sample-devtools-1.3.0.BUILD-SNAPSHOT.jar");
assertThat(this.filter.isMatch(sourceFolder, fileUrl), equalTo(true));
assertThat(this.filter.isMatch(sourceFolder, fileUrl)).isTrue();
}
private void doTest(String sourcePostfix) throws MalformedURLException {
@ -99,7 +98,8 @@ public class DefaultSourceFolderUrlFilterTests {
for (String postfix : COMMON_POSTFIXES) {
for (URL url : getUrls(moduleRoot + postfix)) {
boolean match = this.filter.isMatch(sourceFolder, url);
assertThat(url + " against " + sourceFolder, match, equalTo(expected));
assertThat(match).as(url + " against " + sourceFolder)
.isEqualTo(expected);
}
}
}

12
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/server/HttpRestartServerTests.java
View File

@ -37,9 +37,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
@ -92,8 +90,8 @@ public class HttpRestartServerTests {
this.server.handle(new ServletServerHttpRequest(request),
new ServletServerHttpResponse(response));
verify(this.delegate).updateAndRestart(this.filesCaptor.capture());
assertThat(this.filesCaptor.getValue().getFile("name"), notNullValue());
assertThat(response.getStatus(), equalTo(200));
assertThat(this.filesCaptor.getValue().getFile("name")).isNotNull();
assertThat(response.getStatus()).isEqualTo(200);
}
@Test
@ -103,7 +101,7 @@ public class HttpRestartServerTests {
this.server.handle(new ServletServerHttpRequest(request),
new ServletServerHttpResponse(response));
verifyZeroInteractions(this.delegate);
assertThat(response.getStatus(), equalTo(500));
assertThat(response.getStatus()).isEqualTo(500);
}
@ -115,7 +113,7 @@ public class HttpRestartServerTests {
this.server.handle(new ServletServerHttpRequest(request),
new ServletServerHttpResponse(response));
verifyZeroInteractions(this.delegate);
assertThat(response.getStatus(), equalTo(500));
assertThat(response.getStatus()).isEqualTo(500);
}
private byte[] serialize(Object object) throws IOException {

12
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/server/RestartServerTests.java
View File

@ -34,9 +34,7 @@ import org.springframework.boot.devtools.restart.classloader.ClassLoaderFile.Kin
import org.springframework.boot.devtools.restart.classloader.ClassLoaderFiles;
import org.springframework.util.FileCopyUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link RestartServer}.
@ -76,8 +74,8 @@ public class RestartServerTests {
files.addFile("my/module-c", "ClassB.class", fileB);
server.updateAndRestart(files);
Set<URL> expectedUrls = new LinkedHashSet<URL>(Arrays.asList(url1, url3));
assertThat(server.restartUrls, equalTo(expectedUrls));
assertThat(server.restartFiles, equalTo(files));
assertThat(server.restartUrls).isEqualTo(expectedUrls);
assertThat(server.restartFiles).isEqualTo(files);
}
@Test
@ -95,7 +93,7 @@ public class RestartServerTests {
ClassLoaderFile fileA = new ClassLoaderFile(Kind.ADDED, new byte[0]);
files.addFile("my/module-a", "ClassA.class", fileA);
server.updateAndRestart(files);
assertThat(jarFile.lastModified(), greaterThan(startTime - 1000));
assertThat(jarFile.lastModified()).isGreaterThan(startTime - 1000);
}
@Test
@ -114,7 +112,7 @@ public class RestartServerTests {
ClassLoaderFile fileA = new ClassLoaderFile(Kind.ADDED, "def".getBytes());
files.addFile("my/module-a", "ClassA.class", fileA);
server.updateAndRestart(files);
assertThat(FileCopyUtils.copyToByteArray(classFile), equalTo("def".getBytes()));
assertThat(FileCopyUtils.copyToByteArray(classFile)).isEqualTo("def".getBytes());
}
private static class MockRestartServer extends RestartServer {

28
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/settings/DevToolsSettingsTests.java
View File

@ -24,9 +24,7 @@ import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link DevToolsSettings}.
@ -45,28 +43,30 @@ public class DevToolsSettingsTests {
public void includePatterns() throws Exception {
DevToolsSettings settings = DevToolsSettings
.load(ROOT + "spring-devtools-include.properties");
assertThat(settings.isRestartInclude(new URL("file://test/a")), equalTo(true));
assertThat(settings.isRestartInclude(new URL("file://test/b")), equalTo(true));
assertThat(settings.isRestartInclude(new URL("file://test/c")), equalTo(false));
assertThat(settings.isRestartInclude(new URL("file://test/a"))).isTrue();
assertThat(settings.isRestartInclude(new URL("file://test/b"))).isTrue();
assertThat(settings.isRestartInclude(new URL("file://test/c"))).isFalse();
}
@Test
public void excludePatterns() throws Exception {
DevToolsSettings settings = DevToolsSettings
.load(ROOT + "spring-devtools-exclude.properties");
assertThat(settings.isRestartExclude(new URL("file://test/a")), equalTo(true));
assertThat(settings.isRestartExclude(new URL("file://test/b")), equalTo(true));
assertThat(settings.isRestartExclude(new URL("file://test/c")), equalTo(false));
assertThat(settings.isRestartExclude(new URL("file://test/a"))).isTrue();
assertThat(settings.isRestartExclude(new URL("file://test/b"))).isTrue();
assertThat(settings.isRestartExclude(new URL("file://test/c"))).isFalse();
}
@Test
public void defaultIncludePatterns() throws Exception {
DevToolsSettings settings = DevToolsSettings.get();
assertTrue(settings.isRestartExclude(makeUrl("spring-boot")));
assertTrue(settings.isRestartExclude(makeUrl("spring-boot-autoconfigure")));
assertTrue(settings.isRestartExclude(makeUrl("spring-boot-actuator")));
assertTrue(settings.isRestartExclude(makeUrl("spring-boot-starter")));
assertTrue(settings.isRestartExclude(makeUrl("spring-boot-starter-some-thing")));
assertThat(settings.isRestartExclude(makeUrl("spring-boot"))).isTrue();
assertThat(settings.isRestartExclude(makeUrl("spring-boot-autoconfigure")))
.isTrue();
assertThat(settings.isRestartExclude(makeUrl("spring-boot-actuator"))).isTrue();
assertThat(settings.isRestartExclude(makeUrl("spring-boot-starter"))).isTrue();
assertThat(settings.isRestartExclude(makeUrl("spring-boot-starter-some-thing")))
.isTrue();
}
private URL makeUrl(String name) throws IOException {

14
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/client/HttpTunnelConnectionTests.java
View File

@ -36,9 +36,7 @@ import org.springframework.boot.devtools.tunnel.client.HttpTunnelConnection.Tunn
import org.springframework.http.HttpStatus;
import org.springframework.util.SocketUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@ -107,9 +105,9 @@ public class HttpTunnelConnectionTests {
public void closeTunnelChangesIsOpen() throws Exception {
this.requestFactory.willRespondAfterDelay(1000, HttpStatus.GONE);
WritableByteChannel channel = openTunnel(false);
assertThat(channel.isOpen(), equalTo(true));
assertThat(channel.isOpen()).isTrue();
channel.close();
assertThat(channel.isOpen(), equalTo(false));
assertThat(channel.isOpen()).isFalse();
}
@Test
@ -129,7 +127,7 @@ public class HttpTunnelConnectionTests {
write(channel, "hello");
write(channel, "1+1");
write(channel, "1+2");
assertThat(this.incomingData.toString(), equalTo("hi=2=3"));
assertThat(this.incomingData.toString()).isEqualTo("hi=2=3");
}
@Test
@ -140,8 +138,8 @@ public class HttpTunnelConnectionTests {
this.requestFactory.willRespond("hi");
TunnelChannel channel = openTunnel(true);
write(channel, "hello");
assertThat(this.incomingData.toString(), equalTo("hi"));
assertThat(this.requestFactory.getExecutedRequests().size(), greaterThan(10));
assertThat(this.incomingData.toString()).isEqualTo("hi");
assertThat(this.requestFactory.getExecutedRequests().size()).isGreaterThan(10);
}
private void write(TunnelChannel channel, String string) throws IOException {

17
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/client/TunnelClientTests.java
View File

@ -31,8 +31,7 @@ import org.junit.rules.ExpectedException;
import org.springframework.util.SocketUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@ -76,7 +75,7 @@ public class TunnelClientTests {
channel.read(buffer);
channel.close();
this.tunnelConnection.verifyWritten("hello");
assertThat(new String(buffer.array()), equalTo("olleh"));
assertThat(new String(buffer.array())).isEqualTo("olleh");
}
@Test
@ -89,8 +88,8 @@ public class TunnelClientTests {
channel.close();
client.getServerThread().stopAcceptingConnections();
client.getServerThread().join(2000);
assertThat(this.tunnelConnection.getOpenedTimes(), equalTo(1));
assertThat(this.tunnelConnection.isOpen(), equalTo(false));
assertThat(this.tunnelConnection.getOpenedTimes()).isEqualTo(1);
assertThat(this.tunnelConnection.isOpen()).isFalse();
}
@Test
@ -101,9 +100,9 @@ public class TunnelClientTests {
.open(new InetSocketAddress(this.listenPort));
Thread.sleep(200);
client.stop();
assertThat(this.tunnelConnection.getOpenedTimes(), equalTo(1));
assertThat(this.tunnelConnection.isOpen(), equalTo(false));
assertThat(channel.read(ByteBuffer.allocate(1)), equalTo(-1));
assertThat(this.tunnelConnection.getOpenedTimes()).isEqualTo(1);
assertThat(this.tunnelConnection.isOpen()).isFalse();
assertThat(channel.read(ByteBuffer.allocate(1))).isEqualTo(-1);
}
@Test
@ -144,7 +143,7 @@ public class TunnelClientTests {
public void verifyWritten(byte[] expected) {
synchronized (this.written) {
assertThat(this.written.toByteArray(), equalTo(expected));
assertThat(this.written.toByteArray()).isEqualTo(expected);
this.written.reset();
}
}

7
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/payload/HttpTunnelPayloadForwarderTests.java
View File

@ -25,8 +25,7 @@ import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link HttpTunnelPayloadForwarder}.
@ -53,7 +52,7 @@ public class HttpTunnelPayloadForwarderTests {
forwarder.forward(payload(1, "he"));
forwarder.forward(payload(2, "ll"));
forwarder.forward(payload(3, "o"));
assertThat(out.toByteArray(), equalTo("hello".getBytes()));
assertThat(out.toByteArray()).isEqualTo("hello".getBytes());
}
@Test
@ -64,7 +63,7 @@ public class HttpTunnelPayloadForwarderTests {
forwarder.forward(payload(3, "o"));
forwarder.forward(payload(2, "ll"));
forwarder.forward(payload(1, "he"));
assertThat(out.toByteArray(), equalTo("hello".getBytes()));
assertThat(out.toByteArray()).isEqualTo("hello".getBytes());
}
@Test

22
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/payload/HttpTunnelPayloadTests.java
View File

@ -36,9 +36,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
@ -70,14 +68,14 @@ public class HttpTunnelPayloadTests {
@Test
public void getSequence() throws Exception {
HttpTunnelPayload payload = new HttpTunnelPayload(1, ByteBuffer.allocate(1));
assertThat(payload.getSequence(), equalTo(1L));
assertThat(payload.getSequence()).isEqualTo(1L);
}
@Test
public void getData() throws Exception {
ByteBuffer data = ByteBuffer.wrap("hello".getBytes());
HttpTunnelPayload payload = new HttpTunnelPayload(1, data);
assertThat(getData(payload), equalTo(data.array()));
assertThat(getData(payload)).isEqualTo(data.array());
}
@Test
@ -87,8 +85,8 @@ public class HttpTunnelPayloadTests {
MockHttpServletResponse servletResponse = new MockHttpServletResponse();
HttpOutputMessage response = new ServletServerHttpResponse(servletResponse);
payload.assignTo(response);
assertThat(servletResponse.getHeader("x-seq"), equalTo("2"));
assertThat(servletResponse.getContentAsString(), equalTo("hello"));
assertThat(servletResponse.getHeader("x-seq")).isEqualTo("2");
assertThat(servletResponse.getContentAsString()).isEqualTo("hello");
}
@Test
@ -96,7 +94,7 @@ public class HttpTunnelPayloadTests {
MockHttpServletRequest servletRequest = new MockHttpServletRequest();
HttpInputMessage request = new ServletServerHttpRequest(servletRequest);
HttpTunnelPayload payload = HttpTunnelPayload.get(request);
assertThat(payload, nullValue());
assertThat(payload).isNull();
}
@Test
@ -116,8 +114,8 @@ public class HttpTunnelPayloadTests {
servletRequest.addHeader("x-seq", 123);
HttpInputMessage request = new ServletServerHttpRequest(servletRequest);
HttpTunnelPayload payload = HttpTunnelPayload.get(request);
assertThat(payload.getSequence(), equalTo(123L));
assertThat(getData(payload), equalTo("hello".getBytes()));
assertThat(payload.getSequence()).isEqualTo(123L);
assertThat(getData(payload)).isEqualTo("hello".getBytes());
}
@Test
@ -130,7 +128,7 @@ public class HttpTunnelPayloadTests {
while (payloadData.hasRemaining()) {
writeChannel.write(payloadData);
}
assertThat(out.toByteArray(), equalTo("hello".getBytes()));
assertThat(out.toByteArray()).isEqualTo("hello".getBytes());
}
@Test
@ -139,7 +137,7 @@ public class HttpTunnelPayloadTests {
given(channel.read(any(ByteBuffer.class)))
.willThrow(new SocketTimeoutException());
ByteBuffer payload = HttpTunnelPayload.getPayloadData(channel);
assertThat(payload, nullValue());
assertThat(payload).isNull();
}
private byte[] getData(HttpTunnelPayload payload) throws IOException {

43
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/server/HttpTunnelServerTests.java
View File

@ -47,8 +47,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Mockito.mock;
@ -154,7 +153,7 @@ public class HttpTunnelServerTests {
this.serverChannel.send("hello");
this.serverChannel.disconnect();
this.server.getServerThread().join();
assertThat(this.servletResponse.getContentAsString(), equalTo("hello"));
assertThat(this.servletResponse.getContentAsString()).isEqualTo("hello");
this.serverChannel.verifyReceived("hello");
}
@ -193,7 +192,7 @@ public class HttpTunnelServerTests {
this.server.handle(h1);
this.serverChannel.disconnect();
this.server.getServerThread().join();
assertThat(h1.getServletResponse().getStatus(), equalTo(410));
assertThat(h1.getServletResponse().getStatus()).isEqualTo(410);
}
@Test
@ -204,8 +203,8 @@ public class HttpTunnelServerTests {
h2.getServletRequest().addHeader("Content-Type", "application/x-disconnect");
this.server.handle(h2);
this.server.getServerThread().join();
assertThat(h1.getServletResponse().getStatus(), equalTo(410));
assertThat(this.serverChannel.isOpen(), equalTo(false));
assertThat(h1.getServletResponse().getStatus()).isEqualTo(410);
assertThat(this.serverChannel.isOpen()).isFalse();
}
@Test
@ -217,7 +216,7 @@ public class HttpTunnelServerTests {
MockHttpConnection h3 = new MockHttpConnection("2", 3);
this.server.handle(h3);
h1.waitForResponse();
assertThat(h1.getServletResponse().getStatus(), equalTo(429));
assertThat(h1.getServletResponse().getStatus()).isEqualTo(429);
this.serverChannel.disconnect();
this.server.getServerThread().join();
}
@ -246,8 +245,8 @@ public class HttpTunnelServerTests {
Thread.sleep(400);
this.serverChannel.disconnect();
this.server.getServerThread().join();
assertThat(h1.getServletResponse().getStatus(), equalTo(204));
assertThat(h2.getServletResponse().getStatus(), equalTo(204));
assertThat(h1.getServletResponse().getStatus()).isEqualTo(204);
assertThat(h2.getServletResponse().getStatus()).isEqualTo(204);
}
@Test
@ -258,7 +257,7 @@ public class HttpTunnelServerTests {
this.server.handle(h1);
this.serverChannel.send("hello");
this.server.getServerThread().join();
assertThat(this.serverChannel.isOpen(), equalTo(false));
assertThat(this.serverChannel.isOpen()).isFalse();
}
@Test
@ -273,9 +272,9 @@ public class HttpTunnelServerTests {
HttpConnection connection = new HttpConnection(this.request, this.response);
connection.waitForResponse();
connection.respond(new HttpTunnelPayload(1, ByteBuffer.wrap("hello".getBytes())));
assertThat(this.servletResponse.getStatus(), equalTo(200));
assertThat(this.servletResponse.getContentAsString(), equalTo("hello"));
assertThat(this.servletResponse.getHeader(SEQ_HEADER), equalTo("1"));
assertThat(this.servletResponse.getStatus()).isEqualTo(200);
assertThat(this.servletResponse.getContentAsString()).isEqualTo("hello");
assertThat(this.servletResponse.getHeader(SEQ_HEADER)).isEqualTo("1");
}
@Test
@ -283,8 +282,8 @@ public class HttpTunnelServerTests {
HttpConnection connection = new HttpConnection(this.request, this.response);
connection.waitForResponse();
connection.respond(HttpStatus.I_AM_A_TEAPOT);
assertThat(this.servletResponse.getStatus(), equalTo(418));
assertThat(this.servletResponse.getContentLength(), equalTo(0));
assertThat(this.servletResponse.getStatus()).isEqualTo(418);
assertThat(this.servletResponse.getContentLength()).isEqualTo(0);
}
@Test
@ -322,19 +321,19 @@ public class HttpTunnelServerTests {
};
connectionThread.start();
assertThat(responded.get(), equalTo(false));
assertThat(responded.get()).isFalse();
Thread.sleep(sleepBeforeResponse);
connection.respond(HttpStatus.NO_CONTENT);
connectionThread.join();
assertThat(responded.get(), equalTo(true));
assertThat(responded.get()).isTrue();
}
@Test
public void httpConnectionRunning() throws Exception {
HttpConnection connection = new HttpConnection(this.request, this.response);
assertThat(connection.isOlderThan(100), equalTo(false));
assertThat(connection.isOlderThan(100)).isFalse();
Thread.sleep(200);
assertThat(connection.isOlderThan(100), equalTo(true));
assertThat(connection.isOlderThan(100)).isTrue();
}
/**
@ -374,7 +373,7 @@ public class HttpTunnelServerTests {
public void verifyReceived(byte[] expected) {
synchronized (this.written) {
assertThat(this.written.toByteArray(), equalTo(expected));
assertThat(this.written.toByteArray()).isEqualTo(expected);
this.written.reset();
}
}
@ -466,8 +465,8 @@ public class HttpTunnelServerTests {
throws Exception {
waitForServletResponse();
MockHttpServletResponse resp = getServletResponse();
assertThat(resp.getContentAsString(), equalTo(expectedContent));
assertThat(resp.getHeader(SEQ_HEADER), equalTo(String.valueOf(expectedSeq)));
assertThat(resp.getContentAsString()).isEqualTo(expectedContent);
assertThat(resp.getHeader(SEQ_HEADER)).isEqualTo(String.valueOf(expectedSeq));
}
public void waitForServletResponse() throws InterruptedException {

13
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/server/SocketTargetServerConnectionTests.java
View File

@ -29,10 +29,7 @@ import org.junit.Test;
import org.springframework.util.SocketUtils;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThanOrEqualTo;
import static org.hamcrest.Matchers.lessThan;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
/**
@ -65,7 +62,7 @@ public class SocketTargetServerConnectionTests {
ByteChannel channel = this.connection.open(DEFAULT_TIMEOUT);
ByteBuffer buffer = ByteBuffer.allocate(5);
channel.read(buffer);
assertThat(buffer.array(), equalTo("hello".getBytes()));
assertThat(buffer.array()).isEqualTo("hello".getBytes());
}
@Test
@ -91,8 +88,8 @@ public class SocketTargetServerConnectionTests {
catch (SocketTimeoutException ex) {
// Expected
long runTime = System.currentTimeMillis() - startTime;
assertThat(runTime, greaterThanOrEqualTo(10L));
assertThat(runTime, lessThan(10000L));
assertThat(runTime).isGreaterThanOrEqualTo(10L);
assertThat(runTime).isLessThan(10000L);
}
}
@ -134,7 +131,7 @@ public class SocketTargetServerConnectionTests {
public void closeAndVerify() throws InterruptedException {
close();
assertThat(this.actualRead.array(), equalTo(this.expect));
assertThat(this.actualRead.array()).isEqualTo(this.expect);
}
public void close() throws InterruptedException {

5
spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/server/StaticPortProviderTests.java
View File

@ -20,8 +20,7 @@ import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link StaticPortProvider}.
@ -43,7 +42,7 @@ public class StaticPortProviderTests {
@Test
public void getPort() throws Exception {
StaticPortProvider provider = new StaticPortProvider(123);
assertThat(provider.getPort(), equalTo(123));
assertThat(provider.getPort()).isEqualTo(123);
}
}