Improve tests, tidy up a little.

src/com/dmdirc/config/profiles/Profile.java

     private final List<String> nicknames;
 
     public Profile(final String name, final String realname, final Optional<String> ident,
-            final Iterable<String> nicknames) {
+            final List<String> nicknames) {
         this.name = name;
         this.realname = realname;
         this.ident = ident;
         return Collections.unmodifiableList(nicknames);
     }
 
+    @Override
     public String toString() {
         return MoreObjects.toStringHelper(this)
                 .add("name", name)
         final Profile profile = (Profile) o;
         return Objects.equals(name, profile.getName())
                 && Objects.equals(realname, profile.getRealname())
-                && Objects.equals(nicknames, profile.getNicknames())
-                && Objects.equals(ident, profile.getIdent());
+                && Objects.equals(ident, profile.getIdent())
+                && Objects.equals(nicknames, profile.getNicknames());
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(name, realname, ident, nicknames);
+        return Objects.hash(name, realname, ident);
     }
 }

src/com/dmdirc/config/profiles/ProfileManager.java

         profiles = new ArrayList<>();
     }
 
-    /**
-     * Starts this manager, registering listeners.
-     */
-    public void start() {
-    }
-
-    /**
-     * Stops this manager, unregistering listeners.
-     */
-    public void stop() {
-    }
-
     /**
      * Adds a profile to the manager.
      *

src/com/dmdirc/config/profiles/ProfileManagerLifeCycleManager.java

 public class ProfileManagerLifeCycleManager implements SystemLifecycleComponent {
 
     private final ProfileManager profileManager;
+    private final ProfileStore profileStore;
 
     @Inject
-    public ProfileManagerLifeCycleManager(final ProfileManager profileManager) {
+    public ProfileManagerLifeCycleManager(final ProfileManager profileManager,
+            final ProfileStore profileStore) {
         this.profileManager = profileManager;
+        this.profileStore = profileStore;
     }
 
     @Override
     public void startUp() {
-        profileManager.start();
+        profileStore.readProfiles().forEach(profileManager::addProfile);
     }
 
     @Override
     public void shutDown() {
-        profileManager.stop();
+        profileStore.writeProfiles(profileManager.getProfiles());
     }
 }

src/com/dmdirc/config/profiles/ProfileStore.java

 
 package com.dmdirc.config.profiles;
 
-import java.util.Set;
+import java.util.Collection;
 
 /**
  * A store of {@link Profile}s that can read and write them to some kind of persistent media.
      *
      * @return A set of known profiles, or an empty set if the store is uninitialised.
      */
-    Set<Profile> readProfiles();
+    Collection<Profile> readProfiles();
 
     /**
      * Writes all the given profiles to the store, replacing any existing commands.
      *
-     * @param profiles The set of profiles to be written to the store.
+     * @param profiles The collection of profiles to be written to the store.
      */
-    void writeProfiles(Set<Profile> profiles);
+    void writeProfiles(Collection<Profile> profiles);
 
 }

src/com/dmdirc/config/profiles/ProfilesModule.java

 
 package com.dmdirc.config.profiles;
 
+import com.dmdirc.commandline.CommandLineOptionsModule;
+import com.dmdirc.commandparser.auto.AutoCommandStore;
+import com.dmdirc.commandparser.auto.YamlAutoCommandStore;
 import com.dmdirc.interfaces.SystemLifecycleComponent;
 
+import java.nio.file.Path;
+
+import javax.inject.Singleton;
+
 import dagger.Module;
 import dagger.Provides;
 
 @Module(library = true, complete = false)
 public class ProfilesModule {
 
+    @Provides
+    @Singleton
+    public ProfileStore getProfileStore(
+            @CommandLineOptionsModule.Directory(CommandLineOptionsModule.DirectoryType.BASE) final Path directory) {
+        return new YamlProfileStore(directory.resolve("auto-commands.yml"));
+    }
+
     @Provides(type = Provides.Type.SET)
     public SystemLifecycleComponent getLifecycleComponent(
             final ProfileManagerLifeCycleManager manager) {

src/com/dmdirc/config/profiles/YamlProfileStore.java

     }
 
     @Override
-    public Set<Profile> readProfiles() {
-        final Set<Profile> commands = new HashSet<>();
+    public Collection<Profile> readProfiles() {
+        final Set<Profile> profiles = new HashSet<>();
         if (Files.exists(path)) {
             try (final InputStream stream = Files.newInputStream(path);
                     final InputStreamReader reader = new InputStreamReader(stream, CHARSET)) {
                 final YamlReader yamlReader = new YamlReader(reader);
                 final Object root = yamlReader.read();
-                commands.addAll(readProfilesFromYaml(asList(root)));
+                profiles.addAll(readProfilesFromYaml(asList(root)));
                 yamlReader.close();
             } catch (IOException | IllegalArgumentException ex) {
                 LOG.warn("Unable to read auto commands", ex);
             }
         }
 
-        return commands;
+        return profiles;
     }
 
     @Override
-    public void writeProfiles(final Set<Profile> profiles) {
+    public void writeProfiles(final Collection<Profile> profiles) {
         final List<Object> list = getProfilesForYaml(profiles);
         try (final OutputStream stream = Files.newOutputStream(path);
                 final OutputStreamWriter writer = new OutputStreamWriter(stream, CHARSET)) {
                 final Map<Object, Object> map = asMap(profile);
                 final String name = requiredString(map, "name");
                 final String realname = requiredString(map, "realname");
-                final Optional<String> ident =
-                        Optional.ofNullable(optionalString(map, "ident"));
-                final List<String> nicknames =
-                        Splitter.on('\n').splitToList(requiredString(map, "nicknames"));
+                final Optional<String> ident = Optional.ofNullable(optionalString(map, "ident"));
+                final List<String> nicknames = Splitter.on('\n')
+                        .splitToList(requiredString(map, "nicknames"));
                 res.add(new Profile(name, realname, ident, nicknames));
             } catch (IllegalArgumentException ex) {
                 LOG.info("Unable to read alias", ex);

test-res/com/dmdirc/config/profiles/profiles.yml

   nicknames: nickname1, nickname2
 - name: profile2
   realname: realname2
-  nicknames: nickname1, nickname1
+  nicknames: nickname1, nickname3
   ident: ident2
 - name: profile3
   realname: profile3

test/com/dmdirc/config/profiles/YamlProfileStoreTest.java

 import java.util.Optional;
 import java.util.Set;
 
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.runners.MockitoJUnitRunner;
 
 import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
 
 @RunWith(MockitoJUnitRunner.class)
 public class YamlProfileStoreTest {
 
+    private Profile profile1;
+    private Profile profile2;
+    private Profile profile3;
+
+    @Before
+    public void setup() {
+        profile1 = new Profile("profile1", "realname1", Optional.empty(),
+                Lists.newArrayList("nickname1", "nickname2"));
+        profile2 = new Profile("profile2", "realname2", Optional.of("ident2"),
+                Lists.newArrayList("nickname1", "nickname3"));
+        profile3 = new Profile("profile3", "realname3", Optional.empty(),
+                Lists.newArrayList("nickname3"));
+    }
+
     @Test
     public void testReadProfiles() throws Exception {
         final ProfileStore store = new YamlProfileStore(Paths.get(getClass()
                 .getResource("profiles.yml").toURI()));
         final Collection<Profile> profiles = store.readProfiles();
         assertEquals(3, profiles.size());
+        profiles.forEach(System.out::println);
+        assertTrue(profiles.contains(profile1));
+        assertTrue(profiles.contains(profile2));
+        assertTrue(profiles.contains(profile3));
     }
 
     @Test
         try (FileSystem fs = Jimfs.newFileSystem(Configuration.unix())) {
             final ProfileStore store = new YamlProfileStore(fs.getPath("/")
                     .resolve("profiles.yml"));
-            final Profile profile1 = new Profile("name", "realname", Optional.of("ident"),
-                    Lists.newArrayList("nickname"));
-            final Set<Profile> profiles = Sets.newHashSet(profile1);
+            final List<Profile> profiles = Lists.newArrayList(profile1, profile2, profile3);
             store.writeProfiles(profiles);
-            final List<String> lines = Files.readAllLines(fs.getPath("/").resolve("profiles.yml"));
-            assertEquals(5, lines.size());
+            final Collection<Profile> readProfiles = store.readProfiles();
+            assertEquals(3, readProfiles.size());
+            assertTrue(readProfiles.contains(profile1));
+            assertTrue(readProfiles.contains(profile2));
+            assertTrue(readProfiles.contains(profile3));
         }
     }
 }