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