public void CallApiAsync_ShouldPassExceptionToOnError_IfThereAreResponseErrors() { var mockFactory = new Mock <IRestClientFactory>(MockBehavior.Strict); var mockRestClient = new Mock <IRestClient>(MockBehavior.Strict); var mockProcessor = new Mock <IResponseProcessor>(MockBehavior.Strict); var response = new RestResponse <object>(); var expectedException = new GitHubException(new GitHubResponse(response), ErrorType.NoNetwork); mockFactory.Setup <IRestClient>(f => f.CreateRestClient(It.IsAny <string>())).Returns(mockRestClient.Object); mockRestClient .Setup(c => c.ExecuteAsync <object>(It.IsAny <IRestRequest>(), It.IsAny <Action <IRestResponse <object>, RestRequestAsyncHandle> >())) .Returns(_testHandle) .Callback <IRestRequest, Action <IRestResponse <object>, RestRequestAsyncHandle> >((r, c) => c(response, _testHandle)); mockRestClient.SetupSet(c => c.Authenticator = It.IsAny <IAuthenticator>()); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny <IGitHubResponse>(), out expectedException)) .Returns(true); var client = CreateClient(mockFactory.Object, mockProcessor.Object); GitHubException actualException = null; client.CallApiAsync <object>(new GitHubRequest("foo", API.v3, NGitHub.Web.Method.GET), o => { }, e => actualException = e); Assert.AreEqual(expectedException, actualException); }
public bool TryProcessResponseErrors(IGitHubResponse response, out GitHubException exception) { Requires.ArgumentNotNull(response, "response"); if (response.StatusCode == HttpStatusCode.OK || response.StatusCode == HttpStatusCode.Created || response.StatusCode == HttpStatusCode.Accepted) { exception = null; return false; } var errorType = ErrorType.Unknown; if (response.ResponseStatus == ResponseStatus.Error) { errorType = ErrorType.NoNetwork; } else if (response.StatusCode == HttpStatusCode.BadGateway) { errorType = ErrorType.ServerError; } else if (response.StatusCode == HttpStatusCode.Forbidden) { errorType = ErrorType.ApiLimitExceeded; } else if (response.StatusCode == HttpStatusCode.NotFound) { errorType = ErrorType.ResourceNotFound; } else if (response.StatusCode == HttpStatusCode.Unauthorized) { errorType = ErrorType.Unauthorized; } // TODO: Other error types exception = new GitHubException(response, errorType); return true; }
public void CallApiAsync_ShouldCallOnError_IfRestRequestDoesNotCompleteSuccessfully() { var mockFactory = new Mock<IRestClientFactory>(MockBehavior.Strict); var mockRestClient = new Mock<IRestClient>(MockBehavior.Strict); var mockProcessor = new Mock<IResponseProcessor>(MockBehavior.Strict); var response = new RestResponse<object>(); var exception = new GitHubException(new GitHubResponse(response), ErrorType.NoNetwork); mockFactory.Setup<IRestClient>(f => f.CreateRestClient(It.IsAny<string>())).Returns(mockRestClient.Object); mockRestClient .Setup(c => c.ExecuteAsync<object>(It.IsAny<IRestRequest>(), It.IsAny<Action<RestResponse<object>, RestRequestAsyncHandle>>())) .Returns(_testHandle) .Callback<IRestRequest, Action<RestResponse<object>, RestRequestAsyncHandle>>((r, c) => c(response, _testHandle)); mockRestClient.SetupSet(c => c.Authenticator = It.IsAny<IAuthenticator>()); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny<IGitHubResponse>(), out exception)) .Returns(true); var client = CreateClient(mockFactory.Object, mockProcessor.Object); var onErrorInvoked = false; client.CallApiAsync<object>(new GitHubRequest("foo", API.v3, NGitHub.Web.Method.GET), o => { }, e => onErrorInvoked = true); Assert.IsTrue(onErrorInvoked); }
public void IsPullRequestMergedAsync_ShouldCallbackWithError_WhenResponseIsSomeRandomError() { var mockResponse = new Mock <IGitHubResponse <object> >(MockBehavior.Strict); var mockClient = new Mock <IGitHubClient>(MockBehavior.Strict); mockResponse.Setup(r => r.ErrorException) .Returns(new Exception()); mockResponse.Setup(r => r.StatusCode) .Returns(HttpStatusCode.Forbidden); var expectedException = new GitHubException(mockResponse.Object, ErrorType.Unauthorized); mockClient.Setup(c => c.CallApiAsync <object>(It.IsAny <GitHubRequest>(), It.IsAny <Action <IGitHubResponse <object> > >(), It.IsAny <Action <GitHubException> >())) .Callback <GitHubRequest, Action <IGitHubResponse <object> >, Action <GitHubException> >((req, c, e) => { e(expectedException); }) .Returns(TestHelpers.CreateTestHandle()); var pullReqSvc = new PullRequestService(mockClient.Object); GitHubException actualException = null; pullReqSvc.IsPullRequestMergedAsync("akilb", "ngithub", 1, c => { }, e => actualException = e); Assert.AreSame(expectedException, actualException); }
public void GetAccessTokenAsync_ShouldCallCallback_IfRequestSucceeds() { var callbackCalled = false; var responseContent = "access_token=something"; GitHubException ex = null; var mockClient = new Mock <IRestClient>(MockBehavior.Strict); var mockProcessor = new Mock <IResponseProcessor>(MockBehavior.Strict); var mockFactory = new Mock <IRestClientFactory>(MockBehavior.Strict); mockFactory.Setup(f => f.CreateRestClient(It.IsAny <string>())) .Returns(mockClient.Object); mockClient.Setup(c => c.ExecuteAsync(It.IsAny <RestRequest>(), It.IsAny <Action <IRestResponse, RestRequestAsyncHandle> >())) .Returns(_testHandle) .Callback <RestRequest, Action <IRestResponse, RestRequestAsyncHandle> >( (req, c) => c(new RestResponse { Content = responseContent }, _testHandle)); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny <GitHubResponse>(), out ex)) .Returns(false); var auth = CreateAuthorizer(mockFactory.Object, mockProcessor.Object); auth.GetAccessTokenAsync("foo", "bar", "baz", t => callbackCalled = true, e => { }); Assert.IsTrue(callbackCalled); }
public void IsPullRequestMergedAsync_ShouldCallbackWithError_WhenResponseIsSomeRandomError() { var mockResponse = new Mock<IGitHubResponse<object>>(MockBehavior.Strict); var mockClient = new Mock<IGitHubClient>(MockBehavior.Strict); mockResponse.Setup(r => r.ErrorException) .Returns(new Exception()); mockResponse.Setup(r => r.StatusCode) .Returns(HttpStatusCode.Forbidden); var expectedException = new GitHubException(mockResponse.Object, ErrorType.Unauthorized); mockClient.Setup(c => c.CallApiAsync<object>(It.IsAny<GitHubRequest>(), It.IsAny<Action<IGitHubResponse<object>>>(), It.IsAny<Action<GitHubException>>())) .Callback<GitHubRequest, Action<IGitHubResponse<object>>, Action<GitHubException>>((req, c, e) => { e(expectedException); }) .Returns(TestHelpers.CreateTestHandle()); var pullReqSvc = new PullRequestService(mockClient.Object); GitHubException actualException = null; pullReqSvc.IsPullRequestMergedAsync("akilb", "ngithub", 1, c => { }, e => actualException = e); Assert.AreSame(expectedException, actualException); }
public void CallApiAsync_ShouldCallOnError_IfRestRequestDoesNotCompleteSuccessfully() { var mockFactory = new Mock <IRestClientFactory>(MockBehavior.Strict); var mockRestClient = new Mock <IRestClient>(MockBehavior.Strict); var mockProcessor = new Mock <IResponseProcessor>(MockBehavior.Strict); var response = new RestResponse <object>(); var exception = new GitHubException(new GitHubResponse(response), ErrorType.NoNetwork); mockFactory.Setup <IRestClient>(f => f.CreateRestClient(It.IsAny <string>())).Returns(mockRestClient.Object); mockRestClient .Setup(c => c.ExecuteAsync <object>(It.IsAny <IRestRequest>(), It.IsAny <Action <IRestResponse <object>, RestRequestAsyncHandle> >())) .Returns(_testHandle) .Callback <IRestRequest, Action <IRestResponse <object>, RestRequestAsyncHandle> >((r, c) => c(response, _testHandle)); mockRestClient.SetupSet(c => c.Authenticator = It.IsAny <IAuthenticator>()); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny <IGitHubResponse>(), out exception)) .Returns(true); var client = CreateClient(mockFactory.Object, mockProcessor.Object); var onErrorInvoked = false; client.CallApiAsync <object>(new GitHubRequest("foo", API.v3, NGitHub.Web.Method.GET), o => { }, e => onErrorInvoked = true); Assert.IsTrue(onErrorInvoked); }
public void GetAccessTokenAsync_ShouldPassAccessTokenToCallback_IfRequestSucceeds() { var expectedToken = "token"; var responseContent = string.Format("access_token={0}&other_stuff=some%20crap", expectedToken); GitHubException ex = null; var mockClient = new Mock <IRestClient>(MockBehavior.Strict); var mockProcessor = new Mock <IResponseProcessor>(MockBehavior.Strict); var mockFactory = new Mock <IRestClientFactory>(MockBehavior.Strict); mockFactory.Setup(f => f.CreateRestClient(It.IsAny <string>())) .Returns(mockClient.Object); mockClient.Setup(c => c.ExecuteAsync(It.IsAny <RestRequest>(), It.IsAny <Action <IRestResponse, RestRequestAsyncHandle> >())) .Returns(_testHandle) .Callback <RestRequest, Action <IRestResponse, RestRequestAsyncHandle> >( (req, c) => c(new RestResponse { Content = responseContent }, _testHandle)); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny <GitHubResponse>(), out ex)) .Returns(false); var auth = CreateAuthorizer(mockFactory.Object, mockProcessor.Object); string actualToken = null; auth.GetAccessTokenAsync("foo", "bar", "baz", t => actualToken = t, e => { }); Assert.AreEqual(expectedToken, actualToken); }
public void Response_ShouldBeTheGivenResponse() { var mockResponse = new Mock<IGitHubResponse>(MockBehavior.Strict); mockResponse.Setup(r => r.ErrorException).Returns<Exception>(null); IGitHubResponse expectedResponse = mockResponse.Object; var ex = new GitHubException(expectedResponse, ErrorType.Unknown); Assert.AreSame(expectedResponse, ex.Response); }
public void ErrorType_ShouldBeTheGivenErrorType() { ErrorType expectedErrorType = ErrorType.ServerError; var mockResponse = new Mock<IGitHubResponse>(MockBehavior.Strict); mockResponse.Setup(r => r.ErrorException).Returns<Exception>(null); var ex = new GitHubException(mockResponse.Object, expectedErrorType); Assert.AreEqual(expectedErrorType, ex.ErrorType); }
public void InnerException_ShouldBeTheErrorExceptionOfTheResponse() { var expectedInnerException = new Exception(); var mockResponse = new Mock<IGitHubResponse>(MockBehavior.Strict); mockResponse.Setup(e => e.ErrorException) .Returns(expectedInnerException); var ex = new GitHubException(mockResponse.Object, ErrorType.Unknown); Assert.AreSame(expectedInnerException, ex.InnerException); }
public void Response_ShouldBeTheGivenResponse() { var mockResponse = new Mock <IGitHubResponse>(MockBehavior.Strict); mockResponse.Setup(r => r.ErrorException).Returns <Exception>(null); var expectedResponse = mockResponse.Object; var ex = new GitHubException(expectedResponse, ErrorType.Unknown); Assert.AreSame(expectedResponse, ex.Response); }
public void ErrorType_ShouldBeTheGivenErrorType() { var expectedErrorType = ErrorType.ServerError; var mockResponse = new Mock <IGitHubResponse>(MockBehavior.Strict); mockResponse.Setup(r => r.ErrorException).Returns <Exception>(null); var ex = new GitHubException(mockResponse.Object, expectedErrorType); Assert.AreEqual <ErrorType>(expectedErrorType, ex.ErrorType); }
public void InnerException_ShouldBeTheErrorExceptionOfTheResponse() { var expectedInnerException = new Exception(); var mockResponse = new Mock <IGitHubResponse>(MockBehavior.Strict); mockResponse.Setup(e => e.ErrorException) .Returns(expectedInnerException); var ex = new GitHubException(mockResponse.Object, ErrorType.Unknown); Assert.AreSame(expectedInnerException, ex.InnerException); }
public void TryProcessError_ShouldReturnFalse_IfResponseStatusCodeIsCreated() { var mockResp = new Mock <IGitHubResponse>(MockBehavior.Strict); mockResp.Setup(r => r.StatusCode) .Returns(HttpStatusCode.Created); var processor = new ResponseProcessor(); GitHubException ex = null; Assert.IsFalse(processor.TryProcessResponseErrors(mockResp.Object, out ex)); }
public void TryProcessError_ShouldReturnTrue_IfResponseStatusCodeIsNotOKOrCreated() { var mockResp = new Mock <IGitHubResponse>(MockBehavior.Strict); mockResp.Setup(r => r.StatusCode).Returns(HttpStatusCode.Forbidden); mockResp.Setup(r => r.ErrorException).Returns <Exception>(null); mockResp.Setup(r => r.ResponseStatus).Returns(ResponseStatus.Completed); var processor = new ResponseProcessor(); GitHubException ex = null; Assert.IsTrue(processor.TryProcessResponseErrors(mockResp.Object, out ex)); }
public void TryProcessError_ShouldReturnException_WithNoNetworkErrorType_IfResponseStatusIsError() { var mockResp = new Mock <IGitHubResponse>(MockBehavior.Strict); mockResp.Setup(r => r.StatusCode).Returns(HttpStatusCode.RequestTimeout); mockResp.Setup(r => r.ErrorException).Returns <Exception>(null); mockResp.Setup(r => r.ResponseStatus).Returns(ResponseStatus.Error); var processor = new ResponseProcessor(); GitHubException ex = null; processor.TryProcessResponseErrors(mockResp.Object, out ex); Assert.AreEqual(ErrorType.NoNetwork, ex.ErrorType); }
public void TryProcessError_ShouldReturnException_WithNotFoundErrorType_IfResponseStatusCodeIsNotFound() { var mockResp = new Mock <IGitHubResponse>(MockBehavior.Strict); mockResp.Setup(r => r.StatusCode).Returns(HttpStatusCode.NotFound); mockResp.Setup(r => r.ErrorException).Returns <Exception>(null); mockResp.Setup(r => r.ResponseStatus).Returns(ResponseStatus.Completed); var processor = new ResponseProcessor(); GitHubException ex = null; processor.TryProcessResponseErrors(mockResp.Object, out ex); Assert.AreEqual(ErrorType.ResourceNotFound, ex.ErrorType); }
private GitHubClient CreateClient(IRestClientFactory factory = null, IResponseProcessor processor = null) { if (processor == null) { GitHubException ex = null; var mockProcessor = new Mock <IResponseProcessor>(MockBehavior.Strict); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny <IGitHubResponse>(), out ex)) .Returns(false); processor = mockProcessor.Object; } return(new GitHubClient(factory ?? new Mock <IRestClientFactory>(MockBehavior.Strict).Object, processor)); }
public void GetAccessTokenAsync(string clientId, string clientSecret, string code, Action <string> callback, Action <GitHubException> onError) { Requires.ArgumentNotNull(clientId, "clientId"); Requires.ArgumentNotNull(clientSecret, "clientSecret"); Requires.ArgumentNotNull(code, "code"); Requires.ArgumentNotNull(callback, "callback"); Requires.ArgumentNotNull(onError, "onError"); var request = new RestRequest { Resource = "/access_token", Method = Method.POST }; request.AddParameter("client_id", clientId); request.AddParameter("client_secret", clientSecret); request.AddParameter("code", code); var client = _factory.CreateRestClient(Constants.AuthorizeUrl); client.ExecuteAsync( request, (r, h) => { var response = new GitHubResponse(r); GitHubException ex = null; if (_processor.TryProcessResponseErrors(response, out ex)) { onError(ex); return; } var parameters = response.Content.Split('&'); var accessToken = parameters.Where(p => p.StartsWith("access_token=")) .Select(p => p.Substring(("access_token=").Length)) .FirstOrDefault(); Debug.Assert(accessToken != null, ""); callback(accessToken); }); }
public bool TryProcessResponseErrors(IGitHubResponse response, out GitHubException exception) { Requires.ArgumentNotNull(response, "response"); if (response.StatusCode == HttpStatusCode.OK || response.StatusCode == HttpStatusCode.Created || response.StatusCode == HttpStatusCode.Accepted) { exception = null; return(false); } var errorType = ErrorType.Unknown; if (response.ResponseStatus == ResponseStatus.Error) { errorType = ErrorType.NoNetwork; } else if (response.StatusCode == HttpStatusCode.BadGateway) { errorType = ErrorType.ServerError; } else if (response.StatusCode == HttpStatusCode.Forbidden) { errorType = ErrorType.ApiLimitExceeded; } else if (response.StatusCode == HttpStatusCode.NotFound) { errorType = ErrorType.ResourceNotFound; } else if (response.StatusCode == HttpStatusCode.Unauthorized) { errorType = ErrorType.Unauthorized; } // TODO: Other error types exception = new GitHubException(response, errorType); return(true); }
public void GetAccessTokenAsync_ShouldPassExpectedError_IfRequestFails() { GitHubException expectedException = new GitHubException(new GitHubResponse(new RestResponse()), ErrorType.Unknown); var mockClient = new Mock <IRestClient>(MockBehavior.Strict); var mockProcessor = new Mock <IResponseProcessor>(MockBehavior.Strict); var mockFactory = new Mock <IRestClientFactory>(MockBehavior.Strict); mockFactory.Setup(f => f.CreateRestClient(It.IsAny <string>())) .Returns(mockClient.Object); mockClient.Setup(c => c.ExecuteAsync(It.IsAny <RestRequest>(), It.IsAny <Action <IRestResponse, RestRequestAsyncHandle> >())) .Returns(_testHandle) .Callback <RestRequest, Action <IRestResponse, RestRequestAsyncHandle> >((req, c) => c(new RestResponse(), _testHandle)); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny <GitHubResponse>(), out expectedException)) .Returns(true); var auth = CreateAuthorizer(mockFactory.Object, mockProcessor.Object); GitHubException actualException = null; auth.GetAccessTokenAsync("foo", "bar", "baz", s => { }, e => actualException = e); Assert.AreSame(expectedException, actualException); }
public void GetAccessTokenAsync_ShouldCallOnError_IfRequestFails() { bool onErrorCalled = false; GitHubException ex = null; var mockClient = new Mock <IRestClient>(MockBehavior.Strict); var mockProcessor = new Mock <IResponseProcessor>(MockBehavior.Strict); var mockFactory = new Mock <IRestClientFactory>(MockBehavior.Strict); mockFactory.Setup(f => f.CreateRestClient(It.IsAny <string>())) .Returns(mockClient.Object); mockClient.Setup(c => c.ExecuteAsync(It.IsAny <RestRequest>(), It.IsAny <Action <IRestResponse, RestRequestAsyncHandle> >())) .Returns(_testHandle) .Callback <RestRequest, Action <IRestResponse, RestRequestAsyncHandle> >( (req, c) => c(new RestResponse(), _testHandle)); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny <GitHubResponse>(), out ex)) .Returns(true); var auth = CreateAuthorizer(mockFactory.Object, mockProcessor.Object); auth.GetAccessTokenAsync("foo", "bar", "baz", s => { }, e => onErrorCalled = true); Assert.IsTrue(onErrorCalled); }
private void LogError(GitHubException obj) { }
public void CallApiAsync_ShouldPassExceptionToOnError_IfThereAreResponseErrors() { var mockFactory = new Mock<IRestClientFactory>(MockBehavior.Strict); var mockRestClient = new Mock<IRestClient>(MockBehavior.Strict); var mockProcessor = new Mock<IResponseProcessor>(MockBehavior.Strict); var response = new RestResponse<object>(); var expectedException = new GitHubException(new GitHubResponse(response), ErrorType.NoNetwork); mockFactory.Setup<IRestClient>(f => f.CreateRestClient(It.IsAny<string>())).Returns(mockRestClient.Object); mockRestClient .Setup(c => c.ExecuteAsync<object>(It.IsAny<IRestRequest>(), It.IsAny<Action<RestResponse<object>, RestRequestAsyncHandle>>())) .Returns(_testHandle) .Callback<IRestRequest, Action<RestResponse<object>, RestRequestAsyncHandle>>((r, c) => c(response, _testHandle)); mockRestClient.SetupSet(c => c.Authenticator = It.IsAny<IAuthenticator>()); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny<IGitHubResponse>(), out expectedException)) .Returns(true); var client = CreateClient(mockFactory.Object, mockProcessor.Object); GitHubException actualException = null; client.CallApiAsync<object>(new GitHubRequest("foo", API.v3, NGitHub.Web.Method.GET), o => { }, e => actualException = e); Assert.AreEqual(expectedException, actualException); }
public void GetAccessTokenAsync_ShouldPassExpectedError_IfRequestFails() { var expectedException = new GitHubException(new GitHubResponse(new RestResponse()), ErrorType.Unknown); var mockClient = new Mock<IRestClient>(MockBehavior.Strict); var mockProcessor = new Mock<IResponseProcessor>(MockBehavior.Strict); var mockFactory = new Mock<IRestClientFactory>(MockBehavior.Strict); mockFactory.Setup(f => f.CreateRestClient(It.IsAny<string>())) .Returns(mockClient.Object); mockClient.Setup(c => c.ExecuteAsync(It.IsAny<IRestRequest>(), It.IsAny<Action<IRestResponse, RestRequestAsyncHandle>>())) .Returns(_testHandle) .Callback<RestRequest, Action<RestResponse, RestRequestAsyncHandle>>( (req, c) => c(new RestResponse(), _testHandle)); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny<GitHubResponse>(), out expectedException)) .Returns(true); GitHubOAuthAuthorizer auth = CreateAuthorizer(mockFactory.Object, mockProcessor.Object); GitHubException actualException = null; auth.GetAccessTokenAsync("foo", "bar", "baz", s => { }, e => actualException = e); Assert.AreSame(expectedException, actualException); }