public void ThrowsOnIncorrectType(object responseData, Type targetType)
{
var converter = new ResponseConverter();
var response = new RemoteResponse(responseData);
Assert.Throws <InvalidCastException>(() => converter.Convert(response, targetType));
}
public async void ExceptionWrapped()
{
Exception ex = null;
try
{
throw new NotImplementedException();
}
catch (Exception e)
{
ex = e;
}
var converter = new ResponseConverter();
var response = new RemoteResponse(ex);
object result = converter.Convert(response, typeof(int));
var castedResult = result.ShouldBeAssignableTo <Task <int> >();
castedResult.IsFaulted.ShouldBe(true);
castedResult.Exception.ShouldNotBeNull();
var targetInvocationException = castedResult.Exception.InnerExceptions.First().ShouldBeAssignableTo <TargetInvocationException>();
targetInvocationException.GetBaseException().ShouldBeAssignableTo <NotImplementedException>();
await Assert.ThrowsAsync <TargetInvocationException>(() => castedResult);
}
public void TaskOfExpectedTypeReturned(object responseData, Type targetType)
{
var converter = new ResponseConverter();
var response = new RemoteResponse(responseData);
object result = converter.Convert(response, targetType);
result.ShouldBeAssignableTo(typeof(Task <>).MakeGenericType(targetType));
}
public void ResponseConverterShouldHandleStartDiscoveryStatus()
{
var status = MobileConnectStatus.StartDiscovery();
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("discovery", actual.Action);
}
public void ResponseConverterShouldHandleOperatorSelectionStatus()
{
var status = MobileConnectStatus.OperatorSelection(OPERATOR_SELECTION_URL);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("operator_selection", actual.Action);
Assert.AreEqual(OPERATOR_SELECTION_URL, actual.Url);
}
public void ResponseConverterShouldHandleTokenRevokedStatus()
{
var response = new RevokeTokenResponse(_responses["token-revoked"]);
var status = MobileConnectStatus.TokenRevoked(response);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("token_revoked", actual.Action);
}
public void ResponseConverterShouldHandleCompleteStatus()
{
var response = new RequestTokenResponse(_responses["token"]);
var status = MobileConnectStatus.Complete(response);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("complete", actual.Action);
Assert.AreEqual(status.TokenResponse.ResponseData, actual.Token);
}
public void ResponseConverterShouldHandleErrorStatus()
{
var error = "this is the error";
var description = "this is the description";
var status = MobileConnectStatus.Error(error, description, null);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("failure", actual.Status);
Assert.AreEqual("error", actual.Action);
Assert.AreEqual(error, actual.Error);
Assert.AreEqual(description, actual.Description);
}
private IHttpActionResult CreateResponse(MobileConnectStatus status)
{
var response = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(status));
if (status.SetCookie != null)
{
foreach (var cookie in status.SetCookie)
{
response.Headers.Add("Set-Cookie", cookie);
}
}
return(new ResponseMessageResult(response));
}
public void ResponseConverterShouldHandleAuthenticationStatus()
{
var state = "qpwoeirurytalsksjdhdgf";
var nonce = "qpwowieuryrttalksjsggdfj";
var status = MobileConnectStatus.Authentication(AUTHORIZE_URL, state, nonce);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("authentication", actual.Action);
Assert.AreEqual(AUTHORIZE_URL, actual.Url);
Assert.AreEqual(state, actual.State);
Assert.AreEqual(nonce, actual.Nonce);
}
public void ResponseConverterShouldHandleStartAuthenticationStatus()
{
var session = "session";
var response = new DiscoveryResponse(_responses["authentication"]);
var status = MobileConnectStatus.StartAuthentication(response);
status.SDKSession = session;
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("start_authentication", actual.Action);
Assert.IsNotNull(actual.SdkSession);
Assert.IsNotNull(actual.SubscriberId);
}
protected IHttpActionResult CreateResponse(MobileConnectStatus status)
{
HttpResponseMessage response;
if (!string.IsNullOrEmpty(status.ErrorCode))
{
response = Request.CreateResponse(HttpStatusCode.Found, ResponseConverter.Convert(status));
}
else
{
response = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(status));
}
if (status.SetCookie != null)
{
foreach (var cookie in status.SetCookie)
{
response.Headers.Add("Set-Cookie", cookie);
}
}
return(new ResponseMessageResult(response));
}
protected IHttpActionResult CreateIdentityResponse(MobileConnectStatus authnStatus, MobileConnectStatus identityUserInfoStatustatus = null)
{
var authnResponse = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(authnStatus));
if (identityUserInfoStatustatus != null)
{
var response = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(identityUserInfoStatustatus));
authnResponse.Content = new StringContent(СreateNewHttpResponseMessage(authnResponse, response));
if (identityUserInfoStatustatus.SetCookie != null)
{
foreach (var cookie in identityUserInfoStatustatus.SetCookie)
{
authnResponse.Headers.Add("Set-Cookie", cookie);
}
}
}
else
{
authnResponse.Content = new StringContent(СreateNewHttpResponseMessage(authnResponse));
}
return(new ResponseMessageResult(authnResponse));
}
public async void Initialize()
{
jsonResponse = await dataFetcher.GetThings();
convertedResponse = await Task.Run(() => responseConverter.Convert(jsonResponse)).ConfigureAwait(false);
}
