Rewrite the ConfigFileBackedConfigProviderTest.

(aka the "IdentityTest")

Make it a lot less dumb, use a virtual FS so we can test reloading
and saving. Fix a bunch of bugs the tests highlighted.

Only things not really tested are the global config specific
behaviours.

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

src/com/dmdirc/config/ConfigFileBackedConfigProvider.java

@@ -42,6 +42,7 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.Objects;
 
 import javax.annotation.Nullable;
 
@@ -210,7 +211,7 @@ public class ConfigFileBackedConfigProvider extends BaseConfigProvider implement
         final Collection<String[]> changes = new LinkedList<>();
 
         synchronized (this) {
-            final Map<String, Map<String, String>> oldProps = file.getKeyDomains();
+            final Map<String, Map<String, String>> oldProps = new HashMap<>(file.getKeyDomains());
 
             file.read();
 
@@ -221,20 +222,34 @@ public class ConfigFileBackedConfigProvider extends BaseConfigProvider implement
                     final String key = subentry.getKey();
                     final String value = subentry.getValue();
 
-                    if (!oldProps.containsKey(domain)) {
+                    if (!oldProps.containsKey(domain) || !oldProps.get(domain).containsKey(key)) {
+                        // Newly added (didn't exist in the old file)
                         changes.add(new String[]{domain, key});
-                    } else if (!oldProps.get(domain).containsKey(key)
-                            || !oldProps.get(domain).get(key).equals(value)) {
+                    } else if (!oldProps.get(domain).get(key).equals(value)) {
+                        // Modified in some way
                         changes.add(new String[]{domain, key});
                         oldProps.get(domain).remove(key);
+                    } else {
+                        // Not modified
+                        oldProps.get(domain).remove(key);
                     }
                 }
 
+                // Anything left in the domain must have been moved
                 if (oldProps.containsKey(domain)) {
                     for (String key : oldProps.get(domain).keySet()) {
                         changes.add(new String[]{domain, key});
                     }
                 }
+
+                oldProps.remove(domain);
+            }
+
+            // Any domains left must have been removed
+            for (Map.Entry<String, Map<String, String>> entry : oldProps.entrySet()) {
+                for (String key : entry.getValue().keySet()) {
+                    changes.add(new String[]{entry.getKey(), key});
+                }
             }
         }
 
@@ -360,8 +375,7 @@ public class ConfigFileBackedConfigProvider extends BaseConfigProvider implement
 
         // Fire any setting change listeners now we're no longer holding
         // a lock on this identity.
-        if (unset || oldValue == null && value != null
-                || oldValue != null && !oldValue.equals(value)) {
+        if (unset || !Objects.equals(oldValue, value)) {
             fireSettingChange(domain, option);
         }
     }
@@ -391,6 +405,10 @@ public class ConfigFileBackedConfigProvider extends BaseConfigProvider implement
 
     @Override
     public void unsetOption(final String domain, final String option) {
+        if (!file.isKeyDomain(domain) || !file.getKeyDomain(domain).containsKey(option)) {
+            return;
+        }
+
         synchronized (this) {
             file.getKeyDomain(domain).remove(option);
             needSave = true;

test-res/com/dmdirc/config/invalid-config-file

@@ -0,0 +1 @@
+Hello!

test-res/com/dmdirc/config/profile-new

@@ -0,0 +1,11 @@
+keysections:
+  identity
+  profile
+
+identity:
+  name=New Profile
+
+profile:
+  nicknames=nick1\nnick2\nnick3
+  ident=ident
+  realname=Guy Incognito

test-res/com/dmdirc/config/profile-old

@@ -0,0 +1,12 @@
+keysections:
+  identity
+  profile
+
+identity:
+  name=New Profile
+
+profile:
+  nickname=nick1
+  altnicks=nick2\nnick3
+  ident=ident
+  realname=Guy Incognito

test-res/com/dmdirc/config/profile-old-no-alts

@@ -0,0 +1,11 @@
+keysections:
+  identity
+  profile
+
+identity:
+  name=New Profile
+
+profile:
+  nickname=nick1
+  ident=ident
+  realname=Guy Incognito

test-res/com/dmdirc/config/identity3 → test-res/com/dmdirc/config/simple-ircd

@@ -6,9 +6,11 @@ keysections:
 identity:
   name=unit test
   ircd=DMDircircd!
+  order=5000
 
 meep:
   moop=2
+  mop=yes
 
 unit:
   test=true

test-res/com/dmdirc/config/simple-ircd-extra

@@ -0,0 +1,19 @@
+keysections:
+  identity
+  meep
+  more
+
+identity:
+  name=unit test
+  ircd=DMDircircd!
+  order=5000
+
+meep:
+  moop=3
+  mop=yes
+
+more:
+  settings=here
+  because=they
+  are=very
+  fun=11111

test-res/com/dmdirc/config/simple-server

@@ -0,0 +1,10 @@
+keysections:
+  identity
+  meep
+
+identity:
+  name=unit test
+  server=test123
+
+meep:
+  moop=2

test/com/dmdirc/config/ConfigFileBackedConfigProviderTest.java

@@ -0,0 +1,350 @@
+/*
+ * 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.config;
+
+import com.dmdirc.interfaces.config.ConfigChangeListener;
+import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.util.io.InvalidConfigFileException;
+import com.dmdirc.util.validators.NumericalValidator;
+import com.dmdirc.util.validators.PermissiveValidator;
+
+import com.google.common.collect.Lists;
+import com.google.common.jimfs.Configuration;
+import com.google.common.jimfs.Jimfs;
+
+import java.io.IOException;
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+
+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.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ConfigFileBackedConfigProviderTest {
+
+    private static final String[] FILES = {
+            "simple-ircd", "simple-server", "profile-new", "profile-old", "profile-old-no-alts",
+            "no-name", "no-target", "invalid-config-file", "simple-ircd-extra"
+    };
+
+    public static final PermissiveValidator<String> PERMISSIVE_VALIDATOR =
+            new PermissiveValidator<>();
+
+    @Mock private IdentityManager identityManager;
+    @Mock private ConfigChangeListener changeListener;
+
+    private FileSystem fs;
+
+    @Before
+    public void setUp() throws Exception {
+        fs = Jimfs.newFileSystem(Configuration.unix());
+
+        for (String file: FILES) {
+            Files.copy(getClass().getResourceAsStream(file), fs.getPath(file));
+        }
+    }
+
+    @Test(expected = InvalidIdentityFileException.class)
+    public void testNoName() throws IOException, InvalidIdentityFileException {
+        new ConfigFileBackedConfigProvider(identityManager, fs.getPath("no-name"), false);
+    }
+
+    @Test(expected = InvalidIdentityFileException.class)
+    public void testNoTarget() throws IOException, InvalidIdentityFileException {
+        new ConfigFileBackedConfigProvider(identityManager, fs.getPath("no-target"), false);
+    }
+
+    @Test(expected = InvalidIdentityFileException.class)
+    public void testInvalidConfigFile() throws IOException, InvalidIdentityFileException {
+        new ConfigFileBackedConfigProvider(identityManager, fs.getPath("invalid-config-file"),
+                false);
+    }
+
+    @Test
+    public void testProfileSimple() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("profile-new");
+        assertTrue(provider.isProfile());
+        assertEquals("nick1\nnick2\nnick3", provider.getOption("profile", "nicknames"));
+        assertEquals("ident", provider.getOption("profile", "ident"));
+        assertEquals("Guy Incognito", provider.getOption("profile", "realname"));
+    }
+
+    @Test
+    public void testProfileOldWithAltNicks() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("profile-old");
+        assertTrue(provider.isProfile());
+        assertEquals("nick1\nnick2\nnick3", provider.getOption("profile", "nicknames"));
+        assertEquals("ident", provider.getOption("profile", "ident"));
+        assertEquals("Guy Incognito", provider.getOption("profile", "realname"));
+
+        assertFalse(provider.hasOptionString("profile", "nickname"));
+        assertFalse(provider.hasOptionString("profile", "altnicknames"));
+    }
+
+    @Test
+    public void testProfileOldWithNoAlts() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("profile-old-no-alts");
+        assertTrue(provider.isProfile());
+        assertEquals("nick1", provider.getOption("profile", "nicknames"));
+        assertEquals("ident", provider.getOption("profile", "ident"));
+        assertEquals("Guy Incognito", provider.getOption("profile", "realname"));
+
+        assertFalse(provider.hasOptionString("profile", "nickname"));
+        assertFalse(provider.hasOptionString("profile", "altnicknames"));
+    }
+
+    @Test
+    public void testProfileNonProfileConfig() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        assertFalse(provider.isProfile());
+    }
+
+    @Test
+    public void testReadsIrcdTarget() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        assertEquals(ConfigTarget.TYPE.IRCD, provider.getTarget().getType());
+        assertEquals("DMDircircd!", provider.getTarget().getData());
+    }
+
+    @Test
+    public void testReadsServerTarget() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-server");
+        assertEquals(ConfigTarget.TYPE.SERVER, provider.getTarget().getType());
+        assertEquals("test123", provider.getTarget().getData());
+    }
+
+    @Test
+    public void testSetsOrder() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        assertEquals(5000, provider.getTarget().getOrder());
+    }
+
+    @Test
+    public void testHasOptionPermissiveValidator()
+            throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        assertTrue(provider.hasOption("unit", "test", PERMISSIVE_VALIDATOR));
+        assertFalse(provider.hasOption("unit", "untest", PERMISSIVE_VALIDATOR));
+        assertFalse(provider.hasOption("foo", "test", PERMISSIVE_VALIDATOR));
+    }
+
+    @Test
+    public void testHasOptionFailingValidator() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        assertFalse(provider.hasOption("unit", "test", new NumericalValidator(0, 100)));
+    }
+
+    @Test
+    public void testGetOptionPermissioveValidator()
+            throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        assertEquals("true", provider.getOption("unit", "test", PERMISSIVE_VALIDATOR));
+    }
+
+    @Test
+    public void testGetOptionFailingValidator() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        assertNull(provider.getOption("unit", "test", new NumericalValidator(0, 100)));
+    }
+
+    @Test
+    public void testUnsetOption() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.unsetOption("unit", "test");
+        assertFalse(provider.hasOption("unit", "test", PERMISSIVE_VALIDATOR));
+    }
+
+    @Test
+    public void testSetOptionBoolean() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.setOption("new", "option", true);
+        assertEquals("true", provider.getOption("new", "option", PERMISSIVE_VALIDATOR));
+    }
+
+    @Test
+    public void testSetOptionInt() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.setOption("new", "option", 1234);
+        assertEquals("1234", provider.getOption("new", "option", PERMISSIVE_VALIDATOR));
+    }
+
+    @Test
+    public void testSetOptionList() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.setOption("new", "option", Lists.newArrayList("first", "second"));
+        assertEquals("first\nsecond", provider.getOption("new", "option", PERMISSIVE_VALIDATOR));
+    }
+
+    @Test
+    public void testSetOptionListWithSingleEntry()
+            throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.setOption("new", "option", Lists.newArrayList("first"));
+        assertEquals("first", provider.getOption("new", "option", PERMISSIVE_VALIDATOR));
+    }
+
+    @Test
+    public void testSaveSimple() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.setOption("newdomain", "test123", 47);
+        provider.save();
+
+        final ConfigFileBackedConfigProvider loaded = getProvider("simple-ircd");
+        assertTrue(loaded.hasOptionInt("newdomain", "test123"));
+        assertEquals(Integer.valueOf(47), loaded.getOptionInt("newdomain", "test123"));
+
+        // Check old settings are preserved
+        assertTrue(loaded.hasOptionString("unit", "test"));
+        assertEquals(ConfigTarget.TYPE.IRCD, loaded.getTarget().getType());
+        assertEquals("DMDircircd!", loaded.getTarget().getData());
+    }
+
+    @Test
+    public void testFiresSettingChanged() throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.addListener(changeListener);
+        provider.setOption("new", "option", "boo");
+        verify(changeListener).configChanged("new", "option");
+    }
+
+    @Test
+    public void testDoesNotFireSettingChangedIfValueIsSame()
+            throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.setOption("new", "option", "boo");
+        provider.addListener(changeListener);
+        provider.setOption("new", "option", "boo");
+        verify(changeListener, never()).configChanged(anyString(), anyString());
+    }
+
+    @Test
+    public void testFiresSettingChangedWhenUnset()
+            throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.setOption("new", "option", "boo");
+        provider.addListener(changeListener);
+        provider.unsetOption("new", "option");
+        verify(changeListener).configChanged("new", "option");
+    }
+
+    @Test
+    public void testDoesNotFireSettingChangedIfNonExistantOptionUnset()
+            throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.addListener(changeListener);
+        provider.unsetOption("new", "option");
+        verify(changeListener, never()).configChanged(anyString(), anyString());
+    }
+
+    @Test
+    public void testDoesNotFireSettingChangedIfRemoved()
+            throws IOException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.addListener(changeListener);
+        provider.removeListener(changeListener);
+        provider.setOption("new", "option", "boo");
+        verify(changeListener, never()).configChanged(anyString(), anyString());
+    }
+
+    @Test
+    public void testReloadLoadsExtraSettings()
+            throws IOException, InvalidConfigFileException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        copyFileAndReload(provider);
+        assertTrue(provider.hasOption("more", "settings", PERMISSIVE_VALIDATOR));
+        assertEquals("here", provider.getOption("more", "settings", PERMISSIVE_VALIDATOR));
+    }
+
+    @Test
+    public void testReloadUnsetsMissingSettings()
+            throws IOException, InvalidConfigFileException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        copyFileAndReload(provider);
+        assertFalse(provider.hasOption("unit", "test", PERMISSIVE_VALIDATOR));
+    }
+
+    @Test
+    public void testReloadFiresSettingChangedForChangedOptions()
+            throws IOException, InvalidConfigFileException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.addListener(changeListener);
+        copyFileAndReload(provider);
+        verify(changeListener).configChanged("meep", "moop");
+    }
+
+    @Test
+    public void testReloadFiresSettingChangedForNewOptions()
+            throws IOException, InvalidConfigFileException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.addListener(changeListener);
+        copyFileAndReload(provider);
+        verify(changeListener).configChanged("more", "settings");
+        verify(changeListener).configChanged("more", "because");
+        verify(changeListener).configChanged("more", "are");
+        verify(changeListener).configChanged("more", "fun");
+    }
+
+    @Test
+    public void testReloadFiresSettingChangedForRemovedOptions()
+            throws IOException, InvalidConfigFileException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.addListener(changeListener);
+        copyFileAndReload(provider);
+        verify(changeListener).configChanged("unit", "test");
+    }
+
+    @Test
+    public void testReloadDoesNotFireSettingChangedForUnchangedOptions()
+            throws IOException, InvalidConfigFileException, InvalidIdentityFileException {
+        final ConfigFileBackedConfigProvider provider = getProvider("simple-ircd");
+        provider.addListener(changeListener);
+        copyFileAndReload(provider);
+        verify(changeListener, never()).configChanged("meep", "mop");
+    }
+
+    private void copyFileAndReload(final ConfigProvider provider)
+            throws IOException, InvalidConfigFileException {
+        Files.copy(fs.getPath("simple-ircd-extra"), fs.getPath("simple-ircd"),
+                StandardCopyOption.REPLACE_EXISTING);
+        provider.reload();
+    }
+
+    private ConfigFileBackedConfigProvider getProvider(final String file)
+            throws IOException, InvalidIdentityFileException {
+        return new ConfigFileBackedConfigProvider(identityManager,
+                fs.getPath(file), false);
+    }
+
+}

test/com/dmdirc/config/IdentityTest.java

@@ -1,204 +0,0 @@
-/*
- * 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.config;
-
-import com.dmdirc.interfaces.config.ConfigChangeListener;
-import com.dmdirc.util.io.ConfigFile;
-import com.dmdirc.util.validators.PermissiveValidator;
-
-import java.io.IOException;
-import java.util.Map;
-
-import org.junit.Before;
-import org.junit.Ignore;
-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 IdentityTest {
-
-    @Mock private IdentityManager identityManager;
-    private ConfigFileBackedConfigProvider myIdent;
-    private ConfigTarget target;
-
-    @Before
-    public void setUp() throws Exception {
-        target = new ConfigTarget();
-        target.setChannel("#unittest@unittest");
-
-        myIdent = new ConfigFileBackedConfigProvider(identityManager,
-                new ConfigFile(getClass().getResourceAsStream("identity2")), target);
-    }
-
-    @Test
-    public void testToString() {
-        assertEquals(myIdent.getName(), myIdent.toString());
-    }
-
-    @Test
-    public void testIsProfile() {
-        assertFalse(myIdent.isProfile());
-
-        myIdent.setOption("profile", "nickname", "foo");
-        myIdent.setOption("profile", "realname", "foo");
-
-        assertTrue(myIdent.isProfile());
-
-        myIdent.unsetOption("profile", "nickname");
-        myIdent.unsetOption("profile", "realname");
-    }
-
-    @Test
-    public void testHasOption() {
-        assertFalse(myIdent.hasOption("has", "option", new PermissiveValidator<String>()));
-
-        myIdent.setOption("has", "option", "");
-
-        assertTrue(myIdent.hasOption("has", "option", new PermissiveValidator<String>()));
-
-        myIdent.unsetOption("has", "option");
-    }
-
-    @Test
-    public void testGetOption() {
-        myIdent.setOption("domain", "option", "value");
-        final Map<String, String> props = myIdent.getOptions("domain");
-
-        assertEquals(props.get("option"), myIdent.getOption("domain", "option"));
-
-        myIdent.unsetOption("domain", "option");
-    }
-
-    @Test
-    public void testSetOption() {
-        final int count = myIdent.getOptions("foo").size();
-
-        myIdent.setOption("foo", "bar", "baz");
-
-        assertEquals(count + 1, myIdent.getOptions("foo").size());
-
-        myIdent.unsetOption("foo", "bar");
-    }
-
-    @Test
-    public void testSetOptionInt() {
-        myIdent.setOption("foo", "baz", 123);
-        assertEquals("123", myIdent.getOption("foo", "baz"));
-    }
-
-    @Test
-    public void testSetOptionBool() {
-        myIdent.setOption("foo", "baz", false);
-        assertEquals("false", myIdent.getOption("foo", "baz"));
-        myIdent.setOption("foo", "baz", true);
-        assertEquals("true", myIdent.getOption("foo", "baz"));
-    }
-
-    @Test
-    public void testRemoveOption() {
-        final Map<String, String> props = myIdent.getOptions("foo");
-        final int count = props.size();
-
-        myIdent.setOption("foo", "bar", "baz");
-
-        assertEquals(count + 1, myIdent.getOptions("foo").size());
-
-        myIdent.unsetOption("foo", "bar");
-
-        assertEquals(count, myIdent.getOptions("foo").size());
-    }
-
-    @Test
-    @Ignore("Needs to be rewritten to work without a file system, and not be completely nuts")
-    public void testSave() throws IOException, InvalidIdentityFileException {
-        myIdent.setOption("foo", "bar", "baz!");
-
-        myIdent.save();
-
-        //myIdent = new ConfigFileBackedConfigProvider(identityManager,
-        //        myIdent.file.getFile().toPath(), false);
-
-        assertEquals("baz!", myIdent.getOption("foo", "bar"));
-    }
-
-    @Test
-    public void testGetTarget() {
-        assertEquals(target.getData(), myIdent.getTarget().getData());
-        assertEquals(target.getType(), myIdent.getTarget().getType());
-    }
-
-    @Test(expected = InvalidIdentityFileException.class)
-    public void testNoName() throws IOException, InvalidIdentityFileException {
-        new ConfigFileBackedConfigProvider(getClass().getResourceAsStream("identity1"), false);
-    }
-
-    @Test(expected = InvalidIdentityFileException.class)
-    public void testNoTarget() throws IOException, InvalidIdentityFileException {
-        new ConfigFileBackedConfigProvider(getClass().getResourceAsStream("identity2"), false);
-    }
-
-    @Test
-    public void testMigrate() throws IOException, InvalidIdentityFileException {
-        final ConfigFileBackedConfigProvider id = new ConfigFileBackedConfigProvider(getClass().
-                getResourceAsStream("identity3"), false);
-
-        assertTrue(id.file.isKeyDomain("identity"));
-        assertTrue(id.file.isKeyDomain("meep"));
-        assertTrue(id.file.isKeyDomain("unit"));
-
-        assertEquals("unit test", id.file.getKeyDomain("identity").get("name"));
-        assertEquals("true", id.file.getKeyDomain("unit").get("test"));
-        assertEquals("2", id.file.getKeyDomain("meep").get("moop"));
-    }
-
-    @Test
-    public void testSetListener() {
-        final ConfigChangeListener listener = mock(ConfigChangeListener.class);
-        myIdent.addListener(listener);
-
-        verify(listener, never()).configChanged(anyString(), anyString());
-
-        myIdent.setOption("unit", "test", "meep");
-
-        verify(listener).configChanged("unit", "test");
-    }
-
-    @Test
-    public void testUnsetListener() {
-        final ConfigChangeListener listener = mock(ConfigChangeListener.class);
-        myIdent.setOption("unit", "test", "meep");
-        myIdent.addListener(listener);
-
-        verify(listener, never()).configChanged(anyString(), anyString());
-
-        myIdent.unsetOption("unit", "test");
-
-        verify(listener).configChanged("unit", "test");
-    }
-
-}