mRemoteNG/mRemoteNGTests/Config/Serializers/MiscSerializers/RemoteDesktopConnectionManagerDeserializerTests.cs

using System.IO;
using System.Linq;
using mRemoteNG.Config.Serializers.MiscSerializers;
using mRemoteNG.Connection.Protocol;
using mRemoteNG.Connection.Protocol.RDP;
using mRemoteNG.Container;
using mRemoteNG.Tree;
using mRemoteNGTests.Properties;
using NUnit.Framework;

namespace mRemoteNGTests.Config.Serializers.MiscSerializers
{
    public class RemoteDesktopConnectionManagerDeserializerTests
    {
        private string _connectionFileContents;
        private RemoteDesktopConnectionManagerDeserializer _deserializer;
        private ConnectionTreeModel _connectionTreeModel;
        private const string ExpectedName = "server1_displayname";
        private const string ExpectedHostname = "server1";
        private const string ExpectedDescription = "Comment text here";
        private const string ExpectedUsername = "myusername1";
        private const string ExpectedDomain = "mydomain";
        private const string ExpectedPassword = "passwordHere!";
        private const bool ExpectedUseConsoleSession = true;
        private const int ExpectedPort = 9933;
        private const RDGatewayUsageMethod ExpectedGatewayUsageMethod = RDGatewayUsageMethod.Always;
        private const string ExpectedGatewayHostname = "gatewayserverhost.innerdomain.net";
        private const string ExpectedGatewayUsername = "gatewayusername";
        private const string ExpectedGatewayDomain = "innerdomain";
        private const string ExpectedGatewayPassword = "gatewayPassword123";
        private const RDPResolutions ExpectedRdpResolution = RDPResolutions.FitToWindow;
        private const RDPColors ExpectedRdpColorDepth = RDPColors.Colors24Bit;
        private const RDPSounds ExpectedAudioRedirection = RDPSounds.DoNotPlay;
        private const bool ExpectedKeyRedirection = true;
        private const bool ExpectedSmartcardRedirection = true;
        private const RDPDiskDrives ExpectedDriveRedirection = RDPDiskDrives.Local;
        private const bool ExpectedPortRedirection = true;
        private const bool ExpectedPrinterRedirection = true;
        private const AuthenticationLevel ExpectedAuthLevel = AuthenticationLevel.AuthRequired;
        private const string ExpectedStartProgram = "alternate shell";

        [OneTimeSetUp]
        public void OnetimeSetup()
        {
            _connectionFileContents = Resources.test_rdcman_v2_2_schema1;
            _deserializer = new RemoteDesktopConnectionManagerDeserializer();
            _connectionTreeModel = _deserializer.Deserialize(_connectionFileContents);
        }

        [Test]
        public void ConnectionTreeModelHasARootNode()
        {
            var numberOfRootNodes = _connectionTreeModel.RootNodes.Count;
            Assert.That(numberOfRootNodes, Is.GreaterThan(0));
        }

        [Test]
        public void RootNodeHasContents()
        {
            var rootNodeContents = _connectionTreeModel.RootNodes.First().Children;
            Assert.That(rootNodeContents, Is.Not.Empty);
        }

        [Test]
        public void AllSubRootFoldersImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var rootNodeContents = importedRdcmanRootNode.Children.Count(node => node.Name == "Group1" || node.Name == "Group2");
            Assert.That(rootNodeContents, Is.EqualTo(2));
        }

        [Test]
        public void ConnectionDisplayNameImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.Name, Is.EqualTo(ExpectedName));
        }

        [Test]
        public void ConnectionHostnameImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.Hostname, Is.EqualTo(ExpectedHostname));
        }

        [Test]
        public void ConnectionDescriptionImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.Description, Is.EqualTo(ExpectedDescription));
        }

        [Test]
        public void ConnectionUsernameImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.Username, Is.EqualTo(ExpectedUsername));
        }

        [Test]
        public void ConnectionDomainImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.Domain, Is.EqualTo(ExpectedDomain));
        }

        // Since password is encrypted with a machine key, cant test decryption on another machine
        //[Test]
        //public void ConnectionPasswordImported()
        //{
        //    var rootNode = _connectionTreeModel.RootNodes.First();
        //    var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
        //    var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
        //    var connection = group1.Children.First();
        //    Assert.That(connection.Password, Is.EqualTo(ExpectedPassword));
        //}

        [Test]
        public void ConnectionProtocolSetToRdp()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.Protocol, Is.EqualTo(ProtocolType.RDP));
        }

        [Test]
        public void ConnectionUseConsoleSessionImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.UseConsoleSession, Is.EqualTo(ExpectedUseConsoleSession));
        }

        [Test]
        public void ConnectionPortImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.Port, Is.EqualTo(ExpectedPort));
        }

        [Test]
        public void ConnectionGatewayUsageMethodImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RDGatewayUsageMethod, Is.EqualTo(ExpectedGatewayUsageMethod));
        }

        [Test]
        public void ConnectionGatewayHostnameImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RDGatewayHostname, Is.EqualTo(ExpectedGatewayHostname));
        }

        [Test]
        public void ConnectionGatewayUsernameImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RDGatewayUsername, Is.EqualTo(ExpectedGatewayUsername));
        }

        // Since password is encrypted with a machine key, cant test decryption on another machine
        //[Test]
        //public void ConnectionGatewayPasswordImported()
        //{
        //    var rootNode = _connectionTreeModel.RootNodes.First();
        //    var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
        //    var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
        //    var connection = group1.Children.First();
        //    Assert.That(connection.RDGatewayPassword, Is.EqualTo(ExpectedGatewayPassword));
        //}

        [Test]
        public void ConnectionGatewayDomainImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RDGatewayDomain, Is.EqualTo(ExpectedGatewayDomain));
        }

        [Test]
        public void ConnectionResolutionImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.Resolution, Is.EqualTo(ExpectedRdpResolution));
        }

        [Test]
        public void ConnectionColorDepthImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.Colors, Is.EqualTo(ExpectedRdpColorDepth));
        }

        [Test]
        public void ConnectionAudioRedirectionImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RedirectSound, Is.EqualTo(ExpectedAudioRedirection));
        }

        [Test]
        public void ConnectionKeyRedirectionImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RedirectKeys, Is.EqualTo(ExpectedKeyRedirection));
        }

        [Test]
        public void ConnectionDriveRedirectionImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RedirectDiskDrives, Is.EqualTo(ExpectedDriveRedirection));
        }

        [Test]
        public void ConnectionPortRedirectionImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RedirectPorts, Is.EqualTo(ExpectedPortRedirection));
        }

        [Test]
        public void ConnectionPrinterRedirectionImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RedirectPrinters, Is.EqualTo(ExpectedPrinterRedirection));
        }

        [Test]
        public void ConnectionSmartcardRedirectionImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RedirectSmartCards, Is.EqualTo(ExpectedSmartcardRedirection));
        }

        [Test]
        public void ConnectionauthenticationLevelImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RDPAuthenticationLevel, Is.EqualTo(ExpectedAuthLevel));
        }

        [Test]
        public void ExceptionThrownOnBadSchemaVersion()
        {
            var badFileContents = Resources.test_rdcman_v2_2_badschemaversion;
            Assert.That(() => _deserializer.Deserialize(badFileContents), Throws.TypeOf<FileFormatException>());
        }

        [Test]
        public void ExceptionThrownOnUnsupportedVersion()
        {
            var badFileContents = Resources.test_rdcman_badVersionNumber;
            Assert.That(() => _deserializer.Deserialize(badFileContents), Throws.TypeOf<FileFormatException>());
        }

        [Test]
        public void ExceptionThrownOnNoVersion()
        {
            var badFileContents = Resources.test_rdcman_noversion;
            Assert.That(() => _deserializer.Deserialize(badFileContents), Throws.TypeOf<FileFormatException>());
        }

        [Test]
        public void StartProgramImported()
        {
            var rootNode = _connectionTreeModel.RootNodes.First();
            var importedRdcmanRootNode = rootNode.Children.OfType<ContainerInfo>().First();
            var group1 = importedRdcmanRootNode.Children.OfType<ContainerInfo>().First(node => node.Name == "Group1");
            var connection = group1.Children.First();
            Assert.That(connection.RDPStartProgram, Is.EqualTo(ExpectedStartProgram));
        }
    }
}