Exemple #1
0
        public void TestBodyStructureWithNonLatinCharacter()
        {
            Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             string attachmentName = "本本本.zip";

             string filename = Path.Combine(Path.GetTempPath(), attachmentName);
             File.WriteAllText(filename, "tjena moss");

             var message = new Message();
             message.Charset = "utf-8";
             message.AddRecipient("test", account.Address);
             message.From = "Test";
             message.FromAddress = account.Address;
             message.Body = "hejsan";
             message.Attachments.Add(filename);
             message.Save();

             TestSetup.AssertFolderMessageCount(account.IMAPFolders[0], 1);

             var oSimulator = new IMAPSimulator();
             oSimulator.ConnectAndLogon(account.Address, "test");
             oSimulator.SelectFolder("INBOX");
             string result = oSimulator.Fetch("1 BODYSTRUCTURE");
             oSimulator.Disconnect();

             // utf-8 representation of 本本本.zip:
             Assert.IsTrue(result.Contains("=?utf-8?B?5pys5pys5pys?=.zip"));
        }
Exemple #2
0
        public void TestDateSortOrder()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
             var oSimulator = new IMAPSimulator();

             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.LogonWithLiteral("*****@*****.**", "test");
             Assert.IsTrue(oSimulator.SelectFolder("Inbox"));

             string response =
            oSimulator.SendSingleCommandWithLiteral("A04 APPEND INBOX \"22-Feb-2008 22:00:00 +0200\" {37}",
                                                    "Date: Wed, 15 Dec 2010 13:00:00 +0000");
             Assert.IsTrue(response.Contains("* 1 EXISTS"), response);

             response = oSimulator.SendSingleCommandWithLiteral("A04 APPEND INBOX \"22-Feb-2008 21:00:00 +0200\" {37}",
                                                            "Date: Wed, 15 Dec 2010 14:00:00 +0000");
             Assert.IsTrue(response.Contains("* 2 EXISTS"), response);

             response = oSimulator.SendSingleCommandWithLiteral("A04 APPEND INBOX \"22-Feb-2008 20:00:00 +0200\" {37}",
                                                            "Date: Wed, 15 Dec 2010 12:00:00 +0000");
             Assert.IsTrue(response.Contains("* 3 EXISTS"), response);

             response = oSimulator.SendSingleCommandWithLiteral("A04 APPEND INBOX \"23-Feb-2008 01:30:23 +0200\" {37}",
                                                            "Date: Wed, 15 Dec 2010 11:00:00 +0000");
             Assert.IsTrue(response.Contains("* 4 EXISTS"), response);

             string sortDateResponse = oSimulator.SendSingleCommand("A10 SORT (DATE) US-ASCII ALL");

             Assert.IsTrue(sortDateResponse.Contains(" 4 3 1 2"));
             oSimulator.Disconnect();
        }
Exemple #3
0
        public void TestIMAPLogonFailure()
        {
            _settings.AutoBanOnLogonFailure = true;
             _settings.MaxInvalidLogonAttempts = 4;
             _settings.MaxInvalidLogonAttemptsWithin = 5;
             _settings.AutoBanMinutes = 3;

             Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             var sim = new IMAPSimulator();
             Assert.IsTrue(sim.ConnectAndLogon(account.Address, "test"));
             sim.Disconnect();

             // confirm that we can retrieve welcome message.
             Assert.IsTrue(sim.GetWelcomeMessage().StartsWith("* OK"));

             // fail to log on 3 times.
             for (int i = 0; i < 4; i++)
             {
            string errorMessage;

            Assert.IsFalse(sim.ConnectAndLogon(account.Address, "testA", out errorMessage));
            sim.Disconnect();

            if (i == 3)
            {
               Assert.IsTrue(errorMessage.Contains("Too many invalid logon attempts."));
            }
             }

             Assert.IsTrue(sim.GetWelcomeMessage().Length == 0);

             string logText = TestSetup.ReadCurrentDefaultLog();
             Assert.IsTrue(logText.Contains("Blocked either by IP range or by connection limit."), logText);
        }
Exemple #4
0
        public void FolderMarkedAsReadOnlyWhenUserHasReadOnlyRights()
        {
            Application application = SingletonProvider<TestSetup>.Instance.GetApp();

             Account account1 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             IMAPFolders publicFolders = _settings.PublicFolders;
             IMAPFolder folder = publicFolders.Add("Share1");
             folder.Save();

             IMAPFolderPermission permission = folder.Permissions.Add();
             permission.PermissionAccountID = account1.ID;
             permission.PermissionType = eACLPermissionType.ePermissionTypeUser;
             permission.set_Permission(eACLPermission.ePermissionLookup, true);
             permission.set_Permission(eACLPermission.ePermissionRead, true);
             permission.Save();

             string selectResult = string.Empty;

             var oSimulator1 = new IMAPSimulator();
             oSimulator1.Connect();
             oSimulator1.LogonWithLiteral(account1.Address, "test");
             oSimulator1.SelectFolder("#Public.Share1", out selectResult);
             oSimulator1.Disconnect();

             Assert.IsTrue(selectResult.Contains("[READ-ONLY]"), selectResult);
             Assert.IsFalse(selectResult.Contains("[READ-WRITE]"), selectResult);
        }
Exemple #5
0
        public void TestChangeSeenFlag()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             Assert.IsTrue(SMTPClientSimulator.StaticSend("*****@*****.**", oAccount.Address, "Test", "test"));
             POP3Simulator.AssertMessageCount(oAccount.Address, "test", 1);

             var simulator = new IMAPSimulator();
             simulator.ConnectAndLogon(oAccount.Address, "test");
             simulator.ExamineFolder("Inbox");
             string flags = simulator.GetFlags(1);
             string body = simulator.Fetch("1 RFC822");
             string flagsAfter = simulator.GetFlags(1);
             simulator.Close();
             simulator.Disconnect();

             Assert.AreEqual(flags, flagsAfter);

             var secondSimulator = new IMAPSimulator();
             secondSimulator.ConnectAndLogon(oAccount.Address, "test");
             secondSimulator.SelectFolder("Inbox");
             string secondFlags = secondSimulator.GetFlags(1);
             string secondBody = secondSimulator.Fetch("1 RFC822");
             string secondFlagsAfter = secondSimulator.GetFlags(1);
             secondSimulator.Close();
             secondSimulator.Disconnect();

             Assert.AreNotEqual(secondFlags, secondFlagsAfter);
        }
Exemple #6
0
        public void ConfirmFileAddedToCorrectAccountFolder()
        {
            TestSetup testSetup = SingletonProvider<TestSetup>.Instance;
             Account oAccount = testSetup.AddAccount(_domain, "*****@*****.**", "test");
             var oSimulator = new IMAPSimulator();

             // Confirm that the public folder is empty before we start our test.
             string publicDir = testSetup.GetPublicDirectory();
             testSetup.AssertFilesInDirectory(publicDir, 0);

             // Add a message to the inbox.
             oSimulator.Connect();
             oSimulator.LogonWithLiteral("*****@*****.**", "test");
             oSimulator.SendSingleCommandWithLiteral("A01 APPEND INBOX {4}", "ABCD");

             // Confirm it exists in the IMAP folder.
             Assert.AreEqual(1, oSimulator.GetMessageCount("INBOX"));
             oSimulator.Disconnect();

             // The public directory should still be empty - the message was added to the user account.
             testSetup.AssertFilesInDirectory(publicDir, 0);

             // There should be a single file in the users directory.
             testSetup.AssertFilesInUserDirectory(oAccount, 1);
        }
Exemple #7
0
        public void TestIMAPServer()
        {
            TestSetup.DeleteCurrentDefaultLog();

             Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             for (int i = 0; i < 30; i++)
             {
            try
            {
               var imapSim = new IMAPSimulator(true, 14300);
               imapSim.ConnectAndLogon(account.Address, "test");
               CustomAssert.IsTrue(imapSim.SelectFolder("Inbox"), "SelectInbox");
               imapSim.CreateFolder("Test");
               CustomAssert.IsTrue(imapSim.SelectFolder("Test"), "SelectTest");
               CustomAssert.IsTrue(imapSim.Logout(), "Logout");

               imapSim.Disconnect();
               break;
            }
            catch (Exception)
            {
               if (i == 29)
                  throw;
            }
             }
        }
Exemple #8
0
        public void TestChangeRecentFlag()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             Assert.IsTrue(SMTPClientSimulator.StaticSend("*****@*****.**", oAccount.Address, "Test", "test"));
             POP3Simulator.AssertMessageCount(oAccount.Address, "test", 1);

             var simulator = new IMAPSimulator();
             simulator.ConnectAndLogon(oAccount.Address, "test");
             string result = simulator.ExamineFolder("Inbox");
             Assert.IsTrue(result.Contains("* 1 RECENT"), result);
             simulator.Close();
             simulator.Disconnect();

             simulator = new IMAPSimulator();
             simulator.ConnectAndLogon(oAccount.Address, "test");
             Assert.IsTrue(simulator.SelectFolder("Inbox", out result));
             Assert.IsTrue(result.Contains("* 1 RECENT"), result);
             simulator.Close();
             simulator.Disconnect();

             simulator = new IMAPSimulator();
             simulator.ConnectAndLogon(oAccount.Address, "test");
             result = simulator.ExamineFolder("Inbox");
             Assert.IsTrue(result.Contains("* 0 RECENT"), result);
             simulator.Close();
             simulator.Disconnect();
        }
Exemple #9
0
        public void TestBatchOfCommands()
        {
            Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             var oSimulator = new IMAPSimulator();
             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.Logon(account.Address, "test");

             string commandSequence = "";
             for (int i = 0; i < 200; i++)
             {
            commandSequence += "A" + i.ToString() + " SELECT INBOX\r\n";
             }
             commandSequence = commandSequence.TrimEnd("\r\n".ToCharArray());

             string result = oSimulator.Send(commandSequence);
             CustomAssert.IsFalse(result.StartsWith("* BYE"));

             oSimulator.Disconnect();

             sWelcomeMessage = oSimulator.Connect();
             oSimulator.Logon(account.Address, "test");
             commandSequence = "";
             for (int i = 0; i < 500; i++)
             {
            commandSequence += "A" + i.ToString() + " SELECT INBOX\r\n";
             }
             commandSequence = commandSequence.TrimEnd("\r\n".ToCharArray());

             result = oSimulator.Send(commandSequence);
             CustomAssert.IsFalse(result.StartsWith("* BYE Excessive number of buffered commands"));
             oSimulator.Disconnect();
        }
        public void TestDistributionListAnnouncementFromDomainAlias()
        {
            var oIMAP = new IMAPSimulator();
             var oSMTP = new SMTPClientSimulator();

             Application application = SingletonProvider<TestSetup>.Instance.GetApp();

             //
             // TEST LIST SECURITY IN COMBINATION WITH DOMAIN NAME ALIASES
             //

             Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             var oRecipients = new List<string>();
             oRecipients.Add("*****@*****.**");

             DistributionList oList3 = SingletonProvider<TestSetup>.Instance.AddDistributionList(_domain, "*****@*****.**",
                                                                                             oRecipients);
             oList3.Mode = eDistributionListMode.eLMAnnouncement;
             oList3.RequireSenderAddress = "*****@*****.**";
             oList3.Save();

             // THIS MESSAGE SHOULD FAIL
             Assert.IsFalse(oSMTP.Send("*****@*****.**", "*****@*****.**", "Mail 1", "Mail 1"));

             DomainAlias oDA = _domain.DomainAliases.Add();
             oDA.AliasName = "dummy-example.com";
             oDA.Save();

             // THIS MESSAGE SHOULD SUCCEED
             Assert.IsTrue(oSMTP.Send("*****@*****.**", "*****@*****.**", "Mail 1", "Mail 1"));
             IMAPSimulator.AssertMessageCount("*****@*****.**", "test", "Inbox", 1);
        }
Exemple #11
0
        public void TestMetaDataSortCC()
        {
            Application application = SingletonProvider<TestSetup>.Instance.GetApp();
             Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "meta'*****@*****.**", "test");

             // disable...
             SendMessage("Test C", "Body", "", "ÄÄÄ");
             IMAPSimulator.AssertMessageCount(account.Address, "test", "Inbox", 1);

             SendMessage("Test B", "Body", "", "ÖÖÖ");
             IMAPSimulator.AssertMessageCount(account.Address, "test", "Inbox", 2);

             SendMessage("Test A", "Body", "", "ÅÅÅ");
             IMAPSimulator.AssertMessageCount(account.Address, "test", "Inbox", 3);

             AssertAllMessagesIndexed();

             var sim = new IMAPSimulator(account.Address, "test", "Inbox");

             string result = sim.Sort("(CC) UTF-8 ALL");

             CustomAssert.AreEqual("3 1 2", result);

             // Disable the indexing functionality
             _indexing.Enabled = false;
             _indexing.Clear();

             // Make sure the sort order is the same.
             string resultAfter = sim.Sort("(CC) UTF-8 ALL");

             CustomAssert.AreEqual(result, resultAfter);
        }
Exemple #12
0
        public void TestNestedOrSearch()
        {
            Application application = SingletonProvider<TestSetup>.Instance.GetApp();

             Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             // Send a message to this account.
             var oSMTP = new SMTPClientSimulator();
             oSMTP.Send("*****@*****.**", "*****@*****.**", "Search test", "This is a test of IMAP Search");

             IMAPSimulator.AssertMessageCount(oAccount.Address, "test", "Inbox", 1);

             var oSimulator = new IMAPSimulator();
             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.Logon("*****@*****.**", "test");
             oSimulator.SelectFolder("INBOX");

             string result =
            oSimulator.SendSingleCommand("A4 SEARCH ALL OR OR SINCE 28-May-2008 SINCE 28-May-2008 SINCE 28-May-2008");
             Assert.IsTrue(result.StartsWith("* SEARCH 1"), result);

             result = oSimulator.SendSingleCommand("A4 SEARCH ALL OR SMALLER 1 LARGER 10000");
             Assert.IsTrue(result.StartsWith("* SEARCH\r\n"), result);

             result = oSimulator.SendSingleCommand("A4 SEARCH ALL OR OR SMALLER 1 LARGER 10000 SMALLER 10000");
             Assert.IsTrue(result.StartsWith("* SEARCH 1\r\n"), result);
        }
Exemple #13
0
        public void ExamineFolderRequiresReadPermission()
        {
            Application application = SingletonProvider<TestSetup>.Instance.GetApp();

             Account account1 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             IMAPFolders publicFolders = _settings.PublicFolders;
             IMAPFolder folder = publicFolders.Add("Share1");
             folder.Save();

             IMAPFolderPermission permission = folder.Permissions.Add();
             permission.PermissionAccountID = account1.ID;
             permission.PermissionType = eACLPermissionType.ePermissionTypeUser;
             permission.set_Permission(eACLPermission.ePermissionLookup, true);
             permission.Save();

             string selectResult = string.Empty;

             var oSimulator1 = new IMAPSimulator();
             oSimulator1.Connect();
             oSimulator1.LogonWithLiteral(account1.Address, "test");
             string examineResult = oSimulator1.ExamineFolder("#Public.Share1");
             oSimulator1.Disconnect();

             Assert.IsTrue(examineResult.Contains("ACL: Read permission denied (Required for EXAMINE command)."),
                       examineResult);
        }
Exemple #14
0
        public void TestAddMessage()
        {
            Application app = SingletonProvider<TestSetup>.Instance.GetApp();
             Utilities utilities = app.Utilities;

             Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             // Create a new folder.
             IMAPFolder folder = account.IMAPFolders.get_ItemByName("INBOX");
             folder.Save();

             for (int i = 0; i < 3; i++)
             {
            hMailServer.Message message = folder.Messages.Add();
            message.set_Flag(eMessageFlag.eMFSeen, true);
            message.Save();

            POP3Simulator.AssertMessageCount(account.Address, "test", ((i + 1)*2) - 1);

            SMTPClientSimulator.StaticSend("*****@*****.**", account.Address, "Test", "Test");
            POP3Simulator.AssertMessageCount(account.Address, "test", (i + 1)*2);
             }

             POP3Simulator.AssertMessageCount(account.Address, "test", 6);

             var sim = new IMAPSimulator();
             sim.ConnectAndLogon(account.Address, "test");
             sim.SelectFolder("Inbox");

             string response = sim.Fetch("1:6 UID");

             string[] lines = Strings.Split(response, Environment.NewLine, -1, CompareMethod.Text);

             var uids = new List<string>();

             foreach (string line in lines)
             {
            int paraPos = line.IndexOf("(");
            int paraEndPos = line.IndexOf(")");

            if (paraPos < 0 || paraEndPos < 0)
               continue;

            string paraContent = line.Substring(paraPos + 1, paraEndPos - paraPos - 1);

            if (!uids.Contains(paraContent))
               uids.Add(paraContent);
             }

             Assert.AreEqual(6, uids.Count);

             // Make sure the UIDS are sorted properly by creating a copy, sort the copy
             // and then compare to original.
             var copy = new List<string>();
             copy.InsertRange(0, uids);
             copy.Sort();

             Assert.AreEqual(copy, uids);
        }
Exemple #15
0
 public void TestIMAPServerLiteral()
 {
     var sim = new IMAPSimulator();
      sim.Connect();
      Assert.IsTrue(sim.Send("a01 login " + GetUsername() + " {4}").StartsWith("+"));
      sim.Send(GetPassword());
      EnsureNoPassword();
 }
Exemple #16
0
        public void IfStartTlsNotEnabledStartTlsShouldNotBeShownInEhloResponse()
        {
            var imapSimulator = new IMAPSimulator(false, 143);
            imapSimulator.Connect();
            var data = imapSimulator.GetCapabilities();

            CustomAssert.IsFalse(data.Contains("STARTTLS"));
        }
Exemple #17
0
        public void StlsCommandShouldSwithToTls()
        {
            var imapSimulator = new IMAPSimulator(false, 14300);
               imapSimulator.Connect();
               var data = imapSimulator.GetCapabilities();
               imapSimulator.SendSingleCommand("A01 STARTTLS");
               imapSimulator.Handshake();

               // command is sent over TLS.
               imapSimulator.GetCapabilities();
        }
Exemple #18
0
        public void TestCreateFolderWithHash()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             var oSimulator = new IMAPSimulator();

             oSimulator.Connect();
             oSimulator.Logon(oAccount.Address, "test");
             CustomAssert.IsFalse(oSimulator.CreateFolder("#Test"));
             CustomAssert.IsTrue(oSimulator.CreateFolder("Test.#Testar"));
             oSimulator.Disconnect();
        }
Exemple #19
0
        public void TestChangeFlags()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             Assert.IsTrue(SMTPClientSimulator.StaticSend("*****@*****.**", oAccount.Address, "Test", "test"));
             POP3Simulator.AssertMessageCount(oAccount.Address, "test", 1);

             var simulator = new IMAPSimulator();
             simulator.ConnectAndLogon(oAccount.Address, "test");
             simulator.ExamineFolder("Inbox");
             Assert.IsFalse(simulator.SetFlagOnMessage(1, true, @"\Deleted"));
        }
Exemple #20
0
        public void TestAppendBadLiteral()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             var oSimulator = new IMAPSimulator();

             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.LogonWithLiteral("*****@*****.**", "test");
             oSimulator.SendSingleCommandWithLiteral("A01 APPEND INBOX {TEST}", "ABCD");
             Assert.AreEqual(0, oSimulator.GetMessageCount("INBOX"));
             oSimulator.Disconnect();
        }
Exemple #21
0
        public void TestParseMultipartNoBody()
        {
            Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
             string body = TestSetup.GetResource("Messages.MultipartMessageWithNoMainBodyText.txt");
             SMTPClientSimulator.StaticSendRaw(account.Address, account.Address, body);

             POP3Simulator.AssertMessageCount(account.Address, "test", 1);

             var imapSim = new IMAPSimulator("*****@*****.**", "test", "INBOX");
             string result = imapSim.Fetch("1 (BODY.PEEK[HEADER] BODY.PEEK[TEXT])");

             imapSim.Logout();
        }
Exemple #22
0
        public void TestCreateFolderWithSlash()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             const string folderName = "ABC\\123";

             var oSimulator = new IMAPSimulator();
             oSimulator.Connect();
             oSimulator.Logon(oAccount.Address, "test");
             CustomAssert.IsTrue(oSimulator.CreateFolder(folderName));
             CustomAssert.IsTrue(oSimulator.List().Contains(folderName));
             CustomAssert.IsTrue(oSimulator.SelectFolder(folderName));
             oSimulator.Disconnect();
        }
Exemple #23
0
        public void TestCreateDeepFolder()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             var oSimulator = new IMAPSimulator();

             oSimulator.Connect();
             oSimulator.LogonWithLiteral(oAccount.Address, "test");
             string result =
            oSimulator.Send("A01 CREATE 1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26");
             CustomAssert.IsTrue(result.Contains("A01 NO"));

             oSimulator.Disconnect();
        }
Exemple #24
0
        public void TestEmptyPassword()
        {
            Account account1 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "");

             string message;
             var sim = new POP3Simulator();
             Assert.IsFalse(sim.ConnectAndLogon(account1.Address, "", out message));

             var simIMAP = new IMAPSimulator();
             Assert.IsFalse(simIMAP.ConnectAndLogon(account1.Address, "", out message));
             Assert.AreEqual("A01 NO Invalid user name or password.\r\n", message);

             var simSMTP = new SMTPClientSimulator();
             Assert.IsFalse(simSMTP.ConnectAndLogon(25, "dGVzdEB0ZXN0LmNvbQ==", "", out message));
             Assert.AreEqual("535 Authentication failed. Restarting authentication process.\r\n", message);
        }
Exemple #25
0
        public void TestLongCommand()
        {
            Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             var oSimulator = new IMAPSimulator();
             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.Logon(account.Address, "test");

             var sb = new StringBuilder();

             for (int i = 0; i < 240000; i++)
             {
            sb.Append("A");
             }

             string result = oSimulator.Send("A01 " + sb);
             CustomAssert.IsTrue(result.Length == 0 || result.StartsWith("A01"));
        }
Exemple #26
0
        public void TestFetchCharsetInQuotesWithoutSpace()
        {
            Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             SMTPClientSimulator.StaticSendRaw(account.Address, account.Address,
                                           "From: [email protected]\r\n" +
                                           "Content-Type: text/plain; charset =\"iso-8859-1\"\r\n" +
                                           "\r\n" +
                                           "Test\r\n");

             IMAPSimulator.AssertMessageCount(account.Address, "test", "Inbox", 1);

             var sim = new IMAPSimulator(account.Address, "test", "Inbox");
             string result = sim.Fetch("1 BODYSTRUCTURE");
             sim.Disconnect();

             Assert.IsTrue(result.Contains("(\"CHARSET\" \"iso-8859-1\")"), result);
        }
        public void TestHierarchyDelimiterListResponse()
        {
            Application application = SingletonProvider<TestSetup>.Instance.GetApp();
             Settings settings = _settings;
             settings.IMAPHierarchyDelimiter = "\\";

             Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");

             string folderName = "Test\\Test";

             var oSimulator = new IMAPSimulator();
             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.Logon(account.Address, "test");
             Assert.IsTrue(oSimulator.CreateFolder(folderName));
             string listResponse = oSimulator.List();
             Assert.IsTrue(listResponse.Contains("\"Test\\Test\""));
             Assert.IsTrue(listResponse.Contains("\"Test\""));
             oSimulator.Disconnect();
        }
Exemple #28
0
        public static void AssertMessageCount(string accountName, string accountPassword, string folderName,
                                            int expectedCount)
        {
            if (expectedCount == 0)
             {
            // make sure that we aren't currently delivering messages.
            TestSetup.AssertRecipientsInDeliveryQueue(0);
             }

             var oIMAP = new IMAPSimulator();
             CustomAssert.IsTrue(oIMAP.ConnectAndLogon(accountName, accountPassword));

             if (expectedCount != 0)
            oIMAP.AssertFolderExists(folderName);

             int currentCount = 0;
             int timeout = 1000; // 1000 * 25 = 25 seconds.
             while (timeout > 0)
             {
            currentCount = oIMAP.GetMessageCount(folderName);

            if (currentCount > expectedCount)
               break;

            if (currentCount == expectedCount)
            {
               oIMAP.Disconnect();
               return;
            }

            timeout--;
            Thread.Sleep(25);
             }

             oIMAP.Disconnect();

             string error = "Wrong number of messages in mailbox " + folderName + " in account " + accountName +
                        " Actual: " + currentCount.ToString() + " Expected: " + expectedCount.ToString();
             CustomAssert.Fail(error);
        }
        public void Test()
        {
            IMAPSimulator sim = new IMAPSimulator();
             sim.ConnectAndLogon("*****@*****.**", "test");
             sim.SelectFolder("Inbox");

             Stopwatch watch = new Stopwatch();

             watch.Start();
             string result = sim.SendSingleCommand("A282 SORT (SIZE) UTF-8");
             watch.Stop();

             long sortSizeTime = watch.ElapsedMilliseconds;
             watch.Reset();

             watch.Start();
             result = sim.SendSingleCommand("A282 SORT (FROM) UTF-8");
             watch.Stop();

             long sortFromTime = watch.ElapsedMilliseconds;
             watch.Reset();

             watch.Start();
             result = sim.SendSingleCommand("A282 SORT (FROM) UTF-8 1:15");
             watch.Stop();

             long sortFromTimeLimit15 = watch.ElapsedMilliseconds;
             watch.Reset();

             watch.Start();
             result = sim.SendSingleCommand("A282 SORT (DATE) UTF-8");
             watch.Stop();

             long sortDateTime = watch.ElapsedMilliseconds;
             watch.Reset();

             System.Threading.Thread.Sleep(1);
        }
Exemple #30
0
        public void ConfirmFileAddedToCorrectPublicFolder()
        {
            TestSetup testSetup = SingletonProvider<TestSetup>.Instance;
             Account oAccount = testSetup.AddAccount(_domain, "*****@*****.**", "test");
             var oSimulator = new IMAPSimulator();

             // Confirm that the public folder is empty before we start our test.
             string publicDir = testSetup.GetPublicDirectory();
             testSetup.AssertFilesInDirectory(publicDir, 0);

             IMAPFolders folders = _application.Settings.PublicFolders;
             IMAPFolder folder = folders.Add("Share");
             folder.Save();

             // Give everyone access to the folder.
             IMAPFolderPermission permission = folder.Permissions.Add();
             permission.PermissionType = eACLPermissionType.ePermissionTypeAnyone;
             permission.set_Permission(eACLPermission.ePermissionLookup, true);
             permission.set_Permission(eACLPermission.ePermissionRead, true);
             permission.set_Permission(eACLPermission.ePermissionInsert, true);
             permission.Save();

             // Add the message to the public folder.
             oSimulator.Connect();
             oSimulator.LogonWithLiteral("*****@*****.**", "test");
             oSimulator.SendSingleCommandWithLiteral("A01 APPEND #Public.Share {4}", "ABCD");

             // Confirm that the message exists in the public folder and not in the inbox.
             Assert.AreEqual(1, oSimulator.GetMessageCount("#Public.Share"));
             Assert.AreEqual(0, oSimulator.GetMessageCount("INBOX"));
             oSimulator.Disconnect();

             // The public directory should now contain the message.
             testSetup.AssertFilesInDirectory(publicDir, 1);

             // There users directory should still be empty.
             testSetup.AssertFilesInUserDirectory(oAccount, 0);
        }