X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Ftest%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fdata%2FMocks.java;h=19626864526db6378e510804d1facd85cb365295;hb=22d68072fb1770cdc4262ede974bd0a6202d7062;hp=88baf22b39a3d360d8d160cd41867e77d00f305e;hpb=5bee7fb48ebff210d2b68f1939acbdb4ea10d1c1;p=Sone.git diff --git a/src/test/java/net/pterodactylus/sone/data/Mocks.java b/src/test/java/net/pterodactylus/sone/data/Mocks.java index 88baf22..1962686 100644 --- a/src/test/java/net/pterodactylus/sone/data/Mocks.java +++ b/src/test/java/net/pterodactylus/sone/data/Mocks.java @@ -24,25 +24,46 @@ import static com.google.common.collect.ArrayListMultimap.create; import static com.google.common.collect.Maps.newHashMap; import static com.google.common.collect.Ordering.from; import static java.util.Collections.emptySet; +import static org.mockito.Matchers.any; import static org.mockito.Matchers.anyString; import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.Collection; import java.util.List; import java.util.Map; +import java.util.Set; import net.pterodactylus.sone.core.Core; +import net.pterodactylus.sone.core.Options; +import net.pterodactylus.sone.core.Options.DefaultOption; +import net.pterodactylus.sone.core.Preferences; import net.pterodactylus.sone.data.impl.DefaultPostBuilder; import net.pterodactylus.sone.data.impl.DefaultPostReplyBuilder; import net.pterodactylus.sone.database.Database; +import net.pterodactylus.sone.database.PostBuilder.PostCreated; import net.pterodactylus.sone.database.PostReplyBuilder; +import net.pterodactylus.sone.database.PostReplyBuilder.PostReplyCreated; +import net.pterodactylus.sone.freenet.wot.OwnIdentity; +import net.pterodactylus.sone.utils.IntegerRangePredicate; +import net.pterodactylus.sone.web.WebInterface; +import net.pterodactylus.sone.web.page.FreenetRequest; +import freenet.clients.http.SessionManager.Session; +import freenet.clients.http.ToadletContext; +import freenet.support.api.HTTPRequest; + +import com.google.common.base.Function; import com.google.common.base.Optional; +import com.google.common.base.Predicates; import com.google.common.collect.FluentIterable; +import com.google.common.collect.HashMultimap; import com.google.common.collect.Multimap; import com.google.common.collect.Ordering; +import com.google.common.collect.SetMultimap; +import org.mockito.Matchers; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; @@ -55,20 +76,73 @@ public class Mocks { private final Multimap sonePosts = create(); private final Map sones = newHashMap(); + private Optional currentSone = absent(); + private final Map posts = newHashMap(); private final Multimap postReplies = create(); private final Multimap directedPosts = create(); + private final SetMultimap postLikingSones = HashMultimap.create(); + private final SetMultimap postReplyLikingSones = HashMultimap.create(); public final Database database; public final Core core; + public final WebInterface webInterface; public Mocks() { database = mockDatabase(); core = mockCore(database); + webInterface = mockWebInterface(core); + when(database.getSone()).thenReturn(new Function>() { + @Override + public Optional apply(String soneId) { + return (soneId == null) ? Optional.absent() : fromNullable(sones.get(soneId)); + } + }); + Answer returnCurrentSone = new Answer() { + @Override + public Sone answer(InvocationOnMock invocation) throws Throwable { + return currentSone.orNull(); + } + }; + when(webInterface.getCurrentSone(any(ToadletContext.class))).then(returnCurrentSone); + when(webInterface.getCurrentSone(any(Session.class))).then(returnCurrentSone); + when(core.getSones()).then(new Answer>() { + @Override + public Collection answer(InvocationOnMock invocation) throws Throwable { + return sones.values(); + } + }); + when(core.getLocalSone(anyString())).then(new Answer>() { + @Override + public Optional answer(InvocationOnMock invocation) throws Throwable { + Sone localSone = sones.get(invocation.getArguments()[0]); + return ((localSone == null) || (!localSone.isLocal())) ? Optional.absent() : of(localSone); + } + }); when(core.getLocalSones()).then(new Answer>() { @Override public Collection answer(InvocationOnMock invocation) throws Throwable { return FluentIterable.from(sones.values()).filter(Sone.LOCAL_SONE_FILTER).toList(); } }); + when(core.postCreated()).thenReturn(Optional.of(new PostCreated() { + @Override + public void postCreated(Post post) { + posts.put(post.getId(), post); + sonePosts.put(post.getSone(), post); + } + })); + when(core.postReplyCreated()).then(new Answer>() { + @Override + public Optional answer(InvocationOnMock invocation) throws Throwable { + return Optional.of(new PostReplyCreated() { + @Override + public void postReplyCreated(PostReply postReply) { + postReplies.put(postReply.getPost().get(), postReply); + } + }); + } + }); + Options options = createOptions(); + when(core.getPreferences()).thenReturn(new Preferences(options)); when(database.getDirectedPosts(anyString())).then(new Answer>() { @Override public Collection answer(InvocationOnMock invocation) throws Throwable { @@ -77,6 +151,22 @@ public class Mocks { }); } + private Options createOptions() { + Options options = new Options(); + options.addIntegerOption("InsertionDelay", new DefaultOption(60, new IntegerRangePredicate(0, Integer.MAX_VALUE))); + options.addIntegerOption("PostsPerPage", new DefaultOption(10, new IntegerRangePredicate(1, Integer.MAX_VALUE))); + options.addIntegerOption("ImagesPerPage", new DefaultOption(9, new IntegerRangePredicate(1, Integer.MAX_VALUE))); + options.addIntegerOption("CharactersPerPost", new DefaultOption(400, Predicates.or(new IntegerRangePredicate(50, Integer.MAX_VALUE), Predicates.equalTo(-1)))); + options.addIntegerOption("PostCutOffLength", new DefaultOption(200, Predicates.or(new IntegerRangePredicate(50, Integer.MAX_VALUE), Predicates.equalTo(-1)))); + options.addBooleanOption("RequireFullAccess", new DefaultOption(false)); + options.addIntegerOption("PositiveTrust", new DefaultOption(75, new IntegerRangePredicate(0, 100))); + options.addIntegerOption("NegativeTrust", new DefaultOption(-25, new IntegerRangePredicate(-100, 100))); + options.addStringOption("TrustComment", new DefaultOption("Set from Sone Web Interface")); + options.addBooleanOption("ActivateFcpInterface", new DefaultOption(false)); + options.addIntegerOption("FcpFullAccessRequired", new DefaultOption(2)); + return options; + } + private static Core mockCore(Database database) { Core core = mock(Core.class); when(core.getDatabase()).thenReturn(database); @@ -84,14 +174,25 @@ public class Mocks { return core; } - private static Database mockDatabase() { + private Database mockDatabase() { Database database = mock(Database.class); when(database.getSone(anyString())).thenReturn(Optional.absent()); - when(database.getPost(anyString())).thenReturn(Optional.absent()); + when(database.getPost(anyString())).then(new Answer>() { + @Override + public Optional answer(InvocationOnMock invocation) throws Throwable { + return fromNullable(posts.get(invocation.getArguments()[0])); + } + }); when(database.getPostReply(anyString())).thenReturn(Optional.absent()); return database; } + private static WebInterface mockWebInterface(Core core) { + WebInterface webInterface = mock(WebInterface.class); + when(webInterface.getCore()).thenReturn(core); + return webInterface; + } + public SoneMocker mockSone(String id) { return new SoneMocker(id); } @@ -104,11 +205,22 @@ public class Mocks { return new PostReplyMocker(replyId, sone); } + public FreenetRequest mockRequest(String path) { + HTTPRequest httpRequest = mock(HTTPRequest.class); + when(httpRequest.getMethod()).thenReturn("GET"); + when(httpRequest.getPath()).thenReturn(path); + FreenetRequest request = mock(FreenetRequest.class); + when(request.getHttpRequest()).thenReturn(httpRequest); + return request; + } + public class SoneMocker { private final Sone mockedSone = mock(Sone.class); private final String id; + private String insertUrI; private boolean local; + private boolean current; private Optional name = absent(); private long time; private Profile profile = new Profile(mockedSone); @@ -123,6 +235,16 @@ public class Mocks { return this; } + public SoneMocker insertUri(String insertUri) { + this.insertUrI = insertUri; + return this; + } + + public SoneMocker current() { + current = true; + return this; + } + public SoneMocker withName(String name) { this.name = fromNullable(name); return this; @@ -151,6 +273,14 @@ public class Mocks { public Sone create() { when(mockedSone.getId()).thenReturn(id); when(mockedSone.isLocal()).thenReturn(local); + if (local) { + OwnIdentity ownIdentity = mock(OwnIdentity.class); + when(ownIdentity.getInsertUri()).thenReturn(insertUrI); + when(mockedSone.getIdentity()).thenReturn(ownIdentity); + } + if (current) { + currentSone = of(mockedSone); + } if (name.isPresent()) { when(mockedSone.getName()).thenReturn(name.get()); } @@ -239,6 +369,26 @@ public class Mocks { return Ordering.from(Reply.TIME_COMPARATOR).sortedCopy(postReplies.get(post)); } }); + doAnswer(new Answer() { + @Override + public Void answer(InvocationOnMock invocation) throws Throwable { + postLikingSones.put(post, (Sone) invocation.getArguments()[0]); + return null; + } + }).when(post).like(Matchers.any()); + doAnswer(new Answer() { + @Override + public Void answer(InvocationOnMock invocation) throws Throwable { + postLikingSones.remove(post, (Sone) invocation.getArguments()[0]); + return null; + } + }).when(post).unlike(Matchers.any()); + when(post.getLikes()).thenAnswer(new Answer>() { + @Override + public Set answer(InvocationOnMock invocation) throws Throwable { + return postLikingSones.get(post); + } + }); return post; } @@ -284,6 +434,26 @@ public class Mocks { if (text.isPresent()) { when(postReply.getText()).thenReturn(text.get()); } + doAnswer(new Answer() { + @Override + public Void answer(InvocationOnMock invocation) throws Throwable { + postReplyLikingSones.put(postReply, (Sone) invocation.getArguments()[0]); + return null; + } + }).when(postReply).like(Matchers.any()); + doAnswer(new Answer() { + @Override + public Void answer(InvocationOnMock invocation) throws Throwable { + postReplyLikingSones.remove(postReply, invocation.getArguments()[0]); + return null; + } + }).when(postReply).unlike(Matchers.any()); + when(postReply.getLikes()).thenAnswer(new Answer>() { + @Override + public Set answer(InvocationOnMock invocation) throws Throwable { + return postReplyLikingSones.get(postReply); + } + }); return postReply; } }