Some tidying + testing in Time plugin.

time/src/com/dmdirc/addons/time/TimeActionMetaType.java

 
     /** Time type. */
     TIME_TIME {
-                @Override
-                public int getArity() {
-                    return 1;
-                }
-
-                @Override
-                public Class<?>[] getArgTypes() {
-                    return new Class<?>[]{Calendar.class};
-                }
-
-                @Override
-                public String[] getArgNames() {
-                    return new String[]{"Date"};
-                }
-            };
+        @Override
+        public int getArity() {
+            return 1;
+        }
+
+        @Override
+        public Class<?>[] getArgTypes() {
+            return new Class<?>[]{Calendar.class};
+        }
+
+        @Override
+        public String[] getArgNames() {
+            return new String[]{"Date"};
+        }
+    };
 
     @Override
     public String getGroup() {

time/src/com/dmdirc/addons/time/TimedCommand.java

 
 package com.dmdirc.addons.time;
 
-import com.dmdirc.DMDircMBassador;
 import com.dmdirc.FrameContainer;
-import com.dmdirc.commandparser.parsers.CommandParser;
-import com.dmdirc.commandparser.parsers.GlobalCommandParser;
-import com.dmdirc.interfaces.CommandController;
 
 import java.util.Timer;
 import java.util.TimerTask;
     private final String command;
     /** The container to use for executing commands. */
     private final FrameContainer origin;
-    /** The timer we're using for scheduling this command. */
-    private final Timer timer;
+    /** The number of seconds between each execution. */
+    private final int delay;
     /** The key for this timer in the Timer Manager. */
     private final int timerKey;
     /** The manager for this timer. */
     private final TimerManager manager;
-    /** The command controller to use when executing global commands. */
-    private final CommandController commandController;
-    /** Event bus to post events on. */
-    private final DMDircMBassador eventBus;
+    /** The timer we're using for scheduling this command. */
+    private Timer timer;
 
     /**
      * Creates a new instance of TimedCommand.
      *
      * @param manager           The manager that is controlling this command.
-     * @param commandController The command controller to use when executing global commands.
      * @param timerKey          The key for this timer in the Timer Manager.
      * @param repetitions       The number of times this command will be executed
      * @param delay             The number of seconds between each execution
      * @param command           The command to be executed
      * @param origin            The frame container to use for the execution
-     * @param eventBus          The Event bus to post events on
      */
     public TimedCommand(
             final TimerManager manager,
-            final CommandController commandController,
             final int timerKey,
             final int repetitions,
             final int delay,
             final String command,
-            final FrameContainer origin,
-            final DMDircMBassador eventBus) {
-        this.commandController = commandController;
+            final FrameContainer origin) {
         this.timerKey = timerKey;
         this.repetitions = repetitions;
         this.command = command;
         this.origin = origin;
         this.manager = manager;
-        this.eventBus = eventBus;
+        this.delay = delay;
+    }
 
-        timer = new Timer("Timed Command Timer");
+    public void schedule(final TimerFactory timerFactory) {
+        timer = timerFactory.getTimer("Timed Command Timer");
         timer.schedule(this, delay * 1000L, delay * 1000L);
     }
 
      */
     public void cancelTimer() {
         manager.removeTimer(timerKey);
-        timer.cancel();
+        if (timer != null) {
+            timer.cancel();
+        }
     }
 
     @Override
     public void run() {
-        final CommandParser parser;
-        if (origin == null) {
-            parser = new GlobalCommandParser(origin.getConfigManager(), commandController, eventBus);
-        } else {
-            parser = origin.getCommandParser();
+        if (timer == null) {
+            return;
         }
-
-        parser.parseCommand(origin, command);
+        origin.getCommandParser().parseCommand(origin, command);
 
         if (--repetitions <= 0) {
             manager.removeTimer(timerKey);

time/src/com/dmdirc/addons/time/TimerCommand.java

 
 import java.util.Map.Entry;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import javax.annotation.Nonnull;
 import javax.inject.Inject;
         if (args.getArguments().length > 0) {
             switch (args.getArguments()[0]) {
                 case "--cancel":
-                    final int timerKey;
-                    try {
-                        timerKey = Integer.parseInt(args.getArgumentsAsString(1));
-                    } catch (NumberFormatException ex) {
-                        doUsage(origin, args.isSilent());
-                        return;
-                    }
-                    if (manager.hasTimerWithID(timerKey)) {
-                        manager.getTimerByID(timerKey).cancelTimer();
-                        sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Timer cancelled");
-                    } else {
-                        sendLine(origin, args.isSilent(), FORMAT_ERROR, "There is currently"
-                                + " no timer with that ID");
-                        return;
-                    }
+                    doCancel(origin, args.isSilent(), args.getArgumentsAsString(1));
                     break;
                 case "--list":
-                    final Set<Entry<Integer, TimedCommand>> timerList = manager.listTimers();
-                    if (!timerList.isEmpty()) {
-                        for (Entry<Integer, TimedCommand> entry : timerList) {
-                            sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Timer ID: "
-                                    + entry.getKey() + " - " + entry.getValue().getCommand());
-                        }
-                    } else {
-                        sendLine(origin, args.isSilent(), FORMAT_ERROR, "There are "
-                                + "currently no active timers");
-                    }
+                    doList(origin, args.isSilent());
                     break;
                 default:
                     if (args.getArguments().length < 3) {
                         doUsage(origin, args.isSilent());
                     } else {
-                        final int repetitions;
-                        final int interval;
+                        doCommand(origin, args);
+                    }
+                    break;
+            }
+        } else {
+            doUsage(origin, args.isSilent());
+        }
+    }
+
+    private void doCommand(final FrameContainer origin, final CommandArguments args) {
+        final int repetitions;
+        final int interval;
+
+        final String command = args.getArgumentsAsString(2);
 
-                        final String command = args.getArgumentsAsString(2);
+        try {
+            repetitions = Integer.parseInt(args.getArguments()[0]);
+            interval = Integer.parseInt(args.getArguments()[1]);
+        } catch (NumberFormatException ex) {
+            doUsage(origin, args.isSilent());
+            return;
+        }
 
-                        try {
-                            repetitions = Integer.parseInt(args.getArguments()[0]);
-                            interval = Integer.parseInt(args.getArguments()[1]);
-                        } catch (NumberFormatException ex) {
-                            doUsage(origin, args.isSilent());
-                            return;
-                        }
+        if (interval < 1) {
+            sendLine(origin, args.isSilent(), FORMAT_ERROR, "Cannot use intervals below 1");
+            return;
+        }
 
-                        if (interval < 1) {
-                            sendLine(origin, args.isSilent(), FORMAT_ERROR, "Cannot use"
-                                    + " intervals below 1");
-                            return;
-                        }
+        manager.addTimer(repetitions, interval, command, origin);
 
-                        manager.addTimer(repetitions, interval, command,
-                                origin);
+        sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Command scheduled.");
+    }
 
-                        sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Command scheduled.");
-                    }
-                    break;
-            }
+    private void doCancel(final FrameContainer origin, final boolean isSilent, final String arg) {
+        final int timerKey;
+        try {
+            timerKey = Integer.parseInt(arg);
+        } catch (NumberFormatException ex) {
+            doUsage(origin, isSilent);
+            return;
+        }
+        if (manager.hasTimerWithID(timerKey)) {
+            manager.getTimerByID(timerKey).cancelTimer();
+            sendLine(origin, isSilent, FORMAT_OUTPUT, "Timer cancelled");
         } else {
-            doUsage(origin, args.isSilent());
+            sendLine(origin, isSilent, FORMAT_ERROR, "There is currently no timer with that ID");
+        }
+    }
+
+    private void doList(final FrameContainer origin, final boolean isSilent) {
+        final Set<Entry<Integer, TimedCommand>> timerList = manager.listTimers();
+        if (timerList.isEmpty()) {
+            sendLine(origin, isSilent, FORMAT_ERROR, "There are " + "currently no active timers");
+        } else {
+            for (Entry<Integer, TimedCommand> entry : timerList) {
+                sendLine(origin, isSilent, FORMAT_OUTPUT,
+                        "Timer ID: " + entry.getKey() + " - " + entry.getValue().getCommand());
+            }
         }
     }
 
             targets.add("--list");
             targets.add("--cancel");
         } else if (arg == 1 && "--cancel".equals(context.getPreviousArgs().get(0))) {
-            for (Integer i : manager.getTimerIDs()) {
-                targets.add(i.toString());
-            }
+            targets.addAll(manager.getTimerIDs().stream()
+                    .map(Object::toString).collect(Collectors.toList()));
         }
 
         return targets;

time/src/com/dmdirc/addons/time/TimerFactory.java

+/*
+ * Copyright (c) 2006-2014 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.time;
+
+import java.util.Timer;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/**
+ * Factory to create {@link Timer}s.
+ */
+@Singleton
+public class TimerFactory {
+
+    @Inject
+    public TimerFactory() {}
+
+    public Timer getTimer(final String name) {
+        return new Timer(name);
+    }
+}

time/src/com/dmdirc/addons/time/TimerManager.java

 
 package com.dmdirc.addons.time;
 
-import com.dmdirc.DMDircMBassador;
 import com.dmdirc.FrameContainer;
 import com.dmdirc.interfaces.ActionController;
-import com.dmdirc.interfaces.CommandController;
 
 import java.util.Calendar;
 import java.util.HashMap;
 
     /** Map of all the timers that are running. */
     private final Map<Integer, TimedCommand> timerList = new HashMap<>();
-    /** The command controller to use when executing global commands. */
-    private final CommandController commandController;
     /** Action controller. */
     private final ActionController actionController;
-    /** Event bus to post events on . */
-    private final DMDircMBassador eventBus;
     /** Have we registered our types already? */
     private static boolean registered;
+    /** The timer factory to create timers with. */
+    private final TimerFactory timerFactory;
     /** The timer to use for scheduling. */
     private Timer timer;
 
     @Inject
-    public TimerManager(final CommandController commandController,
-            final ActionController actionController,
-            final DMDircMBassador eventBus) {
-        this.commandController = commandController;
+    public TimerManager(final ActionController actionController, final TimerFactory timerFactory) {
         this.actionController = actionController;
-        this.eventBus = eventBus;
+        this.timerFactory = timerFactory;
     }
 
     public void load() {
 
         synchronized (this) {
             final int timerKey = findFreeKey();
-            timerList.put(timerKey, new TimedCommand(this, commandController, timerKey,
-                    repetitions, interval, command, origin, eventBus));
+            final TimedCommand timedCommand = new TimedCommand(this, timerKey,
+                    repetitions, interval, command, origin);
+            timerList.put(timerKey, timedCommand);
+            timedCommand.schedule(timerFactory);
         }
     }
 

time/test/com/dmdirc/addons/time/TimedCommandTest.java

+/*
+ * Copyright (c) 2006-2014 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.time;
+
+import com.dmdirc.FrameContainer;
+import com.dmdirc.commandparser.parsers.CommandParser;
+
+import java.util.Timer;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import static junit.framework.TestCase.assertEquals;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TimedCommandTest {
+
+    @Mock private TimerManager timerManager;
+    @Mock private FrameContainer origin;
+    @Mock private CommandParser commandParser;
+    @Mock private TimerFactory timerFactory;
+    @Mock private Timer timer;
+
+    private TimedCommand instance;
+
+    @Before
+    public void setUp() throws Exception {
+        when(timerFactory.getTimer(anyString())).thenReturn(timer);
+        when(origin.getCommandParser()).thenReturn(commandParser);
+        instance = new TimedCommand(timerManager, 1, 2, 3, "command", origin);
+    }
+
+    @Test
+    public void testSchedule() throws Exception {
+        instance.schedule(timerFactory);
+        verify(timer).schedule(instance, 3000, 3000);
+    }
+
+    @Test
+    public void testGetCommand() throws Exception {
+        assertEquals("command", instance.getCommand());
+    }
+
+    @Test
+    public void testCancelTimer_WithoutSchedule() throws Exception {
+        instance.cancelTimer();
+        verify(timerManager).removeTimer(1);
+    }
+
+    @Test
+    public void testCancelTimer() throws Exception {
+        instance.schedule(timerFactory);
+        instance.cancelTimer();
+        verify(timerManager).removeTimer(1);
+        verify(timer).cancel();
+    }
+
+    @Test
+    public void testRun_withoutSchedule() throws Exception {
+        instance.run();
+        verify(commandParser, never()).parseCommand(origin, "command");
+        verify(timerManager, never()).removeTimer(1);
+        verify(timer, never()).cancel();
+    }
+
+    @Test
+    public void testRun_LessThanRepetitions() throws Exception {
+        instance.schedule(timerFactory);
+        instance.run();
+        verify(commandParser, times(1)).parseCommand(origin, "command");
+        verify(timerManager, never()).removeTimer(1);
+        verify(timer, never()).cancel();
+    }
+
+    @Test
+    public void testRun_AllRepetitions() throws Exception {
+        instance.schedule(timerFactory);
+        instance.run();
+        instance.run();
+        verify(commandParser, times(2)).parseCommand(origin, "command");
+        verify(timerManager, times(1)).removeTimer(1);
+        verify(timer, times(1)).cancel();
+    }
+}