Stop IdentityManager initialising itself.

Instead, have Main provide the instance which becomes the
singleton. This allows us to inject dependencies to it, and
construct it using dagger later, while keeping all of the
code that calls the static getIdentityManager() method working.

Change-Id: I4ceaa062c84509bed66824f39cca8e76d25d131c
Reviewed-on: http://gerrit.dmdirc.com/2677
Reviewed-by: Greg Holmes <greg@dmdirc.com>
Automatic-Compile: DMDirc Build Manager

src/com/dmdirc/Main.java

     public void init(final String[] args) {
         Thread.setDefaultUncaughtExceptionHandler(new DMDircExceptionHandler());
 
+        IdentityManager.setIdentityManager(new IdentityManager());
         IdentityManager.getIdentityManager().loadVersionIdentity();
         serverManager = new ServerManager(
                 new ParserFactoryProvider(),

src/com/dmdirc/config/IdentityManager.java

 public class IdentityManager implements IdentityFactory, IdentityController {
 
     /** A singleton instance of IdentityManager. */
-    private static final IdentityManager INSTANCE = new IdentityManager();
+    private static IdentityManager instance;
 
     /** Config Directory. */
     private String configDirectory;
     private ConfigManager globalconfig;
 
     /** Creates a new instance of IdentityManager. */
-    private IdentityManager() {
+    public IdentityManager() {
     }
 
     /** {@inheritDoc} */
     /** {@inheritDoc} */
     @Override
     public List<Identity> getIdentitiesForManager(final ConfigManager manager) {
-        final List<Identity> sources = new ArrayList<Identity>();
+        final List<Identity> sources = new ArrayList<>();
 
         synchronized (identities) {
             for (Identity identity : identities.safeGet(null)) {
      * @return A singleton instance of the IdentityManager.
      */
     public static IdentityManager getIdentityManager() {
-        return INSTANCE;
+        return instance;
+    }
+
+    /**
+     * Sets the singleton instance of the Identity Manager.
+     *
+     * @param identityManager The identity manager to use.
+     */
+    public static void setIdentityManager(IdentityManager identityManager) {
+        instance = identityManager;
     }
 
 }

test/com/dmdirc/TestMain.java

 
         // TODO: Tests probably shouldn't rely on a config dir... Who knows
         //       what the user has done with their config.
+        IdentityManager.setIdentityManager(new IdentityManager());
         IdentityManager.getIdentityManager().loadVersionIdentity();
         try {
             IdentityManager.getIdentityManager().initialise(getConfigDir());

test/com/dmdirc/actions/ActionComponentChainTest.java

 package com.dmdirc.actions;
 
 import com.dmdirc.Server;
+import com.dmdirc.config.ConfigManager;
+import com.dmdirc.config.IdentityManager;
 
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
+@RunWith(MockitoJUnitRunner.class)
 public class ActionComponentChainTest {
 
     @Mock private ActionManager actionManager;
+    @Mock private IdentityManager identityManager;
+    @Mock private ConfigManager configManager;
 
     @Before
     public void setUp() throws Exception {
-        MockitoAnnotations.initMocks(this);
+        IdentityManager.setIdentityManager(identityManager);
+        when(identityManager.getGlobalConfiguration()).thenReturn(configManager);
 
         when(actionManager.getComponent("SERVER_NAME"))
                 .thenReturn(CoreActionComponent.SERVER_NAME);

test/com/dmdirc/actions/wrappers/AliasWrapperTest.java

 
         action = mock(Action.class);
         condition = mock(ActionCondition.class);
-        conditions = new ArrayList<ActionCondition>();
+        conditions = new ArrayList<>();
         aliasWrapper = new AliasWrapper(controller, TestMain.getTestMain().getServerManager());
 
         when(condition.getArg()).thenReturn(1);

test/com/dmdirc/commandparser/CommandArgumentsTest.java

 
 package com.dmdirc.commandparser;
 
+import com.dmdirc.config.ConfigManager;
+import com.dmdirc.config.IdentityManager;
 import com.dmdirc.interfaces.CommandController;
 
 import java.util.Arrays;
 
 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.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
+@RunWith(MockitoJUnitRunner.class)
 public class CommandArgumentsTest {
 
-    private CommandController controller;
+    @Mock private CommandController controller;
+    @Mock private IdentityManager identityManager;
+    @Mock private ConfigManager configManager;
 
     @Before
     public void setUp() {
-        this.controller = mock(CommandController.class);
+        when(identityManager.getGlobalConfiguration()).thenReturn(configManager);
+        IdentityManager.setIdentityManager(identityManager);
+
         when(this.controller.getCommandChar()).thenReturn('/');
         when(this.controller.getSilenceChar()).thenReturn('.');
     }

test/com/dmdirc/config/ConfigManagerTest.java

 import com.dmdirc.interfaces.ConfigChangeListener;
 import com.dmdirc.util.validators.PermissiveValidator;
 
+import java.util.Collections;
+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.junit.Assert.*;
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
+@RunWith(MockitoJUnitRunner.class)
 public class ConfigManagerTest {
 
+    @Mock private IdentityManager identityManager;
+
+    @Before
+    public void setup() {
+        IdentityManager.setIdentityManager(identityManager);
+        when(identityManager.getIdentitiesForManager(any(ConfigManager.class)))
+                .thenReturn(Collections.<Identity>emptyList());
+    }
+
     @Test
     public void testNonExistantOption() {
         assertNull(new ConfigManager("", "", "", "").getOption("unit-test123", "foobar"));

test/com/dmdirc/ui/messages/FormatterTest.java

  */
 package com.dmdirc.ui.messages;
 
+import com.dmdirc.config.ConfigManager;
+import com.dmdirc.config.Identity;
+import com.dmdirc.config.IdentityManager;
 import com.dmdirc.harness.TestConfigManagerOptionToggle;
 
+import java.util.Collections;
+
+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.junit.Assert.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.when;
 
+@RunWith(MockitoJUnitRunner.class)
 public class FormatterTest {
 
-    private final TestConfigManagerOptionToggle mcm = new TestConfigManagerOptionToggle();
+    private TestConfigManagerOptionToggle mcm;
+
+    @Mock private IdentityManager identityManager;
+
+    @Before
+    public void setup() {
+        IdentityManager.setIdentityManager(identityManager);
+        when(identityManager.getIdentitiesForManager(any(ConfigManager.class)))
+                .thenReturn(Collections.<Identity>emptyList());
+
+        mcm = new TestConfigManagerOptionToggle();
+    }
 
     @Test
     public void testBasicFormats() {