C# ImapPseudoServer.EnqueueResponse方法代码示例

        public void TestBeginGetResponse()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var request = WebRequest.Create(string.Format("imap://{0}/", server.HostPort)) as ImapWebRequest;

            request.Method = "NOOP";
            request.KeepAlive = false;

            // greeting
            server.EnqueueResponse("* OK [CAPABILITY IMAP4rev1] ready\r\n");
            // LOGIN
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0000 OK done\r\n");
            // NOOP
            server.EnqueueResponse("0001 OK done\r\n");
            // LOGOUT
            server.EnqueueResponse("* BYE logging out\r\n" +
                               "0002 OK done\r\n");

            var asyncState = "async state";
            var asyncResult = request.BeginGetResponse(null, asyncState);

            Assert.IsNotNull(asyncResult);
            Assert.AreEqual(asyncResult.AsyncState, asyncState);

            using (var response = request.EndGetResponse(asyncResult)) {
            }

            StringAssert.Contains("LOGIN", server.DequeueRequest());
            StringAssert.Contains("NOOP", server.DequeueRequest());
            StringAssert.Contains("LOGOUT", server.DequeueRequest());
              }
        }

        public void TestAuthenticateAnonymousMechanismSpecifiedAuthenticationFailure()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var prof = new Profile(null, "user%40imap.example.net;auth=anonymous", server.HostPort);

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY response
            server.EnqueueResponse("* CAPABILITY IMAP4rev1 AUTH=ANONYMOUS\r\n" +
                               "0000 OK done\r\n");
            // AUTHENTICATE response
            server.EnqueueResponse("+ \r\n");
            server.EnqueueResponse("0001 NO done\r\n");

            try {
              Assert.IsNull(ImapSessionCreator.CreateSession(prof, null, null));
              Assert.Fail("ImapAuthenticationException not thrown");
            }
            catch (ImapAuthenticationException ex) {
              Assert.IsNull(ex.InnerException);
              Assert.IsNotNull(ex.Result);
              Assert.AreEqual(Protocol.Client.ImapCommandResultCode.No, ex.Result.Code);
            }

            server.DequeueRequest(); // CAPABILITY
            StringAssert.Contains("AUTHENTICATE ANONYMOUS", server.DequeueRequest());
            StringAssert.Contains("[email protected]", Base64.GetDecodedString(server.DequeueRequest()));
              }
        }

        public void TestCreateSessionAppropriateMechanismNotFound()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var credential = new NetworkCredential("user", "pass");
            var requestUri = new Uri(string.Format("imap://{0}/", server.HostPort));
            var request = WebRequest.Create(requestUri) as ImapWebRequest;

            request.Credentials = credential;
            request.UseTlsIfAvailable = true;
            request.KeepAlive = false;
            request.Timeout = 1000;

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY response
            server.EnqueueResponse("* CAPABILITY IMAP4rev1 LOGINDISABLED\r\n" +
                               "0000 OK done\r\n");

            try {
              using (var response = request.GetResponse()) {
              }
            }
            catch (WebException ex) {
              WebExceptionAssertion(WebExceptionStatus.RequestCanceled, ex);
            }

            server.DequeueRequest(); // CAPABILITY
              }
        }

        public void TestAuthenticateAnonymousMechanismSpecified()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var prof = new Profile(null, "user%40imap.example.net;auth=anonymous", server.HostPort);

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY response
            server.EnqueueResponse("* CAPABILITY IMAP4rev1 AUTH=ANONYMOUS\r\n" +
                               "0000 OK done\r\n");
            // AUTHENTICATE response
            server.EnqueueResponse("+ \r\n");
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0001 OK done\r\n");

            using (var session = ImapSessionCreator.CreateSession(prof, null, null)) {
              Assert.AreEqual(ImapSessionState.Authenticated, session.State);
              Assert.AreEqual(prof.Authority, session.Authority);
            }

            server.DequeueRequest(); // CAPABILITY
            StringAssert.Contains("AUTHENTICATE ANONYMOUS", server.DequeueRequest());
            StringAssert.Contains("[email protected]", Base64.GetDecodedString(server.DequeueRequest()));
              }
        }

        public void TestGetResponseStreamResponseHasNoStream()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var request = WebRequest.Create(string.Format("imap://{0}/", server.HostPort)) as ImapWebRequest;

            request.Timeout = 1000;
            request.Method = ImapWebRequestMethods.NoOp;
            request.KeepAlive = false;

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0000 OK done\r\n");
            // LOGIN
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0001 OK done\r\n");
            // NOOP
            server.EnqueueResponse("0002 OK done\r\n");
            // LOGOUT
            server.EnqueueResponse("* BYE logging out\r\n" +
                               "0003 OK done\r\n");

            using (var response = request.GetResponse()) {
              try {
            response.GetResponseStream();
            Assert.Fail("InvalidOperationException not thrown");
              }
              catch (InvalidOperationException) {
              }
            }
              }
        }

        public void TestBeginGetResponseCallback()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var request = WebRequest.Create(string.Format("imap://{0}/", server.HostPort)) as ImapWebRequest;

            request.Method = "NOOP";
            request.KeepAlive = false;

            // greeting
            server.EnqueueResponse("* OK [CAPABILITY IMAP4rev1] ready\r\n");
            // LOGIN
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0000 OK done\r\n");

            var asyncResult = request.BeginGetResponse(BeginGetResponseCallbackProc, request);

            Assert.IsNotNull(asyncResult);
            Assert.AreEqual(asyncResult.AsyncState, request);

            Thread.Sleep(1000);

            StringAssert.Contains("LOGIN", server.DequeueRequest());

            // NOOP
            server.EnqueueResponse("0001 OK done\r\n");
            // LOGOUT
            server.EnqueueResponse("* BYE logging out\r\n" +
                               "0002 OK done\r\n");

            if (!asyncResult.AsyncWaitHandle.WaitOne(5000))
              Assert.Fail("not completed");

            StringAssert.Contains("NOOP", server.DequeueRequest());
            StringAssert.Contains("LOGOUT", server.DequeueRequest());
              }
        }

        public void TestBeginGetRequestStreamCallback()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0000 OK done\r\n");
            // LOGIN
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0001 OK done\r\n");
            // APPEND
            server.EnqueueResponse("+ continue\r\n");
            server.EnqueueResponse(string.Empty);

            var request = WebRequest.Create(string.Format("imap://{0}/INBOX", server.HostPort)) as ImapWebRequest;

            request.Method = "APPEND";
            request.Timeout = 3000;
            request.ReadWriteTimeout = 3000;
            request.AllowInsecureLogin = true;

            var asyncResult = request.BeginGetRequestStream((AsyncCallback)BeginGetRequestStreamCallbackProc, request);

            Thread.Sleep(100); // XXX

            if (!asyncResult.AsyncWaitHandle.WaitOne(5000))
              Assert.Fail("wait time out");

            server.EnqueueResponse("0002 OK done\r\n");

            using (var response = request.GetResponse()) {
            }

            server.DequeueRequest(); // CAPABILITY
            server.DequeueRequest(); // LOGIN

            var appendCommand = server.DequeueAll();

            StringAssert.StartsWith("0002 APPEND \"INBOX\" ", appendCommand);
            StringAssert.EndsWith(" {12}\r\ntest message\r\n", appendCommand);
              }
        }

        public void TestCloseMailboxFailure()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var credential = new NetworkCredential("user", "pass");
            var request1 = WebRequest.Create(string.Format("imap://{0}@{1}/INBOX", credential.UserName, server.HostPort)) as ImapWebRequest;

            request1.Credentials = credential;
            request1.Timeout = 1000;
            request1.Method = "CHECK";
            request1.KeepAlive = true;
            request1.AllowInsecureLogin = true;

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0000 OK done\r\n");
            // LOGIN
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0001 OK done\r\n");
            // SELECT
            server.EnqueueResponse("0002 OK [READ-WRITE] done\r\n");
            // CHECK
            server.EnqueueResponse("0003 OK done\r\n");

            using (var response = request1.GetResponse()) {
              Assert.AreEqual(response.ResponseUri, request1.RequestUri);
            }

            server.DequeueRequest(); // CAPABILITY
            server.DequeueRequest(); // LOGIN
            StringAssert.Contains("SELECT \"INBOX\"", server.DequeueRequest()); // SELECT
            server.DequeueRequest(); // CHECK

            var request2 = WebRequest.Create(string.Format("imap://{0}@{1}/INBOX/child", credential.UserName, server.HostPort)) as ImapWebRequest;

            request2.Credentials = credential;
            request2.Timeout = 1000;
            request2.Method = "CHECK";
            request2.KeepAlive = false;

            // NOOP
            server.EnqueueResponse("0004 OK done\r\n");
            // CLOSE
            server.EnqueueResponse("0005 OK done\r\n");
            // SELECT
            server.EnqueueResponse("0006 OK [READ-WRITE] done\r\n");
            // CHECK
            server.EnqueueResponse("0007 OK done\r\n");
            // CLOSE
            server.EnqueueResponse("0008 BAD invalid argument\r\n");

            try {
              using (var response = request2.GetResponse()) {
            Assert.AreEqual(response.ResponseUri, request2.RequestUri);
              }
            }
            catch (WebException ex) {
              Assert.AreEqual(WebExceptionStatus.ProtocolError, ex);
            }

            server.DequeueRequest(); // NOOP

            StringAssert.Contains("CLOSE", server.DequeueRequest());
              }
        }

        private void TestExceptionWhileCloseSession(string test)
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var request = WebRequest.Create(string.Format("imap://{0}/", server.HostPort)) as ImapWebRequest;

            request.Timeout = 3000;
            request.ReadWriteTimeout = 3000;

            request.Method = ImapWebRequestMethods.NoOp;
            request.KeepAlive = false;

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0000 OK done\r\n");
            // LOGIN
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0001 OK done\r\n");
            // NOOP
            server.EnqueueResponse("0002 OK done\r\n");

            var asyncResult = request.BeginGetResponse(null, null);

            Thread.Sleep(500);

            server.DequeueRequest(); // CAPABILITY
            server.DequeueRequest(); // LOGIN
            StringAssert.Contains("NOOP", server.DequeueRequest());

            if (test == "not responding")
              // not respond to LOGOUT
              ;
            else if (test == "disconnected")
              server.Stop();

            using (var response = request.EndGetResponse(asyncResult) as ImapWebResponse) {
              Assert.IsTrue(response.Result.Succeeded);
            }
              }
        }

        private void SelectRequestMailboxReselect(bool readOnlyFirst)
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var credential = new NetworkCredential("user", "pass");
            var firstRequest = WebRequest.Create(string.Format("imap://{0}@{1}/INBOX", credential.UserName, server.HostPort)) as ImapWebRequest;

            firstRequest.Credentials = credential;
            firstRequest.Timeout = 1000;
            firstRequest.Method = "CHECK";
            firstRequest.KeepAlive = true;
            firstRequest.ReadOnly = readOnlyFirst;
            firstRequest.AllowInsecureLogin = true;

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0000 OK done\r\n");
            // LOGIN
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0001 OK done\r\n");
            // SELECT/EXAMINE
            if (readOnlyFirst)
              server.EnqueueResponse("0002 OK [READ-ONLY] done\r\n");
            else
              server.EnqueueResponse("0002 OK [READ-WRITE] done\r\n");
            // CHECK
            server.EnqueueResponse("0003 OK done\r\n");

            using (var response = firstRequest.GetResponse()) {
              Assert.AreEqual(response.ResponseUri, firstRequest.RequestUri);
            }

            server.DequeueRequest(); // CAPABILITY
            StringAssert.Contains("LOGIN", server.DequeueRequest());
            if (readOnlyFirst)
              StringAssert.Contains("EXAMINE \"INBOX\"", server.DequeueRequest());
            else
              StringAssert.Contains("SELECT \"INBOX\"", server.DequeueRequest());
            StringAssert.Contains("CHECK", server.DequeueRequest());

            var secondRequest = WebRequest.Create(firstRequest.RequestUri) as ImapWebRequest;

            secondRequest.Credentials = credential;
            secondRequest.Timeout = 1000;
            secondRequest.Method = "CHECK";
            secondRequest.KeepAlive = false;
            secondRequest.ReadOnly = !readOnlyFirst;

            // NOOP
            server.EnqueueResponse("0004 OK done\r\n");
            // CLOSE
            server.EnqueueResponse("0005 OK done\r\n");
            // SELECT/EXAMINE
            if (readOnlyFirst)
              server.EnqueueResponse("0006 OK [READ-WRITE] done\r\n");
            else
              server.EnqueueResponse("0006 OK [READ-ONLY] done\r\n");
            // CHECK
            server.EnqueueResponse("0007 OK done\r\n");
            // CLOSE
            server.EnqueueResponse("0008 OK done\r\n");
            // LOGOUT
            server.EnqueueResponse("* BYE logging out\r\n" +
                               "0009 OK done\r\n");

            using (var response = secondRequest.GetResponse()) {
              Assert.AreEqual(response.ResponseUri, secondRequest.RequestUri);
            }

            server.DequeueRequest(); // NOOP
            StringAssert.Contains("CLOSE", server.DequeueRequest());
            if (readOnlyFirst)
              StringAssert.Contains("SELECT \"INBOX\"", server.DequeueRequest());
            else
              StringAssert.Contains("EXAMINE \"INBOX\"", server.DequeueRequest());
            StringAssert.Contains("CHECK", server.DequeueRequest());
              }
        }

        public void TestCreateSessionSecureChannelFailureStartTlsBad()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var credential = new NetworkCredential("user", "pass");
            var request = WebRequest.Create(string.Format("imap://{0}@{1}/", credential.UserName, server.HostPort)) as ImapWebRequest;

            request.UseTlsIfAvailable = true;
            request.KeepAlive = false;
            request.Method = "NOOP";
            request.Timeout = 1000;

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY response
            server.EnqueueResponse("* CAPABILITY IMAP4rev1 STARTTLS LOGINDISABLED\r\n" +
                               "0000 OK done\r\n");
            // STARTTLS response
            server.EnqueueResponse("0001 BAD done\r\n");

            try {
              using (var response = request.GetResponse()) {
              }
            }
            catch (WebException ex) {
              WebExceptionAssertion(WebExceptionStatus.SecureChannelFailure, ex);
              Assert.IsNull(ex.InnerException);
            }
              }
        }

        public void TestGetResponseOk()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var request = WebRequest.Create(string.Format("imap://{0}/", server.HostPort)) as ImapWebRequest;

            request.Timeout = 1000;
            request.Method = "NOOP";
            request.KeepAlive = false;

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0000 OK done\r\n");
            // LOGIN
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0001 OK done\r\n");
            // NOOP
            server.EnqueueResponse("0002 OK done\r\n");
            // LOGOUT
            server.EnqueueResponse("* BYE logging out\r\n" +
                               "0003 OK done\r\n");

            using (var response = request.GetResponse()) {
              Assert.IsNotNull(response);
              Assert.IsInstanceOfType(typeof(ImapWebResponse), response);

              var r = response as ImapWebResponse;

              Assert.IsNotNull(r.Result);
            }

            server.DequeueRequest(); // CAPABILITY
            server.DequeueRequest(); // LOGIN
            StringAssert.Contains("NOOP", server.DequeueRequest());
              }
        }

        public void TestGetResponseNoWithExpectedResponseCode()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var request = WebRequest.Create(string.Format("imap://{0}/INBOX", server.HostPort)) as ImapWebRequest;

            request.Timeout = 1000;
            request.Method = "SELECT";
            request.ExpectedErrorResponseCodes = new[] {ImapResponseCode.PrivacyRequired};
            request.KeepAlive = false;

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0000 OK done\r\n");
            // LOGIN
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                               "0001 OK done\r\n");
            // SELECT
            server.EnqueueResponse("0002 NO [PRIVACYREQUIRED] failed\r\n");
            // LOGOUT
            server.EnqueueResponse("* BYE logging out\r\n" +
                               "0003 OK done\r\n");

            using (var response = request.GetResponse() as ImapWebResponse) {
              Assert.IsTrue(response.Result.Failed);
            }

            server.DequeueRequest(); // CAPABILITY
            server.DequeueRequest(); // LOGIN
            StringAssert.EndsWith("SELECT \"INBOX\"\r\n", server.DequeueRequest());
              }
        }

        public void TestGetResponseKeepAliveTrue()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            for (var req = 0; req < 3; req++) {
              /*
               * request/response
               */
              var request = WebRequest.Create(string.Format("imap://{0}/", server.HostPort)) as ImapWebRequest;

              request.Timeout = 1000;
              request.Method = "NOOP";
              request.KeepAlive = true;

              if (req == 0) {
            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                                   "0000 OK done\r\n");
            // LOGIN
            server.EnqueueResponse("* CAPABILITY IMAP4rev1\r\n" +
                                   "0001 OK done\r\n");
            // NOOP
            server.EnqueueResponse("0002 OK done\r\n");
              }
              else if (req == 1) {
            // NOOP
            server.EnqueueResponse("0003 OK done\r\n");
              }
              else if (req == 2) {
            // NOOP
            server.EnqueueResponse("0004 OK done\r\n");
              }

              using (var response = request.GetResponse()) {
              }

              if (req == 0) {
            server.DequeueRequest(); // CAPABILITY
            server.DequeueRequest(); // LOGIN
              }

              StringAssert.Contains("NOOP", server.DequeueRequest(), "request #{0}", req);
            }
              }
        }

        public void TestUsingSaslMechanismsNonEmpty()
        {
            using (var server = new ImapPseudoServer()) {
            server.Start();

            var credential = new NetworkCredential("user", "pass");
            var request = WebRequest.Create(string.Format("imap://{0}@{1}/", credential.UserName, server.HostPort)) as ImapWebRequest;

            request.UsingSaslMechanisms = new string[] {"X-UNKWNON-MECHANISM", "PLAIN", "login"};
            request.Credentials = credential;
            request.Timeout = 1000;
            request.Method = "NOOP";
            request.KeepAlive = true;
            request.AllowInsecureLogin = true;

            // greeting
            server.EnqueueResponse("* OK ready\r\n");
            // CAPABILITY
            server.EnqueueResponse("* CAPABILITY IMAP4rev1 AUTH=DIGEST-MD5 AUTH=PLAIN AUTH=NTLM AUTH=CRAM-MD5 AUTH=LOGIN\r\n" +
                               "0000 OK done\r\n");
            // AUTHENTICATE PLAIN response
            server.EnqueueResponse("+ \r\n");
            server.EnqueueResponse("0001 NO failure\r\n");
            // AUTHENTICATE LOGIN response
            server.EnqueueResponse("+ \r\n");
            server.EnqueueResponse("0002 NO failure\r\n");
            // LOGIN response
            server.EnqueueResponse("0003 NO failure\r\n");

            try {
              using (var response = request.GetResponse()) {
              }
            }
            catch (WebException ex) {
              Assert.AreEqual(WebExceptionStatus.ProtocolError, ex.Status);
            }

            server.DequeueRequest(); // CAPABILITY
            StringAssert.Contains("AUTHENTICATE PLAIN", server.DequeueRequest());
            server.DequeueRequest(); // AUTHENTICATE PLAIN client response
            StringAssert.Contains("AUTHENTICATE LOGIN", server.DequeueRequest());
              }
        }