Merge lp:~adam-rpconnelly/dbversion/saved-connection into lp:dbversion

[Adam Connelly]

I've added the saved-connection command. The command allows multiple connections to be saved with a name. This means that when you want to specify a database to connect to you just have to specify the connection name instead of typing out the full connection details.

The command also allows existing saved connections to be used as a template when creating new ones so that only the connection properties that have changed need to be specified, and allows a default connection to be specified which will be used by default if no connection name is specified when running commands.

=== modified file 'src/DatabaseVersion.Console.Tests/Command/Create/CreateCommandTests.cs'
--- src/DatabaseVersion.Console.Tests/Command/Create/CreateCommandTests.cs	2011-09-05 19:50:57 +0000
+++ src/DatabaseVersion.Console.Tests/Command/Create/CreateCommandTests.cs	2011-11-15 22:04:37 +0000
@@ -4,6 +4,7 @@
 
     using dbversion;
     using dbversion.Archives;
+    using dbversion.Connections;
     using dbversion.Console.Command.Create;
     using dbversion.Property;
     using dbversion.Session;
@@ -25,6 +26,7 @@
         private readonly Mock<IDatabaseArchive> archive = new Mock<IDatabaseArchive>();
         private readonly Mock<IDatabaseArchiveFactory> archiveFactory = new Mock<IDatabaseArchiveFactory>();
         private readonly Mock<ISettingsService> settingsService = new Mock<ISettingsService>();
+        private readonly Mock<ISavedConnectionService> savedConnectionService = new Mock<ISavedConnectionService>();
 
         #endregion
 
@@ -58,8 +60,7 @@
         public void ShouldPrintMessageIfArchiveIsNotSpecified()
         {
             // Arrange
-            var command = new CreateCommand();
-            command.MessageService = messageService.Object;
+            var command = this.CreateCommand();
 
             // Act
             command.Execute(new string[] { });
@@ -85,10 +86,9 @@
         public void ShouldPrintMessageIfArchiveIsNotSupported()
         {
             // Arrange
-            var command = new CreateCommand();
-            command.MessageService = messageService.Object;
-            var archiveFactory = new Mock<IDatabaseArchiveFactory>();
-            command.ArchiveFactories = new[] { archiveFactory.Object };
+            var command = this.CreateCommand();
+            command.ArchiveFactories = new[] { this.archiveFactory.Object };
+            this.archiveFactory.Setup(f => f.Create(It.IsAny<string>())).Returns((IDatabaseArchive)null);
 
             // Act
             command.Execute(new[] { "-a", "myArchive" });
@@ -324,6 +324,7 @@
             command.SettingsService = this.settingsService.Object;
             command.PropertyService = this.propertyService.Object;
             command.MessageService = this.messageService.Object;
+            command.SavedConnectionService = this.savedConnectionService.Object;
 
             archiveFactory.Setup(f => f.CanCreate("myArchive")).Returns(true);
             archiveFactory.Setup(f => f.Create("myArchive")).Returns(archive.Object);

=== modified file 'src/DatabaseVersion.Console.Tests/Command/History/HistoryCommandTests.cs'
--- src/DatabaseVersion.Console.Tests/Command/History/HistoryCommandTests.cs	2011-10-17 20:07:45 +0000
+++ src/DatabaseVersion.Console.Tests/Command/History/HistoryCommandTests.cs	2011-11-15 22:04:37 +0000
@@ -6,6 +6,8 @@
     using System.Linq;
     using System.Text;
 
+    using dbversion.Archives;
+    using dbversion.Connections;
     using dbversion.Console.Command.History;
     using dbversion.Property;
     using dbversion.Session;
@@ -27,6 +29,8 @@
         private readonly Mock<ISessionFactoryProvider> sessionFactoryProvider = new Mock<ISessionFactoryProvider>() { DefaultValue = DefaultValue.Mock };
         private readonly Mock<ISettingsService> settingsService = new Mock<ISettingsService>();
         private readonly Mock<IPropertyService> propertyService = new Mock<IPropertyService>();
+        private readonly Mock<IDatabaseArchiveFactory> archiveFactory = new Mock<IDatabaseArchiveFactory>();
+        private readonly Mock<ISavedConnectionService> savedConnectionService = new Mock<ISavedConnectionService>();
 
         public HistoryCommandTests()
         {
@@ -248,6 +252,8 @@
             command.SessionFactoryProvider = this.sessionFactoryProvider.Object;
             command.SettingsService = this.settingsService.Object;
             command.PropertyService = this.propertyService.Object;
+            command.ArchiveFactories = new[] { this.archiveFactory.Object };
+            command.SavedConnectionService = this.savedConnectionService.Object;
 
             return command;
         }

=== added directory 'src/DatabaseVersion.Console.Tests/Command/SavedConnection'
=== added file 'src/DatabaseVersion.Console.Tests/Command/SavedConnection/SavedConnectionCommandTests.cs'
--- src/DatabaseVersion.Console.Tests/Command/SavedConnection/SavedConnectionCommandTests.cs	1970-01-01 00:00:00 +0000
+++ src/DatabaseVersion.Console.Tests/Command/SavedConnection/SavedConnectionCommandTests.cs	2011-11-15 22:04:37 +0000
@@ -0,0 +1,546 @@
+namespace dbversion.Console.Tests.Command.SavedConnection
+{
+    using System;
+    using System.Collections.Generic;
+
+    using dbversion.Connections;
+
+    using dbversion.Console.Command.SavedConnection;
+
+    using Moq;
+
+    using Xunit;
+
+    public class SavedConnectionCommandTests
+    {
+        [Fact]
+        public void ShouldHaveCorrectCommandName()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+
+            // Act
+            var name = command.Name;
+
+            // Assert
+            Assert.Equal("saved-connection", name);
+        }
+
+        [Fact]
+        public void ShouldHaveCorrectCommandDescription()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+
+            // Act
+            var description = command.Description;
+
+            // Assert
+            Assert.Equal("Allows connection details to be saved and managed.", description);
+        }
+
+        [Fact]
+        public void ShouldListAllConnectionsWhenNoArgumentsAreSpecified()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+
+            // Act
+            command.Execute(new[] { "saved-connection" });
+
+            // Assert
+            var expectedMessage = "connection2:" + Environment.NewLine +
+                "  Connection String: connString2" + Environment.NewLine +
+                "  Driver Class: driver2" + Environment.NewLine +
+                "  Provider: provider2" + Environment.NewLine +
+                "  Dialect: dialect2" + Environment.NewLine +
+                "  Default: True" + Environment.NewLine + Environment.NewLine +
+                "connection1:" + Environment.NewLine +
+                "  Connection String: connString" + Environment.NewLine +
+                "  Driver Class: driver" + Environment.NewLine +
+                "  Provider: provider" + Environment.NewLine +
+                "  Dialect: dialect" + Environment.NewLine +
+                "  Default: False" + Environment.NewLine + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+        }
+
+        [Fact]
+        public void ShouldDisplayMessageWhenNoSavedConnectionsExist()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            // Act
+            command.Execute(new[] { "saved-connection" });
+
+            // Assert
+            var expectedMessage = "There are no saved connections." + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+        }
+
+        [Fact]
+        public void ShouldListCorrectConnectionWhenConnectionNameIsSpecified()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+
+            // Act
+            command.Execute(new[] { "saved-connection", "-n", "connection1" });
+
+            // Assert
+            var expectedMessage = "connection1:" + Environment.NewLine +
+                "  Connection String: connString" + Environment.NewLine +
+                "  Driver Class: driver" + Environment.NewLine +
+                "  Provider: provider" + Environment.NewLine +
+                "  Dialect: dialect" + Environment.NewLine +
+                "  Default: False" + Environment.NewLine + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+        }
+
+        [Fact]
+        public void ShouldDisplayMessageWhenSpecifiedConnectionDoesNotExist()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+
+            // Act
+            command.Execute(new[] { "saved-connection", "-n", "abc" });
+
+            // Assert
+            var expectedMessage = "There is no saved connection called \"abc\"." + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+        }
+
+        [Fact]
+        public void ShouldBeAbleToCreateNewSavedConnection()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.CreateSavedConnection("connection1", "connString", "provider", "driver", "dialect"))
+                .Returns(new SavedConnection("connection1", "connString", "provider", "driver", "dialect", true));
+
+            // Act
+            command.Execute(
+                new[]
+                {
+                    "saved-connection",
+                    "-n", "connection1",
+                    "-c", "connString",
+                    "-l", "dialect",
+                    "-p", "provider",
+                    "-d", "driver"
+                });
+
+            // Assert
+            var expectedMessage = "Created new saved connection \"connection1\":" + Environment.NewLine +
+                "  Connection String: connString" + Environment.NewLine +
+                "  Driver Class: driver" + Environment.NewLine +
+                "  Provider: provider" + Environment.NewLine +
+                "  Dialect: dialect" + Environment.NewLine +
+                "  Default: True" + Environment.NewLine + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+            service.Verify(s => s.CreateSavedConnection("connection1", "connString", "provider", "driver", "dialect"));
+            service.Verify(s => s.SaveConnections());
+        }
+
+        [Fact]
+        public void ShouldBeAbleToUpdateExistingSavedConnection()
+        {
+                        // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(
+                new[] { new SavedConnection("connection1", "connString", "provider", "driver", "dialect", true) });
+            service.Setup(s => s.CreateSavedConnection("connection1", "newConnString", "provider", "driver", "dialect"))
+                .Returns(new SavedConnection("connection1", "newConnString", "provider", "driver", "dialect", true));
+
+            // Act
+            command.Execute(
+                new[]
+                {
+                    "saved-connection",
+                    "-n", "connection1",
+                    "-c", "newConnString"
+                });
+
+            // Assert
+            service.Verify(s => s.CreateSavedConnection("connection1", "newConnString", "provider", "driver", "dialect"));
+            service.Verify(s => s.SaveConnections());
+        }
+
+        [Fact]
+        public void ShouldBeAbleToDeleteSavedConnection()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+            service.Setup(s => s.DeleteConnection("connection1")).Returns(true);
+
+            // Act
+            command.Execute(new[] { "saved-connection", "-rn", "connection1" });
+
+            // Assert
+            var expectedMessage = "\"connection1\" has been deleted." + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+            service.Verify(s => s.SaveConnections());
+        }
+
+        [Fact]
+        public void ShouldPrintErrorMessageIfDeletingConnectionFails()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+            service.Setup(s => s.DeleteConnection("connection1")).Returns(false);
+
+            // Act
+            command.Execute(new[] { "saved-connection", "-rn", "connection1" });
+
+            // Assert
+            var expectedMessage = "There is no saved connection called \"connection1\"." + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+            service.Verify(s => s.SaveConnections(), Times.Never());
+        }
+
+        [Fact]
+        public void ShouldBeAbleToDefaultSavedConnection()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+            service.Setup(s => s.SetDefaultConnection("connection1")).Returns(true);
+
+            // Act
+            command.Execute(new[] { "saved-connection", "-n", "connection1", "--default" });
+
+            // Assert
+            var expectedMessage = "\"connection1\" is now the default connection." + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+            service.Verify(s => s.SaveConnections());
+        }
+
+        [Fact]
+        public void ShouldPrintAnErrorMessageIfDefaultingFails()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+            service.Setup(s => s.SetDefaultConnection("connection5")).Returns(false);
+
+            // Act
+            command.Execute(new[] { "saved-connection", "-n", "connection5", "--default" });
+
+            // Assert
+            var expectedMessage = "There is no saved connection called \"connection5\"." + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+            service.Verify(s => s.SaveConnections(), Times.Never());
+        }
+
+        [Fact]
+        public void ShouldBeAbleToCreateAConnectionFromATemplate()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+            service.Setup(s => s.CreateSavedConnection("connection5", "newConnString", "newProvider", "newDriver", "newDialect"))
+                .Returns(new SavedConnection("connection5", "newConnString", "newProvider", "newDriver", "newDialect", false));
+
+            // Act
+            command.Execute(
+                new[]
+                {
+                    "saved-connection",
+                    "-n", "connection5",
+                    "-t", "connection1",
+                    "-c", "newConnString",
+                    "-d", "newDriver",
+                    "-l", "newDialect",
+                    "-p", "newProvider"
+                });
+
+            // Assert
+            var expectedMessage = "Created a new connection \"connection5\" based on \"connection1\"." + Environment.NewLine +
+                "  Connection String: newConnString" + Environment.NewLine +
+                "  Driver Class: newDriver" + Environment.NewLine +
+                "  Provider: newProvider" + Environment.NewLine +
+                "  Dialect: newDialect" + Environment.NewLine +
+                "  Default: False" + Environment.NewLine + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+            service.Verify(s => s.SaveConnections());
+        }
+
+        [Fact]
+        public void ShouldNotOverwriteConnectionStringWhenCreatingFromTemplate()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+            service.Setup(s => s.CreateSavedConnection("connection5", "connString", "newProvider", "newDriver", "newDialect"))
+                .Returns(new SavedConnection("connection5", "connString", "newProvider", "newDriver", "newDialect", false));
+
+            // Act
+            command.Execute(
+                new[]
+                {
+                    "saved-connection",
+                    "-n", "connection5",
+                    "-t", "connection1",
+                    "-d", "newDriver",
+                    "-l", "newDialect",
+                    "-p", "newProvider"
+                });
+
+            // Assert
+            var expectedMessage = "Created a new connection \"connection5\" based on \"connection1\"." + Environment.NewLine +
+                "  Connection String: connString" + Environment.NewLine +
+                "  Driver Class: newDriver" + Environment.NewLine +
+                "  Provider: newProvider" + Environment.NewLine +
+                "  Dialect: newDialect" + Environment.NewLine +
+                "  Default: False" + Environment.NewLine + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+            service.Verify(s => s.SaveConnections());
+        }
+
+        [Fact]
+        public void ShouldNotOverwriteDriverClassWhenCreatingFromTemplate()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+            service.Setup(s => s.CreateSavedConnection("connection5", "newConnString", "newProvider", "driver", "newDialect"))
+                .Returns(new SavedConnection("connection5", "newConnString", "newProvider", "driver", "newDialect", false));
+
+            // Act
+            command.Execute(
+                new[]
+                {
+                    "saved-connection",
+                    "-n", "connection5",
+                    "-t", "connection1",
+                    "-c", "newConnString",
+                    "-l", "newDialect",
+                    "-p", "newProvider"
+                });
+
+            // Assert
+            var expectedMessage = "Created a new connection \"connection5\" based on \"connection1\"." + Environment.NewLine +
+                "  Connection String: newConnString" + Environment.NewLine +
+                "  Driver Class: driver" + Environment.NewLine +
+                "  Provider: newProvider" + Environment.NewLine +
+                "  Dialect: newDialect" + Environment.NewLine +
+                "  Default: False" + Environment.NewLine + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+            service.Verify(s => s.SaveConnections());
+        }
+
+        [Fact]
+        public void ShouldNotOverwriteDialectWhenCreatingFromTemplate()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+            service.Setup(s => s.CreateSavedConnection("connection5", "newConnString", "newProvider", "newDriver", "dialect"))
+                .Returns(new SavedConnection("connection5", "newConnString", "newProvider", "newDriver", "dialect", false));
+
+            // Act
+            command.Execute(
+                new[]
+                {
+                    "saved-connection",
+                    "-n", "connection5",
+                    "-t", "connection1",
+                    "-c", "newConnString",
+                    "-d", "newDriver",
+                    "-p", "newProvider"
+                });
+
+            // Assert
+            var expectedMessage = "Created a new connection \"connection5\" based on \"connection1\"." + Environment.NewLine +
+                "  Connection String: newConnString" + Environment.NewLine +
+                "  Driver Class: newDriver" + Environment.NewLine +
+                "  Provider: newProvider" + Environment.NewLine +
+                "  Dialect: dialect" + Environment.NewLine +
+                "  Default: False" + Environment.NewLine + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+            service.Verify(s => s.SaveConnections());
+        }
+
+        [Fact]
+        public void ShouldNotOverwriteProviderWhenCreatingFromTemplate()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+            service.Setup(s => s.CreateSavedConnection("connection5", "newConnString", "provider", "newDriver", "newDialect"))
+                .Returns(new SavedConnection("connection5", "newConnString", "provider", "newDriver", "newDialect", false));
+
+            // Act
+            command.Execute(
+                new[]
+                {
+                    "saved-connection",
+                    "-n", "connection5",
+                    "-t", "connection1",
+                    "-c", "newConnString",
+                    "-d", "newDriver",
+                    "-l", "newDialect"
+                });
+
+            // Assert
+            var expectedMessage = "Created a new connection \"connection5\" based on \"connection1\"." + Environment.NewLine +
+                "  Connection String: newConnString" + Environment.NewLine +
+                "  Driver Class: newDriver" + Environment.NewLine +
+                "  Provider: provider" + Environment.NewLine +
+                "  Dialect: newDialect" + Environment.NewLine +
+                "  Default: False" + Environment.NewLine + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+            service.Verify(s => s.SaveConnections());
+        }
+
+        [Fact]
+        public void ShouldPrintErrorIfTemplateCannotBeFound()
+        {
+            // Arrange
+            var command = new SavedConnectionCommand();
+            var service = new Mock<ISavedConnectionService>();
+            var messageService = new MessageServiceMock();
+
+            command.SavedConnectionService = service.Object;
+            command.MessageService = messageService;
+
+            service.Setup(s => s.SavedConnections).Returns(CreateConnections());
+
+            // Act
+            command.Execute(
+                new[]
+                {
+                    "saved-connection",
+                    "-n", "connection5",
+                    "-t", "missingConnection",
+                    "-c", "newConnString"
+                });
+
+            // Assert
+            var expectedMessage =
+                "Template connection \"missingConnection\" could not be found." + Environment.NewLine;
+            Assert.Equal(expectedMessage, messageService.Contents);
+        }
+
+        private static IEnumerable<SavedConnection> CreateConnections()
+        {
+            return new[]
+                {
+                    new SavedConnection
+                    {
+                        Name = "connection1",
+                        ConnectionProvider = "provider",
+                        ConnectionString = "connString",
+                        Dialect = "dialect",
+                        DriverClass = "driver",
+                        IsDefault = false
+                    },
+                    new SavedConnection
+                    {
+                        Name = "connection2",
+                        ConnectionProvider = "provider2",
+                        ConnectionString = "connString2",
+                        Dialect = "dialect2",
+                        DriverClass = "driver2",
+                        IsDefault = true
+                    }
+                };
+        }
+    }
+}
+

=== modified file 'src/DatabaseVersion.Console.Tests/dbversion.Console.Tests.csproj'
--- src/DatabaseVersion.Console.Tests/dbversion.Console.Tests.csproj	2011-10-25 21:46:32 +0000
+++ src/DatabaseVersion.Console.Tests/dbversion.Console.Tests.csproj	2011-11-15 22:04:37 +0000
@@ -48,6 +48,7 @@
     <Compile Include="Command\Help\HelpCommandTests.cs" />
     <Compile Include="MessageServiceMock.cs" />
     <Compile Include="Command\History\HistoryCommandTests.cs" />
+    <Compile Include="Command\SavedConnection\SavedConnectionCommandTests.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ItemGroup>

=== removed file 'src/DatabaseVersion.Console/Arguments.cs'
--- src/DatabaseVersion.Console/Arguments.cs	2011-09-04 22:51:13 +0000
+++ src/DatabaseVersion.Console/Arguments.cs	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-using System.ComponentModel;
-using System;
-using CommandLine;
-using CommandLine.Text;
-
-namespace dbversion.Console
-{
-    /// <summary>
-    /// The command line arguments that define how the application should function.
-    /// </summary>
-    public class Arguments
-    {
-        /// <summary>
-        /// The connection string to the database.
-        /// </summary>
-        [Option("c", "connectionString", HelpText = "The database connection string.")]
-        public string ConnectionString;
-
-        /// <summary>
-        /// The archive containing the database scripts.
-        /// </summary>
-        [Option("a", "archive", HelpText = "The archive containing the database versions.")]
-        public string Archive;
-
-        /// <summary>
-        /// The version to create or upgrade to.
-        /// </summary>
-        [Option("v", "version", HelpText = "The version to create or upgrade to.")]
-        public string Version;
-        
-        /// <summary>
-        /// Gets or sets the hibernate connection provider.
-        /// </summary>
-        [Option("p", "connectionProvider", HelpText = "The hibernate connection provider.")]
-        public string ConnectionProvider;
-
-        /// <summary>
-        /// Gets or sets the hibernate driver class.
-        /// </summary>
-        [Option("d", "driverClass", HelpText = "The hibernate driver class.")]
-        public string DriverClass;
-
-        /// <summary>
-        /// Gets or sets the hibernate dialect.
-        /// </summary>
-        [Option("l", "dialect", HelpText = "The hibernate dialect.")]
-        public string Dialect;
-
-        [HelpOption("h", "help", HelpText = "Display this help screen.")]
-        public string GetHelp()
-        {
-            var help = new HelpText("dbversion");
-            help.AdditionalNewLineAfterOption = true;
-            help.AddOptions(this);
-
-            return help;
-        }
-    }
-}

=== added file 'src/DatabaseVersion.Console/Command/ConnectionArguments.cs'
--- src/DatabaseVersion.Console/Command/ConnectionArguments.cs	1970-01-01 00:00:00 +0000
+++ src/DatabaseVersion.Console/Command/ConnectionArguments.cs	2011-11-15 22:04:37 +0000
@@ -0,0 +1,46 @@
+using System.ComponentModel;
+using System;
+using CommandLine;
+using CommandLine.Text;
+
+namespace dbversion.Console.Command
+{
+    /// <summary>
+    /// The command line arguments that define how the application should function.
+    /// </summary>
+    public class ConnectionArguments
+    {
+        /// <summary>
+        /// The connection string to the database.
+        /// </summary>
+        [Option("c", "connectionString", HelpText = "The database connection string.")]
+        public string ConnectionString;
+        
+        /// <summary>
+        /// Gets or sets the hibernate connection provider.
+        /// </summary>
+        [Option("p", "connectionProvider", HelpText = "The hibernate connection provider.")]
+        public string ConnectionProvider;
+
+        /// <summary>
+        /// Gets or sets the hibernate driver class.
+        /// </summary>
+        [Option("d", "driverClass", HelpText = "The hibernate driver class.")]
+        public string DriverClass;
+
+        /// <summary>
+        /// Gets or sets the hibernate dialect.
+        /// </summary>
+        [Option("l", "dialect", HelpText = "The hibernate dialect.")]
+        public string Dialect;
+
+        [Option("s", "saved-connection")]
+        public string SavedConnection;
+
+        /// <summary>
+        /// The archive containing the database scripts.
+        /// </summary>
+        [Option("a", "archive", HelpText = "The archive containing the database versions.")]
+        public string Archive;
+    }
+}

=== added file 'src/DatabaseVersion.Console/Command/ConnectionCommandBase.cs'
--- src/DatabaseVersion.Console/Command/ConnectionCommandBase.cs	1970-01-01 00:00:00 +0000
+++ src/DatabaseVersion.Console/Command/ConnectionCommandBase.cs	2011-11-15 22:04:37 +0000
@@ -0,0 +1,233 @@
+namespace dbversion.Console.Command
+{
+    using System.Collections.Generic;
+    using System.ComponentModel.Composition;
+    using System.Linq;
+
+    using CommandLine;
+
+    using dbversion.Archives;
+    using dbversion.Connections;
+    using dbversion.Property;
+    using dbversion.Session;
+    using dbversion.Settings;
+
+    /// <summary>
+    /// A base class for commands that need to connect to the database.
+    /// </summary>
+    public abstract class ConnectionCommandBase<T> : IConsoleCommand where T : ConnectionArguments, new()
+    {
+        [Import]
+        public IMessageService MessageService
+        {
+            get;
+            set;
+        }
+
+        [Import]
+        public IPropertyService PropertyService
+        {
+            get;
+            set;
+        }
+
+        [Import]
+        public ISettingsService SettingsService
+        {
+            get;
+            set;
+        }
+
+        [Import]
+        public ISavedConnectionService SavedConnectionService
+        {
+            get;
+            set;
+        }
+
+        [ImportMany]
+        public IEnumerable<IDatabaseArchiveFactory> ArchiveFactories
+        {
+            get;
+            set;
+        }
+
+        public abstract string Name { get; }
+
+        public abstract string Description { get; }
+
+        public abstract string Usage { get; }
+
+        public abstract IEnumerable<CommandParameter> Parameters { get; }
+
+        /// <summary>
+        /// Execute the command with the specified arguments.
+        /// </summary>
+        /// <param name='args'>
+        /// The arguments.
+        /// </param>
+        public void Execute(string[] args)
+        {
+            T arguments = ParseArguments(args);
+
+            var archive = GetArchive(arguments.Archive);
+
+            this.SavedConnectionService.LoadConnections();
+
+            this.PropertyService.SetDefaultProperties();
+            this.MergePropertiesFromSettings();
+
+            if (archive != null)
+            {
+                this.PropertyService.Merge(archive.Properties);
+            }
+
+            this.MergeDefaultConnectionProperties();
+            this.SetPropertiesFromCommandArguments(arguments);
+
+            this.Execute(args, arguments, archive);
+        }
+
+        protected abstract void Execute(string[] args, T arguments, IDatabaseArchive archive);
+
+        /// <summary>
+        /// Parses the arguments.
+        /// </summary>
+        /// <param name='args'>
+        /// The command line arguments.
+        /// </param>
+        /// <returns>
+        /// The parsed arguments.
+        /// </returns>
+        private static T ParseArguments(string[] args)
+        {
+            T arguments = new T();
+            var parserSettings = new CommandLineParserSettings();
+            parserSettings.CaseSensitive = true;
+            parserSettings.HelpWriter = System.Console.Out;
+
+            var parser = new CommandLineParser(parserSettings);
+            parser.ParseArguments(args, arguments);
+
+            return arguments;
+        }
+
+        /// <summary>
+        /// Gets the archive.
+        /// </summary>
+        /// <param name='archivePath'>
+        /// Archive path.
+        /// </param>
+        /// <returns>
+        /// The archive or null if none could be created.
+        /// </returns>
+        private IDatabaseArchive GetArchive(string archivePath)
+        {
+            IDatabaseArchiveFactory archiveFactory = GetArchiveFactory(archivePath);
+            if (archiveFactory == null)
+            {
+                return null;
+            }
+
+            return archiveFactory.Create(archivePath);
+        }
+
+        /// <summary>
+        /// Gets the archive factory.
+        /// </summary>
+        /// <param name='archivePath'>
+        /// Archive path.
+        /// </param>
+        /// <returns>
+        /// The archive factory or null if none can be found.
+        /// </returns>
+        private IDatabaseArchiveFactory GetArchiveFactory(string archivePath)
+        {
+            return this.ArchiveFactories.FirstOrDefault(f => f.CanCreate(archivePath));
+        }
+
+        /// <summary>
+        /// Sets the properties from the command arguments.
+        /// </summary>
+        /// <param name='arguments'>
+        /// The command arguments.
+        /// </param>
+        private void SetPropertiesFromCommandArguments(T arguments)
+        {
+            if (!string.IsNullOrEmpty(arguments.ConnectionString))
+            {
+                this.PropertyService.Add(
+                 new Property
+                 {
+                     Key = SessionFactoryProvider.ConnectionStringProperty,
+                     Value = arguments.ConnectionString
+                 });
+            }
+         
+            if (!string.IsNullOrEmpty(arguments.ConnectionProvider))
+            {
+                this.PropertyService.Add(
+                 new Property
+                 {
+                     Key = SessionFactoryProvider.ProviderProperty,
+                     Value = arguments.ConnectionProvider
+                 });
+            }
+         
+            if (!string.IsNullOrEmpty(arguments.DriverClass))
+            {
+                this.PropertyService.Add(
+                 new Property
+                 {
+                     Key = SessionFactoryProvider.DriverClassProperty,
+                     Value = arguments.DriverClass
+                 });
+            }
+         
+            if (!string.IsNullOrEmpty(arguments.Dialect))
+            {
+                this.PropertyService.Add(
+                 new Property
+                 {
+                     Key = SessionFactoryProvider.DialectProperty,
+                     Value = arguments.Dialect
+                 });
+            }
+
+            if (!string.IsNullOrEmpty(arguments.SavedConnection))
+            {
+                var savedConnection =
+                    this.SavedConnectionService.SavedConnections.FirstOrDefault(c => c.Name == arguments.SavedConnection);
+                if (savedConnection != null)
+                {
+                    this.PropertyService.Merge(savedConnection.GetConnectionProperties());
+                }
+            }
+        }
+
+        /// <summary>
+        /// Merges the properties from user settings.
+        /// </summary>
+        private void MergePropertiesFromSettings()
+        {
+            var propertyCollection = this.SettingsService.DeSerialize<PropertyCollection>("properties.xml");
+            if (propertyCollection != null)
+            {
+                this.PropertyService.Merge(propertyCollection.Properties);
+            }
+        }
+
+        /// <summary>
+        /// Merges the default connection properties.
+        /// </summary>
+        private void MergeDefaultConnectionProperties()
+        {
+            var defaultConnection = this.SavedConnectionService.DefaultConnection;
+            if (defaultConnection != null)
+            {
+                this.PropertyService.Merge(defaultConnection.GetConnectionProperties());
+            }
+        }
+    }
+}
+

=== added file 'src/DatabaseVersion.Console/Command/Create/CreateArguments.cs'
--- src/DatabaseVersion.Console/Command/Create/CreateArguments.cs	1970-01-01 00:00:00 +0000
+++ src/DatabaseVersion.Console/Command/Create/CreateArguments.cs	2011-11-15 22:04:37 +0000
@@ -0,0 +1,17 @@
+namespace dbversion.Console.Command.Create
+{
+    using CommandLine;
+
+    /// <summary>
+    /// The arguments for the create command.
+    /// </summary>
+    public class CreateArguments : ConnectionArguments
+    {
+        /// <summary>
+        /// The version to create or upgrade to.
+        /// </summary>
+        [Option("v", "version", HelpText = "The version to create or upgrade to.")]
+        public string Version;
+    }
+}
+

=== modified file 'src/DatabaseVersion.Console/Command/Create/CreateCommand.cs'
--- src/DatabaseVersion.Console/Command/Create/CreateCommand.cs	2011-10-06 11:08:56 +0000
+++ src/DatabaseVersion.Console/Command/Create/CreateCommand.cs	2011-11-15 22:04:37 +0000
@@ -1,23 +1,16 @@
 namespace dbversion.Console.Command.Create
 {
-    using System;
     using System.Collections.Generic;
     using System.ComponentModel.Composition;
-    using System.Linq;
-
-    using CommandLine;
 
     using dbversion.Archives;
-    using dbversion.Property;
-    using dbversion.Session;
-    using dbversion.Settings;
+    using dbversion.Version;
     using dbversion.Tasks;
-    using dbversion.Version;
 
     [Export(typeof(IConsoleCommand))]
-    public class CreateCommand : IConsoleCommand
+    public class CreateCommand : ConnectionCommandBase<CreateArguments>
     {
-        public string Name
+        public override string Name
         {
             get
             {
@@ -25,7 +18,7 @@
             }
         }
 
-        public string Description
+        public override string Description
         {
             get
             {
@@ -33,7 +26,7 @@
             }
         }
 
-        public string Usage
+        public override string Usage
         {
             get
             {
@@ -41,7 +34,7 @@
             }
         }
 
-        public IEnumerable<CommandParameter> Parameters
+        public override IEnumerable<CommandParameter> Parameters
         {
             get
             {
@@ -52,7 +45,8 @@
                     new CommandParameter("-v", "--version", "The version to create or upgrade to."),
                     new CommandParameter("-p", "--connectionProvider", "The hibernate connection provider."),
                     new CommandParameter("-d", "--driverClass", "The hibernate driver class."),
-                    new CommandParameter("-l", "--dialect", "The hibernate dialect.")
+                    new CommandParameter("-l", "--dialect", "The hibernate dialect."),
+                    new CommandParameter("-s", "--saved-connection", "The name of the saved connection to use.")
                 };
             }
         }
@@ -64,61 +58,26 @@
             set;
         }
 
-        [ImportMany]
-        public IEnumerable<IDatabaseArchiveFactory> ArchiveFactories
-        {
-            get;
-            set;
-        }
-
-        [Import]
-        public IMessageService MessageService
-        {
-            get;
-            set;
-        }
-
-        [Import]
-        public IPropertyService PropertyService
-        {
-            get;
-            set;
-        }
-
-        [Import]
-        public ISettingsService SettingsService
-        {
-            get;
-            set;
-        }
-
         /// <summary>
         /// Execute the command with the specified arguments.
         /// </summary>
         /// <param name='args'>
         /// The arguments.
         /// </param>
-        public void Execute(string[] args)
+        protected override void Execute (string[] args, CreateArguments arguments, IDatabaseArchive archive)
         {
-            Arguments arguments = ParseArguments(args);
             if (string.IsNullOrEmpty(arguments.Archive))
             {
                 this.MessageService.WriteLine("Please specify an archive using the -a switch");
                 return;
             }
 
-            var archive = GetArchive(arguments.Archive);
             if (archive == null)
             {
                 this.MessageService.WriteLine("The specified archive is not supported");
                 return;
             }
 
-            this.PropertyService.SetDefaultProperties();
-            this.MergePropertiesFromSettings();
-            this.PropertyService.Merge(archive.Properties);
-            this.SetPropertiesFromCommandArguments(arguments);
-
             try
             {
                 this.Creator.Create(archive, arguments.Version, new ConsoleTaskExecuter(MessageService));
@@ -132,122 +91,5 @@
                 this.MessageService.WriteLine(t.Message);
             }
         }
-
-        /// <summary>
-        /// Parses the arguments.
-        /// </summary>
-        /// <param name='args'>
-        /// The command line arguments.
-        /// </param>
-        /// <returns>
-        /// The parsed arguments.
-        /// </returns>
-        private static Arguments ParseArguments(string[] args)
-        {
-            Arguments arguments = new Arguments();
-            var parserSettings = new CommandLineParserSettings();
-            parserSettings.CaseSensitive = true;
-            parserSettings.HelpWriter = System.Console.Out;
-
-            var parser = new CommandLineParser(parserSettings);
-            parser.ParseArguments(args, arguments);
-
-            return arguments;
-        }
-
-        /// <summary>
-        /// Gets the archive.
-        /// </summary>
-        /// <param name='archivePath'>
-        /// Archive path.
-        /// </param>
-        /// <returns>
-        /// The archive or null if none could be created.
-        /// </returns>
-        private IDatabaseArchive GetArchive(string archivePath)
-        {
-            IDatabaseArchiveFactory archiveFactory = GetArchiveFactory(archivePath);
-            if (archiveFactory == null)
-            {
-                return null;
-            }
-
-            return archiveFactory.Create(archivePath);
-        }
-
-        /// <summary>
-        /// Gets the archive factory.
-        /// </summary>
-        /// <param name='archivePath'>
-        /// Archive path.
-        /// </param>
-        /// <returns>
-        /// The archive factory or null if none can be found.
-        /// </returns>
-        private IDatabaseArchiveFactory GetArchiveFactory(string archivePath)
-        {
-            return this.ArchiveFactories.FirstOrDefault(f => f.CanCreate(archivePath));
-        }
-
-        /// <summary>
-        /// Sets the properties from the command arguments.
-        /// </summary>
-        /// <param name='arguments'>
-        /// The command arguments.
-        /// </param>
-        private void SetPropertiesFromCommandArguments(Arguments arguments)
-        {
-            if (!string.IsNullOrEmpty(arguments.ConnectionString))
-            {
-                this.PropertyService.Add(
-                 new Property
-                 {
-                     Key = SessionFactoryProvider.ConnectionStringProperty,
-                     Value = arguments.ConnectionString
-                 });
-            }
-         
-            if (!string.IsNullOrEmpty(arguments.ConnectionProvider))
-            {
-                this.PropertyService.Add(
-                 new Property
-                 {
-                     Key = SessionFactoryProvider.ProviderProperty,
-                     Value = arguments.ConnectionProvider
-                 });
-            }
-         
-            if (!string.IsNullOrEmpty(arguments.DriverClass))
-            {
-                this.PropertyService.Add(
-                 new Property
-                 {
-                     Key = SessionFactoryProvider.DriverClassProperty,
-                     Value = arguments.DriverClass
-                 });
-            }
-         
-            if (!string.IsNullOrEmpty(arguments.Dialect))
-            {
-                this.PropertyService.Add(
-                 new Property
-                 {
-                     Key = SessionFactoryProvider.DialectProperty,
-                     Value = arguments.Dialect
-                 });
-            }
-        }
-
-        /// <summary>
-        /// Merges the properties from user settings.
-        /// </summary>
-        private void MergePropertiesFromSettings()
-        {
-            var propertyCollection = this.SettingsService.DeSerialize<PropertyCollection>("properties.xml");
-            if (propertyCollection != null)
-            {
-                this.PropertyService.Merge(propertyCollection.Properties);
-            }
-        }
     }
 }

=== modified file 'src/DatabaseVersion.Console/Command/History/HistoryArguments.cs'
--- src/DatabaseVersion.Console/Command/History/HistoryArguments.cs	2011-10-17 17:38:28 +0000
+++ src/DatabaseVersion.Console/Command/History/HistoryArguments.cs	2011-11-15 22:04:37 +0000
@@ -5,33 +5,9 @@
     /// <summary>
     /// The arguments for the history command.
     /// </summary>
-    public class HistoryArguments
+    public class HistoryArguments : ConnectionArguments
     {
         /// <summary>
-        /// The connection string.
-        /// </summary>
-        [Option("c", "connectionString")]
-        public string ConnectionString;
-        
-        /// <summary>
-        /// Gets or sets the hibernate connection provider.
-        /// </summary>
-        [Option("p", "connectionProvider", HelpText = "The hibernate connection provider.")]
-        public string ConnectionProvider;
-
-        /// <summary>
-        /// Gets or sets the hibernate driver class.
-        /// </summary>
-        [Option("d", "driverClass", HelpText = "The hibernate driver class.")]
-        public string DriverClass;
-
-        /// <summary>
-        /// Gets or sets the hibernate dialect.
-        /// </summary>
-        [Option("l", "dialect", HelpText = "The hibernate dialect.")]
-        public string Dialect;
-
-        /// <summary>
         /// The sort order.
         /// </summary>
         [Option("o", "order")]

=== modified file 'src/DatabaseVersion.Console/Command/History/HistoryCommand.cs'
--- src/DatabaseVersion.Console/Command/History/HistoryCommand.cs	2011-10-17 20:07:45 +0000
+++ src/DatabaseVersion.Console/Command/History/HistoryCommand.cs	2011-11-15 22:04:37 +0000
@@ -17,12 +17,12 @@
     /// A command for outputting the history of versions installed in the database.
     /// </summary>
     [Export(typeof(IConsoleCommand))]
-    public class HistoryCommand : IConsoleCommand
+    public class HistoryCommand : ConnectionCommandBase<HistoryArguments>
     {
         /// <summary>
         /// Gets the command name.
         /// </summary>
-        public string Name
+        public override string Name
         {
             get
             {
@@ -33,7 +33,7 @@
         /// <summary>
         /// Gets a description of the command.
         /// </summary>
-        public string Description
+        public override string Description
         {
             get
             {
@@ -44,7 +44,7 @@
         /// <summary>
         /// Gets the usage of the command.
         /// </summary>
-        public string Usage
+        public override string Usage
         {
             get
             {
@@ -55,7 +55,7 @@
         /// <summary>
         /// Gets the command parameters.
         /// </summary>
-        public IEnumerable<CommandParameter> Parameters
+        public override IEnumerable<CommandParameter> Parameters
         {
             get
             {
@@ -66,18 +66,13 @@
                     new CommandParameter("-d", "--driverClass", "The hibernate driver class."),
                     new CommandParameter("-l", "--dialect", "The hibernate dialect."),
                     new CommandParameter("-o", "--order", "The order to sort the versions by [asc|desc]."),
-                    new CommandParameter("-t", "--showTasks", "Indicates whether the tasks for each version should be output.")
+                    new CommandParameter("-t", "--showTasks", "Indicates whether the tasks for each version should be output."),
+                    new CommandParameter("-s", "--saved-connection", "The name of the saved connection to use.")
                 };
             }
         }
 
         /// <summary>
-        /// Gets or sets the message service.
-        /// </summary>
-        [Import]
-        public IMessageService MessageService { get; set; }
-
-        /// <summary>
         /// Gets or sets the session factory provider.
         /// </summary>
         [Import]
@@ -90,31 +85,13 @@
         public IVersionProvider VersionProvider { get; set; }
 
         /// <summary>
-        /// Gets or sets the property service.
-        /// </summary>
-        [Import]
-        public IPropertyService PropertyService { get; set; }
-
-        /// <summary>
-        /// Gets or sets the settings service.
-        /// </summary>
-        [Import]
-        public ISettingsService SettingsService { get; set; }
-
-        /// <summary>
         /// Execute the command with the specified arguments.
         /// </summary>
         /// <param name='args'>
         /// The arguments.
         /// </param>
-        public void Execute (string[] args)
+        protected override void Execute (string[] args, HistoryArguments arguments, dbversion.Archives.IDatabaseArchive archive)
         {
-            var arguments = ParseArguments(args);
-
-            this.PropertyService.SetDefaultProperties();
-            this.MergePropertiesFromSettings();
-            this.SetPropertiesFromCommandArguments(arguments);
-
             VersionBase requiredVersion = null;
             if (!string.IsNullOrEmpty(arguments.Version))
             {
@@ -241,89 +218,6 @@
                 this.MessageService.WriteLine(taskString);
             }
         }
-
-        /// <summary>
-        /// Parses the arguments.
-        /// </summary>
-        /// <param name='args'>
-        /// The command line arguments.
-        /// </param>
-        /// <returns>
-        /// The parsed arguments.
-        /// </returns>
-        private static HistoryArguments ParseArguments(string[] args)
-        {
-            HistoryArguments arguments = new HistoryArguments();
-            var parserSettings = new CommandLineParserSettings();
-            parserSettings.CaseSensitive = true;
-            parserSettings.HelpWriter = System.Console.Out;
-
-            var parser = new CommandLineParser(parserSettings);
-            parser.ParseArguments(args, arguments);
-
-            return arguments;
-        }
-
-        /// <summary>
-        /// Merges the properties from user settings.
-        /// </summary>
-        private void MergePropertiesFromSettings()
-        {
-            var propertyCollection = this.SettingsService.DeSerialize<PropertyCollection>("properties.xml");
-            if (propertyCollection != null)
-            {
-                this.PropertyService.Merge(propertyCollection.Properties);
-            }
-        }
-
-        /// <summary>
-        /// Sets the properties from the command arguments.
-        /// </summary>
-        /// <param name='arguments'>
-        /// The command arguments.
-        /// </param>
-        private void SetPropertiesFromCommandArguments(HistoryArguments arguments)
-        {
-            if (!string.IsNullOrEmpty(arguments.ConnectionString))
-            {
-                this.PropertyService.Add(
-                 new Property
-                 {
-                     Key = Session.SessionFactoryProvider.ConnectionStringProperty,
-                     Value = arguments.ConnectionString
-                 });
-            }
-
-            if (!string.IsNullOrEmpty(arguments.ConnectionProvider))
-            {
-                this.PropertyService.Add(
-                 new Property
-                 {
-                     Key = Session.SessionFactoryProvider.ProviderProperty,
-                     Value = arguments.ConnectionProvider
-                 });
-            }
-         
-            if (!string.IsNullOrEmpty(arguments.DriverClass))
-            {
-                this.PropertyService.Add(
-                 new Property
-                 {
-                     Key = Session.SessionFactoryProvider.DriverClassProperty,
-                     Value = arguments.DriverClass
-                 });
-            }
-         
-            if (!string.IsNullOrEmpty(arguments.Dialect))
-            {
-                this.PropertyService.Add(
-                 new Property
-                 {
-                     Key = Session.SessionFactoryProvider.DialectProperty,
-                     Value = arguments.Dialect
-                 });
-            }
-        }
     }
 }
 

=== added directory 'src/DatabaseVersion.Console/Command/SavedConnection'
=== added file 'src/DatabaseVersion.Console/Command/SavedConnection/SavedConnectionArguments.cs'
--- src/DatabaseVersion.Console/Command/SavedConnection/SavedConnectionArguments.cs	1970-01-01 00:00:00 +0000
+++ src/DatabaseVersion.Console/Command/SavedConnection/SavedConnectionArguments.cs	2011-11-15 22:04:37 +0000
@@ -0,0 +1,52 @@
+namespace dbversion.Console.Command.SavedConnection
+{
+    using System.ComponentModel;
+    using System;
+    using CommandLine;
+    using CommandLine.Text;
+
+    /// <summary>
+    /// The command line arguments that define how the application should function.
+    /// </summary>
+    public class SavedConnectionArguments
+    {
+        /// <summary>
+        /// The archive containing the database scripts.
+        /// </summary>
+        [Option("n", "name")]
+        public string Name;
+
+        /// <summary>
+        /// The connection string to the database.
+        /// </summary>
+        [Option("c", "connectionString", HelpText = "The database connection string.")]
+        public string ConnectionString;
+        
+        /// <summary>
+        /// Gets or sets the hibernate connection provider.
+        /// </summary>
+        [Option("p", "connectionProvider", HelpText = "The hibernate connection provider.")]
+        public string ConnectionProvider;
+
+        /// <summary>
+        /// Gets or sets the hibernate driver class.
+        /// </summary>
+        [Option("d", "driverClass", HelpText = "The hibernate driver class.")]
+        public string DriverClass;
+
+        /// <summary>
+        /// Gets or sets the hibernate dialect.
+        /// </summary>
+        [Option("l", "dialect", HelpText = "The hibernate dialect.")]
+        public string Dialect;
+
+        [Option("r", "delete")]
+        public bool Delete;
+
+        [Option(null, "default")]
+        public bool SetDefaultConnection;
+
+        [Option("t", "template")]
+        public string TemplateConnection;
+    }
+}

=== added file 'src/DatabaseVersion.Console/Command/SavedConnection/SavedConnectionCommand.cs'
--- src/DatabaseVersion.Console/Command/SavedConnection/SavedConnectionCommand.cs	1970-01-01 00:00:00 +0000
+++ src/DatabaseVersion.Console/Command/SavedConnection/SavedConnectionCommand.cs	2011-11-15 22:04:37 +0000
@@ -0,0 +1,326 @@
+namespace dbversion.Console.Command.SavedConnection
+{
+    using System.Collections.Generic;
+    using System.ComponentModel.Composition;
+    using System.Linq;
+
+    using CommandLine;
+
+    using dbversion.Connections;
+
+    using dbversion.Console.Command;
+
+    [Export(typeof(IConsoleCommand))]
+    public class SavedConnectionCommand : IConsoleCommand
+    {
+        /// <summary>
+        /// Gets the name of the command. This is the name that will be used
+        /// to execute the command at the command line.
+        /// </summary>
+        /// <value>
+        /// The name of the command to execute.
+        /// </value>
+        public string Name
+        {
+            get
+            {
+                return "saved-connection";
+            }
+        }
+
+        /// <summary>
+        /// Gets a short description of what the command does.
+        /// </summary>
+        /// <value>
+        /// The description of the command.
+        /// </value>
+        public string Description
+        {
+            get
+            {
+                return "Allows connection details to be saved and managed.";
+            }
+        }
+
+        /// <summary>
+        /// Gets the command usage.
+        /// </summary>
+        /// <value>
+        /// The command usage.
+        /// </value>
+        public string Usage
+        {
+            get
+            {
+                return "dbversion saved-connection [options]";
+            }
+        }
+
+        /// <summary>
+        /// Gets the parameters that can be used with the command.
+        /// </summary>
+        /// <value>
+        /// The parameters or an empty enumerable.
+        /// </value>
+        public System.Collections.Generic.IEnumerable<CommandParameter> Parameters
+        {
+            get
+            {
+                return new[]
+                {
+                    new CommandParameter("-n", "--name", "The name of the connection."),
+                    new CommandParameter("-c", "--connectionString", "The database connection string."),
+                    new CommandParameter("-p", "--connectionProvider", "The hibernate connection provider."),
+                    new CommandParameter("-d", "--driverClass", "The hibernate driver class."),
+                    new CommandParameter("-l", "--dialect", "The hibernate dialect."),
+                    new CommandParameter("-r", "--remove", "Deletes the connection specified using the -n option."),
+                    new CommandParameter(string.Empty, "--default", "Sets the connection specified using the -n option as the default."),
+                    new CommandParameter("-t", "--template", "Uses the specified connection as a template.")
+                };
+            }
+        }
+
+        [Import]
+        public IMessageService MessageService
+        {
+            get;
+            set;
+        }
+
+        [Import]
+        public ISavedConnectionService SavedConnectionService
+        {
+            get;
+            set;
+        }
+        
+
+        public void Execute (string[] args)
+        {
+            var arguments = ParseArguments(args);
+
+            this.SavedConnectionService.LoadConnections();
+
+            if (!string.IsNullOrEmpty(arguments.Name) &&
+                !string.IsNullOrEmpty(arguments.TemplateConnection))
+            {
+                this.CreateFromTemplate(arguments);
+            }
+            else if (!string.IsNullOrEmpty(arguments.Name) &&
+                (!string.IsNullOrEmpty(arguments.ConnectionProvider) ||
+                !string.IsNullOrEmpty(arguments.ConnectionString) ||
+                !string.IsNullOrEmpty(arguments.Dialect) ||
+                !string.IsNullOrEmpty(arguments.DriverClass)))
+            {
+                this.CreateNewConnection(arguments);
+            }
+            else if (!string.IsNullOrEmpty(arguments.Name) && arguments.SetDefaultConnection)
+            {
+                this.SetDefaultConnection(arguments);
+            }
+            else if (!string.IsNullOrEmpty(arguments.Name) && arguments.Delete)
+            {
+                this.DeleteConnection(arguments);
+            }
+            else
+            {
+                this.ListConnections(arguments);
+            }
+        }
+
+        private void CreateFromTemplate (SavedConnectionArguments arguments)
+        {
+            var template = this.SavedConnectionService.SavedConnections.FirstOrDefault(
+             c => c.Name == arguments.TemplateConnection);
+         
+            if (template != null)
+            {
+                var connectionString = !string.IsNullOrEmpty(arguments.ConnectionString)
+                    ? arguments.ConnectionString : template.ConnectionString;
+                var driverClass = !string.IsNullOrEmpty(arguments.DriverClass)
+                    ? arguments.DriverClass : template.DriverClass;
+                var dialect = !string.IsNullOrEmpty(arguments.Dialect)
+                    ? arguments.Dialect : template.Dialect;
+                var provider = !string.IsNullOrEmpty(arguments.ConnectionProvider)
+                    ? arguments.ConnectionProvider : template.ConnectionProvider;
+
+                var connection = this.SavedConnectionService.CreateSavedConnection(
+                    arguments.Name,
+                    connectionString,
+                    provider,
+                    driverClass,
+                    dialect);
+                this.SavedConnectionService.SaveConnections();
+
+                this.MessageService.WriteLine(
+                    string.Format(
+                        "Created a new connection \"{0}\" based on \"{1}\".", arguments.Name, arguments.TemplateConnection));
+                this.WriteConnectionInfo(connection);
+            }
+            else
+            {
+                this.MessageService.WriteLine(
+                string.Format("Template connection \"{0}\" could not be found.", arguments.TemplateConnection));
+            }
+        }
+
+        /// <summary>
+        /// Creates the new connection.
+        /// </summary>
+        /// <param name='arguments'>
+        /// The arguments to create the connection with.
+        /// </param>
+        /// <returns>
+        /// The new connection.
+        /// </returns>
+        private void CreateNewConnection(SavedConnectionArguments arguments)
+        {
+            var existingConnection =
+                this.SavedConnectionService.SavedConnections.FirstOrDefault(c => c.Name == arguments.Name);
+
+            string name;
+            string connectionString;
+            string connectionProvider;
+            string driverClass;
+            string dialect;
+
+            if (existingConnection != null)
+            {
+                name = existingConnection.Name;
+                connectionString = !string.IsNullOrEmpty(arguments.ConnectionString)
+                    ? arguments.ConnectionString : existingConnection.ConnectionString;
+                connectionProvider = !string.IsNullOrEmpty(arguments.ConnectionProvider)
+                    ? arguments.ConnectionProvider : existingConnection.ConnectionProvider;
+                driverClass = !string.IsNullOrEmpty(arguments.DriverClass)
+                    ? arguments.DriverClass : existingConnection.DriverClass;
+                dialect = !string.IsNullOrEmpty(arguments.Dialect)
+                    ? arguments.Dialect : existingConnection.Dialect;
+            }
+            else
+            {
+                name = arguments.Name;
+                connectionString = arguments.ConnectionString;
+                connectionProvider = arguments.ConnectionProvider;
+                driverClass = arguments.DriverClass;
+                dialect = arguments.Dialect;
+            }
+
+            var connection = this.SavedConnectionService.CreateSavedConnection(
+                name,
+                connectionString,
+                connectionProvider,
+                driverClass,
+                dialect);
+            this.SavedConnectionService.SaveConnections();
+
+            this.MessageService.WriteLine(
+                string.Format("Created new saved connection \"{0}\":", connection.Name));
+            this.WriteConnectionInfo(connection);
+        }
+
+        private void SetDefaultConnection (SavedConnectionArguments arguments)
+        {
+            if (this.SavedConnectionService.SetDefaultConnection(arguments.Name))
+            {
+                this.SavedConnectionService.SaveConnections();
+                this.MessageService.WriteLine(
+                    string.Format("\"{0}\" is now the default connection.", arguments.Name));
+            }
+            else
+            {
+                this.MessageService.WriteLine(
+                    string.Format("There is no saved connection called \"{0}\".", arguments.Name));
+            }
+        }
+
+        private void DeleteConnection (SavedConnectionArguments arguments)
+        {
+            if (this.SavedConnectionService.DeleteConnection(arguments.Name))
+            {
+                this.SavedConnectionService.SaveConnections();
+                this.MessageService.WriteLine(
+                    string.Format("\"{0}\" has been deleted.", arguments.Name));
+            }
+            else
+            {
+                this.MessageService.WriteLine(
+                    string.Format("There is no saved connection called \"{0}\".", arguments.Name));
+            }
+        }
+
+        private void ListConnections (SavedConnectionArguments arguments)
+        {
+            var connections = this.GetConnections(arguments);
+
+            if (connections.Count() == 0)
+            {
+                if (!string.IsNullOrEmpty(arguments.Name))
+                {
+                    this.MessageService.WriteLine(
+                        string.Format("There is no saved connection called \"{0}\".", arguments.Name));
+                }
+                else
+                {
+                    this.MessageService.WriteLine("There are no saved connections.");
+                }
+            }
+            else
+            {
+                foreach (var connection in connections)
+                {
+                    this.MessageService.WriteLine(connection.Name + ":");
+                    this.WriteConnectionInfo(connection);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses the arguments.
+        /// </summary>
+        /// <param name='args'>
+        /// The command line arguments.
+        /// </param>
+        /// <returns>
+        /// The parsed arguments.
+        /// </returns>
+        private static SavedConnectionArguments ParseArguments(string[] args)
+        {
+            var arguments = new SavedConnectionArguments();
+            var parserSettings = new CommandLineParserSettings();
+            parserSettings.CaseSensitive = true;
+            parserSettings.HelpWriter = System.Console.Out;
+
+            var parser = new CommandLineParser(parserSettings);
+            parser.ParseArguments(args, arguments);
+
+            return arguments;
+        }
+
+        private IEnumerable<SavedConnection> GetConnections(SavedConnectionArguments arguments)
+        {
+            if (!string.IsNullOrEmpty(arguments.Name))
+            {
+                return this.SavedConnectionService.SavedConnections
+                    .Where(c => c.Name == arguments.Name);
+            }
+
+            return this.SavedConnectionService.SavedConnections
+                .Where(c => c.IsDefault)
+                    .Union(
+                        this.SavedConnectionService.SavedConnections
+                            .Where(c => !c.IsDefault)
+                            .OrderBy(c => c.Name));
+        }
+
+        private void WriteConnectionInfo(SavedConnection connection)
+        {
+            this.MessageService.WriteLine(string.Format("  Connection String: {0}", connection.ConnectionString));
+            this.MessageService.WriteLine(string.Format("  Driver Class: {0}", connection.DriverClass));
+            this.MessageService.WriteLine(string.Format("  Provider: {0}", connection.ConnectionProvider));
+            this.MessageService.WriteLine(string.Format("  Dialect: {0}", connection.Dialect));
+            this.MessageService.WriteLine(string.Format("  Default: {0}", connection.IsDefault));
+            this.MessageService.WriteLine();
+        }
+    }
+}
+

=== modified file 'src/DatabaseVersion.Console/dbversion.Console.csproj'
--- src/DatabaseVersion.Console/dbversion.Console.csproj	2011-10-25 21:46:32 +0000
+++ src/DatabaseVersion.Console/dbversion.Console.csproj	2011-11-15 22:04:37 +0000
@@ -13,7 +13,7 @@
     <FileAlignment>512</FileAlignment>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <PlatformTarget>x86</PlatformTarget>
+    <PlatformTarget>AnyCPU</PlatformTarget>
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
@@ -21,10 +21,10 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <Commandlineparameters>create -c "Server=localhost;Database=library;User ID=adam;Password=adam;" -a /home/adam/bzr/dbversion/console-command/samples/classic-sample.zip -v 16.0</Commandlineparameters>
+    <Commandlineparameters>create -a "/Users/adamconnelly/bzr/dbversion/saved-connection/samples/classic-sample"</Commandlineparameters>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <PlatformTarget>x86</PlatformTarget>
+    <PlatformTarget>AnyCPU</PlatformTarget>
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
@@ -54,7 +54,6 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Arguments.cs" />
     <Compile Include="ConsoleTaskExecuter.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -71,6 +70,11 @@
     <Compile Include="Command\History\HistoryCommand.cs" />
     <Compile Include="Command\History\HistoryArguments.cs" />
     <Compile Include="Command\History\HistoryOrder.cs" />
+    <Compile Include="Command\SavedConnection\SavedConnectionCommand.cs" />
+    <Compile Include="Command\SavedConnection\SavedConnectionArguments.cs" />
+    <Compile Include="Command\ConnectionArguments.cs" />
+    <Compile Include="Command\ConnectionCommandBase.cs" />
+    <Compile Include="Command\Create\CreateArguments.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
@@ -86,16 +90,17 @@
     <None Include="scripts\dbversion" />
   </ItemGroup>
   <ItemGroup>
+    <Folder Include="Command\SavedConnection\" />
     <Folder Include="Command\History\" />
     <Folder Include="scripts\" />
   </ItemGroup>
+  <Target Name="AfterBuild">
+    <Copy SourceFiles="scripts\dbversion" DestinationFolder="$(OutputPath)" />
+  </Target>
   <ItemGroup>
     <ProjectReference Include="..\DatabaseVersion\dbversion.csproj">
       <Project>{694D9BDF-DCE8-4FC6-A416-CE4573F2F00C}</Project>
       <Name>dbversion</Name>
     </ProjectReference>
   </ItemGroup>
-  <Target Name="AfterBuild">
-    <Copy SourceFiles="scripts\dbversion" DestinationFolder="$(OutputPath)" />
-  </Target>
-</Project>
\ No newline at end of file
+</Project>

=== added directory 'src/DatabaseVersion.Tests/Connections'
=== added file 'src/DatabaseVersion.Tests/Connections/SavedConnectionServiceTests.cs'
--- src/DatabaseVersion.Tests/Connections/SavedConnectionServiceTests.cs	1970-01-01 00:00:00 +0000
+++ src/DatabaseVersion.Tests/Connections/SavedConnectionServiceTests.cs	2011-11-15 22:04:37 +0000
@@ -0,0 +1,313 @@
+namespace DatabaseVersion.Tests.Connections
+{
+    using System.Collections.Generic;
+    using System.Linq;
+
+    using dbversion.Connections;
+    using dbversion.Settings;
+
+    using Moq;
+
+    using Xunit;
+
+    public class SavedConnectionServiceTests
+    {
+        #region Default Connection
+        [Fact]
+        public void ShouldMakeFirstSavedConnectionTheDefault()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            // Act
+            var connection = service.CreateSavedConnection(
+                "library", "conn", "provider", "driverClass", "dialect");
+
+            // Assert
+            Assert.True(connection.IsDefault);
+        }
+
+        [Fact]
+        public void ShouldNotMakeOtherConnectionsTheDefault()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            service.CreateSavedConnection("a", "conn", "provider", "driverClass", "dialect");
+
+            // Act
+            var connection = service.CreateSavedConnection("b", "conn", "provider", "driverClass", "dialect");
+
+            // Assert
+            Assert.False(connection.IsDefault);
+        }
+
+        [Fact]
+        public void ShouldReturnTheDefaultConnection()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+            var settingsService = new Mock<ISettingsService>();
+
+            service.SettingsService = settingsService.Object;
+
+            var savedConnections = new List<SavedConnection>()
+            {
+                new SavedConnection { Name = "connection1", IsDefault = false },
+                new SavedConnection { Name = "connection2", IsDefault = true },
+                new SavedConnection { Name = "connection3", IsDefault = false }
+            };
+
+            settingsService.Setup(
+                s => s.DeSerialize<List<SavedConnection>>(SavedConnectionService.SettingsFileName))
+                .Returns(savedConnections);
+
+            service.LoadConnections();
+
+            // Act
+            var defaultConnection = service.DefaultConnection;
+
+            // Assert
+            Assert.Equal("connection2", defaultConnection.Name);
+        }
+
+        [Fact]
+        public void ShouldReturnNullDefaultConnectionIfThereIsNoDefaultConnection()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+            var settingsService = new Mock<ISettingsService>();
+
+            service.SettingsService = settingsService.Object;
+
+            var savedConnections = new List<SavedConnection>()
+            {
+                new SavedConnection { Name = "connection1", IsDefault = false }
+            };
+
+            settingsService.Setup(
+                s => s.DeSerialize<List<SavedConnection>>(SavedConnectionService.SettingsFileName))
+                .Returns(savedConnections);
+
+            service.LoadConnections();
+
+            // Act
+            var defaultConnection = service.DefaultConnection;
+
+            // Assert
+            Assert.Null(defaultConnection);
+        }
+        #endregion
+
+        #region Connection Properties
+        [Fact]
+        public void ShouldSetConnectionNameWhenCreatingConnection()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            // Act
+            var connection = service.CreateSavedConnection("connection1", "conn", "provider", "driverClass", "dialect");
+
+            // Assert
+            Assert.Equal("connection1", connection.Name);
+        }
+
+        [Fact]
+        public void ShouldSetConnectionStringWhenCreatingConnection()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            // Act
+            var connection = service.CreateSavedConnection("connection1", "conn", "provider", "driverClass", "dialect");
+
+            // Assert
+            Assert.Equal("conn", connection.ConnectionString);
+        }
+
+        [Fact]
+        public void ShouldSetConnectionProviderWhenCreatingConnection()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            // Act
+            var connection = service.CreateSavedConnection("connection1", "conn", "provider", "driverClass", "dialect");
+
+            // Assert
+            Assert.Equal("provider", connection.ConnectionProvider);
+        }
+
+        [Fact]
+        public void ShouldSetDriverClassWhenCreatingConnection()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            // Act
+            var connection = service.CreateSavedConnection("connection1", "conn", "provider", "driverClass", "dialect");
+
+            // Assert
+            Assert.Equal("driverClass", connection.DriverClass);
+        }
+
+        [Fact]
+        public void ShouldSetDialectWhenCreatingConnection()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            // Act
+            var connection = service.CreateSavedConnection("connection1", "conn", "provider", "driverClass", "dialect");
+
+            // Assert
+            Assert.Equal("dialect", connection.Dialect);
+        }
+        #endregion
+
+        [Fact]
+        public void ShouldReplaceConnectionIfCreatingConnectionWithSameName()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            // Act
+            service.CreateSavedConnection("connection1", null, null, null, null);
+            var connection = service.CreateSavedConnection("connection1", "conn", "provider", "driverClass", "dialect");
+
+            // Assert
+            Assert.Equal(1, service.SavedConnections.Count());
+            Assert.Same(connection, service.SavedConnections.Single());
+        }
+
+        #region Save
+        [Fact]
+        public void ShouldBeAbleToSaveConnections()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+            var settingsService = new Mock<ISettingsService>();
+
+            service.SettingsService = settingsService.Object;
+
+            List<SavedConnection> expectedConnections = new List<SavedConnection>();
+            expectedConnections.Add(service.CreateSavedConnection("a", null, null, null, null));
+            expectedConnections.Add(service.CreateSavedConnection("b", null, null, null, null));
+
+            // Act
+            service.SaveConnections();
+
+            // Assert
+            settingsService.Verify(s => s.Serialize(expectedConnections, "saved-connections.xml"));
+        }
+        #endregion
+
+        #region Load
+        [Fact]
+        public void ShouldBeAbleToLoadSavedConnections()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+            var settingsService = new Mock<ISettingsService>();
+
+            service.SettingsService = settingsService.Object;
+
+            List<SavedConnection> expectedConnections = new List<SavedConnection>();
+            expectedConnections.Add(new SavedConnection("a", null, null, null, null, true));
+            expectedConnections.Add(new SavedConnection("b", null, null, null, null, false));
+
+            settingsService.Setup(
+                s => s.DeSerialize<List<SavedConnection>>("saved-connections.xml")).Returns(expectedConnections);
+
+            // Act
+            service.LoadConnections();
+
+            // Assert
+            Assert.Equal(expectedConnections, service.SavedConnections);
+        }
+
+        [Fact]
+        public void ShouldHaveNoConnectionsIfNoConnectionsAreSavedInSettings()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+            var settingsService = new Mock<ISettingsService>();
+
+            service.SettingsService = settingsService.Object;
+
+            settingsService.Setup(
+                s => s.DeSerialize<List<SavedConnection>>("saved-connections.xml")).Returns((List<SavedConnection>)null);
+
+            // Act
+            service.LoadConnections();
+
+            // Assert
+            Assert.Empty(service.SavedConnections);
+        }
+        #endregion
+
+        [Fact]
+        public void ShouldBeAbleToDeleteASavedConnection()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            service.CreateSavedConnection("a", null, null, null, null);
+            service.CreateSavedConnection("b", null, null, null, null);
+            service.CreateSavedConnection("c", null, null, null, null);
+
+            // Act
+            service.DeleteConnection("b");
+
+            // Assert
+            Assert.Equal(2, service.SavedConnections.Count());
+            Assert.Null(service.SavedConnections.SingleOrDefault(c => c.Name == "b"));
+        }
+
+        #region Default
+
+        [Fact]
+        public void ShouldBeAbleToSetConnectionAsDefault()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            var connectionA = service.CreateSavedConnection("a", null, null, null, null);
+            var connectionB = service.CreateSavedConnection("b", null, null, null, null);
+            var connectionC = service.CreateSavedConnection("c", null, null, null, null);
+
+            // Act
+            var success = service.SetDefaultConnection("b");
+
+            // Assert
+            Assert.True(connectionB.IsDefault, "Connection B should be the default");
+            Assert.False(connectionA.IsDefault, "Connection A should not be default");
+            Assert.False(connectionC.IsDefault, "Connection C should not be default");
+
+            Assert.True(success, "The method should have succeeded");
+        }
+
+        [Fact]
+        public void ShouldReturnFalseIfConnectionToDefaultDoesNotExist()
+        {
+            // Arrange
+            var service = new SavedConnectionService();
+
+            var connectionA = service.CreateSavedConnection("a", null, null, null, null);
+            service.CreateSavedConnection("b", null, null, null, null);
+            service.CreateSavedConnection("c", null, null, null, null);
+
+            // Act
+            var success = service.SetDefaultConnection("ZZZ");
+
+            // Assert
+            Assert.True(connectionA.IsDefault, "Connection A should still be default");
+
+            Assert.False(success, "The method should not have succeeded");
+        }
+
+        #endregion
+    }
+}
+

=== modified file 'src/DatabaseVersion.sln'
--- src/DatabaseVersion.sln	2011-10-17 08:44:54 +0000
+++ src/DatabaseVersion.sln	2011-11-15 22:04:37 +0000
@@ -1,4 +1,4 @@
-
+
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "dbversion", "DatabaseVersion\dbversion.csproj", "{694D9BDF-DCE8-4FC6-A416-CE4573F2F00C}"

=== added directory 'src/DatabaseVersion/Connections'
=== added file 'src/DatabaseVersion/Connections/ISavedConnectionService.cs'
--- src/DatabaseVersion/Connections/ISavedConnectionService.cs	1970-01-01 00:00:00 +0000
+++ src/DatabaseVersion/Connections/ISavedConnectionService.cs	2011-11-15 22:04:37 +0000
@@ -0,0 +1,92 @@
+namespace dbversion.Connections
+{
+    using System.Collections.Generic;
+
+    using dbversion.Settings;
+
+    /// <summary>
+    /// Used to manage the saved connections.
+    /// </summary>
+    public interface ISavedConnectionService
+    {
+        /// <summary>
+        /// Gets the saved connections.
+        /// </summary>
+        /// <value>
+        /// The saved connections.
+        /// </value>
+        IEnumerable<SavedConnection> SavedConnections
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the default connection.
+        /// </summary>
+        /// <value>
+        /// The default connection.
+        /// </value>
+        SavedConnection DefaultConnection
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Creates a new saved connection or updates an existing saved connection if a connection
+        /// with the specified name already exists.
+        /// </summary>
+        /// <param name='name'>
+        /// The name of the saved connection.
+        /// </param>
+        /// <param name='connectionString'>
+        /// The connection string.
+        /// </param>
+        /// <param name='provider'>
+        /// The connection provider.
+        /// </param>
+        /// <param name='driverClass'>
+        /// The driver class.
+        /// </param>
+        /// <param name='dialect'>
+        /// The dialect.
+        /// </param>
+        /// <returns>
+        /// The saved connection.
+        /// </returns>
+        SavedConnection CreateSavedConnection(
+            string name, string connectionString, string provider, string driverClass, string dialect);
+
+        /// <summary>
+        /// Saves the connections to settings.
+        /// </summary>
+        void SaveConnections();
+
+        /// <summary>
+        /// Loads the connections from settings.
+        /// </summary>
+        void LoadConnections();
+
+        /// <summary>
+        /// Deletes the connection.
+        /// </summary>
+        /// <param name='name'>
+        /// The connection name.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if the connection was deleted; otherwise <c>false</c>.
+        /// </returns>
+        bool DeleteConnection(string name);
+
+        /// <summary>
+        /// Sets the specified connection as the default.
+        /// </summary>
+        /// <param name='name'>
+        /// The name of the connection to set as default.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if the connection exists; otherwise <c>false</c>.
+        /// </returns>
+        bool SetDefaultConnection(string name);
+    }
+}
+

=== added file 'src/DatabaseVersion/Connections/SavedConnection.cs'
--- src/DatabaseVersion/Connections/SavedConnection.cs	1970-01-01 00:00:00 +0000
+++ src/DatabaseVersion/Connections/SavedConnection.cs	2011-11-15 22:04:37 +0000
@@ -0,0 +1,150 @@
+namespace dbversion.Connections
+{
+    using System.Collections.Generic;
+
+    using dbversion.Property;
+    using dbversion.Session;
+
+    public class SavedConnection
+    {
+        public SavedConnection()
+        {
+        }
+        
+        public SavedConnection(
+            string name, string connectionString, string connectionProvider, string driverClass, string dialect, bool isDefault)
+        {
+            this.Name = name;
+            this.ConnectionString = connectionString;
+            this.ConnectionProvider = connectionProvider;
+            this.DriverClass = driverClass;
+            this.Dialect = dialect;
+            this.IsDefault = isDefault;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this is the default connection.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance is default; otherwise, <c>false</c>.
+        /// </value>
+        public bool IsDefault
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the name of the connection.
+        /// </summary>
+        /// <value>
+        /// The name.
+        /// </value>
+        public string Name
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the connection string.
+        /// </summary>
+        /// <value>
+        /// The connection string.
+        /// </value>
+        public string ConnectionString
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the connection provider.
+        /// </summary>
+        /// <value>
+        /// The connection provider.
+        /// </value>
+        public string ConnectionProvider
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the driver class.
+        /// </summary>
+        /// <value>
+        /// The driver class.
+        /// </value>
+        public string DriverClass
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the dialect.
+        /// </summary>
+        /// <value>
+        /// The dialect.
+        /// </value>
+        public string Dialect
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Makes a copy of the connection.
+        /// </summary>
+        public SavedConnection Copy()
+        {
+            return new SavedConnection(
+                this.Name, this.ConnectionString, this.ConnectionProvider, this.DriverClass, this.Dialect, this.IsDefault);
+        }
+
+        /// <summary>
+        /// Returns the set of connection properties based on the values in this instance.
+        /// These properties can be used by the <see cref="SessionFactoryProvider"/> to
+        /// create a session factory.
+        /// </summary>
+        /// <returns>
+        /// The connection properties.
+        /// </returns>
+        public IEnumerable<Property> GetConnectionProperties()
+        {
+            if (!string.IsNullOrEmpty(this.ConnectionString))
+            {
+                yield return new Property
+                {
+                    Key = SessionFactoryProvider.ConnectionStringProperty, Value = this.ConnectionString
+                };
+            }
+
+            if (!string.IsNullOrEmpty(this.Dialect))
+            {
+                yield return new Property
+                {
+                    Key = SessionFactoryProvider.DialectProperty, Value = this.Dialect
+                };
+            }
+
+            if (!string.IsNullOrEmpty(this.DriverClass))
+            {
+                yield return new Property
+                {
+                    Key = SessionFactoryProvider.DriverClassProperty, Value = this.DriverClass
+                };
+            }
+
+            if (!string.IsNullOrEmpty(this.ConnectionProvider))
+            {
+                yield return new Property
+                {
+                    Key = SessionFactoryProvider.ProviderProperty, Value = this.ConnectionProvider
+                };
+            }
+        }
+    }
+}
+

=== added file 'src/DatabaseVersion/Connections/SavedConnectionService.cs'
--- src/DatabaseVersion/Connections/SavedConnectionService.cs	1970-01-01 00:00:00 +0000
+++ src/DatabaseVersion/Connections/SavedConnectionService.cs	2011-11-15 22:04:37 +0000
@@ -0,0 +1,171 @@
+namespace dbversion.Connections
+{
+    using System.Collections.Generic;
+    using System.ComponentModel.Composition;
+    using System.Linq;
+
+    using dbversion.Settings;
+
+    /// <summary>
+    /// Used to manage the saved connections.
+    /// </summary>
+    [Export(typeof(ISavedConnectionService))]
+    public class SavedConnectionService : ISavedConnectionService
+    {
+        /// <summary>
+        /// The name of the file to store the saved connections in.
+        /// </summary>
+        public const string SettingsFileName = "saved-connections.xml";
+
+        /// <summary>
+        /// The saved connections.
+        /// </summary>
+        private List<SavedConnection> savedConnections = new List<SavedConnection>();
+
+        /// <summary>
+        /// Gets or sets the settings service.
+        /// </summary>
+        /// <value>
+        /// The settings service.
+        /// </value>
+        [Import]
+        public ISettingsService SettingsService
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets the saved connections.
+        /// </summary>
+        /// <value>
+        /// The saved connections.
+        /// </value>
+        public IEnumerable<SavedConnection> SavedConnections
+        {
+            get
+            {
+                return this.savedConnections;
+            }
+        }
+
+        public SavedConnection DefaultConnection
+        {
+            get
+            {
+                return this.savedConnections.FirstOrDefault(c => c.IsDefault);
+            }
+        }
+
+        /// <summary>
+        /// Creates a new saved connection or updates an existing saved connection if a connection
+        /// with the specified name already exists.
+        /// </summary>
+        /// <param name='name'>
+        /// The name of the saved connection.
+        /// </param>
+        /// <param name='connectionString'>
+        /// The connection string.
+        /// </param>
+        /// <param name='provider'>
+        /// The connection provider.
+        /// </param>
+        /// <param name='driverClass'>
+        /// The driver class.
+        /// </param>
+        /// <param name='dialect'>
+        /// The dialect.
+        /// </param>
+        /// <returns>
+        /// The saved connection.
+        /// </returns>
+        public SavedConnection CreateSavedConnection(
+            string name, string connectionString, string provider, string driverClass, string dialect)
+        {
+            var isDefault = this.savedConnections.Count == 0;
+
+            var connection = this.SavedConnections.FirstOrDefault(c => c.Name == name);
+            if (connection != null)
+            {
+                connection.ConnectionString = connectionString;
+                connection.ConnectionProvider = provider;
+                connection.DriverClass = driverClass;
+                connection.Dialect = dialect;
+            }
+            else
+            {
+                connection = new SavedConnection(name, connectionString, provider, driverClass, dialect, isDefault);
+                this.savedConnections.Add(connection);
+            }
+
+            return connection;
+        }
+
+        /// <summary>
+        /// Saves the connections to settings.
+        /// </summary>
+        public void SaveConnections()
+        {
+            this.SettingsService.Serialize(savedConnections, SettingsFileName);
+        }
+
+        /// <summary>
+        /// Loads the connections from settings.
+        /// </summary>
+        public void LoadConnections()
+        {
+            var connections = this.SettingsService.DeSerialize<List<SavedConnection>>(SettingsFileName);
+            if (connections != null)
+            {
+                this.savedConnections = connections;
+            }
+            else
+            {
+                this.savedConnections = new List<SavedConnection>();
+            }
+        }
+
+        /// <summary>
+        /// Deletes the connection.
+        /// </summary>
+        /// <param name='name'>
+        /// The name of the connection to delete.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if the connection was deleted; otherwise <c>false</c>.
+        /// </returns>
+        public bool DeleteConnection(string name)
+        {
+            var connection = this.savedConnections.FirstOrDefault(c => c.Name == name);
+            if (connection != null)
+            {
+                return this.savedConnections.Remove(connection);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Sets the specified connection as the default.
+        /// </summary>
+        /// <param name='name'>
+        /// The name of the connection to set as default.
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if the connection exists; otherwise <c>false</c>.
+        /// </returns>
+        public bool SetDefaultConnection(string name)
+        {
+            var connection = this.savedConnections.FirstOrDefault(c => c.Name == name);
+            if (connection != null)
+            {
+                this.savedConnections.ForEach(c => c.IsDefault = false);
+                connection.IsDefault = true;
+                return true;
+            }
+
+            return false;
+        }
+    }
+}
+

=== modified file 'src/DatabaseVersion/Settings/SettingsService.cs'
--- src/DatabaseVersion/Settings/SettingsService.cs	2011-10-25 21:44:23 +0000
+++ src/DatabaseVersion/Settings/SettingsService.cs	2011-11-15 22:04:37 +0000
@@ -117,7 +117,19 @@
 
             if (stream != null)
             {
-                return XmlSerializer.DeSerialize<T>(stream);
+                try
+                {
+                    return XmlSerializer.DeSerialize<T>(stream);
+                }
+                catch (Exception)
+                {
+                    // TODO: Add logging?
+                    return default(T);
+                }
+                finally
+                {
+                    stream.Dispose();
+                }
             }
 
             return default(T);

=== modified file 'src/DatabaseVersion/dbversion.csproj'
--- src/DatabaseVersion/dbversion.csproj	2011-10-25 21:46:32 +0000
+++ src/DatabaseVersion/dbversion.csproj	2011-11-15 22:04:37 +0000
@@ -112,6 +112,9 @@
     <Compile Include="..\CommonAssemblyInfo.cs">
       <Link>Properties\CommonAssemblyInfo.cs</Link>
     </Compile>
+    <Compile Include="Connections\ISavedConnectionService.cs" />
+    <Compile Include="Connections\SavedConnection.cs" />
+    <Compile Include="Connections\SavedConnectionService.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.