@Test
public void write() throws IOException
{
int bufferedDataBlocks = 3;
int expectedOnProgressCallWithBuffer = bufferedDataBlocks;
int expectedOnFinishCall = 1;
final int[] actualOnProgressCall = {0};
final int[] actualOnFinishCall = {0};
byte[] bytes = new byte[InputStreamExtensions.IO_BUFFER_SIZE * bufferedDataBlocks];
ByteArrayOutputStream os = new ByteArrayOutputStream(bytes.length);
ProgressBufferedOutputStream progressBufferedOutputStream
= new ProgressBufferedOutputStream(os, new StreamProgressListener(bytes.length, new ProgressListener<Long>()
{
@Override
public void onProgress(int progress)
{
actualOnProgressCall[0]++;
}
@Override
public void onFinish(Long toalBytes)
{
actualOnFinishCall[0]++;
}
}));
_._(new ByteArrayInputStream(new byte[bytes.length])).copyTo(progressBufferedOutputStream,true,true);
MatcherAssert.assertThat(actualOnProgressCall[0], is(expectedOnProgressCallWithBuffer));
MatcherAssert.assertThat(actualOnFinishCall[0], is(expectedOnFinishCall));
}
@BenchmarkOptions(benchmarkRounds = 1, warmupRounds = 0)
@Test
public void validateRetieveItemWithLastAccessUpdateTimeDelay() throws Exception {
// need to ensure we wait 100 ms
int wait = 100;
((DefaultAttributesHandler) repository.getAttributesHandler()).setLastRequestedResolution(wait);
Thread.sleep(wait);
AttributeStorage attributeStorageSpy =
Mockito.spy(repository.getAttributesHandler().getAttributeStorage());
repository.getAttributesHandler().setAttributeStorage(attributeStorageSpy);
ResourceStoreRequest resourceRequest = new ResourceStoreRequest(testFilePath);
resourceRequest.getRequestContext().put(AccessManager.REQUEST_REMOTE_ADDRESS, "127.0.0.1");
AbstractStorageItem storageItem =
localRepositoryStorageUnderTest.retrieveItem(repository, resourceRequest);
MatcherAssert.assertThat(storageItem, Matchers.notNullValue());
MatcherAssert.assertThat(
storageItem.getLastRequested(), Matchers.greaterThan(originalLastAccessTime));
Mockito.verify(attributeStorageSpy, Mockito.times(1))
.putAttributes(Mockito.<RepositoryItemUid>any(), Mockito.<Attributes>any());
Mockito.verify(attributeStorageSpy, Mockito.times(1))
.getAttributes(Mockito.<RepositoryItemUid>any());
}
/**
* Cacheable can cache static calls.
*
* @throws Exception If something goes wrong
*/
@Test
public void cachesSimpleStaticCall() throws Exception {
final String first = CacheableTest.Foo.staticGet();
MatcherAssert.assertThat(first, Matchers.equalTo(CacheableTest.Foo.staticGet()));
CacheableTest.Foo.staticFlush();
MatcherAssert.assertThat(CacheableTest.Foo.staticGet(), Matchers.not(Matchers.equalTo(first)));
}
@BenchmarkOptions(benchmarkRounds = 10, warmupRounds = 1)
@Test
public void validateRetieveItemWithOutLastAccessUpdateTimeDelay()
throws LocalStorageException, ItemNotFoundException, IOException {
// do the test, but make sure the _iterations_ will not get out of the "resolution" span!
// Note: this test is just broken as is, what guarantees it will finish the cycles in given X
// millis?
// Meaning, the assertions + rounds is wrong.
((DefaultAttributesHandler) repository.getAttributesHandler())
.setLastRequestedResolution(30000L);
AttributeStorage attributeStorageSpy =
Mockito.spy(repository.getAttributesHandler().getAttributeStorage());
repository.getAttributesHandler().setAttributeStorage(attributeStorageSpy);
ResourceStoreRequest resourceRequest = new ResourceStoreRequest(testFilePath);
resourceRequest.getRequestContext().put(AccessManager.REQUEST_REMOTE_ADDRESS, "127.0.0.1");
AbstractStorageItem storageItem =
localRepositoryStorageUnderTest.retrieveItem(repository, resourceRequest);
MatcherAssert.assertThat(storageItem, Matchers.notNullValue());
MatcherAssert.assertThat(
storageItem.getLastRequested(), Matchers.equalTo(originalLastAccessTime));
Mockito.verify(attributeStorageSpy, Mockito.times(0))
.putAttributes(Mockito.<RepositoryItemUid>any(), Mockito.<Attributes>any());
Mockito.verify(attributeStorageSpy, Mockito.times(1))
.getAttributes(Mockito.<RepositoryItemUid>any());
}
@Test
public void testLatLonInOneValue() throws Exception {
String mapping =
XContentFactory.contentTextBuilder(XContentType.JSON)
.startObject()
.startObject("type")
.startObject("properties")
.startObject("point")
.field("type", "geo_point")
.field("geohash", true)
.field("lat_lon", false)
.endObject()
.endObject()
.endObject()
.endObject()
.string();
XContentDocumentMapper defaultMapper = XContentMapperTests.newParser().parse(mapping);
ParsedDocument doc =
defaultMapper.parse(
"type",
"1",
XContentFactory.jsonBuilder()
.startObject()
.field("point", "1.2,1.3")
.endObject()
.copiedBytes());
MatcherAssert.assertThat(doc.doc().getField("point.lat"), nullValue());
MatcherAssert.assertThat(doc.doc().getField("point.lon"), nullValue());
MatcherAssert.assertThat(
doc.doc().get("point.geohash"), equalTo(GeoHashUtils.encode(1.2, 1.3)));
}
@Test
public void includeAsClasses() throws Exception {
String baseDir = testIssue("flexmojos-247").getBasedir();
File target = new File(baseDir, "target");
Assert.assertTrue(target.exists());
File swc = new File(target, "flexmojos-247-1.0-SNAPSHOT.swc");
Assert.assertTrue(swc.exists());
String catalog;
ZipFile zf = new ZipFile(swc);
try {
InputStream in = zf.getInputStream(zf.getEntry("catalog.xml"));
catalog = IOUtils.toString(in);
in.close();
} finally {
zf.close();
}
// must have both classes and the uri
MatcherAssert.assertThat(catalog, StringContains.containsString("AClass"));
MatcherAssert.assertThat(catalog, StringContains.containsString("BClass"));
MatcherAssert.assertThat(
catalog, StringContains.containsString("http://flexmojos.sonatype.org/tests"));
}
/**
* RtRepoCommits can compare two commits and return result in patch mode.
*
* @throws Exception if there is no github key provided
*/
@Test
public final void compareCommitsPatch() throws Exception {
final String patch = RtRepoCommitsITCase.repo().commits().patch("5339b8e35b", "9b2e6efde9");
MatcherAssert.assertThat(
patch, Matchers.startsWith("From 9b2e6efde94fabec5876dc481b38811e8b4e992f"));
MatcherAssert.assertThat(
patch, Matchers.containsString("Issue #430 RepoCommit interface was added"));
}
/**
* Cacheable can cache calls.
*
* @throws Exception If something goes wrong
*/
@Test
public void cachesSimpleCall() throws Exception {
final CacheableTest.Foo foo = new CacheableTest.Foo(1L);
final String first = foo.get().toString();
MatcherAssert.assertThat(first, Matchers.equalTo(foo.get().toString()));
foo.flush();
MatcherAssert.assertThat(foo.get().toString(), Matchers.not(Matchers.equalTo(first)));
}
/**
* RtReleases can remove a release.
*
* @throws Exception if any problem inside
*/
@Test
public void canRemoveRelease() throws Exception {
final Releases releases = repo.releases();
final Release release = releases.create(RandomStringUtils.randomAlphanumeric(Tv.TEN));
MatcherAssert.assertThat(releases.iterate(), Matchers.hasItem(release));
releases.remove(release.number());
MatcherAssert.assertThat(releases.iterate(), Matchers.not(Matchers.hasItem(release)));
}
/**
* FkHost can match a host.
*
* @throws IOException If some problem inside
*/
@Test
public void matchesByHost() throws IOException {
MatcherAssert.assertThat(
new FkHost("www.example.com", new TkEmpty()).route(new RqFake("GET", "/hel?a=1")).has(),
Matchers.is(true));
MatcherAssert.assertThat(
new FkHost("google.com", new TkEmpty()).route(new RqFake("PUT", "/?test")).has(),
Matchers.is(false));
}
/**
* CcBase64 can encode and decode.
*
* @throws IOException If some problem inside
*/
@Test
public void encodesAndDecodes() throws IOException {
final String urn = "urn:test:Hello World!";
final Map<String, String> properties = ImmutableMap.of("userName", "user");
final Codec codec = new CcBase64(new CcPlain());
final Identity expected = codec.decode(codec.encode(new Identity.Simple(urn, properties)));
MatcherAssert.assertThat(expected.urn(), Matchers.equalTo(urn));
MatcherAssert.assertThat(expected.properties(), Matchers.equalTo(properties));
}
public static void verifyOrderedList(SortedSet<Bid> bids) {
if (bids.size() > 0) {
double firstPrice = bids.first().getPrice();
double lastPrice = bids.last().getPrice();
for (Bid bid : bids) {
MatcherAssert.assertThat(bid.getPrice(), greaterThanOrEqualTo(firstPrice));
MatcherAssert.assertThat(bid.getPrice(), lessThanOrEqualTo(lastPrice));
}
}
}
/**
* ArrayMap can be equal to another map.
*
* @throws Exception If some problem inside
*/
@Test
public void comparesCorrectlyWithAnotherMap() throws Exception {
MatcherAssert.assertThat(
new ArrayMap<Integer, Integer>().with(1, 1).with(2, 2),
Matchers.equalTo(new ArrayMap<Integer, Integer>().with(2, 2).with(1, 1)));
MatcherAssert.assertThat(
new ArrayMap<Class<?>, Integer>().with(String.class, 1).with(Integer.class, 2),
Matchers.equalTo(
new ArrayMap<Class<?>, Integer>().with(Integer.class, 2).with(String.class, 1)));
}
/**
* Cacheable can Asynchronous update.
*
* @throws Exception If something goes wrong
*/
@Test
public void asyncUpdateCacheSimpleCall() throws Exception {
final CacheableTest.Foo foo = new CacheableTest.Foo(1L);
final String first = foo.asyncGet().toString();
MatcherAssert.assertThat(first, Matchers.equalTo(foo.asyncGet().toString()));
TimeUnit.SECONDS.sleep(2);
MatcherAssert.assertThat(first, Matchers.equalTo(foo.asyncGet().toString()));
TimeUnit.SECONDS.sleep(2);
MatcherAssert.assertThat(first, Matchers.not(Matchers.equalTo(foo.asyncGet().toString())));
}
/** AwsRules can cache results of get() and iterator() as same rules. */
@Test
public void returnsGetAndIteratorAsSameRules() {
final Item item = Mockito.mock(Item.class);
final String name = "rule-name-foo";
Mockito.doReturn(new AttributeValue(name)).when(item).get(Mockito.anyString());
final Region region = new RegionMocker().with(item).mock();
final Rules rules = new AwsRules(region, Mockito.mock(SQSClient.class), new URN());
MatcherAssert.assertThat(rules.get(name).name(), Matchers.equalTo(name));
MatcherAssert.assertThat(rules.iterator().next().name(), Matchers.equalTo(name));
Mockito.verify(item, Mockito.times(1)).get(Mockito.anyString());
}
/**
* DyAlias can make an alias.
*
* @throws Exception If there is some problem inside
*/
@Test
public void makesAlias() throws Exception {
final Aliases aliases = new DyBase().user(new URN("urn:test:12")).aliases();
final String name = "walter";
aliases.add(name);
MatcherAssert.assertThat(aliases.check(name), Matchers.not(Matchers.isEmptyOrNullString()));
final Alias alias = aliases.iterate().iterator().next();
MatcherAssert.assertThat(alias, new Alias.HasName(Matchers.equalTo(name)));
alias.photo(new URI("http://localhost#test"));
MatcherAssert.assertThat(alias.photo().toString(), Matchers.containsString("#test"));
}
@Test
public void listAll() {
Mockito.when(repository.all(QSampleEntity.sampleEntity, QSampleEntity.sampleEntity))
.thenReturn(getList());
List<SampleEntity> list = service.list("");
Mockito.verify(repository).all(QSampleEntity.sampleEntity, QSampleEntity.sampleEntity);
MatcherAssert.assertThat(list, Matchers.hasSize(1));
MatcherAssert.assertThat(list, Matchers.contains(createSampleEntity(ID, null)));
}
/**
* RtReleases can fetch a single release.
*
* @throws Exception if any error inside
*/
@Test
public void canFetchRelease() throws Exception {
final Releases releases = repo.releases();
final String tag = "v1.0";
final Release release = releases.create(tag);
MatcherAssert.assertThat(
releases.get(release.number()).number(), Matchers.equalTo(release.number()));
MatcherAssert.assertThat(
new Release.Smart(releases.get(release.number())).tag(), Matchers.equalTo(tag));
releases.remove(release.number());
}
@Test
public void testEntrySet() {
Map<Integer, String> map = redisson.getMap("simple12");
map.put(1, "12");
map.put(2, "33");
map.put(3, "43");
Assert.assertEquals(3, map.entrySet().size());
MatcherAssert.assertThat(map, Matchers.hasEntry(Matchers.equalTo(1), Matchers.equalTo("12")));
MatcherAssert.assertThat(map, Matchers.hasEntry(Matchers.equalTo(2), Matchers.equalTo("33")));
MatcherAssert.assertThat(map, Matchers.hasEntry(Matchers.equalTo(3), Matchers.equalTo("43")));
}
@BenchmarkOptions(benchmarkRounds = 10, warmupRounds = 1)
@Test
public void testRetieveItemWithoutLastAccessUpdate()
throws LocalStorageException, ItemNotFoundException {
ResourceStoreRequest resourceRequest = new ResourceStoreRequest(testFilePath);
AbstractStorageItem storageItem =
localRepositoryStorageUnderTest.retrieveItem(repository, resourceRequest);
MatcherAssert.assertThat(storageItem, Matchers.notNullValue());
MatcherAssert.assertThat(
storageItem.getLastRequested(), Matchers.equalTo(originalLastAccessTime));
}
/**
* AwsUser can work with real data.
*
* @throws Exception If some problem inside
*/
@Test
public void worksWithRealDynamoDb() throws Exception {
final URN urn = new URN("urn:github:66");
final User user = new AwsUser(this.region, Mockito.mock(SQSClient.class), urn);
MatcherAssert.assertThat(user.urn(), Matchers.equalTo(urn));
for (Rule rule : user.rules()) {
user.rules().remove(rule.name());
}
final String name = "simple-rule";
user.rules().create(name);
MatcherAssert.assertThat(user.rules(), Matchers.<Rule>iterableWithSize(1));
MatcherAssert.assertThat(user.rules().contains(name), Matchers.is(true));
}
@BenchmarkOptions(benchmarkRounds = 10, warmupRounds = 1)
@Test
public void testRetieveItemWithLastAccessUpdate()
throws LocalStorageException, ItemNotFoundException {
ResourceStoreRequest resourceRequest = new ResourceStoreRequest(testFilePath);
resourceRequest.getRequestContext().put(AccessManager.REQUEST_REMOTE_ADDRESS, "127.0.0.1");
AbstractStorageItem storageItem =
localRepositoryStorageUnderTest.retrieveItem(repository, resourceRequest);
MatcherAssert.assertThat(storageItem, Matchers.notNullValue());
MatcherAssert.assertThat(
storageItem.getLastRequested(), Matchers.greaterThan(originalLastAccessTime));
}
/**
* RtReleases can create a release.
*
* @throws Exception if any error inside
*/
@Test
public void canCreateRelease() throws Exception {
final Releases releases = repo.releases();
final Release created = releases.create("0.1");
final int number = created.number();
try {
final Release obtained = releases.get(number);
MatcherAssert.assertThat(created, Matchers.is(obtained));
MatcherAssert.assertThat(
new Release.Smart(created).tag(), Matchers.equalTo(new Release.Smart(obtained).tag()));
} finally {
releases.remove(number);
}
}
public static void transactionVerification(Queue<Transaction> transactions) {
for (Transaction transaction : transactions) {
MatcherAssert.assertThat(
transaction.getBuy().getStock(), is(transaction.getSell().getStock()));
double buyPrice = transaction.getBuy().getPrice();
double sellPrice = transaction.getSell().getPrice();
double transactionPrice = transaction.getPrice();
MatcherAssert.assertThat(buyPrice, greaterThanOrEqualTo(sellPrice));
MatcherAssert.assertThat(
transactionPrice, anyOf(closeTo(buyPrice, 0.0001), closeTo(sellPrice, 0.0001)));
}
}
@Test
public void testWordListPath() throws Exception {
Environment env = new Environment(ImmutableSettings.Builder.EMPTY_SETTINGS);
String[] words = new String[] {"donau", "dampf", "schiff", "spargel", "creme", "suppe"};
File wordListFile = generateWordList(words);
Settings settings =
settingsBuilder()
.loadFromSource("index: \n word_list_path: " + wordListFile.getAbsolutePath())
.build();
Set<String> wordList = Analysis.getWordSet(env, settings, "index.word_list");
MatcherAssert.assertThat(wordList.size(), equalTo(6));
MatcherAssert.assertThat(wordList, hasItems(words));
}
/**
* WebLinkingResponse can follow a link.
*
* @throws Exception If something goes wrong inside
*/
@Test
public void followsLinksInHeaders() throws Exception {
final WebLinkingResponse response =
new WebLinkingResponse(
new FakeRequest()
.withHeader("Link", "</a>; rel=\"first\", <http://localhost/o>; rel=\"second\"")
.uri()
.set(new URI("http://localhost/test"))
.back()
.fetch());
MatcherAssert.assertThat(
response.follow("first").uri().get(), Matchers.equalTo(new URI("http://localhost/a")));
MatcherAssert.assertThat(
response.follow("second").uri().get(), Matchers.equalTo(new URI("http://localhost/o")));
}
/**
* AwsUser can have a name.
*
* @throws Exception If some problem inside
*/
@Test
public void hasName() throws Exception {
final Region region = Mockito.mock(Region.class);
final URN urn = new URN("urn:facebook:444");
final User user = new AwsUser(region, Mockito.mock(SQSClient.class), urn);
MatcherAssert.assertThat(user.urn(), Matchers.equalTo(urn));
}
@Test
public void testOnInsertString() {
// Given:
selectedTU = currentPageRows.get(0);
when(editor.getId()).thenReturn(selectedTU.getId());
when(display.getId()).thenReturn(selectedTU.getId());
when(display.getEditors()).thenReturn(Lists.newArrayList(editor));
when(tableEditorMessages.notifyCopied()).thenReturn("copied");
when(sourceContentPresenter.getSourceContent(selectedTU.getId()))
.thenReturn(Optional.of("source content"));
presenter.setStatesForTesting(selectedTU.getId(), 0, display);
// When:
presenter.onInsertString(new InsertStringInEditorEvent("", "suggestion"));
// Then:
verify(editor).insertTextInCursorPosition("suggestion");
verify(eventBus, atLeastOnce()).fireEvent(eventCaptor.capture());
NotificationEvent notificationEvent =
TestFixture.extractFromEvents(eventCaptor.getAllValues(), NotificationEvent.class);
MatcherAssert.assertThat(notificationEvent.getMessage(), Matchers.equalTo("copied"));
RunValidationEvent runValidationEvent =
TestFixture.extractFromEvents(eventCaptor.getAllValues(), RunValidationEvent.class);
assertThat(runValidationEvent.getSourceContent(), equalTo("source content"));
}
/** MkAnswerMatchers can match MkAnswer body bytes. */
@Test
public void canMatchBodyBytes() {
final byte[] body = {0x01, 0x45, 0x21};
final MkAnswer query = Mockito.mock(MkAnswer.class);
Mockito.doReturn(body).when(query).bodyBytes();
MatcherAssert.assertThat(query, MkAnswerMatchers.hasBodyBytes(Matchers.is(body)));
}
/** MkAnswerMatchers should be able to match MkAnswer body. */
@Test
public void canMatchBody() {
final String body = "Hello \u20ac!";
final MkAnswer query = Mockito.mock(MkAnswer.class);
Mockito.doReturn(body).when(query).body();
MatcherAssert.assertThat(query, MkAnswerMatchers.hasBody(Matchers.is(body)));
}