@Test
public void ensureLoadCascadesWell() {
User u1 = getUserService().find().matching(new FindUserByLogin()).getFirst();
assertThat(u1.about, IsNull.notNullValue());
assertThat(u1.about, IsInstanceOf.instanceOf(Post.class));
assertThat(((Post) u1.about).text, IsNull.notNullValue());
}
@Test
public void ensureAPostCanHaveAValueNulled() throws IOException, ClassNotFoundException {
Post tested = new Post().withAuthor(author).withText("ensureAPostCanHaveAValueNulled");
tested = getPostService().create(tested);
assertThat(tested.text, IsNull.notNullValue());
tested.text = null;
tested = getPostService().update(tested);
// force reload from graph
tested = ((IdBasedService<Post>) getPostService()).findById(tested.id);
assertThat(tested.text, IsNull.nullValue());
}
@Test
public void responseWithoutDescriptionsCanBeRoundTripped() {
// Act:
final ErrorResponse response =
createRoundTrippedResponse(new ErrorResponse(new TimeInstant(54), null, 890));
// Assert:
Assert.assertThat(response.getTimeStamp(), IsEqual.equalTo(new TimeInstant(54)));
Assert.assertThat(response.getError(), IsNull.nullValue());
Assert.assertThat(response.getMessage(), IsNull.nullValue());
Assert.assertThat(response.getStatus(), IsEqual.equalTo(890));
}
@Test
public void parseTest() {
System.setProperty("http.proxyHost", "myproxy");
System.setProperty("http.proxyPort", "80");
System.setProperty("http.nonProxyHosts", "127.0.0.1|localhost|*.company.com");
{
final List<Proxy> proxyList =
ProxySelector.getDefault().select(URI.create("http://localhost:8080/confluence/xmlrpc"));
Assert.assertThat(proxyList.isEmpty(), Is.is(false));
Assert.assertThat(proxyList.size(), Is.is(1));
final Proxy p = proxyList.get(0);
System.out.printf("type=[%s] address=[%s]\n", p.type(), p.address());
Assert.assertThat(p.type(), Is.is(Type.DIRECT));
Assert.assertThat(p.address(), IsNull.nullValue());
}
{
final List<Proxy> proxyList =
ProxySelector.getDefault()
.select(URI.create("http://my.company.com:8033/confluence/xmlrpc"));
Assert.assertThat(proxyList.isEmpty(), Is.is(false));
Assert.assertThat(proxyList.size(), Is.is(1));
final Proxy p = proxyList.get(0);
System.out.printf("type=[%s] address=[%s]\n", p.type(), p.address());
Assert.assertThat(p.type(), Is.is(Type.DIRECT));
Assert.assertThat(p.address(), IsNull.nullValue());
}
{
final List<Proxy> proxyList =
ProxySelector.getDefault().select(URI.create("http://www.google.com/confluence/xmlrpc"));
Assert.assertThat(proxyList.isEmpty(), Is.is(false));
Assert.assertThat(proxyList.size(), Is.is(1));
final Proxy p = proxyList.get(0);
System.out.printf("type=[%s] address=[%s]\n", p.type(), p.address());
Assert.assertThat(p.type(), Is.is(Type.HTTP));
Assert.assertThat(p.address(), IsNull.notNullValue());
}
}
@Test
public void ensureCascadedCreateWorks() throws IOException, ClassNotFoundException {
String METHOD_NAME = "ensureCascadedCreateWorks";
Post toCreate = new Post();
toCreate.text = METHOD_NAME;
User author = new User();
author.password = METHOD_NAME;
author.setLogin(METHOD_NAME);
toCreate.author = author;
getPostService().create(toCreate);
// Find it back
Post found = getPostService().find().matching(new FindPostByText(METHOD_NAME)).getFirst();
assertThat(found, IsNull.notNullValue());
assertThat(found.author, IsNull.notNullValue());
assertThat(found.author.getLogin(), IsNull.notNullValue());
}
@Test
public void serializeAuthorAndPosts() throws IOException, ClassNotFoundException {
User u1 = getUserService().find().matching(new FindUserByLogin()).getFirst();
assertThat(u1, IsNull.notNullValue());
assertThat(u1.posts.size(), IsNot.not(0));
// Now serialize and deserialize a second version of author
User u2 = getUserService().find().matching(new FindUserByLogin()).getFirst();
// Serialize it
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream output = new ObjectOutputStream(bos);
output.writeObject(u2);
output.close();
bos.close();
// then deserialize
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream input = new ObjectInputStream(bis);
User u3 = (User) input.readObject();
input.close();
bis.close();
assertThat(u3, Is.is(u1));
assertThat(u3.posts.size(), Is.is(u1.posts.size()));
assertThat(Proxy.isProxyClass(u3.posts.getClass()), Is.is(false));
}
@Before
public void loadCredentials() {
login = System.getProperty("wordpress.login");
assertThat(login, IsNull.notNullValue());
password = System.getProperty("wordpress.password");
assertThat(password, IsNull.notNullValue());
site = System.getProperty("wordpress.address");
assertThat(site, IsNull.notNullValue());
configuration =
new WordpressConfiguration(VFSHelper.getRunningDir())
.withLogin(login)
.withPassword(password)
.withSite(site);
tested = new Wordpress();
}
@Test
public void shouldParseMotechProperties() {
MotechProperties motechProperties =
(MotechProperties) reader.readFromFile("/motech-properties.json", MotechProperties.class);
assertThat(motechProperties.size(), IsEqual.equalTo(14));
assertThat(motechProperties.get("case_name"), IsEqual.equalTo("Pankaja"));
assertThat(motechProperties.get("family_number"), IsEqual.equalTo(""));
assertThat(motechProperties.get("external_id"), IsNull.nullValue());
}
@Test
public void ensureMapIsWellLoaded() throws IOException, ClassNotFoundException {
Post first = getPostService().find().matching(new FindPostByNote(1)).getFirst();
assertThat(first.id, Is.is(1L));
assertThat(first.annotations.size(), IsNot.not(0));
// Now serialize all to the second
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutput = new ObjectOutputStream(outputStream);
objectOutput.writeObject(first);
ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
ObjectInputStream objectInput = new ObjectInputStream(inputStream);
Post second = (Post) objectInput.readObject();
// Now perform some verifications
assertThat(second, IsNull.notNullValue());
assertThat(second.id, Is.is(1L));
assertThat(second.annotations, IsNull.notNullValue());
assertThat(second.annotations.size(), IsNot.not(0));
}
@Test
public void ensureFindByIdWorksWell() {
if (getPostService() instanceof IdBasedService) {
IdBasedService idPosts = (IdBasedService) getPostService();
Post first = (Post) idPosts.findById(ID_POST_1);
assertThat(first, IsNull.notNullValue());
} else {
Assert.fail("post service is an id based service, we all know that !");
}
}
@Test
public void openWriteCanOpenFileThatExists() throws IOException {
// Arrange:
final TEntityFileDescriptor descriptor = this.createDescriptor(TEST_FILE);
// Act:
try (final OutputStream os = descriptor.openWrite()) {
// Assert:
Assert.assertThat(os, IsNull.notNullValue());
}
}
@Test
public void ensureDeletCascadesWell() {
User other = new User().withId(2).withLogin("other login").withPassword("other password");
long id = DELETABLE_POST;
other.about = new Post(id, "a post about another user", 2, State.PUBLIC, other);
getUserService().create(other);
Post about = ((IdBasedService<Post>) getPostService()).findById(id);
assertThat(about, IsNull.notNullValue());
getUserService().delete(other);
try {
if (environment.getGraph() instanceof TransactionalGraph) {
TransactionalGraph transactionalGraph = (TransactionalGraph) environment.getGraph();
// transactionalGraph.startTransaction();
}
about = ((IdBasedService<Post>) getPostService()).findById(id);
assertThat(about, IsNull.nullValue());
} catch (NoReturnableVertexException e) {
// that exception is one of possible correct behaviours
}
}
@Test
public void testFixture_SetterInjection() {
MyCommandHandler commandHandler = new MyCommandHandler();
commandHandler.setRepository(fixture.getRepository());
fixture
.registerAnnotatedCommandHandler(commandHandler)
.given(new MyEvent("aggregateId", 1), new MyEvent("aggregateId", 2))
.when(new TestCommand("aggregateId"))
.expectReturnValue(IsNull.nullValue())
.expectEvents(new MyEvent("aggregateId", 3));
}
@Test
public void updateAboutWithAuthor() {
author.setLogin("new login");
// here we modify about and let author update it for us
String aboutText = "this is now user " + author.getLogin();
((Post) author.about).text = aboutText;
getUserService().update(author);
Post about = ((IdBasedService<Post>) getPostService()).findById(ABOUT_ID);
assertThat(about, IsNull.notNullValue());
assertThat(about.text, Is.is(aboutText));
}
@Test
public void canBeCreatedAroundUnknownHttpStatus() {
// Arrange:
final ErrorResponse response =
new ErrorResponse(new TimeInstant(18), "exception message", -123);
// Assert:
Assert.assertThat(response.getTimeStamp(), IsEqual.equalTo(new TimeInstant(18)));
Assert.assertThat(response.getError(), IsNull.nullValue());
Assert.assertThat(response.getMessage(), IsEqual.equalTo("exception message"));
Assert.assertThat(response.getStatus(), IsEqual.equalTo(-123));
}
@Test
public void openWriteCanOpenFileThatDoesNotExist() throws IOException {
// Arrange:
final File file = new File(TEST_FILE_DIRECTORY, "imaginary-write.bar");
final TEntityFileDescriptor descriptor = this.createDescriptor(file);
// Act:
try (final OutputStream os = descriptor.openWrite()) {
// Assert:
Assert.assertThat(os, IsNull.notNullValue());
}
}
private static void assertJvmInfo(JsonObject jvm) {
assertThat(jvm, IsNull.notNullValue());
assertThat(jvm.get("vendor"), IsNull.notNullValue());
assertThat(jvm.get("version"), IsNull.notNullValue());
JsonArray jPackages = (JsonArray) jvm.get("platformPackages");
for (JsonElement jPackage : jPackages) {
String name = jPackage.getAsString();
if ("java.lang".equals(name)) {
return;
}
}
jPackages = (JsonArray) jvm.get("vendorPackages");
for (JsonElement jPackage : jPackages) {
String name = jPackage.getAsString();
System.out.println(name);
if ("sun.misc".equals(name)) {
return;
}
}
fail("Unable to find package java.lang");
}
/**
* According to latest modifications, the both note and text will be linked to literal vertex
* containing value "3.0". How will it work ?
*
* @throws IOException
* @throws ClassNotFoundException
*/
@Test
public void ensurePostCanHaveTextIdenticalToNote() throws IOException, ClassNotFoundException {
Post third = getPostService().find().matching(new FindPostByNote(3.0f)).getFirst();
// set value
third.text = "3.0";
third = getPostService().update(third);
// get modified post (notice we test here note to be equals to 3 - AS AN INTEGER - which allows
// us to test equality between integer and float by the way)
third = getPostService().find().matching(new FindPostByNote(3)).getFirst();
assertThat(third, IsNull.notNullValue());
assertThat(third.note, Is.is(3.0f));
assertThat(third.text, Is.is("3.0"));
}
@Test
public void addressConstantIsConsistentWithNemesisBlock() {
// Arrange:
final Block block = this.loadNemesisBlock();
final Address blockAddress = block.getSigner().getAddress();
// Assert:
Assert.assertThat(blockAddress, IsEqual.equalTo(NEMESIS_BLOCK_INFO.getAddress()));
Assert.assertThat(
blockAddress.getPublicKey(),
IsEqual.equalTo(NEMESIS_BLOCK_INFO.getAddress().getPublicKey()));
Assert.assertThat(blockAddress.getPublicKey(), IsNull.notNullValue());
}
@Test
public void test() throws Exception {
Properties proxyProps = readProxyProperties();
if (proxyProps != null) {
Set<Entry<Object, Object>> entrySet = proxyProps.entrySet();
for (Entry<Object, Object> entry : entrySet) {
System.setProperty(entry.getKey().toString(), entry.getValue().toString());
}
}
final File javaHome = new File(System.getProperty("java.home"));
assertThat(javaHome.exists(), Is.is(true));
final List<File> javaHomes = new ArrayList<File>();
javaHomes.add(javaHome);
StringWriter writer = new StringWriter();
ExecutionEnvironmentAnalyzer jvmWriter = new ExecutionEnvironmentAnalyzer();
jvmWriter.analyze(javaHomes, writer);
JsonArray jvms = parse(writer.toString());
assertThat(jvms, IsNull.notNullValue());
assertThat(jvms.size(), Is.is(1));
for (JsonElement jvm : jvms) {
assertJvmInfo((JsonObject) jvm);
}
javaHomes.add(javaHome);
writer = new StringWriter();
jvmWriter.analyze(javaHomes, writer);
jvms = parse(writer.toString());
assertThat(jvms, IsNull.notNullValue());
assertThat(jvms.size(), Is.is(2));
for (JsonElement jvm : jvms) {
assertJvmInfo((JsonObject) jvm);
}
}
@Test
public void ensureUpdateCascadesWell() {
User other = new User().withId(2).withLogin("other login").withPassword("other password");
long id = DELETABLE_POST;
String POST_TEXT = "a post about another user";
other.about = new Post(id, POST_TEXT, 2, State.PUBLIC, other);
getUserService().create(other);
Post about = ((IdBasedService<Post>) getPostService()).findById(id);
assertThat(about, IsNull.notNullValue());
assertThat(about.text, Is.is(POST_TEXT));
about.text += POST_TEXT;
getUserService().update(other);
about = ((IdBasedService<Post>) getPostService()).findById(id);
assertThat(about, IsNull.notNullValue());
// we didn't change author's about Post, but the one we fetched separatly
assertThat(about.text, Is.is(POST_TEXT));
// Now we update the GOOD about message (yeah these cascade things are a nightmare)
((Post) other.about).text += POST_TEXT;
getUserService().update(other);
about = ((IdBasedService<Post>) getPostService()).findById(id);
assertThat(about, IsNull.notNullValue());
assertThat(about.text, Is.is(POST_TEXT + POST_TEXT));
}
/**
* Test to show assertion using "org.junit.Assert.assertThat()" method<br>
*
* @see http ://junit.org/junit/javadoc/4.5/org/hamcrest/core/package-frame.html
*/
@Test
public void showAssertThat() {
String localVar = null;
// Assert True if "this.bean" object is a instance of "ProcessingBean"
// class
Assert.assertThat(this.bean, IsInstanceOf.instanceOf(ProcessingBean.class));
// Assert True if at least one assert included in the "AnyOf" operator
// is True
Assert.assertThat(
this.bean.getMessage(),
AnyOf.anyOf(IsEqual.equalTo("Hello World !"), IsNot.not(IsEqual.equalTo("Hello World !"))));
// Assert True if all assert included in the "AllOf" operator are True
Assert.assertThat(
this.bean.getMessage(),
AllOf.allOf(IsEqual.equalTo("Hello World !"), Is.is("Hello World !")));
// Assert True if "this.bean" is the same instance than
// "this.bean.getInstance()"
Assert.assertThat(this.bean, IsSame.sameInstance(this.bean.getInstance()));
// Assert True if "localVar" is null
Assert.assertThat(localVar, IsNull.nullValue());
// Assert True if "localVar" is not null
localVar = "value";
Assert.assertThat(localVar, IsNull.notNullValue());
}
private Properties readProxyProperties() throws IOException {
InputStream stream =
getClass().getClassLoader().getResourceAsStream("META-INF/proxy.properties");
try {
final Properties properties = new Properties();
assertThat(stream, IsNull.notNullValue());
properties.load(stream);
String property = properties.getProperty("http.proxyHost", "").trim();
if (property.length() == 0 || property.startsWith("$")) {
return null;
}
return properties;
} finally {
IOUtils.closeQuietly(stream);
}
}
@Test
public void cannotReturnWalletAccountInClosedWallet() {
// Arrange:
final WalletAccount account = new WalletAccount();
final TestContext context = new TestContext();
context.originalWallet.addOtherAccount(account);
// Act:
context.walletServices.open(context.pair);
context.walletServices.close(context.pair.getName());
final WalletAccount resultAccount =
context.walletServices.tryFindOpenAccount(account.getAddress());
// Assert:
Assert.assertThat(resultAccount, IsNull.nullValue());
}
@Test
@InstallFile("samples/helloAndFinish.xml")
public void testHelloAndFinishPanels() throws Exception {
Image image = icons.get("JFrameIcon").getImage();
assertThat(image, IsNull.<Object>notNullValue());
languageDialog.initLangPack();
installerFrameFixture =
HelperTestMethod.prepareFrameFixture(installerFrame, installerController);
// Hello panel
// installerFrameFixture.requireSize(new Dimension(640, 480));
installerFrameFixture.button(GuiId.BUTTON_NEXT.id).click();
installerFrameFixture.requireVisible();
// Finish panel
}
@Test
public void renamedWalletIsNotAccessibleByOldName() {
// Arrange:
final WalletNamePasswordPair pair2 = createPair("n2", "p");
final WalletDescriptor descriptor2 = createDescriptor("n2");
final TestContext context = new TestContext();
Mockito.when(context.descriptorFactory.createNew(pair2, FILE_EXTENSION))
.thenReturn(descriptor2);
// Act:
context.walletServices.open(context.pair);
context.walletServices.move(context.pair, pair2);
// Assert:
Assert.assertThat(context.walletServices.get(new WalletName("n2")), IsNull.notNullValue());
ExceptionAssert.assertThrowsNccException(
v -> context.walletServices.get(new WalletName("n")), NccException.Code.WALLET_IS_NOT_OPEN);
}
@Test
public void nemesisTransactionSignersHavePublicKeys() {
// Arrange:
final Block block = this.loadNemesisBlock();
// Act:
final Set<Address> signerAddresses =
block
.getTransactions()
.stream()
.map(t -> t.getSigner().getAddress())
.collect(Collectors.toSet());
// Assert:
for (final Address address : signerAddresses) {
Assert.assertThat(address.getPublicKey(), IsNull.notNullValue());
}
}
@Test
public void nemesisBlockCanBeCreated() {
// Act:
final Block block = this.loadNemesisBlock();
// Assert:
Assert.assertThat(
block.getSigner().getAddress(), IsEqual.equalTo(NEMESIS_BLOCK_INFO.getAddress()));
Assert.assertThat(block.getType(), IsEqual.equalTo(-1));
Assert.assertThat(block.getVersion(), IsEqual.equalTo(EXPECTED_VERSION));
Assert.assertThat(block.getTimeStamp(), IsEqual.equalTo(TimeInstant.ZERO));
// 2 multisig aggregate transactions
Assert.assertThat(
block.getTotalFee(), IsEqual.equalTo(EXPECTED_MULTISIG_AGGREGATE_FEE.multiply(2)));
Assert.assertThat(block.getPreviousBlockHash(), IsEqual.equalTo(Hash.ZERO));
Assert.assertThat(block.getHeight(), IsEqual.equalTo(BlockHeight.ONE));
Assert.assertThat(block.getTransactions().size(), IsEqual.equalTo(NUM_NEMESIS_TRANSACTIONS));
Assert.assertThat(block.getDifficulty(), IsEqual.equalTo(BlockDifficulty.INITIAL_DIFFICULTY));
Assert.assertThat(block.getGenerationHash(), IsNull.notNullValue());
}
public void notNull() {
verifyUsingMatcher(IsNull.notNullValue());
}
@Test
@Ignore
public void canLoadXMLData() {
String xml = tested.downloadXML(WebClientFactory.getWebClient(), configuration);
assertThat(xml, IsNull.notNullValue());
}