X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Ftest%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Ffcp%2FAbstractSoneCommandTest.java;h=86a7e3f00717a05b2deec9b82a5b6b20328959e5;hb=1bcfb294c231b086910eb125b724df28737ad347;hp=84e3ec58b8e3398b2770498ea690eaa937bd2ab6;hpb=500504890e6fc9d125c46ddd7192c92215d4a119;p=Sone.git diff --git a/src/test/java/net/pterodactylus/sone/fcp/AbstractSoneCommandTest.java b/src/test/java/net/pterodactylus/sone/fcp/AbstractSoneCommandTest.java index 84e3ec5..86a7e3f 100644 --- a/src/test/java/net/pterodactylus/sone/fcp/AbstractSoneCommandTest.java +++ b/src/test/java/net/pterodactylus/sone/fcp/AbstractSoneCommandTest.java @@ -19,6 +19,7 @@ package net.pterodactylus.sone.fcp; import static com.google.common.base.Optional.of; import static java.util.Arrays.asList; +import static java.util.UUID.randomUUID; import static net.pterodactylus.sone.fcp.AbstractSoneCommand.encodeSone; import static net.pterodactylus.sone.fcp.AbstractSoneCommand.encodeString; import static net.pterodactylus.sone.template.SoneAccessor.getNiceName; @@ -26,16 +27,24 @@ import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.notNullValue; import static org.hamcrest.CoreMatchers.nullValue; import static org.hamcrest.MatcherAssert.assertThat; +import static org.mockito.Matchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; +import net.pterodactylus.sone.core.Core; +import net.pterodactylus.sone.data.Post; +import net.pterodactylus.sone.data.PostReply; import net.pterodactylus.sone.data.Profile; import net.pterodactylus.sone.data.Sone; +import net.pterodactylus.sone.database.Database; +import net.pterodactylus.sone.freenet.SimpleFieldSetBuilder; +import net.pterodactylus.sone.freenet.fcp.FcpException; import freenet.node.FSParseException; import freenet.support.SimpleFieldSet; +import freenet.support.api.Bucket; import com.google.common.base.Optional; import org.junit.Test; @@ -48,6 +57,19 @@ import org.mockito.Matchers; */ public class AbstractSoneCommandTest { + private final Core core = mock(Core.class); + private final Database database = mock(Database.class); + private final AbstractSoneCommand abstractSoneCommand = new AbstractSoneCommand(core) { + @Override + public Response execute(SimpleFieldSet parameters, Bucket data, AccessType accessType) throws FcpException { + return null; + } + }; + + public AbstractSoneCommandTest() { + when(core.getDatabase()).thenReturn(database); + } + @Test public void testStringEncoding() { String testString = prepareStringToBeEncoded(); @@ -67,7 +89,7 @@ public class AbstractSoneCommandTest { @Test public void testEncodingASone() throws FSParseException { - Sone sone = prepareSoneToBeEncoded(); + Sone sone = createSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "test", "First", "M.", "Last", (long) (Math.random() * Long.MAX_VALUE)); SimpleFieldSet soneFieldSet = encodeSone(sone, "Prefix.", Optional.absent()); assertThat(soneFieldSet, notNullValue()); assertThat(soneFieldSet.get("Prefix.Name"), is("test")); @@ -81,7 +103,7 @@ public class AbstractSoneCommandTest { @Test public void testEncodingAFollowedSone() throws FSParseException { - Sone sone = prepareSoneToBeEncoded(); + Sone sone = createSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "test", "First", "M.", "Last", (long) (Math.random() * Long.MAX_VALUE)); Sone localSone = prepareLocalSoneThatFollowsEverybody(); SimpleFieldSet soneFieldSet = encodeSone(sone, "Prefix.", of(localSone)); assertThat(soneFieldSet, notNullValue()); @@ -96,7 +118,7 @@ public class AbstractSoneCommandTest { @Test public void testEncodingANotFollowedSone() throws FSParseException { - Sone sone = prepareSoneToBeEncoded(); + Sone sone = createSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "test", "First", "M.", "Last", (long) (Math.random() * Long.MAX_VALUE)); Sone localSone = prepareLocalSoneThatFollowsNobody(); SimpleFieldSet soneFieldSet = encodeSone(sone, "Prefix.", of(localSone)); assertThat(soneFieldSet, notNullValue()); @@ -121,15 +143,6 @@ public class AbstractSoneCommandTest { return sone; } - private Sone prepareSoneToBeEncoded() { - long time = (long) (Math.random() * Long.MAX_VALUE); - Sone sone = mock(Sone.class); - when(sone.getName()).thenReturn("test"); - when(sone.getTime()).thenReturn(time); - when(sone.getProfile()).thenReturn(prepareProfile(sone, "First", "M.", "Last")); - return sone; - } - @Test public void testEncodingMultipleSones() throws FSParseException { List sones = prepareMultipleSones(); @@ -151,28 +164,225 @@ public class AbstractSoneCommandTest { } private List prepareMultipleSones() { - Sone sone1 = mock(Sone.class); - when(sone1.getId()).thenReturn("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E"); - when(sone1.getName()).thenReturn("Test1"); - when(sone1.getProfile()).thenReturn(prepareProfile(sone1, "Alpha", "A.", "First")); - when(sone1.getTime()).thenReturn((long) (Math.random() * Long.MAX_VALUE)); - Sone sone2 = mock(Sone.class); - when(sone2.getId()).thenReturn("KpoohJSbZGltHHG-YsxKV8ojjS5gwScRv50kl3AkLXg"); - when(sone2.getName()).thenReturn("Test2"); - when(sone2.getProfile()).thenReturn(prepareProfile(sone2, "Beta", "B.", "Second")); - when(sone2.getTime()).thenReturn((long) (Math.random() * Long.MAX_VALUE)); - Sone sone3 = mock(Sone.class); - when(sone3.getId()).thenReturn("-1Q6LhHvx91C1mSjOS3zznRSNUC4OxoHUbhIgBAyW1U"); - when(sone3.getName()).thenReturn("Test3"); - when(sone3.getProfile()).thenReturn(prepareProfile(sone3, "Gamma", "C.", "Third")); - when(sone3.getTime()).thenReturn((long) (Math.random() * Long.MAX_VALUE)); + Sone sone1 = createSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "Test1", "Alpha", "A.", "First", (long) (Math.random() * Long.MAX_VALUE)); + Sone sone2 = createSone("KpoohJSbZGltHHG-YsxKV8ojjS5gwScRv50kl3AkLXg", "Test2", "Beta", "B.", "Second", (long) (Math.random() * Long.MAX_VALUE)); + Sone sone3 = createSone("-1Q6LhHvx91C1mSjOS3zznRSNUC4OxoHUbhIgBAyW1U", "Test3", "Gamma", "C.", "Third", (long) (Math.random() * Long.MAX_VALUE)); return asList(sone1, sone2, sone3); } + private Sone createSone(String id, String name, String firstName, String middleName, String lastName, long time) { + Sone sone = mock(Sone.class); + when(sone.getId()).thenReturn(id); + when(sone.getName()).thenReturn(name); + when(sone.getProfile()).thenReturn(prepareProfile(sone, firstName, middleName, lastName)); + when(sone.getTime()).thenReturn(time); + return sone; + } + + private Sone createLocalSone(String id, String name, String firstName, String middleName, String lastName, long time) { + Sone sone = mock(Sone.class); + when(sone.getId()).thenReturn(id); + when(sone.getName()).thenReturn(name); + when(sone.getProfile()).thenReturn(prepareProfile(sone, firstName, middleName, lastName)); + when(sone.getTime()).thenReturn(time); + when(sone.isLocal()).thenReturn(true); + return sone; + } + private Profile prepareProfile(Sone sone, String firstName, String middleName, String lastName) { Profile profile = new Profile(sone).modify().setFirstName(firstName).setMiddleName(middleName).setLastName(lastName).update(); profile.setField(profile.addField("Test1"), "Value1"); return profile; } + @Test + public void testEncodingReplies() throws FSParseException { + List postReplies = preparePostReplies(); + SimpleFieldSet postRepliesFieldSet = AbstractSoneCommand.encodeReplies(postReplies, "Prefix."); + assertThat(postRepliesFieldSet, notNullValue()); + assertThat(postRepliesFieldSet.getInt("Prefix.Replies.Count"), is(postReplies.size())); + assertThat(postRepliesFieldSet.get("Prefix.Replies.0.ID"), is(postReplies.get(0).getId())); + assertThat(postRepliesFieldSet.get("Prefix.Replies.0.Sone"), is(postReplies.get(0).getSone().getId())); + assertThat(postRepliesFieldSet.getLong("Prefix.Replies.0.Time"), is(postReplies.get(0).getTime())); + assertThat(postRepliesFieldSet.get("Prefix.Replies.0.Text"), is(postReplies.get(0).getText())); + assertThat(postRepliesFieldSet.get("Prefix.Replies.1.ID"), is(postReplies.get(1).getId())); + assertThat(postRepliesFieldSet.get("Prefix.Replies.1.Sone"), is(postReplies.get(1).getSone().getId())); + assertThat(postRepliesFieldSet.getLong("Prefix.Replies.1.Time"), is(postReplies.get(1).getTime())); + assertThat(postRepliesFieldSet.get("Prefix.Replies.1.Text"), is(postReplies.get(1).getText())); + assertThat(postRepliesFieldSet.get("Prefix.Replies.2.ID"), is(postReplies.get(2).getId())); + assertThat(postRepliesFieldSet.get("Prefix.Replies.2.Sone"), is(postReplies.get(2).getSone().getId())); + assertThat(postRepliesFieldSet.getLong("Prefix.Replies.2.Time"), is(postReplies.get(2).getTime())); + assertThat(postRepliesFieldSet.get("Prefix.Replies.2.Text"), is(postReplies.get(2).getText())); + } + + private List preparePostReplies() { + Sone sone1 = createSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "Test1", "Alpha", "A.", "First", (long) (Math.random() * Long.MAX_VALUE)); + Sone sone2 = createSone("KpoohJSbZGltHHG-YsxKV8ojjS5gwScRv50kl3AkLXg", "Test2", "Beta", "B.", "Second", (long) (Math.random() * Long.MAX_VALUE)); + Sone sone3 = createSone("-1Q6LhHvx91C1mSjOS3zznRSNUC4OxoHUbhIgBAyW1U", "Test3", "Gamma", "C.", "Third", (long) (Math.random() * Long.MAX_VALUE)); + PostReply postReply1 = createPostReply(sone1, "Text 1"); + PostReply postReply2 = createPostReply(sone2, "Text 2"); + PostReply postReply3 = createPostReply(sone3, "Text 3"); + return asList(postReply1, postReply2, postReply3); + } + + private PostReply createPostReply(Sone sone, String text) { + PostReply postReply = mock(PostReply.class); + when(postReply.getId()).thenReturn(randomUUID().toString()); + when(postReply.getSone()).thenReturn(sone); + when(postReply.getTime()).thenReturn((long) (Math.random() * Long.MAX_VALUE)); + when(postReply.getText()).thenReturn(text); + return postReply; + } + + @Test + public void testEncodingLikes() throws FSParseException { + List likes = prepareMultipleSones(); + SimpleFieldSet likesFieldSet = AbstractSoneCommand.encodeLikes(likes, "Prefix."); + assertThat(likesFieldSet, notNullValue()); + assertThat(likesFieldSet.getInt("Prefix.Count"), is(likes.size())); + assertThat(likesFieldSet.get("Prefix.0.ID"), is(likes.get(0).getId())); + assertThat(likesFieldSet.get("Prefix.1.ID"), is(likes.get(1).getId())); + assertThat(likesFieldSet.get("Prefix.2.ID"), is(likes.get(2).getId())); + } + + @Test + public void testParsingAMandatorySone() throws FcpException { + Sone sone = createSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "Test", "First", "M.", "Last", (long) (Math.random() * Long.MAX_VALUE)); + when(core.getSone(eq("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E"))).thenReturn(of(sone)); + SimpleFieldSet soneFieldSet = new SimpleFieldSetBuilder().put("Sone", "jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E").get(); + Sone parsedSone = abstractSoneCommand.getMandatorySone(soneFieldSet, "Sone"); + assertThat(parsedSone, notNullValue()); + assertThat(parsedSone, is(sone)); + } + + @Test(expected = FcpException.class) + public void testParsingANonExistingMandatorySoneCausesAnError() throws FcpException { + when(core.getSone(Matchers.any())).thenReturn(Optional.absent()); + SimpleFieldSet soneFieldSet = new SimpleFieldSetBuilder().put("Sone", "jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E").get(); + abstractSoneCommand.getMandatorySone(soneFieldSet, "Sone"); + } + + @Test(expected = FcpException.class) + public void testParsingAMandatorySoneFromANonExistingFieldCausesAnError() throws FcpException { + when(core.getSone(Matchers.any())).thenReturn(Optional.absent()); + SimpleFieldSet soneFieldSet = new SimpleFieldSetBuilder().put("Sone", "jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E").get(); + abstractSoneCommand.getMandatorySone(soneFieldSet, "RealSone"); + } + + @Test + public void testParsingAMandatoryLocalSone() throws FcpException { + Sone sone = createLocalSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "Test", "First", "M.", "Last", (long) (Math.random() * Long.MAX_VALUE)); + when(core.getSone(eq("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E"))).thenReturn(of(sone)); + SimpleFieldSet soneFieldSet = new SimpleFieldSetBuilder().put("Sone", "jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E").get(); + Sone parsedSone = abstractSoneCommand.getMandatoryLocalSone(soneFieldSet, "Sone"); + assertThat(parsedSone, notNullValue()); + assertThat(parsedSone, is(sone)); + assertThat(parsedSone.isLocal(), is(true)); + } + + @Test(expected = FcpException.class) + public void testParsingANonLocalSoneAsMandatoryLocalSoneCausesAnError() throws FcpException { + Sone sone = createSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "Test", "First", "M.", "Last", (long) (Math.random() * Long.MAX_VALUE)); + when(core.getSone(eq("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E"))).thenReturn(of(sone)); + SimpleFieldSet soneFieldSet = new SimpleFieldSetBuilder().put("Sone", "jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E").get(); + abstractSoneCommand.getMandatoryLocalSone(soneFieldSet, "Sone"); + } + + @Test(expected = FcpException.class) + public void testParsingAMandatoryLocalSoneFromANonExistingFieldCausesAnError() throws FcpException { + when(core.getSone(Matchers.any())).thenReturn(Optional.absent()); + SimpleFieldSet soneFieldSet = new SimpleFieldSetBuilder().put("Sone", "jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E").get(); + abstractSoneCommand.getMandatoryLocalSone(soneFieldSet, "RealSone"); + } + + @Test + public void testParsingAnExistingOptionalSone() throws FcpException { + Sone sone = createSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "Test", "First", "M.", "Last", (long) (Math.random() * Long.MAX_VALUE)); + when(core.getSone(eq("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E"))).thenReturn(of(sone)); + SimpleFieldSet soneFieldSet = new SimpleFieldSetBuilder().put("Sone", "jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E").get(); + Optional parsedSone = abstractSoneCommand.getOptionalSone(soneFieldSet, "Sone"); + assertThat(parsedSone, notNullValue()); + assertThat(parsedSone.isPresent(), is(true)); + assertThat(parsedSone.get(), is(sone)); + } + + @Test + public void testParsingANonExistingOptionalSone() throws FcpException { + when(core.getSone(Matchers.any())).thenReturn(Optional.absent()); + SimpleFieldSet soneFieldSet = new SimpleFieldSetBuilder().put("Sone", "jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E").get(); + Optional parsedSone = abstractSoneCommand.getOptionalSone(soneFieldSet, "Sone"); + assertThat(parsedSone, notNullValue()); + assertThat(parsedSone.isPresent(), is(false)); + } + + @Test(expected = FcpException.class) + public void testParsingAnOptionalSoneFromANonExistingFieldCausesAnError() throws FcpException { + when(core.getSone(Matchers.any())).thenReturn(Optional.absent()); + SimpleFieldSet soneFieldSet = new SimpleFieldSetBuilder().put("Sone", "jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E").get(); + abstractSoneCommand.getOptionalSone(soneFieldSet, "RealSone"); + } + + @Test + public void testParsingAPost() throws FcpException { + Sone sone = createSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "Test", "First", "M.", "Last", (long) (Math.random() * Long.MAX_VALUE)); + Post post = createPost(sone); + when(database.getPost(eq(post.getId()))).thenReturn(of(post)); + SimpleFieldSet postFieldSet = new SimpleFieldSetBuilder().put("Post", post.getId()).get(); + Post parsedPost = abstractSoneCommand.getPost(postFieldSet, "Post"); + assertThat(parsedPost, notNullValue()); + assertThat(parsedPost, is(post)); + } + + private Post createPost(Sone sone) { + Post post = mock(Post.class); + when(post.getId()).thenReturn(randomUUID().toString()); + when(post.getSone()).thenReturn(sone); + return post; + } + + @Test(expected = FcpException.class) + public void testThatTryingToParseANonExistingPostCausesAnError() throws FcpException { + Sone sone = createSone("jXH8d-eFdm14R69WyaCgQoSjaY0jl-Ut6etlXjK0e6E", "Test", "First", "M.", "Last", (long) (Math.random() * Long.MAX_VALUE)); + Post post = createPost(sone); + when(database.getPost(Matchers.any())).thenReturn(Optional.absent()); + SimpleFieldSet postFieldSet = new SimpleFieldSetBuilder().put("Post", post.getId()).get(); + abstractSoneCommand.getPost(postFieldSet, "Post"); + } + + @Test(expected = FcpException.class) + public void testThatTryingToParseAPostFromANonExistingFieldCausesAnError() throws FcpException { + SimpleFieldSet postFieldSet = new SimpleFieldSetBuilder().get(); + abstractSoneCommand.getPost(postFieldSet, "Post"); + } + + @Test + public void testParsingAReply() throws FcpException { + PostReply reply = createPostReply(); + when(database.getPostReply(eq(reply.getId()))).thenReturn(of(reply)); + SimpleFieldSet replyFieldSet = new SimpleFieldSetBuilder().put("Reply", reply.getId()).get(); + PostReply parsedReply = abstractSoneCommand.getReply(replyFieldSet, "Reply"); + assertThat(parsedReply, notNullValue()); + assertThat(parsedReply, is(reply)); + } + + private PostReply createPostReply() { + PostReply postReply = mock(PostReply.class); + when(postReply.getId()).thenReturn(randomUUID().toString()); + return postReply; + } + + @Test(expected = FcpException.class) + public void testParsingANonExistingReply() throws FcpException { + PostReply reply = createPostReply(); + when(database.getPostReply(Matchers.any())).thenReturn(Optional.absent()); + SimpleFieldSet replyFieldSet = new SimpleFieldSetBuilder().put("Reply", reply.getId()).get(); + abstractSoneCommand.getReply(replyFieldSet, "Reply"); + } + + @Test(expected = FcpException.class) + public void testParsingAReplyFromANonExistingField() throws FcpException { + SimpleFieldSet replyFieldSet = new SimpleFieldSetBuilder().get(); + abstractSoneCommand.getReply(replyFieldSet, "Reply"); + } + }