Implement JPQ plugin.

jpq/plugin.config

@@ -7,10 +7,11 @@ keysections:
   metadata
   updates
   version
+  defaults
 
 metadata:
   author=Greg <greg@dmdirc.com>
-  mainclass=com.dmdirc.addons.jpq.JPQPLugin
+  mainclass=com.dmdirc.addons.jpq.JPQPlugin
   description=Hides Joins, parts and quits from specified channels.
   name=jpq
   nicename=JPQ Hiding
@@ -19,4 +20,7 @@ updates:
   id=79
 
 version:
-  friendly=0.1
+  friendly=0.1
+
+defaults:
+  hidejpq=false

jpq/src/com/dmdirc/addons/jpq/GroupChatHandler.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.jpq;
+
+import com.dmdirc.config.ConfigBinder;
+import com.dmdirc.config.ConfigBinding;
+import com.dmdirc.events.ChannelJoinEvent;
+import com.dmdirc.events.ChannelPartEvent;
+import com.dmdirc.events.ChannelQuitEvent;
+import com.dmdirc.events.DisplayProperty;
+import com.dmdirc.events.DisplayableEvent;
+import com.dmdirc.interfaces.GroupChat;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import net.engio.mbassy.listener.Handler;
+
+/**
+ * Handles {@link ChannelJoinEvent}, {@link ChannelPartEvent}, {@link ChannelQuitEvent} events and
+ * hides them if the required.
+ */
+public class GroupChatHandler {
+
+    private final GroupChat groupChat;
+    private final ConfigBinder binder;
+    private boolean hideEvents;
+
+    public GroupChatHandler(final String domain, final GroupChat groupChat) {
+        this.groupChat = groupChat;
+        binder = groupChat.getWindowModel().getConfigManager().getBinder()
+                .withDefaultDomain(domain);
+    }
+
+    /**
+     * Loads this handler, adds required listeners and bindings.
+     */
+    public void load() {
+        groupChat.getEventBus().subscribe(this);
+        binder.bind(this, GroupChatHandler.class);
+    }
+
+    /**
+     * Unloads this handler, removes required listeners and bindings.
+     */
+    public void unload() {
+        groupChat.getEventBus().unsubscribe(this);
+        binder.unbind(this);
+    }
+
+    @VisibleForTesting
+    @ConfigBinding(key = "hidejpq")
+    void handleSettingChange(final boolean value) {
+        hideEvents = value;
+    }
+
+    @SuppressWarnings("TypeMayBeWeakened")
+    @VisibleForTesting
+    @Handler
+    void handleJoin(final ChannelJoinEvent event) {
+        hideEvent(event);
+    }
+
+    @SuppressWarnings("TypeMayBeWeakened")
+    @VisibleForTesting
+    @Handler
+    void handlePart(final ChannelPartEvent event) {
+        hideEvent(event);
+    }
+
+    @SuppressWarnings("TypeMayBeWeakened")
+    @VisibleForTesting
+    @Handler
+    void handleQuit(final ChannelQuitEvent event) {
+        hideEvent(event);
+    }
+
+    private void hideEvent(final DisplayableEvent event) {
+        if (hideEvents) {
+            event.setDisplayProperty(DisplayProperty.DO_NOT_DISPLAY, true);
+        }
+    }
+}

jpq/src/com/dmdirc/addons/jpq/GroupChatHandlerFactory.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.jpq;
+
+import com.dmdirc.interfaces.GroupChat;
+import com.dmdirc.plugins.PluginDomain;
+
+import javax.inject.Inject;
+
+/**
+ * Factory for creating {@link GroupChatHandler}s.
+ */
+public class GroupChatHandlerFactory {
+
+    private final String domain;
+
+    @Inject
+    public GroupChatHandlerFactory(@PluginDomain(JPQPlugin.class) final String domain) {
+        this.domain = domain;
+    }
+
+    /**
+     * Creates a new instance for the specified {@link GroupChat}.
+     *
+     * @param groupChat Group chat to handle
+     *
+     * @return Loaded instance
+     */
+    public GroupChatHandler get(final GroupChat groupChat) {
+        final GroupChatHandler groupChatHandler = new GroupChatHandler(domain, groupChat);
+        groupChatHandler.load();
+        return groupChatHandler;
+    }
+}

jpq/src/com/dmdirc/addons/jpq/JPQManager.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.jpq;
+
+import com.dmdirc.DMDircMBassador;
+import com.dmdirc.config.prefs.PreferencesSetting;
+import com.dmdirc.config.prefs.PreferencesType;
+import com.dmdirc.events.GroupChatPrefsRequestedEvent;
+import com.dmdirc.events.ServerConnectedEvent;
+import com.dmdirc.events.ServerDisconnectedEvent;
+import com.dmdirc.interfaces.Connection;
+import com.dmdirc.interfaces.ConnectionManager;
+import com.dmdirc.interfaces.GroupChat;
+import com.dmdirc.plugins.PluginDomain;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.inject.Inject;
+
+import net.engio.mbassy.listener.Handler;
+
+/**
+ * Provides the ability to hide joins, parts and quits from a {@link GroupChat}.
+ */
+public class JPQManager {
+
+    private final String domain;
+    private final ConnectionManager connectionManager;
+    private final GroupChatHandlerFactory groupChatHandlerFactory;
+    private final DMDircMBassador eventBus;
+    private final Map<GroupChat, GroupChatHandler> groupChatHandlers;
+
+    @Inject
+    public JPQManager(
+            @PluginDomain(JPQPlugin.class) final String domain,
+            final ConnectionManager connectionManager,
+            final GroupChatHandlerFactory groupChatHandlerFactory,
+            final DMDircMBassador eventBus) {
+        this.domain = domain;
+        this.connectionManager = connectionManager;
+        this.groupChatHandlerFactory = groupChatHandlerFactory;
+        this.eventBus = eventBus;
+        groupChatHandlers = new HashMap<>();
+    }
+
+    /**
+     * Unloads this manager, removing required listeners and bindings.
+     */
+    public void load() {
+        connectionManager.getConnections().forEach(this::addGroupChatHandler);
+        eventBus.subscribe(this);
+    }
+
+    /**
+     * Loads this manager, adding required listeners and bindings.
+     */
+    public void unload() {
+        connectionManager.getConnections().forEach(this::removeGroupChatHandler);
+        eventBus.unsubscribe(this);
+    }
+
+    @VisibleForTesting
+    @Handler
+    void handleConnectionAdded(final ServerConnectedEvent event) {
+        addGroupChatHandler(event.getConnection());
+    }
+
+    @VisibleForTesting
+    @Handler
+    void handleConnectionRemoved(final ServerDisconnectedEvent event) {
+        removeGroupChatHandler(event.getConnection());
+    }
+
+    @VisibleForTesting
+    @Handler
+    void handleGroupChatPrefs(final GroupChatPrefsRequestedEvent event) {
+        event.getCategory().addSetting(new PreferencesSetting(PreferencesType.BOOLEAN,
+                domain, "hidejpq", "Hide J/P/Q", "Hides joins, parts and quits in a group chat.",
+                event.getConfig(), event.getIdentity()));
+    }
+
+    private void addGroupChatHandler(final Connection connection) {
+        connection.getGroupChatManager().getChannels().forEach(this::addGroupChatHandler);
+    }
+
+    private void addGroupChatHandler(final GroupChat groupChat) {
+        groupChatHandlers.computeIfAbsent(groupChat, groupChatHandlerFactory::get);
+    }
+
+    private void removeGroupChatHandler(final Connection connection) {
+        connection.getGroupChatManager().getChannels().forEach(this::removeGroupChatHandler);
+    }
+
+    private void removeGroupChatHandler(final GroupChat groupChat) {
+        final GroupChatHandler groupChatHandler = groupChatHandlers.remove(groupChat);
+        if (groupChatHandler != null) {
+            groupChatHandler.unload();
+        }
+    }
+}

jpq/src/com/dmdirc/addons/jpq/JPQModule.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.jpq;
+
+import com.dmdirc.ClientModule;
+import com.dmdirc.plugins.PluginDomain;
+import com.dmdirc.plugins.PluginInfo;
+
+import dagger.Module;
+import dagger.Provides;
+
+@Module(injects = {JPQManager.class, GroupChatHandlerFactory.class}, addsTo = ClientModule.class)
+public class JPQModule {
+
+    private final PluginInfo pluginInfo;
+
+    public JPQModule(final PluginInfo pluginInfo) {
+        this.pluginInfo = pluginInfo;
+    }
+
+    @Provides
+    @PluginDomain(JPQPlugin.class)
+    public String getDomain() {
+        return pluginInfo.getDomain();
+    }
+}

jpq/src/com/dmdirc/addons/jpq/JPQPlugin.java

@@ -22,10 +22,33 @@
 
 package com.dmdirc.addons.jpq;
 
+import com.dmdirc.interfaces.GroupChat;
+import com.dmdirc.plugins.PluginInfo;
 import com.dmdirc.plugins.implementations.BasePlugin;
 
+import dagger.ObjectGraph;
+
 /**
- *
+ * Provides the ability to hide joins, parts and quits from a {@link GroupChat}.
  */
 public class JPQPlugin extends BasePlugin {
+
+    private JPQManager manager;
+
+    @Override
+    public void load(final PluginInfo pluginInfo, final ObjectGraph graph) {
+        super.load(pluginInfo, graph);
+        setObjectGraph(graph.plus(new JPQModule(pluginInfo)));
+        manager = getObjectGraph().get(JPQManager.class);
+    }
+
+    @Override
+    public void onLoad() {
+        manager.load();
+    }
+
+    @Override
+    public void onUnload() {
+        manager.unload();
+    }
 }

jpq/test/com/dmdirc/addons/jpq/GroupChatHandlerTest.java

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.jpq;
+
+import com.dmdirc.DMDircMBassador;
+import com.dmdirc.config.ConfigBinder;
+import com.dmdirc.events.ChannelJoinEvent;
+import com.dmdirc.events.ChannelPartEvent;
+import com.dmdirc.events.ChannelQuitEvent;
+import com.dmdirc.events.DisplayProperty;
+import com.dmdirc.interfaces.GroupChat;
+import com.dmdirc.interfaces.WindowModel;
+import com.dmdirc.interfaces.config.AggregateConfigProvider;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class GroupChatHandlerTest {
+
+    @Mock private GroupChat groupChat;
+    @Mock private WindowModel windowModel;
+    @Mock private AggregateConfigProvider configProvider;
+    @Mock private ConfigBinder configBinder;
+    @Mock private DMDircMBassador eventBus;
+    @Mock private ChannelJoinEvent channelJoinEvent;
+    @Mock private ChannelPartEvent channelPartEvent;
+    @Mock private ChannelQuitEvent channelQuitEvent;
+    private GroupChatHandler instance;
+
+    @Before
+    public void setUp() throws Exception {
+        when(groupChat.getEventBus()).thenReturn(eventBus);
+        when(groupChat.getWindowModel()).thenReturn(windowModel);
+        when(windowModel.getConfigManager()).thenReturn(configProvider);
+        when(configProvider.getBinder()).thenReturn(configBinder);
+        when(configBinder.withDefaultDomain("domain")).thenReturn(configBinder);
+        instance = new GroupChatHandler("domain", groupChat);
+    }
+
+    @Test
+    public void testLoad() throws Exception {
+        instance.load();
+        verify(configBinder).bind(instance, GroupChatHandler.class);
+        verify(eventBus).subscribe(instance);
+    }
+
+    @Test
+    public void testUnload() throws Exception {
+        instance.unload();
+        verify(configBinder).unbind(instance);
+        verify(eventBus).unsubscribe(instance);
+    }
+
+    @Test
+    public void testHandleJoin_On() throws Exception {
+        instance.load();
+        instance.handleSettingChange(true);
+        instance.handleJoin(channelJoinEvent);
+        verify(channelJoinEvent).setDisplayProperty(DisplayProperty.DO_NOT_DISPLAY, true);
+    }
+
+    @Test
+    public void testHandlePart_On() throws Exception {
+        instance.load();
+        instance.handleSettingChange(true);
+        instance.handlePart(channelPartEvent);
+        verify(channelPartEvent).setDisplayProperty(DisplayProperty.DO_NOT_DISPLAY, true);
+    }
+
+    @Test
+    public void testHandleQuit_On() throws Exception {
+        instance.load();
+        instance.handleSettingChange(true);
+        instance.handleQuit(channelQuitEvent);
+        verify(channelQuitEvent).setDisplayProperty(DisplayProperty.DO_NOT_DISPLAY, true);
+    }
+
+    @Test
+    public void testHandleJoin_Off() throws Exception {
+        instance.load();
+        instance.handleSettingChange(false);
+        instance.handleJoin(channelJoinEvent);
+        verify(channelJoinEvent, never()).setDisplayProperty(DisplayProperty.DO_NOT_DISPLAY, true);
+    }
+
+    @Test
+    public void testHandlePart_Off() throws Exception {
+        instance.load();
+        instance.handleSettingChange(false);
+        instance.handlePart(channelPartEvent);
+        verify(channelPartEvent, never()).setDisplayProperty(DisplayProperty.DO_NOT_DISPLAY, true);
+    }
+
+    @Test
+    public void testHandleQuit_Off() throws Exception {
+        instance.load();
+        instance.handleSettingChange(false);
+        instance.handleJoin(channelJoinEvent);
+        verify(channelJoinEvent, never()).setDisplayProperty(DisplayProperty.DO_NOT_DISPLAY, true);
+    }
+}

jpq/test/com/dmdirc/addons/jpq/JPQManagerTest.java

@@ -0,0 +1,122 @@
+package com.dmdirc.addons.jpq;
+
+import com.dmdirc.DMDircMBassador;
+import com.dmdirc.config.prefs.PreferencesCategory;
+import com.dmdirc.config.prefs.PreferencesSetting;
+import com.dmdirc.config.prefs.PreferencesType;
+import com.dmdirc.events.GroupChatPrefsRequestedEvent;
+import com.dmdirc.events.ServerConnectedEvent;
+import com.dmdirc.events.ServerDisconnectedEvent;
+import com.dmdirc.interfaces.Connection;
+import com.dmdirc.interfaces.ConnectionManager;
+import com.dmdirc.interfaces.GroupChat;
+import com.dmdirc.interfaces.GroupChatManager;
+import com.dmdirc.interfaces.config.AggregateConfigProvider;
+
+import com.google.common.collect.Lists;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class JPQManagerTest {
+
+    @Mock private DMDircMBassador eventBus;
+    @Mock private ConnectionManager connectionManager;
+    @Mock private GroupChatHandlerFactory groupChatHandlerFactory;
+    @Mock private ServerConnectedEvent serverConnectedEvent;
+    @Mock private ServerDisconnectedEvent serverDisconnectedEvent;
+    @Mock private GroupChatPrefsRequestedEvent groupChatPrefsRequestedEvent;
+    @Mock private PreferencesCategory prefsCategory;
+    @Mock private AggregateConfigProvider configProvider;
+    @Captor private ArgumentCaptor<PreferencesSetting> preferencesSetting;
+    @Mock private Connection connection1;
+    @Mock private Connection connection2;
+    @Mock private GroupChat groupChat1;
+    @Mock private GroupChat groupChat2;
+    @Mock private GroupChat groupChat3;
+    @Mock private GroupChat groupChat4;
+    @Mock private GroupChatHandler groupChatHandler1;
+    @Mock private GroupChatHandler groupChatHandler2;
+    @Mock private GroupChatHandler groupChatHandler3;
+    @Mock private GroupChatHandler groupChatHandler4;
+    @Mock private GroupChatManager groupChatManager1;
+    @Mock private GroupChatManager groupChatManager2;
+    private JPQManager instance;
+
+    @Before
+    public void setUp() throws Exception {
+        when(groupChatHandlerFactory.get(groupChat1)).thenReturn(groupChatHandler1);
+        when(groupChatHandlerFactory.get(groupChat2)).thenReturn(groupChatHandler2);
+        when(groupChatHandlerFactory.get(groupChat3)).thenReturn(groupChatHandler3);
+        when(groupChatHandlerFactory.get(groupChat4)).thenReturn(groupChatHandler4);
+        when(serverConnectedEvent.getConnection()).thenReturn(connection1);
+        when(serverDisconnectedEvent.getConnection()).thenReturn(connection1);
+        when(connection1.getGroupChatManager()).thenReturn(groupChatManager1);
+        when(connection2.getGroupChatManager()).thenReturn(groupChatManager2);
+        when(groupChatManager1.getChannels())
+                .thenReturn(Lists.newArrayList(groupChat1, groupChat2));
+        when(groupChatManager2.getChannels())
+                .thenReturn(Lists.newArrayList(groupChat3, groupChat4));
+        when(connectionManager.getConnections())
+                .thenReturn(Lists.newArrayList(connection1, connection2));
+        when(groupChatPrefsRequestedEvent.getCategory()).thenReturn(prefsCategory);
+        when(groupChatPrefsRequestedEvent.getConfig()).thenReturn(configProvider);
+        when(configProvider.getOption(anyString(), anyString())).thenReturn("true");
+        instance = new JPQManager("domain", connectionManager, groupChatHandlerFactory, eventBus);
+    }
+
+    @Test
+    public void testLoad() throws Exception {
+        instance.load();
+        verify(groupChatHandlerFactory).get(groupChat1);
+        verify(groupChatHandlerFactory).get(groupChat2);
+        verify(groupChatHandlerFactory).get(groupChat3);
+        verify(groupChatHandlerFactory).get(groupChat4);
+        verify(eventBus).subscribe(instance);
+    }
+
+    @Test
+    public void testUnload() throws Exception {
+        instance.load();
+        instance.unload();
+        verify(groupChatHandler1).unload();
+        verify(groupChatHandler2).unload();
+        verify(groupChatHandler3).unload();
+        verify(groupChatHandler4).unload();
+        verify(eventBus).unsubscribe(instance);
+    }
+
+    @Test
+    public void testHandlePrefsEvent() throws Exception {
+        instance.handleGroupChatPrefs(groupChatPrefsRequestedEvent);
+        verify(prefsCategory).addSetting(preferencesSetting.capture());
+        assertEquals(PreferencesType.BOOLEAN, preferencesSetting.getValue().getType());
+        assertEquals("true", preferencesSetting.getValue().getValue());
+    }
+
+    @Test
+    public void testHandleConnectionAdded() throws Exception {
+        instance.handleConnectionAdded(serverConnectedEvent);
+        verify(groupChatHandlerFactory).get(groupChat1);
+        verify(groupChatHandlerFactory).get(groupChat2);
+    }
+
+    @Test
+    public void testHandleConnectionRemoved() throws Exception {
+        instance.handleConnectionAdded(serverConnectedEvent);
+        instance.handleConnectionRemoved(serverDisconnectedEvent);
+        verify(groupChatHandler1).unload();
+        verify(groupChatHandler2).unload();
+    }
+}

jpq/test/com/dmdirc/addons/jpq/JPQPluginTest.java

@@ -22,14 +22,47 @@
 
 package com.dmdirc.addons.jpq;
 
+import com.dmdirc.plugins.PluginInfo;
+
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
+import dagger.ObjectGraph;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
 @RunWith(MockitoJUnitRunner.class)
 public class JPQPluginTest {
 
+    @Mock private ObjectGraph objectGraph;
+    @Mock private PluginInfo pluginInfo;
+    @Mock private JPQManager manager;
+    private JPQPlugin instance;
+
+    @Before
+    public void setup() {
+        when(objectGraph.plus(any(JPQModule.class))).thenReturn(objectGraph);
+        when(objectGraph.get(JPQManager.class)).thenReturn(manager);
+        instance = new JPQPlugin();
+    }
+
+    @Test
+    public void testLoad() {
+        instance.load(pluginInfo, objectGraph);
+        instance.onLoad();
+        verify(manager).load();
+    }
+
     @Test
-    public void testSomething() {}
+    public void testUnload() {
+        instance.load(pluginInfo, objectGraph);
+        instance.onUnload();
+        verify(manager).unload();
+    }
 
 }