Improve CoreAliasdialogModel.

Depends-On: I7ed08f0738e581840b28851d080b06657299d55b
Change-Id: Ic9c0091441d4f7d87ddc96a327f5e5b12b4cf803
Reviewed-on: http://gerrit.dmdirc.com/3571
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/commandparser/aliases/CoreAliasDialogModel.java

 
 package com.dmdirc.commandparser.aliases;
 
+import com.dmdirc.commandparser.validators.CommandNameValidator;
+import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.ui.AliasDialogModel;
 import com.dmdirc.interfaces.ui.AliasDialogModelListener;
 import com.dmdirc.util.collections.ListenerList;
+import com.dmdirc.util.validators.FileNameValidator;
+import com.dmdirc.util.validators.IntegerValidator;
+import com.dmdirc.util.validators.NotEmptyValidator;
+import com.dmdirc.util.validators.Validator;
+import com.dmdirc.util.validators.ValidatorChain;
 
 import com.google.common.base.Optional;
 
  */
 public class CoreAliasDialogModel implements AliasDialogModel {
 
+    private final CommandController commandController;
     private final AliasManager aliasManager;
     private final AliasFactory factory;
     private final ListenerList listeners;
     private final Map<String, Alias> aliases;
     private Optional<Alias> selectedAlias;
+    private String name;
+    private int minArgs;
+    private String substitution;
 
     @Inject
-    public CoreAliasDialogModel(final AliasManager aliasManager, final AliasFactory factory) {
+    public CoreAliasDialogModel(final AliasManager aliasManager, final AliasFactory factory,
+            final CommandController commandController) {
+        this.commandController = commandController;
         this.aliasManager = aliasManager;
         this.factory = factory;
         listeners = new ListenerList();
     public void editAlias(final String name, final int minArguments, final String substitution) {
         checkNotNull(name, "Name cannot be null");
         checkArgument(aliases.containsKey(name), "Name must already exist");
-        final Alias alias = factory.createAlias(name, minArguments, substitution);
-        aliases.put(name, alias);
-        listeners.getCallable(AliasDialogModelListener.class).aliasEdited(name);
+        final Alias newAlias = factory.createAlias(name, minArguments, substitution);
+        final Alias oldAlias = aliases.put(name, newAlias);
+        listeners.getCallable(AliasDialogModelListener.class).aliasEdited(oldAlias, newAlias);
     }
 
     @Override
     public void renameAlias(final String oldName, final String newName) {
+        renameAlias(oldName, newName, false);
+    }
+
+    public void renameAlias(final String oldName, final String newName, final boolean selection) {
         checkNotNull(oldName, "Oldname cannot be null");
         checkNotNull(newName, "Newname cannot be null");
         checkArgument(aliases.containsKey(oldName), "Old name must exist");
         checkArgument(!aliases.containsKey(newName), "New name must not exist");
         final Alias alias = aliases.get(oldName);
-        aliases.remove(oldName);
-        aliases.put(newName, new Alias(alias.getType(), newName, alias.getMinArguments(),
-                alias.getSubstitution()));
-        listeners.getCallable(AliasDialogModelListener.class).aliasRenamed(oldName, newName);
+        final Alias newAlias = factory.createAlias(newName, alias.getMinArguments(),
+                alias.getSubstitution());
+        final Alias oldAlias = aliases.remove(oldName);
+        aliases.put(newName, newAlias);
+        if (!selection) {
+            setSelectedAlias(Optional.fromNullable(aliases.get(newName)));
+        }
+        listeners.getCallable(AliasDialogModelListener.class).aliasRenamed(oldAlias, newAlias);
     }
 
     @Override
         }
         final Alias alias = aliases.get(name);
         aliases.remove(name);
+        if (getSelectedAlias().isPresent() && getSelectedAlias().get().equals(alias)) {
+            setSelectedAlias(Optional.<Alias>absent());
+        }
         listeners.getCallable(AliasDialogModelListener.class).aliasRemoved(alias);
     }
 
     @Override
     public void save() {
+        setSelectedAlias(Optional.<Alias>absent());
         for (Alias alias : aliasManager.getAliases()) {
-                aliasManager.removeAlias(alias);
+            aliasManager.removeAlias(alias);
         }
         for (Alias alias : aliases.values()) {
             aliasManager.addAlias(alias);
 
     @Override
     public void setSelectedAlias(final Optional<Alias> alias) {
+        if (selectedAlias.isPresent()) {
+            if (selectedAlias.get().getMinArguments() != minArgs
+                    || !selectedAlias.get().getSubstitution().equals(substitution)) {
+                editAlias(selectedAlias.get().getName(), minArgs, substitution);
+            }
+            if (!selectedAlias.get().getName().equals(name)) {
+                renameAlias(selectedAlias.get().getName(), name, true);
+            }
+        }
         selectedAlias = alias;
+        if (alias.isPresent()) {
+            name = alias.get().getName();
+            minArgs = alias.get().getMinArguments();
+            substitution = alias.get().getSubstitution();
+        } else {
+            name = null;
+            minArgs = -1;
+            substitution = null;
+        }
         listeners.getCallable(AliasDialogModelListener.class).aliasSelectionChanged(selectedAlias);
     }
 
         return selectedAlias;
     }
 
+    @Override
+    public String getSelectedAliasName() {
+        return name;
+    }
+
+    @Override
+    public int getSelectedAliasMininumArguments() {
+        return minArgs;
+    }
+
+    @Override
+    public String getSelectedAliasSubstitution() {
+        return substitution;
+    }
+
+    @Override
+    public void setSelectedAliasName(final String aliasName) {
+        this.name = aliasName;
+    }
+
+    @Override
+    public void setSelectedAliasMinimumArguments(final int minArgs) {
+        this.minArgs = minArgs;
+    }
+
+    @Override
+    public void setSelectedAliasSubstitution(final String substitution) {
+        this.substitution = substitution;
+    }
+
+    @Override
+    public boolean isCommandValid() {
+        return selectedAlias.isPresent() && !getCommandValidator().validate(name).isFailure();
+    }
+
+    @Override
+    public boolean isMinimumArgumentsValid() {
+        return selectedAlias.isPresent() && !getMinimumArgumentsValidator().validate(minArgs).
+                isFailure();
+    }
+
+    @Override
+    public boolean isSubstitutionValid() {
+        return selectedAlias.isPresent() && !getSubstitutionValidator().validate(substitution).
+                isFailure();
+    }
+
+    @Override
+    public Validator<String> getCommandValidator() {
+        return ValidatorChain.<String>builder()
+                .addValidator(new CommandNameValidator(commandController.getCommandChar()))
+                .addValidator(new FileNameValidator())
+                .addValidator(new RenameAliasValidator(this))
+                .build();
+    }
+
+    @Override
+    public Validator<String> getNewCommandValidator() {
+        return ValidatorChain.<String>builder()
+                .addValidator(new CommandNameValidator(commandController.getCommandChar()))
+                .addValidator(new FileNameValidator())
+                .addValidator(new NewAliasValidator(this))
+                .build();
+    }
+
+    @Override
+    public Validator<Integer> getMinimumArgumentsValidator() {
+        return new IntegerValidator(0, Integer.MAX_VALUE);
+    }
+
+    @Override
+    public Validator<String> getSubstitutionValidator() {
+        return new NotEmptyValidator();
+    }
+
     @Override
     public void addListener(final AliasDialogModelListener listener) {
         checkNotNull(listener, "Listener must not be null");

src/com/dmdirc/commandparser/aliases/NewAliasValidator.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.commandparser.aliases;
+
+import com.dmdirc.interfaces.ui.AliasDialogModel;
+import com.dmdirc.util.validators.ValidationResponse;
+import com.dmdirc.util.validators.Validator;
+
+/**
+ * Validates an alias name ensuring its uniqueness.
+ */
+public class NewAliasValidator implements Validator<String> {
+
+    /** Model to containing aliases to validate. */
+    private final AliasDialogModel aliases;
+
+    public NewAliasValidator(final AliasDialogModel aliases) {
+        this.aliases = aliases;
+    }
+
+    @Override
+    public ValidationResponse validate(final String object) {
+        for (Alias targetAlias : aliases.getAliases()) {
+            if (targetAlias.getName().equalsIgnoreCase(object)) {
+                return new ValidationResponse("Alias names must be unique");
+            }
+        }
+        return new ValidationResponse();
+    }
+
+}

src/com/dmdirc/commandparser/aliases/RenameAliasValidator.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.commandparser.aliases;
+
+import com.dmdirc.interfaces.ui.AliasDialogModel;
+import com.dmdirc.util.validators.ValidationResponse;
+import com.dmdirc.util.validators.Validator;
+
+/**
+ * Validates the uniqueness of an alias name, taking into account the selected alias.
+ */
+public class RenameAliasValidator implements Validator<String> {
+
+    private final AliasDialogModel model;
+
+    public RenameAliasValidator(final AliasDialogModel model) {
+        this.model = model;
+    }
+
+    @Override
+    public ValidationResponse validate(final String object) {
+        for (Alias targetAlias : model.getAliases()) {
+            if (model.getSelectedAlias().isPresent()) {
+                if (targetAlias != model.getSelectedAlias().get()
+                        && targetAlias.getName().equalsIgnoreCase(object)) {
+                    return new ValidationResponse("Alias names must be unique");
+                }
+            } else {
+                if (targetAlias.getName().equalsIgnoreCase(object)) {
+                    return new ValidationResponse("Alias names must be unique");
+                }
+            }
+        }
+        return new ValidationResponse();
+    }
+
+}

src/com/dmdirc/interfaces/ui/AliasDialogModel.java

 package com.dmdirc.interfaces.ui;
 
 import com.dmdirc.commandparser.aliases.Alias;
+import com.dmdirc.util.validators.Validator;
 
 import com.google.common.base.Optional;
 
      */
     Optional<Alias> getSelectedAlias();
 
+    /**
+     * Gets the name of the selected alias.
+     *
+     * @return Selected alias name
+     */
+    String getSelectedAliasName();
+
+    /**
+     * Gets the minimum arguments of the selected alias.
+     *
+     * @return Selected alias minimum arguments
+     */
+    int getSelectedAliasMininumArguments();
+
+    /**
+     * Gets the substitution of the selected alias.
+     *
+     * @return Selected alias substitution
+     */
+    String getSelectedAliasSubstitution();
+
+    /**
+     * Sets the name of the selected alias.
+     *
+     * @param aliasName New name
+     */
+    void setSelectedAliasName(final String aliasName);
+
+    /**
+     * Sets the minimum arguments of the selected alias.
+     *
+     * @param minArgs New minimum arguments
+     */
+    void setSelectedAliasMinimumArguments(final int minArgs);
+
+    /**
+     * Sets the substitution of the selected alias.
+     *
+     * @param substitution New substitution
+     */
+    void setSelectedAliasSubstitution(final String substitution);
+
+    /**
+     * Tests whether the current command is valid.
+     *
+     * @return true if valid
+     */
+    boolean isCommandValid();
+
+    /**
+     * Tests whether the current minimum arguments is valid.
+     *
+     * @return true if valid
+     */
+    boolean isMinimumArgumentsValid();
+
+    /**
+     * Tests whether the current substitution is valid.
+     *
+     * @return true if valid
+     */
+    boolean isSubstitutionValid();
+
+    /**
+     * Gets a validator for changing the command of an existing alias.
+     *
+     * @return Command name validator
+     */
+    Validator<String> getCommandValidator();
+
+    /**
+     * Gets a validator for the command of a new alias.
+     *
+     * @return Command name validator
+     */
+    Validator<String> getNewCommandValidator();
+
+    /**
+     * Gets a validator for the minimum arguments of an alias.
+     *
+     * @return Arguments validator
+     */
+    Validator<Integer> getMinimumArgumentsValidator();
+
+    /**
+     * Gets a validator for the substitution of an alias.
+     *
+     * @return Substitution validator
+     */
+    Validator<String> getSubstitutionValidator();
+
     /**
      * Adds an alias listener, will be notified of changes to the model.
      *

src/com/dmdirc/interfaces/ui/AliasDialogModelListener.java

     /**
      * An alias has been edited.
      *
-     * @param name Name of the alias that was edited
+     * @param oldAlias Old alias
+     * @param newAlias New alias
      */
-    void aliasEdited(String name);
+    void aliasEdited(Alias oldAlias, Alias newAlias);
 
     /**
      * An alias has been renamed.
      *
-     * @param oldName Old name of the alias
-     * @param newName New name of the alias
+     * @param oldAlias Old alias
+     * @param newAlias New alias
      */
-    void aliasRenamed(String oldName, String newName);
+    void aliasRenamed(Alias oldAlias, Alias newAlias);
 
     /**
      * An alias selection has been changed.

test/com/dmdirc/commandparser/aliases/CoreAliasDialogModelTest.java

 package com.dmdirc.commandparser.aliases;
 
 import com.dmdirc.commandparser.CommandType;
+import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.ui.AliasDialogModelListener;
 
 import com.google.common.base.Optional;
     @Mock private AliasManager aliasModel;
     @Mock private AliasFactory aliasFactory;
     @Mock private AliasDialogModelListener listener;
+    @Mock private CommandController commandController;
     private final Alias alias1 = new Alias(CommandType.TYPE_GLOBAL, "alias1", 0, "");
+    private final Alias alias1Edited = new Alias(CommandType.TYPE_GLOBAL, "alias2", 0, "");
     private final Alias alias2Edited = new Alias(CommandType.TYPE_GLOBAL, "alias1", 1, "");
     private final Alias alias2 = new Alias(CommandType.TYPE_GLOBAL, "alias2", 0, "");
     private Set<Alias> aliases;
     @Before
     public void setupAliases() {
         aliases = new HashSet<>();
+        when(commandController.getCommandChar()).thenReturn('/');
     }
 
     @Before
         aliases.add(alias1);
         aliases.add(alias2);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         assertEquals(model.getAliases().size(), 2);
     }
 
         aliases.add(alias1);
         aliases.add(alias2);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
-        assertEquals(model.getAlias("alias1").get(), alias1);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
+        assertEquals(model.getAlias(alias1.getName()).get(), alias1);
     }
 
     @Test
         aliases.add(alias1);
         aliases.add(alias2);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
-        assertFalse(model.getAlias("alias3").isPresent());
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
+        assertFalse(model.getAlias("test").isPresent());
     }
 
     @Test
     public void testAddAlias() {
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         assertEquals(model.getAliases().size(), 0);
         model.addAlias(alias1.getName(), alias1.getMinArguments(), alias1.getSubstitution());
         assertEquals(model.getAliases().size(), 1);
     @Test
     public void testAddAliasListener() {
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         model.addListener(listener);
         model.addAlias(alias1.getName(), alias1.getMinArguments(), alias1.getSubstitution());
         verify(listener).aliasAdded(alias1);
     public void testEditAlias() {
         aliases.add(alias1);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         assertEquals(model.getAliases().size(), 1);
-        assertEquals(model.getAlias("alias1").get().getMinArguments(), 0);
-        model.editAlias("alias1", alias2Edited.getMinArguments(), alias2Edited.getSubstitution());
-        assertEquals(model.getAlias("alias1").get().getMinArguments(), 1);
+        assertEquals(model.getAlias(alias2Edited.getName()).get().getMinArguments(), 0);
+        model.editAlias(alias1.getName(), alias2Edited.getMinArguments(), alias2Edited.
+                getSubstitution());
+        assertEquals(model.getAlias(alias1.getName()).get().getMinArguments(), 1);
     }
 
     @Test
     public void testEditAliasListener() {
         aliases.add(alias1);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         model.addListener(listener);
-        model.editAlias("alias1", alias2Edited.getMinArguments(), alias2Edited.getSubstitution());
-        verify(listener).aliasEdited("alias1");
+        model.editAlias(alias1.getName(), alias2Edited.getMinArguments(), alias2Edited.
+                getSubstitution());
+        verify(listener).aliasEdited(alias1, alias2Edited);
     }
 
     @Test
     public void testRenameAlias() {
         aliases.add(alias1);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         assertEquals(model.getAliases().size(), 1);
-        assertEquals(model.getAlias("alias1").get(), alias1);
-        model.renameAlias("alias1", "alias2");
-        assertEquals(model.getAlias("alias2").get(), alias2);
+        assertEquals(model.getAlias(alias1.getName()).get(), alias1);
+        model.renameAlias(alias1.getName(), alias1Edited.getName());
+        assertEquals(model.getAlias(alias1Edited.getName()).get(), alias2);
     }
 
     @Test
     public void testRenameAliasListener() {
         aliases.add(alias1);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         model.addListener(listener);
         assertEquals(model.getAliases().size(), 1);
-        assertEquals(model.getAlias("alias1").get(), alias1);
-        model.renameAlias("alias1", "alias2");
-        verify(listener).aliasRenamed("alias1", "alias2");
+        assertEquals(model.getAlias(alias1.getName()).get(), alias1);
+        model.renameAlias(alias1.getName(), alias1Edited.getName());
+        verify(listener).aliasRenamed(alias1, alias1Edited);
     }
 
     @Test
         aliases.add(alias1);
         aliases.add(alias2);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         assertEquals(model.getAliases().size(), 2);
-        model.removeAlias("alias1");
+        model.removeAlias(alias1.getName());
         assertEquals(model.getAliases().size(), 1);
-        assertFalse(model.getAlias("alias1").isPresent());
+        assertFalse(model.getAlias(alias1.getName()).isPresent());
     }
 
     @Test
         aliases.add(alias1);
         aliases.add(alias2);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         model.addListener(listener);
-        model.removeAlias("alias1");
+        model.removeAlias(alias1.getName());
         verify(listener).aliasRemoved(alias1);
     }
 
         aliases.add(alias1);
         aliases.add(alias2);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         assertEquals(model.getAliases().size(), 2);
         assertFalse(model.getSelectedAlias().isPresent());
     }
         aliases.add(alias1);
         aliases.add(alias2);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         assertEquals(model.getAliases().size(), 2);
         assertFalse(model.getSelectedAlias().isPresent());
         model.setSelectedAlias(Optional.fromNullable(alias2));
         aliases.add(alias1);
         aliases.add(alias2);
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         assertEquals(model.getAliases().size(), 2);
         assertFalse(model.getSelectedAlias().isPresent());
         model.setSelectedAlias(Optional.fromNullable(alias2));
     @Test
     public void testRemoveListener() {
         when(aliasModel.getAliases()).thenReturn(aliases);
-        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
         model.addListener(listener);
         model.addAlias(alias1.getName(), alias1.getMinArguments(), alias1.getSubstitution());
         model.removeListener(listener);
         verify(listener, never()).aliasAdded(alias2);
     }
 
+    @Test
+    public void testRenameSelectedAlias() {
+        aliases.add(alias1);
+        when(aliasModel.getAliases()).thenReturn(aliases);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
+        assertEquals(model.getAliases().size(), 1);
+        assertEquals(model.getAlias(alias1.getName()).get(), alias1);
+        model.setSelectedAlias(Optional.fromNullable(alias1));
+        model.setSelectedAliasName(alias1Edited.getName());
+        model.setSelectedAliasMinimumArguments(alias1Edited.getMinArguments());
+        model.setSelectedAliasSubstitution(alias1Edited.getSubstitution());
+        model.setSelectedAlias(Optional.<Alias>absent());
+        assertEquals(model.getAlias(alias1Edited.getName()).get(), alias2);
+    }
+
+    @Test
+    public void testEditSelectedAlias() {
+        aliases.add(alias1);
+        when(aliasModel.getAliases()).thenReturn(aliases);
+        final CoreAliasDialogModel model = new CoreAliasDialogModel(aliasModel, aliasFactory,
+                commandController);
+        assertEquals(model.getAliases().size(), 1);
+        assertEquals(model.getAlias(alias1.getName()).get(), alias1);
+        model.setSelectedAlias(Optional.fromNullable(alias1));
+        model.setSelectedAliasMinimumArguments(alias2Edited.getMinArguments());
+        model.setSelectedAliasSubstitution(alias2Edited.getSubstitution());
+        model.setSelectedAlias(Optional.<Alias>absent());
+        final Alias alias = model.getAlias(alias1.getName()).get();
+        assertEquals(alias.getName(), alias2Edited.getName());
+        assertEquals(alias.getMinArguments(), alias2Edited.getMinArguments());
+        assertEquals(alias.getSubstitution(), alias2Edited.getSubstitution());
+    }
+
 }

test/com/dmdirc/commandparser/aliases/NewAliasValidatorTest.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.commandparser.aliases;
+
+import com.dmdirc.interfaces.ui.AliasDialogModel;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import clover.com.google.common.collect.Lists;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class NewAliasValidatorTest {
+
+    @Mock private AliasDialogModel model;
+    @Mock private Alias alias1;
+    @Mock private Alias alias2;
+
+    @Before
+    public void setupModel() {
+        when(model.getAliases()).thenReturn(Lists.newArrayList(alias1, alias2));
+        when(alias1.getName()).thenReturn("alias1");
+        when(alias2.getName()).thenReturn("alias2");
+    }
+
+    @Test
+    public void testDuplicateName() {
+        final NewAliasValidator instance = new NewAliasValidator(model);
+        assertTrue(instance.validate("alias1").isFailure());
+    }
+
+    @Test
+    public void testUniqueName() {
+        final NewAliasValidator instance = new NewAliasValidator(model);
+        assertFalse(instance.validate("alias3").isFailure());
+    }
+
+}

test/com/dmdirc/commandparser/aliases/RenameAliasValidatorTest.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.commandparser.aliases;
+
+import com.dmdirc.interfaces.ui.AliasDialogModel;
+
+import com.google.common.base.Optional;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import clover.com.google.common.collect.Lists;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RenameAliasValidatorTest {
+
+    @Mock private AliasDialogModel model;
+    @Mock private Alias alias1;
+    @Mock private Alias alias2;
+
+    @Before
+    public void setupModel() {
+        when(alias1.getName()).thenReturn("alias1");
+        when(alias2.getName()).thenReturn("alias2");
+        when(model.getAliases()).thenReturn(Lists.newArrayList(alias1, alias2));
+    }
+
+    @Test
+    public void testRenameSelected() {
+        when(model.getSelectedAlias()).thenReturn(Optional.fromNullable(alias1));
+        when(model.getSelectedAliasName()).thenReturn("alias1");
+        final RenameAliasValidator instance = new RenameAliasValidator(model);
+        assertFalse(instance.validate("alias1").isFailure());
+        assertTrue(instance.validate("alias2").isFailure());
+        assertFalse(instance.validate("test").isFailure());
+
+    }
+
+    @Test
+    public void testRenameNonSelected() {
+        when(model.getSelectedAlias()).thenReturn(Optional.<Alias>absent());
+        when(model.getSelectedAliasName()).thenReturn(null);
+        final RenameAliasValidator instance = new RenameAliasValidator(model);
+        assertTrue(instance.validate("alias1").isFailure());
+        assertTrue(instance.validate("alias2").isFailure());
+        assertFalse(instance.validate("test").isFailure());
+    }
+
+}