C# ImapPseudoServer.DequeueRequest方法代码示例

        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 TestGetCopyResponseCopyUidResponseExists()
        {
            using (var server = new ImapPseudoServer()) {
            var methodResponses = new[] {
              // UID SEARCH
              "* SEARCH 3 4 5\r\n" +
              "0003 OK done\r\n",
              // UID COPY
              "0004 OK [COPYUID 38505 3,4,5 3956:3958] done\r\n"
            };

            var presetRequest = (Action<ImapWebRequest>)delegate(ImapWebRequest req) {
              req.AllowCreateMailbox = false;
              req.DestinationUri = new Uri(req.RequestUri.GetLeftPart(UriPartial.Path) + "/コピー先メールボックス");
            };

            Request(server, ImapWebRequestMethods.Copy, new[] {"IMAP4rev1"}, "?UNSEEN", methodResponses, presetRequest, delegate(ImapWebRequest request, ImapWebResponse response) {
              Assert.AreEqual(new Uri(string.Format("{0}/INBOX/コピー先メールボックス;UIDVALIDITY=38505?UID 3956:3958", request.RequestUri.GetLeftPart(UriPartial.Authority))),
                response.ResponseUri);

              Assert.IsNotNull(response);
              Assert.IsNotNull(response.Result);
              Assert.IsTrue(response.Result.Succeeded);

              Assert.IsNotNull(response.Mailboxes);
              Assert.AreEqual(0, response.Mailboxes.Length);
            });

            StringAssert.EndsWith("UID SEARCH UNSEEN\r\n", server.DequeueRequest());
            StringAssert.EndsWith("UID COPY 3,4,5 \"INBOX/&MLMw1DD8UUgw4TD8MOsw3DDDMK8wuQ-\"\r\n", 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 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 TestGetCopyResponseCreateDestinationMailboxFailure()
        {
            using (var server = new ImapPseudoServer()) {
            var methodResponses = new[] {
              // UID COPY
              "0003 NO [TRYCREATE] failed\r\n",
              // CREATE
              "0004 NO failed\r\n",
            };

            var presetRequest = (Action<ImapWebRequest>)delegate(ImapWebRequest req) {
              req.AllowCreateMailbox = true;
              req.DestinationUri = new Uri(req.RequestUri.GetLeftPart(UriPartial.Path) + "/../コピー先メールボックス");
            };

            Request(server, ImapWebRequestMethods.Copy, methodResponses, presetRequest, delegate(ImapWebRequest request, ImapWebResponse response) {
              Assert.AreEqual(request.RequestUri, response.ResponseUri);

              Assert.IsNotNull(response);
              Assert.IsNotNull(response.Result);
              Assert.IsTrue(response.Result.Failed);
            });

            StringAssert.EndsWith("UID COPY 1 \"INBOX/&MLMw1DD8UUgw4TD8MOsw3DDDMK8wuQ-\"\r\n", server.DequeueRequest());
            StringAssert.EndsWith("CREATE \"INBOX/&MLMw1DD8UUgw4TD8MOsw3DDDMK8wuQ-\"\r\n", 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 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 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 TestGetResponseKeepAliveFalse()
        {
            using (var server = new ImapPseudoServer()) {
            for (var req = 0; req < 3; req++) {
              server.Start();

              /*
               * request/response
               */
              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()) {
              }

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

              server.Stop();
            }
              }
        }

        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());
              }
        }

        public void TestMethodNoOp()
        {
            using (var server = new ImapPseudoServer()) {
            var methodResponse = "0002 OK done\r\n";

            Request(server, ImapWebRequestMethods.NoOp, methodResponse, delegate(ImapWebRequest request, ImapWebResponse response) {
              Assert.IsNotNull(response);

              Assert.AreEqual(response.ResponseUri, request.RequestUri);

              Assert.IsNotNull(response.Result);
              Assert.IsTrue(response.Result.Succeeded);
            });

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

        public void TestGetXListResponse()
        {
            using (var server = new ImapPseudoServer()) {
            var methodResponse = "* XLIST (\\HasNoChildren \\Starred) \"/\" \"[Gmail]/&MLkwvzD8TtgwTQ-\"\r\n" +
                             "0002 OK done\r\n";

            Request(server, ImapWebRequestMethods.XList, new[] {"IMAP4rev1", "XLIST"}, methodResponse, delegate(ImapWebRequest request, ImapWebResponse response) {
              Assert.IsNotNull(response);

              Assert.AreEqual(response.ResponseUri, request.RequestUri);

              Assert.IsNotNull(response.Result);
              Assert.IsTrue(response.Result.Succeeded);

              Assert.IsNotNull(response.Mailboxes);
              Assert.AreEqual(1, response.Mailboxes.Length);

              Assert.AreEqual(new Uri(request.RequestUri, "[Gmail]/スター付き"), response.Mailboxes[0].Url);
            });

            StringAssert.Contains("XLIST \"\" *", 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);
            }
              }
        }

        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 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());
              }
        }