C# ImapClientSimulator.SendSingleCommandWithLiteral方法代码示例

        public void TestDateSortOrder()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "[email protected]", "test");
             var oSimulator = new ImapClientSimulator();

             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.LogonWithLiteral("[email protected]", "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();
        }

        public void ConfirmFileAddedToCorrectAccountFolder()
        {
            TestSetup testSetup = SingletonProvider<TestSetup>.Instance;
             Account oAccount = testSetup.AddAccount(_domain, "[email protected]", "test");
             var oSimulator = new ImapClientSimulator();

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

             // Add a message to the inbox.
             oSimulator.Connect();
             oSimulator.LogonWithLiteral("[email protected]", "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.
             CustomAsserts.AssertFilesInDirectory(publicDir, 0);

             // There should be a single file in the users directory.
             CustomAsserts.AssertFilesInUserDirectory(oAccount, 1);
        }

        public void TestAppendBadLiteral()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "[email protected]", "test");

             var oSimulator = new ImapClientSimulator();

             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.LogonWithLiteral("[email protected]", "test");
             oSimulator.SendSingleCommandWithLiteral("A01 APPEND INBOX {TEST}", "ABCD");
             Assert.AreEqual(0, oSimulator.GetMessageCount("INBOX"));
             oSimulator.Disconnect();
        }

        public void SetupEnvWith50MillionMessages()
        {
            const int accountCount = 1;
             const int folderCount = 1;
             const int messageCount = 100000;

             var accounts = new List<string>();
             for (int accountIdx = 0; accountIdx < accountCount; accountIdx++)
             {
            var account = string.Format("test-{0}@test.com", accountIdx);
            accounts.Add(account);

            TestTracer.WriteTraceInfo("Setting up {0}...", account);
            SingletonProvider<TestSetup>.Instance.AddAccount(_domain, account, "test");
             }

             var folders = new List<string>();
             for (int folderIdx = 0; folderIdx < folderCount; folderIdx++)
            folders.Add(string.Format("Folder-{0}", folderIdx));

             var parallelOptions = new ParallelOptions();
             parallelOptions.MaxDegreeOfParallelism = 10;

             var watch = new Stopwatch();
             watch.Start();

             Parallel.ForEach(accounts, parallelOptions, account =>
            {
               TestTracer.WriteTraceInfo("Processing messages for {0}...", account);

               var sim = new ImapClientSimulator();
               Assert.IsTrue(sim.ConnectAndLogon(account, "test"));

               foreach (var folder in folders)
               {
                  Assert.IsTrue(sim.CreateFolder(folder));

                  for (int i = 0; i < messageCount; i++)
                  {
                     string f = sim.SendSingleCommandWithLiteral("A01 APPEND " + folder + " {1}", "A");
                     Assert.IsTrue(f.Contains("A01 OK APPEND completed"), f);
                  }
               }

               sim.Disconnect();
            });

             watch.Stop();
             TestTracer.WriteTraceInfo(watch.ElapsedMilliseconds.ToString());
        }

        public void TestDateSortOrderNonexistantDate()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "[email protected]", "test");
             var oSimulator = new ImapClientSimulator();

             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.LogonWithLiteral("[email protected]", "test");
             Assert.IsTrue(oSimulator.SelectFolder("Inbox"));

             string response = oSimulator.SendSingleCommandWithLiteral(
            "A04 APPEND INBOX \"22-Feb-2008 22:00:00 +0200\" {4}", "ABCD");
             Assert.IsTrue(response.Contains("* 1 EXISTS"), response);

             response = oSimulator.SendSingleCommandWithLiteral("A04 APPEND INBOX \"22-Feb-2008 21:00:00 +0200\" {4}",
                                                            "ABCD");
             Assert.IsTrue(response.Contains("* 2 EXISTS"), response);

             response = oSimulator.SendSingleCommandWithLiteral("A04 APPEND INBOX \"22-Feb-2008 20:00:00 +0200\" {4}",
                                                            "ABCD");
             Assert.IsTrue(response.Contains("* 3 EXISTS"), response);

             response = oSimulator.SendSingleCommandWithLiteral("A04 APPEND INBOX \"23-Feb-2008 01:30:23 +0200\" {4}",
                                                            "ABCD");
             Assert.IsTrue(response.Contains("* 4 EXISTS"), response);

             /*
              * RFC 5256 "2.2. Sent Date" chapter. If the sent date cannot be determined (a Date: header is missing or cannot be parsed),
              * the INTERNALDATE for that message is used as the sent date.
              */

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

             Assert.IsTrue(sortArivalDateResponse.Contains(" 3 2 1 4"));
             Assert.AreEqual(sortDateResponse, sortArivalDateResponse);
             oSimulator.Disconnect();
        }

        public void ConfirmFileAddedToCorrectPublicFolder()
        {
            TestSetup testSetup = SingletonProvider<TestSetup>.Instance;
             Account oAccount = testSetup.AddAccount(_domain, "[email protected]", "test");
             var oSimulator = new ImapClientSimulator();

             // Confirm that the public folder is empty before we start our test.
             string publicDir = GetPublicDirectory();
             CustomAsserts.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("[email protected]", "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.
             CustomAsserts.AssertFilesInDirectory(publicDir, 1);

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

        public void TestAppendToPublicFolder()
        {
            Application application = SingletonProvider<TestSetup>.Instance.GetApp();

             Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "[email protected]", "test");

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

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

             var oSimulator = new ImapClientSimulator();

             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.LogonWithLiteral(account.Address, "test");
             oSimulator.SendSingleCommandWithLiteral("A01 APPEND #Public.Share1 {4}", "ABCD");
             Assert.AreEqual(1, oSimulator.GetMessageCount("#Public.Share1"));
             oSimulator.Disconnect();
        }

        public void TestAppendResponseContainsExists()
        {
            Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "[email protected]", "test");

             var oSimulator = new ImapClientSimulator();

             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.LogonWithLiteral("[email protected]", "test");
             Assert.IsTrue(oSimulator.SelectFolder("Inbox"));
             string response1 = oSimulator.SendSingleCommandWithLiteral("A01 APPEND INBOX {4}", "ABCD");
             Assert.IsTrue(response1.Contains("* 1 EXISTS"), response1);
             Assert.IsTrue(response1.Contains("* 1 RECENT"), response1);
             Assert.AreEqual(1, oSimulator.GetMessageCount("INBOX"));
             oSimulator.Disconnect();
        }

        public void TestSearchWithLiterals()
        {
            Application application = SingletonProvider<TestSetup>.Instance.GetApp();

             Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "[email protected]", "test");

             // Send a message to this account.
             var smtpClientSimulator = new SmtpClientSimulator();
             smtpClientSimulator.Send("[email protected]", "[email protected]", "Test1", "This is a test of IMAP Search");
             ImapClientSimulator.AssertMessageCount("[email protected]", "test", "INBOX", 1);
             smtpClientSimulator.Send("[email protected]", "[email protected]", "Test2", "This is a test of IMAP Search");
             ImapClientSimulator.AssertMessageCount("[email protected]", "test", "INBOX", 2);

             var oSimulator = new ImapClientSimulator();

             string sWelcomeMessage = oSimulator.Connect();
             oSimulator.Logon("[email protected]", "test");

             Assert.IsTrue(oSimulator.SelectFolder("INBOX"));

             string result = oSimulator.SendSingleCommandWithLiteral("A01 SEARCH HEADER SUBJECT {5}", "Test1");
             Assert.IsTrue(result.StartsWith("* SEARCH 1\r\n"));

             result = oSimulator.SendSingleCommandWithLiteral("A01 SEARCH HEADER SUBJECT {5}", "Test2");
             Assert.IsTrue(result.StartsWith("* SEARCH 2\r\n"));
        }

        public void TestGlobalMaxMessageSizeLimitEnabled()
        {
            Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "[email protected]", "test", 0);
             var message = new StringBuilder();

             // ~2 kb string
             for (int i = 0; i < 25; i++)
            message.AppendLine(
               "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");

             _settings.MaxMessageSize = 1;

             var imapSim = new ImapClientSimulator("[email protected]", "test", "INBOX");
             string result = imapSim.SendSingleCommandWithLiteral("A01 APPEND INBOX {" + message.Length + "}",
                                                              message.ToString());
             imapSim.Logout();

             Assert.IsTrue(result.StartsWith("A01 NO Message size exceeds fixed maximum message size."));
        }