public async Task WhenPersonInfoRestoredFromIdentityWithMinimizedAuthorizedRecords()
{
CreateWebConnectionInfo(minimizedPersonInfoRecords: true);
PersonInfo mockedPersonInfoWithExpandedAuthorizedRecords = new PersonInfo()
{
Name = "Test",
AuthorizedRecords = new Dictionary <Guid, HealthRecordInfo>
{
{ Guid.NewGuid(), new HealthRecordInfo() },
{ Guid.NewGuid(), new HealthRecordInfo() }
}
};
IPersonClient personClient = Substitute.For <IPersonClient>();
personClient.GetPersonInfoAsync().Returns(Task.FromResult(mockedPersonInfoWithExpandedAuthorizedRecords));
Ioc.Container.Configure(c => c.ExportInstance(f => personClient).As <IPersonClient>());
PersonInfo personInfo = await _webHealthVaultConnection.GetPersonInfoAsync();
Assert.AreEqual(mockedPersonInfoWithExpandedAuthorizedRecords.Name, personInfo.Name);
Assert.AreEqual(
mockedPersonInfoWithExpandedAuthorizedRecords.AuthorizedRecords.Count,
personInfo.AuthorizedRecords.Count);
}
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);
}
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);
}
/// <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 async Task WhenPersonInfoRestoredFromIdentityWithMinimizedApplicationSettings()
{
CreateWebConnectionInfo(minimizedApplicationSettings: true);
PersonInfo mockedPersonInfoWithApplicationSettings = new PersonInfo()
{
Name = "Test",
ApplicationSettingsDocument = Substitute.For <XDocument>()
};
IPersonClient personClient = Substitute.For <IPersonClient>();
personClient.GetPersonInfoAsync().Returns(Task.FromResult(mockedPersonInfoWithApplicationSettings));
Ioc.Container.Configure(c => c.ExportInstance(f => personClient).As <IPersonClient>());
PersonInfo personInfo = await _webHealthVaultConnection.GetPersonInfoAsync();
Assert.AreEqual(mockedPersonInfoWithApplicationSettings.Name, personInfo.Name);
Assert.IsNotNull(personInfo.ApplicationSettingsDocument);
}
