Add NewServerDialogModel and associated classes.

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

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

@@ -0,0 +1,215 @@
+/*
+ * 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.interfaces.ui;
+
+import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.util.validators.Validator;
+
+import com.google.common.base.Optional;
+
+import java.util.List;
+
+/**
+ * Model representing a dialog containing the details required to open a new connection.
+ */
+public interface NewServerDialogModel {
+
+    /**
+     * Loads the default and required settings and adds the appropriate listeners.
+     */
+    void loadModel();
+
+    /**
+     * Returns the list of profiles available to the dialog.
+     *
+     * @return List of available profiles
+     */
+    List<ConfigProvider> getProfileList();
+
+    /**
+     * Gets the selected profile in the dialog.
+     *
+     * @return Selected profile
+     */
+    Optional<ConfigProvider> getSelectedProfile();
+
+    /**
+     * Sets the selected profile in the dialog.
+     *
+     * @param selectedProfile New selected profile
+     */
+    void setSelectedProfile(Optional<ConfigProvider> selectedProfile);
+
+    /**
+     * Is the profiles list valid?
+     *
+     * @return true if value
+     */
+    boolean isProfileListValid();
+
+    /**
+     * Returns the validator for the profiles list.
+     *
+     * @return Profile validator
+     */
+    Validator<List<ConfigProvider>> getProfileListValidator();
+
+    /**
+     * Returns the hostname of the server.
+     *
+     * @return Server hostname
+     */
+    Optional<String> getHostname();
+
+    /**
+     * Sets the server hostname.
+     *
+     * @param hostname New server hostname
+     */
+    void setHostname(Optional<String> hostname);
+
+    /**
+     * Is the server hostname valid.
+     *
+     * @return true if valid
+     */
+    boolean isHostnameValid();
+
+    /**
+     * Returns the validator for the server hostname.
+     *
+     * @return Server hostname validator
+     */
+    Validator<String> getHostnameValidator();
+
+    /**
+     * Returns the servers port.
+     *
+     * @return Servers port
+     */
+    Optional<Integer> getPort();
+
+    /**
+     * Sets the servers port.
+     *
+     * @param port New server port
+     */
+    void setPort(Optional<Integer> port);
+
+    /**
+     * Is the port valid?
+     *
+     * @return true if valid
+     */
+    boolean isPortValid();
+
+    /**
+     * Returns the validator for servers port.
+     *
+     * @return Server port validator
+     */
+    Validator<Integer> getPortValidator();
+
+    /**
+     * Gets the servers password.
+     *
+     * @return Servers password
+     */
+    Optional<String> getPassword();
+
+    /**
+     * Sets the password for the server.
+     *
+     * @param password Servers password
+     */
+    void setPassword(Optional<String> password);
+
+    /**
+     * Is the password valid?
+     *
+     * @return true if valid
+     */
+    boolean isPasswordValid();
+
+    /**
+     * Returns the validator for the server password.
+     *
+     * @return Server port validator
+     */
+    Validator<String> getPasswordValidator();
+
+    /**
+     * Should be use SSL to connect to the server?
+     *
+     * @return true if yes
+     */
+    boolean getSSL();
+
+    /**
+     * Sets whether we should connect to the server over SSL.
+     *
+     * @param ssl New SSL state
+     */
+    void setSSL(boolean ssl);
+
+    /**
+     * Should we save these settings as the default?
+     *
+     * @return true if yes
+     */
+    boolean getSaveAsDefault();
+
+    /**
+     * Sets whether we should save these settings as the default.
+     *
+     * @param saveAsDefault true if yes
+     */
+    void setSaveAsDefault(boolean saveAsDefault);
+
+    /**
+     * Saves the defaults as appropriate and connects to the server.
+     */
+    void save();
+
+    /**
+     * Are we allowed to save the dialog and connect to the server?
+     *
+     * @return true if all validations pass
+     */
+    boolean isSaveAllowed();
+
+    /**
+     * Adds a listener for changes on this model.
+     *
+     * @param listener Listener to add
+     */
+    void addListener(NewServerDialogModelListener listener);
+
+    /**
+     * Removes a listener for changes on this model.
+     *
+     * @param listener Listener to remove
+     */
+    void removeListener(NewServerDialogModelListener listener);
+
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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.interfaces.ui;
+
+import com.dmdirc.interfaces.config.ConfigProvider;
+
+import com.google.common.base.Optional;
+
+import java.util.List;
+
+/**
+ * Listener for various events in an new server dialog model.
+ */
+public interface NewServerDialogModelListener {
+
+    /**
+     * Called when the selected profile changes.
+     *
+     * @param oldProfile Old profile
+     * @param newProfile New profile
+     */
+    void selectedProfileChanged(Optional<ConfigProvider> oldProfile,
+            Optional<ConfigProvider> newProfile);
+
+    /**
+     * Called when the profile list is changed.
+     *
+     * @param profiles New profile list
+     */
+    void profileListChanged(List<ConfigProvider> profiles);
+
+    /**
+     * Called when the details of the server are changed.
+     *
+     * @param hostname      Server hostname
+     * @param port          Server port
+     * @param password      Server password
+     * @param ssl           Should we connect over SSL
+     * @param saveAsDefault Should we save these settings as the default
+     */
+    void serverDetailsChanged(Optional<String> hostname, Optional<Integer> port,
+            Optional<String> password, boolean ssl, boolean saveAsDefault);
+
+}

src/com/dmdirc/ui/core/newserver/CoreNewServerDialogModel.java

@@ -0,0 +1,311 @@
+/*
+ * 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.ui.core.newserver;
+
+import com.dmdirc.ClientModule.GlobalConfig;
+import com.dmdirc.ClientModule.UserConfig;
+import com.dmdirc.ServerManager;
+import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.interfaces.config.ConfigProviderListener;
+import com.dmdirc.interfaces.config.IdentityController;
+import com.dmdirc.interfaces.ui.NewServerDialogModel;
+import com.dmdirc.interfaces.ui.NewServerDialogModelListener;
+import com.dmdirc.util.collections.ListenerList;
+import com.dmdirc.util.validators.IntegerPortValidator;
+import com.dmdirc.util.validators.ListNotEmptyValidator;
+import com.dmdirc.util.validators.PermissiveValidator;
+import com.dmdirc.util.validators.ServerNameValidator;
+import com.dmdirc.util.validators.Validator;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.inject.Inject;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Default implementation of a new server dialog model.
+ */
+public class CoreNewServerDialogModel implements NewServerDialogModel, ConfigProviderListener {
+
+    private final ListenerList listeners;
+    private final AggregateConfigProvider globalConfig;
+    private final ConfigProvider userConfig;
+    private final ServerManager serverManager;
+    private final IdentityController controller;
+    private final List<ConfigProvider> profiles;
+    private Optional<ConfigProvider> selectedProfile;
+    private Optional<String> hostname;
+    private Optional<Integer> port;
+    private Optional<String> password;
+    private boolean ssl;
+    private boolean saveAsDefault;
+
+    @Inject
+    public CoreNewServerDialogModel(
+            @GlobalConfig final AggregateConfigProvider globalConfig,
+            @UserConfig final ConfigProvider userConfig,
+            final IdentityController identityController,
+            final ServerManager serverManager) {
+        this.globalConfig = globalConfig;
+        this.userConfig = userConfig;
+        this.controller = identityController;
+        this.serverManager = serverManager;
+        listeners = new ListenerList();
+        profiles = new ArrayList<>(5);
+        selectedProfile = Optional.absent();
+        hostname = Optional.absent();
+        port = Optional.absent();
+        password = Optional.absent();
+        ssl = false;
+        saveAsDefault = false;
+    }
+
+    @Override
+    public void loadModel() {
+        controller.registerIdentityListener("profile", this);
+        for (ConfigProvider provider : controller.getProvidersByType("profile")) {
+            profiles.add(provider);
+        }
+        hostname = Optional.fromNullable(globalConfig.getOption("newserver", "hostname"));
+        port = Optional.fromNullable(globalConfig.getOptionInt("newserver", "port"));
+        password = Optional.fromNullable(globalConfig.getOption("newserver", "password"));
+        ssl = globalConfig.getOptionBool("newserver", "ssl");
+        saveAsDefault = false;
+        listeners.getCallable(NewServerDialogModelListener.class).serverDetailsChanged(hostname,
+                port, password, ssl, saveAsDefault);
+    }
+
+    @Override
+    public List<ConfigProvider> getProfileList() {
+        return ImmutableList.copyOf(profiles);
+    }
+
+    @Override
+    public Optional<ConfigProvider> getSelectedProfile() {
+        return selectedProfile;
+    }
+
+    @Override
+    public void setSelectedProfile(final Optional<ConfigProvider> selectedProfile) {
+        checkNotNull(selectedProfile);
+        final Optional<ConfigProvider> oldSelectedProfile = this.selectedProfile;
+        this.selectedProfile = selectedProfile;
+        listeners.getCallable(NewServerDialogModelListener.class).selectedProfileChanged(
+                oldSelectedProfile, selectedProfile);
+    }
+
+    @Override
+    public boolean isProfileListValid() {
+        return !getProfileListValidator().validate(getProfileList()).isFailure();
+    }
+
+    @Override
+    public Validator<List<ConfigProvider>> getProfileListValidator() {
+        return new ListNotEmptyValidator<ConfigProvider>();
+    }
+
+    @Override
+    public Optional<String> getHostname() {
+        return hostname;
+    }
+
+    @Override
+    public void setHostname(final Optional<String> hostname) {
+        checkNotNull(hostname);
+        this.hostname = hostname;
+        listeners.getCallable(NewServerDialogModelListener.class).serverDetailsChanged(hostname,
+                port, password, ssl, saveAsDefault);
+    }
+
+    @Override
+    public boolean isHostnameValid() {
+        return getHostname().isPresent() && !getHostnameValidator().validate(getHostname().get()).
+                isFailure();
+    }
+
+    @Override
+    public Validator<String> getHostnameValidator() {
+        return new ServerNameValidator();
+    }
+
+    @Override
+    public Optional<Integer> getPort() {
+        return port;
+    }
+
+    @Override
+    public void setPort(final Optional<Integer> port) {
+        checkNotNull(port);
+        this.port = port;
+        listeners.getCallable(NewServerDialogModelListener.class).serverDetailsChanged(hostname,
+                port, password, ssl, saveAsDefault);
+    }
+
+    @Override
+    public boolean isPortValid() {
+        return getPort().isPresent() && !getPortValidator().validate(getPort().get()).isFailure();
+    }
+
+    @Override
+    public Validator<Integer> getPortValidator() {
+        return new IntegerPortValidator();
+    }
+
+    @Override
+    public Optional<String> getPassword() {
+        return password;
+    }
+
+    @Override
+    public void setPassword(final Optional<String> password) {
+        checkNotNull(password);
+        this.password = password;
+        listeners.getCallable(NewServerDialogModelListener.class).serverDetailsChanged(hostname,
+                port, password, ssl, saveAsDefault);
+    }
+
+    @Override
+    public boolean isPasswordValid() {
+        return !getPassword().isPresent() || !getPasswordValidator().validate(getPassword().get()).
+                isFailure();
+    }
+
+    @Override
+    public Validator<String> getPasswordValidator() {
+        return new PermissiveValidator<>();
+    }
+
+    @Override
+    public boolean getSSL() {
+        return ssl;
+    }
+
+    @Override
+    public void setSSL(final boolean ssl) {
+        this.ssl = ssl;
+        listeners.getCallable(NewServerDialogModelListener.class).serverDetailsChanged(hostname,
+                port, password, ssl, saveAsDefault);
+    }
+
+    @Override
+    public boolean getSaveAsDefault() {
+        return saveAsDefault;
+    }
+
+    @Override
+    public void setSaveAsDefault(final boolean saveAsDefault) {
+        this.saveAsDefault = saveAsDefault;
+        listeners.getCallable(NewServerDialogModelListener.class).serverDetailsChanged(hostname,
+                port, password, ssl, saveAsDefault);
+    }
+
+    @Override
+    public void save() {
+        if (saveAsDefault) {
+            userConfig.
+                    setOption("newserver", "hostname", hostname.isPresent() ? hostname.get() : "");
+            userConfig.setOption("newserver", "port", port.isPresent() ? port.get() : 6667);
+            userConfig.setOption("newserver", "password",
+                    password.isPresent() ? password.get() : "");
+            userConfig.setOption("newserver", "ssl", ssl);
+        }
+        try {
+            if (selectedProfile.isPresent()) {
+                serverManager.connectToAddress(getServerURI(), selectedProfile.get());
+            } else {
+                serverManager.connectToAddress(getServerURI());
+            }
+        } catch (URISyntaxException ex) {
+            //This is tested in isSaveAllowed, shouldn't happen here.
+        }
+    }
+
+    @Override
+    public boolean isSaveAllowed() {
+        try {
+            getServerURI();
+        } catch (URISyntaxException ex) {
+            return false;
+        }
+        return isHostnameValid() && isPortValid() && isPasswordValid() && isProfileListValid();
+    }
+
+    @Override
+    public void addListener(final NewServerDialogModelListener listener) {
+        checkNotNull(listener);
+        listeners.add(NewServerDialogModelListener.class, listener);
+    }
+
+    @Override
+    public void removeListener(final NewServerDialogModelListener listener) {
+        checkNotNull(listener);
+        listeners.remove(NewServerDialogModelListener.class, listener);
+    }
+
+    @Override
+    public void configProviderAdded(final ConfigProvider configProvider) {
+        checkNotNull(configProvider);
+        profiles.add(configProvider);
+        listeners.getCallable(NewServerDialogModelListener.class).profileListChanged(
+                ImmutableList.copyOf(profiles));
+    }
+
+    @Override
+    public void configProviderRemoved(final ConfigProvider configProvider) {
+        checkNotNull(configProvider);
+        if (Optional.fromNullable(configProvider).equals(selectedProfile)) {
+            final Optional<ConfigProvider> oldSelectedProfile = selectedProfile;
+            selectedProfile = Optional.absent();
+            listeners.getCallable(NewServerDialogModelListener.class).selectedProfileChanged(
+                    oldSelectedProfile, Optional.<ConfigProvider>absent());
+
+        }
+        profiles.remove(configProvider);
+        listeners.getCallable(NewServerDialogModelListener.class).profileListChanged(
+                ImmutableList.copyOf(profiles));
+    }
+
+    /**
+     * Gets the URI for the details in the dialog.
+     *
+     * @return Returns the URI the details represent
+     *
+     * @throws URISyntaxException    If the resulting URI is invalid
+     */
+    private URI getServerURI() throws URISyntaxException {
+        return new URI("irc" + (ssl ? "s" : ""),
+                password.isPresent() ? password.get() : "",
+                hostname.isPresent() ? hostname.get() : "",
+                port.isPresent() ? port.get() : 6667,
+                null, null, null);
+    }
+
+}

src/com/dmdirc/ui/core/newserver/NewServerDialogModelAdapter.java

@@ -0,0 +1,52 @@
+/*
+ * 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.ui.core.newserver;
+
+import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.interfaces.ui.NewServerDialogModelListener;
+
+import com.google.common.base.Optional;
+
+import java.util.List;
+
+/**
+ * An abstract adapter class for receiving new server dialog model events. The methods in this class
+ * are empty. This class exists as convenience for creating listener objects.
+ */
+public class NewServerDialogModelAdapter implements NewServerDialogModelListener {
+
+    @Override
+    public void selectedProfileChanged(final Optional<ConfigProvider> oldProfile,
+            final Optional<ConfigProvider> newProfile) {
+    }
+
+    @Override
+    public void profileListChanged(final List<ConfigProvider> profiles) {
+    }
+
+    @Override
+    public void serverDetailsChanged(final Optional<String> hostname, final Optional<Integer> port,
+            final Optional<String> password, final boolean ssl, final boolean saveAsDefault) {
+    }
+
+}

test/com/dmdirc/ui/core/newserver/CoreNewServerDialogModelTest.java

@@ -0,0 +1,426 @@
+/*
+ * 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.ui.core.newserver;
+
+import com.dmdirc.ServerManager;
+import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.interfaces.config.IdentityController;
+import com.dmdirc.interfaces.ui.NewServerDialogModelListener;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.Lists;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+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.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class CoreNewServerDialogModelTest {
+
+    @Mock private AggregateConfigProvider globalConfig;
+    @Mock private ConfigProvider userConfig;
+    @Mock private IdentityController controller;
+    @Mock private ServerManager serverManager;
+    @Mock private ConfigProvider profile1;
+    @Mock private ConfigProvider profile2;
+    @Mock private NewServerDialogModelListener listener;
+
+    @Before
+    public void setupMocks() {
+        when(controller.getProvidersByType("profile")).thenReturn(
+                Lists.newArrayList(profile1, profile2));
+        when(globalConfig.getOption("newserver", "hostname")).thenReturn("hostname");
+        when(globalConfig.getOptionInt("newserver", "port")).thenReturn(1111);
+        when(globalConfig.getOption("newserver", "password")).thenReturn("password");
+        when(globalConfig.getOptionBool("newserver", "ssl")).thenReturn(true);
+    }
+
+    @Test
+    public void testGetProfiles() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertEquals("loadModel: ", Lists.newArrayList(profile1, profile2), instance.
+                getProfileList());
+    }
+
+    @Test
+    public void testSelectedProfile() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertEquals("testSelectedProfile: ", Optional.absent(), instance.getSelectedProfile());
+        instance.setSelectedProfile(Optional.fromNullable(profile1));
+        assertEquals("testSelectedProfile", Optional.fromNullable(profile1),
+                instance.getSelectedProfile());
+    }
+
+    @Test
+    public void testProfileValidatorEmpty() {
+        when(controller.getProvidersByType("profile")).thenReturn(
+                Lists.<ConfigProvider>newArrayList());
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertFalse("testProfileValidatorEmpty: ", instance.isProfileListValid());
+    }
+
+    @Test
+    public void testProfileValidatorNotEmpty() {
+        when(controller.getProvidersByType("profile")).thenReturn(
+                Lists.newArrayList(profile1, profile2));
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertTrue("testProfileValidatorNotEmpty: ", instance.isProfileListValid());
+    }
+
+    @Test
+    public void testHostname() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertEquals("testHostname: ", Optional.fromNullable("hostname"), instance.getHostname());
+        instance.setHostname(Optional.fromNullable("test"));
+        assertEquals("testHostname: ", Optional.fromNullable("test"), instance.getHostname());
+    }
+
+    @Test
+    public void testHostnameValidatorValid() {
+        when(globalConfig.getOption("newserver", "hostname")).thenReturn("hostname");
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertTrue("testHostnameValidatorValid: ", instance.isHostnameValid());
+    }
+
+    @Test
+    public void testHostnameValidatorInvalid() {
+        when(globalConfig.getOption("newserver", "hostname")).thenReturn("~!£$^£$%^&");
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertFalse("testHostnameValidatorInvalid: ", instance.isHostnameValid());
+    }
+
+    @Test
+    public void testPort() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertEquals("testPort: ", Optional.fromNullable(1111), instance.getPort());
+        instance.setPort(Optional.fromNullable(5678));
+        assertEquals("testPort: ", Optional.fromNullable(5678), instance.getPort());
+    }
+
+    @Test
+    public void testPortValidatorValid() {
+        when(globalConfig.getOptionInt("newserver", "port")).thenReturn(1111);
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertTrue("testPortValidatorValid: ", instance.isPortValid());
+    }
+
+    @Test
+    public void testPortValidatorTooLow() {
+        when(globalConfig.getOptionInt("newserver", "port")).thenReturn(-1);
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertFalse("testPortValidatorTooLow: ", instance.isPortValid());
+    }
+
+    @Test
+    public void testPortValidatorTooHigh() {
+        when(globalConfig.getOptionInt("newserver", "port")).thenReturn(65536);
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertFalse("testPortValidatorTooHigh: ", instance.isPortValid());
+    }
+
+    @Test
+    public void testPassword() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertEquals("testPassword: ", Optional.fromNullable("password"), instance.getPassword());
+        instance.setPassword(Optional.fromNullable("test"));
+        assertEquals("testPassword: ", Optional.fromNullable("test"), instance.getPassword());
+    }
+
+    @Test
+    public void testPasswordValidatorValid() {
+        when(globalConfig.getOption("newserver", "password")).thenReturn("password");
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertTrue("testPasswordValidatorValid: ", instance.isPortValid());
+    }
+
+    @Test
+    public void testSSL() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertTrue("testSSL: ", instance.getSSL());
+        instance.setSSL(false);
+        assertFalse("testSSL: ", instance.getSSL());
+    }
+
+    @Test
+    public void testSaveAsDefault() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertFalse("testSaveAsDefault:", instance.getSaveAsDefault());
+        instance.setSaveAsDefault(true);
+        assertTrue("testSaveAsDefault:", instance.getSaveAsDefault());
+    }
+
+    @Test
+    public void testIsSaveAllowedValid() {
+        when(globalConfig.getOption("newserver", "hostname")).thenReturn("hostname");
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertTrue("testIsSaveAllowedValid: ", instance.isSaveAllowed());
+    }
+
+    @Test
+    public void testIsSaveAllowedInvalidHostname() {
+        when(globalConfig.getOption("newserver", "hostname")).thenReturn("~!£$^£$%^&");
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertFalse("testIsSaveAllowedInvalidHostname: ", instance.isSaveAllowed());
+    }
+
+    @Test
+    public void testIsSaveAllowedInvalidPort() {
+        when(globalConfig.getOption("newserver", "hostname")).thenReturn("-1");
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertFalse("testIsSaveAllowedInvalidPort: ", instance.isSaveAllowed());
+    }
+
+    @Test
+    public void testSaveSaveDefaults() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.setSaveAsDefault(true);
+        instance.save();
+        verify(userConfig).setOption("newserver", "hostname", "hostname");
+        verify(userConfig).setOption("newserver", "port", 1111);
+        verify(userConfig).setOption("newserver", "password", "password");
+        verify(userConfig).setOption("newserver", "ssl", true);
+    }
+
+    @Test
+    public void testSaveNotDefaults() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.setSaveAsDefault(false);
+        instance.save();
+        verify(userConfig, never()).setOption("newserver", "hostname", "hostname");
+        verify(userConfig, never()).setOption("newserver", "port", 1111);
+        verify(userConfig, never()).setOption("newserver", "password", "password");
+        verify(userConfig, never()).setOption("newserver", "ssl", true);
+    }
+
+    @Test
+    public void testSaveConnectWithoutProfile() throws URISyntaxException {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.save();
+        verify(serverManager).connectToAddress(new URI("ircs://password@hostname:1111"));
+        verify(serverManager, never()).connectToAddress(any(URI.class), any(ConfigProvider.class));
+    }
+
+    @Test
+    public void testSaveConnectWithProfile() throws URISyntaxException {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.setSelectedProfile(Optional.fromNullable(profile1));
+        instance.save();
+        verify(serverManager, never()).connectToAddress(any(URI.class));
+        verify(serverManager).connectToAddress(new URI("ircs://password@hostname:1111"), profile1);
+    }
+
+    @Test
+    public void testAddConfigProvider() {
+        when(controller.getProvidersByType("profile")).thenReturn(Lists.newArrayList(profile1));
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertEquals("testAddConfigProvider:", Lists.newArrayList(profile1),
+                instance.getProfileList());
+        instance.configProviderAdded(profile2);
+        assertEquals("testAddConfigProvider:", Lists.newArrayList(profile1, profile2),
+                instance.getProfileList());
+    }
+
+    @Test
+    public void testRemoveConfigProvider() {
+        when(controller.getProvidersByType("profile")).thenReturn(
+                Lists.newArrayList(profile1, profile2));
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertEquals("testRemoveConfigProvider:", Lists.newArrayList(profile1, profile2),
+                instance.getProfileList());
+        instance.configProviderRemoved(profile2);
+        assertEquals("testRemoveConfigProvider:", Lists.newArrayList(profile1),
+                instance.getProfileList());
+    }
+
+    @Test
+    public void testRemoveConfigProviderSelectedProfile() {
+        when(controller.getProvidersByType("profile")).thenReturn(
+                Lists.newArrayList(profile1, profile2));
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.setSelectedProfile(Optional.fromNullable(profile2));
+        assertEquals("testRemoveConfigProviderSelectedProfile:",
+                Lists.newArrayList(profile1, profile2),
+                instance.getProfileList());
+        assertEquals("testRemoveConfigProviderSelectedProfile:", Optional.fromNullable(profile2),
+                instance.getSelectedProfile());
+        instance.configProviderRemoved(profile2);
+        assertEquals("testRemoveConfigProviderSelectedProfile:", Lists.newArrayList(profile1),
+                instance.getProfileList());
+        assertEquals("testRemoveConfigProviderSelectedProfile:", Optional.absent(),
+                instance.getSelectedProfile());
+    }
+
+    @Test
+    public void testListenerSelectedProfileChanged() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        assertEquals("testListenerSelectedProfileChanged: ", Optional.<ConfigProvider>absent(),
+                instance.getSelectedProfile());
+        instance.addListener(listener);
+        instance.setSelectedProfile(Optional.fromNullable(profile1));
+        assertEquals("testListenerSelectedProfileChanged: ", Optional.fromNullable(profile1),
+                instance.getSelectedProfile());
+        verify(listener).selectedProfileChanged(Optional.<ConfigProvider>absent(),
+                Optional.fromNullable(profile1));
+    }
+
+    @Test
+    public void testListenerProfileListChangedRemoved() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.addListener(listener);
+        assertEquals("testListenerProfileListChangedRemoved: ",
+                Lists.newArrayList(profile1, profile2), instance.getProfileList());
+        instance.configProviderRemoved(profile2);
+        assertEquals("testListenerProfileListChangedRemoved:", Lists.newArrayList(profile1),
+                instance.getProfileList());
+        verify(listener).profileListChanged(Lists.newArrayList(profile1));
+    }
+
+    @Test
+    public void testListenerProfileListChangedAdded() {
+        when(controller.getProvidersByType("profile"))
+                .thenReturn(Lists.newArrayList(profile1));
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.addListener(listener);
+        assertEquals("testListenerProfileListChangedAdded: ", Lists.newArrayList(profile1),
+                instance.getProfileList());
+        instance.configProviderAdded(profile2);
+        assertEquals("testListenerProfileListChangedAdded:", Lists.newArrayList(profile1, profile2),
+                instance.getProfileList());
+        verify(listener).profileListChanged(Lists.newArrayList(profile1, profile2));
+    }
+
+    @Test
+    public void testListenerServerDetailsChangedPort() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.addListener(listener);
+        instance.setPort(Optional.fromNullable(9999));
+        verify(listener).serverDetailsChanged(Optional.fromNullable("hostname"),
+                Optional.fromNullable(9999), Optional.fromNullable("password"), true, false);
+    }
+
+    @Test
+    public void testListenerServerDetailsChangedPassword() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.addListener(listener);
+        instance.setPassword(Optional.fromNullable("password-test"));
+        verify(listener).serverDetailsChanged(Optional.fromNullable("hostname"),
+                Optional.fromNullable(1111), Optional.fromNullable("password-test"), true, false);
+    }
+
+    @Test
+    public void testListenerServerDetailsChangedSSL() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.addListener(listener);
+        instance.setSSL(false);
+        verify(listener).serverDetailsChanged(Optional.fromNullable("hostname"),
+                Optional.fromNullable(1111), Optional.fromNullable("password"), false, false);
+    }
+
+    @Test
+    public void testListenerServerDetailsChangedSaveAsDefault() {
+        CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
+                controller, serverManager);
+        instance.loadModel();
+        instance.addListener(listener);
+        instance.setSaveAsDefault(true);
+        verify(listener).serverDetailsChanged(Optional.fromNullable("hostname"),
+                Optional.fromNullable(1111), Optional.fromNullable("password"), true, true);
+    }
+
+}