public void WhenLoadedFromCookie()
{
// Arrange
IServiceLocator serviceLocator = Substitute.For <IServiceLocator>();
// mock configuration
MockConfiguration(serviceLocator);
// mock request
HttpContextBase httpContext = Substitute.For <HttpContextBase>();
var requestWrapper = MockHttpRequestWithCookie();
httpContext.Request.Returns(requestWrapper);
// mock cookie data manager to send dummy webconnection info
var webConnectionInfo = MockCookieDataManager(serviceLocator);
IWebConnectionInfoProvider webConnectionInfoProvider = new WebConnectionInfoProvider(serviceLocator);
// Act
WebConnectionInfo result = webConnectionInfoProvider.TryLoad(httpContext);
// Assert
Assert.AreEqual(webConnectionInfo.UserAuthToken, result.UserAuthToken);
}
public async Task <WebConnectionInfo> CreateWebConnectionInfoAsync(string token, string instanceId)
{
IServiceInstanceProvider serviceInstanceProvider = _serviceLocator.GetInstance <IServiceInstanceProvider>();
HealthServiceInstance serviceInstance = await serviceInstanceProvider.GetHealthServiceInstanceAsync(instanceId);
IWebHealthVaultConnection connection = Ioc.Container.Locate <IWebHealthVaultConnection>(
extraData:
new
{
serviceLocator = _serviceLocator
});
WebHealthVaultConnection webHealthVaultConnection = connection as WebHealthVaultConnection;
webHealthVaultConnection.ServiceInstance = serviceInstance;
webHealthVaultConnection.UserAuthToken = token;
IPersonClient personClient = webHealthVaultConnection.CreatePersonClient();
var personInfo = await personClient.GetPersonInfoAsync();
WebConnectionInfo webConnectionInfo = new WebConnectionInfo
{
PersonInfo = personInfo,
ServiceInstanceId = instanceId,
SessionCredential = webHealthVaultConnection.SessionCredential,
UserAuthToken = token
};
return(webConnectionInfo);
}
public async Task WhenTokenAndInstanceId()
{
// Arrange
IServiceLocator serviceLocator = Substitute.For <IServiceLocator>();
WebHealthVaultConfiguration webHealthVaultConfiguration = Substitute.For <WebHealthVaultConfiguration>();
ICookieDataManager cookieDataManager = Substitute.For <ICookieDataManager>();
serviceLocator.GetInstance <WebHealthVaultConfiguration>().Returns(webHealthVaultConfiguration);
serviceLocator.GetInstance <ICookieDataManager>().Returns(cookieDataManager);
WebHealthVaultConnection webHealthVaultConnection = Substitute.For <WebHealthVaultConnection>(serviceLocator);
Ioc.Container.Configure(c => c.ExportInstance(webHealthVaultConnection).As <IWebHealthVaultConnection>());
IPersonClient mockedPersonClient = Substitute.For <IPersonClient>();
mockedPersonClient.GetPersonInfoAsync().Returns(Task.FromResult(new PersonInfo()));
Ioc.Container.Configure(c => c.ExportInstance(mockedPersonClient).As <IPersonClient>());
// Act
IWebConnectionInfoProvider webConnectionInfoProvider = new WebConnectionInfoProvider(serviceLocator);
WebConnectionInfo webConnectionInfo = await webConnectionInfoProvider.CreateWebConnectionInfoAsync("someToken", "1");
// Assert
Assert.AreEqual("someToken", webConnectionInfo.UserAuthToken);
}
private WebConnectionInfo CreateWebConnectionInfo(
bool minimizedPersonInfoRecords = false,
bool minimizedApplicationSettings = false)
{
var webConnectionInfo = new WebConnectionInfo
{
MinimizedPersonInfoRecords = minimizedPersonInfoRecords,
MinimizedPersonInfoApplicationSettings = minimizedApplicationSettings,
PersonInfo = new PersonInfo
{
Name = "Test",
AuthorizedRecords = new Dictionary <Guid, HealthRecordInfo> {
{ Guid.NewGuid(), new HealthRecordInfo() }
}
},
ServiceInstanceId = "1",
SessionCredential = new SessionCredential(),
UserAuthToken = "someToken"
};
HttpContext.Current = new HttpContext(
new HttpRequest("", "http://www.bing.com", ""),
new HttpResponse(new StringWriter()));
HttpContext.Current.User = new GenericPrincipal(
new HealthVaultIdentity {
WebConnectionInfo = webConnectionInfo
},
null);
return(webConnectionInfo);
}
/// <summary>
/// Minimizes Application settings from the person info
/// </summary>
/// <param name="webConnectionInfo">WebConnectionInfo</param>
public static void MinimizePersonInfoApplicationSettings(this WebConnectionInfo webConnectionInfo)
{
var personInfo = webConnectionInfo.PersonInfo;
if (personInfo.ApplicationSettingsDocument != null)
{
personInfo.ApplicationSettingsDocument = null;
webConnectionInfo.MinimizedPersonInfoApplicationSettings = true;
}
}
public async Task WhenUserIdentityHasWebConnectionInfo()
{
// Arrange
var webConnectionInfo = new WebConnectionInfo
{
ServiceInstanceId = "1",
PersonInfo = new PersonInfo(),
SessionCredential = new SessionCredential(),
UserAuthToken = "some"
};
// Mock HealthVaultIdentityProvider
IHealthVaultIdentityProvider healthVaultIdentityProvider = Substitute.For <IHealthVaultIdentityProvider>();
healthVaultIdentityProvider.TryGetIdentity().Returns(new HealthVaultIdentity
{
WebConnectionInfo = webConnectionInfo
});
Ioc.Container.Configure(c => c.ExportInstance(healthVaultIdentityProvider).As <IHealthVaultIdentityProvider>());
// Mock HealthVaultConnection
WebHealthVaultConfiguration webHealthVaultConfiguration = new WebHealthVaultConfiguration();
webHealthVaultConfiguration.DefaultHealthVaultUrl = new Uri("http://www.bing.com");
webHealthVaultConfiguration.DefaultHealthVaultShellUrl = new Uri("http://www.bing.com");
IServiceLocator serviceLocator = Substitute.For <IServiceLocator>();
serviceLocator.GetInstance <WebHealthVaultConfiguration>().Returns(webHealthVaultConfiguration);
serviceLocator.GetInstance <IHealthWebRequestClient>().Returns(Substitute.For <IHealthWebRequestClient>());
serviceLocator
.GetInstance <IHealthServiceResponseParser>()
.Returns(Substitute.For <IHealthServiceResponseParser>());
WebHealthVaultConnection webHealthVaultConnection = Substitute.For <WebHealthVaultConnection>(serviceLocator);
Ioc.Container.Configure(c => c.ExportInstance(webHealthVaultConnection).As <IWebHealthVaultConnection>());
// Mock ServiceInstanceProvider
IServiceInstanceProvider serviceInstanceProvider = Substitute.For <IServiceInstanceProvider>();
serviceInstanceProvider
.GetHealthServiceInstanceAsync(Arg.Any <string>())
.Returns(Task.FromResult(new HealthServiceInstance()));
Ioc.Container.Configure(c => c.ExportInstance(serviceInstanceProvider).As <IServiceInstanceProvider>());
WebHealthVaultFactory factory = new WebHealthVaultFactory();
// Act
IWebHealthVaultConnection resultWebHealthVaultConnection = await factory.CreateWebConnectionInternalAsync();
// Assert
Assert.AreEqual(webConnectionInfo.UserAuthToken, resultWebHealthVaultConnection.UserAuthToken);
}
public void WhenWebConnectionInfoIsLessThanCookieSize()
{
// Arrange
WebConnectionInfo webConnectionInfo = CreateWebConnectionInfo();
JsonWriter mockedJsonWriter = Substitute.For <JsonWriter>();
// Act
Serialize(mockedJsonWriter, webConnectionInfo);
// Assert
mockedJsonWriter.Received().WriteValue(Arg.Is <string>(x => x.Contains("ServiceInstanceId")));
}
/// <summary>
/// Get PersonInfo for the authenticated connection.
/// In case the request is not authenticated, then throws <see cref="UserNotFoundException"/>
/// </summary>
/// <returns>PersonInfo</returns>
/// <exception cref="UserNotFoundException">When the request is not authenticated, the method will throw exception</exception>
public override async Task <PersonInfo> GetPersonInfoAsync()
{
if (_personInfo != null)
{
return(_personInfo);
}
using (await _personInfoLock.LockAsync())
{
if (_personInfo == null)
{
IPrincipal principal = HttpContext.Current.User;
HealthVaultIdentity user = principal?.Identity as HealthVaultIdentity;
if (user == null)
{
throw new UserNotFoundException("Request should be authorized to retrieve PersonInfo, use RequireSignIn attribute");
}
WebConnectionInfo webConnectionInfo = user.WebConnectionInfo;
var personInfoFromCookie = webConnectionInfo.PersonInfo;
XDocument applicationSettingsDocument = null;
IDictionary <Guid, HealthRecordInfo> authorizedRecords = null;
// In case application settings/records are minimized due to size constraints in storing the webconnectionInfo object
// as a cookie, we will restore the application settings and authorized documents from the server.
if (webConnectionInfo.MinimizedPersonInfoApplicationSettings || webConnectionInfo.MinimizedPersonInfoRecords)
{
IPersonClient personClient = CreatePersonClient();
var personInfoFromServer = await personClient.GetPersonInfoAsync();
applicationSettingsDocument = personInfoFromServer.ApplicationSettingsDocument;
authorizedRecords = personInfoFromServer.AuthorizedRecords;
}
_personInfo = personInfoFromCookie;
if (applicationSettingsDocument != null)
{
_personInfo.ApplicationSettingsDocument = applicationSettingsDocument;
}
if (authorizedRecords != null)
{
_personInfo.AuthorizedRecords = authorizedRecords;
}
}
return(_personInfo);
}
}
public void WhenBothAuthorizedRecordsAndApplicationSettingsMakeCookieSizeBig()
{
var applicationSettingDocument = CreateApplicationSettingDocumentBiggerThanCookieSize();
var healthRecordInfos = CreateHealthRecordInfosToMakeCookieSizeLarge();
WebConnectionInfo webConnectionInfo = CreateWebConnectionInfo(healthRecordInfos, applicationSettingDocument);
JsonWriter mockedJsonWriter = Substitute.For <JsonWriter>();
Serialize(mockedJsonWriter, webConnectionInfo);
// Verify that person info authorized records have been minimized
mockedJsonWriter.Received().WriteValue(
Arg.Is <string>(x => x.Contains("\"MinimizedPersonInfoRecords\":true") &&
x.Contains("\"MinimizedPersonInfoApplicationSettings\":true")));
}
public void WhenApplicationSettingsMakeWebConnectionInfoGreaterThanCookieSize()
{
// Arrange
var applicationSettingDocument = CreateApplicationSettingDocumentBiggerThanCookieSize();
WebConnectionInfo webConnectionInfo = CreateWebConnectionInfo(null, applicationSettingDocument);
JsonWriter mockedJsonWriter = Substitute.For <JsonWriter>();
// Act
Serialize(mockedJsonWriter, webConnectionInfo);
// Assert
// Verify that person info application settings has been minimized
mockedJsonWriter.Received().WriteValue(
Arg.Is <string>(x => x.Contains("\"MinimizedPersonInfoApplicationSettings\":true")));
}
public void WhenAuthorizedRecordsMakeWebConnectionInfoGreaterThanCookieSize()
{
// Arrange
var healthRecordInfos = CreateHealthRecordInfosToMakeCookieSizeLarge();
WebConnectionInfo webConnectionInfo = CreateWebConnectionInfo(healthRecordInfos);
JsonWriter mockedJsonWriter = Substitute.For <JsonWriter>();
// Act
Serialize(mockedJsonWriter, webConnectionInfo);
// Assert
// Verify that person info authorized records have been minimized
mockedJsonWriter.Received().WriteValue(
Arg.Is <string>(x => x.Contains("\"MinimizedPersonInfoRecords\":true")));
}
/// <summary>
/// Minimize Authorize records from person info
/// </summary>
/// <param name="webConnectionInfo">WebConnectionInfo</param>
public static void MinimizePersonInfoAuthorizedRecords(this WebConnectionInfo webConnectionInfo)
{
var personInfo = webConnectionInfo.PersonInfo;
// Minimize person info authorized records keeping only self record
if (personInfo.AuthorizedRecords.Count > 1)
{
HealthRecordInfo selfRecordInfo = personInfo.GetSelfRecord();
personInfo.AuthorizedRecords = new Dictionary <Guid, HealthRecordInfo> {
{ selfRecordInfo.Id, selfRecordInfo }
};
webConnectionInfo.MinimizedPersonInfoRecords = true;
}
}
public void Save(HttpContextBase httpConext, WebConnectionInfo webConnectionInfo)
{
if (httpConext == null)
{
throw new ArgumentException(nameof(httpConext));
}
if (webConnectionInfo == null)
{
throw new ArgumentException(nameof(webConnectionInfo));
}
string serializedWebConnectionInfo = JsonConvert.SerializeObject(webConnectionInfo, _serializerSettings);
string marshalledCookie = CookieVersion + MarshalCookieVersion1(serializedWebConnectionInfo);
SetCookie(httpConext, marshalledCookie);
}
private static WebConnectionInfo MockCookieDataManager(IServiceLocator serviceLocator)
{
WebConnectionInfo webConnectionInfo = new WebConnectionInfo {
UserAuthToken = "test"
};
string serializedWebConnectionInfo = JsonConvert.SerializeObject(
webConnectionInfo,
new JsonSerializerSettings {
Converters = { new WebConnectionInfoConverter() }
});
ICookieDataManager cookieDataManager = Substitute.For <ICookieDataManager>();
cookieDataManager.Decompress(Arg.Any <string>()).Returns(serializedWebConnectionInfo);
serviceLocator.GetInstance <ICookieDataManager>().Returns(cookieDataManager);
return(webConnectionInfo);
}
public void WhenCookieNotPresent()
{
// Arrange
IServiceLocator serviceLocator = Substitute.For <IServiceLocator>();
// mock configuration
MockConfiguration(serviceLocator);
// mock request
HttpContextBase httpContext = Substitute.For <HttpContextBase>();
var requestWrapper = MockHttpRequestWithCookie("Some");
httpContext.Request.Returns(requestWrapper);
IWebConnectionInfoProvider webConnectionInfoProvider = new WebConnectionInfoProvider(serviceLocator);
// Act
WebConnectionInfo result = webConnectionInfoProvider.TryLoad(httpContext);
// Assert
Assert.IsNull(result);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
WebConnectionInfo webConnectionInfo = value as WebConnectionInfo;
if (webConnectionInfo != null)
{
string serializeObject = JsonConvert.SerializeObject(webConnectionInfo);
if (serializeObject.Length > MaxSize)
{
webConnectionInfo.MinimizePersonInfoApplicationSettings();
serializeObject = JsonConvert.SerializeObject(webConnectionInfo);
}
if (serializeObject.Length > MaxSize)
{
webConnectionInfo.MinimizePersonInfoAuthorizedRecords();
serializeObject = JsonConvert.SerializeObject(webConnectionInfo);
}
writer.WriteValue(serializeObject);
}
}
/// <summary>
/// Sign out of HealthVault
/// </summary>
/// <param name="context">The current controller context</param>
/// <param name="parameters">Parameters to be passed to the sign out page</param>
/// <returns>A redirect result to the HealthVault Shell sign out page</returns>
public static RedirectResult SignOut(ControllerContext context, object parameters)
{
var cookieManager = Ioc.Get <IWebConnectionInfoProvider>();
var httpContextBase = context.HttpContext;
WebConnectionInfo webConnectionInfo = cookieManager.TryLoad(httpContextBase);
string userAuthToken = webConnectionInfo.UserAuthToken;
cookieManager.Clear(httpContextBase);
httpContextBase.User = new GenericPrincipal(new HealthVaultIdentity(), null);
if (!string.IsNullOrEmpty(userAuthToken))
{
var parameterValues = new RouteValueDictionary(parameters)
{
[HealthVaultConstants.ShellRedirectTargetQueryStrings.CredentialToken] = userAuthToken
};
return(new RedirectResult(ShellUrls.Url(context, HealthVaultConstants.ShellRedirectTargets.AppSignOut, parameterValues)));
}
return(new RedirectResult(ShellUrls.Url(context, HealthVaultConstants.ShellRedirectTargets.AppSignOut, parameters)));
}
public WebConnectionInfo TryLoad(HttpContextBase httpContext)
{
if (httpContext == null)
{
throw new ArgumentException(nameof(httpContext));
}
HttpCookie cookie = GetCookie(httpContext);
if (cookie == null)
{
return(null);
}
string cookieVersionSerializedWebConnectionInfo = cookie[HvTokenWebConnectionInfo];
int versionIndex = cookieVersionSerializedWebConnectionInfo.IndexOf(":", StringComparison.InvariantCultureIgnoreCase);
string serializedWebConnectionInfo = cookieVersionSerializedWebConnectionInfo.Substring(versionIndex + 1);
string cookieData = UnmarshalCookieVersion1(serializedWebConnectionInfo);
WebConnectionInfo webConnectionInfo = JsonConvert.DeserializeObject <WebConnectionInfo>(cookieData, _serializerSettings);
return(webConnectionInfo);
}
private void Serialize(JsonWriter mockedJsonWriter, WebConnectionInfo webConnectionInfo)
{
WebConnectionInfoConverter converter = new WebConnectionInfoConverter();
converter.WriteJson(mockedJsonWriter, webConnectionInfo, JsonSerializer.Create());
}
