public void SetBeforeAccess(TokenCacheCallback beforeAccess)
{
GuardOnMobilePlatforms();
ResetDefaultDelegates();
BeforeAccess = beforeAccess;
}
public async Task MergeOccursOnSecondUpdate()
{
var mockPublicClient = new Mock <IPublicClientApplication>();
var mergeMSALCache = new Mock <ITokenCache>();
TokenCacheNotificationArgs mockArgs1 = GetMockArgs(mockSerializer, true);
TokenCacheNotificationArgs mockArgs2 = GetMockArgs(mockSerializer2, true);
mockMSALCache
.Setup(m => m.SetBeforeAccessAsync(It.IsAny <Func <TokenCacheNotificationArgs, Task> >()))
.Callback <Func <TokenCacheNotificationArgs, Task> >(beforeAccess => main_OnBeforeCacheAccessAsync = beforeAccess);
mockMSALCache
.Setup(m => m.SetAfterAccessAsync(It.IsAny <Func <TokenCacheNotificationArgs, Task> >()))
.Callback <Func <TokenCacheNotificationArgs, Task> >(afterAccess => main_OnAfterCacheAccessAsync = afterAccess);
mergeMSALCache
.Setup(m => m.SetBeforeAccess(It.IsAny <TokenCacheCallback>()))
.Callback <TokenCacheCallback>(beforeAccess =>
{
merge_OnBeforeCacheAccessAsync = beforeAccess;
});
mergeMSALCache
.Setup(m => m.SetAfterAccess(It.IsAny <TokenCacheCallback>()))
.Callback <TokenCacheCallback>(afterAccess => merge_OnAfterCacheAccessAsync = afterAccess);
mockSerializer
.SetupSequence(m => m.SerializeMsalV3())
.Returns(bytes)
.Returns(mergedBytes);
mockSerializer2
.SetupSequence(m => m.SerializeMsalV3())
.Returns(updatedBytes);
mockPublicClient
.SetupGet(m => m.UserTokenCache).Returns(mergeMSALCache.Object);
mockPublicClient
.Setup(m => m.GetAccountsAsync())
.ReturnsAsync(() => new List <IAccount>())
.Callback(() =>
{
merge_OnBeforeCacheAccessAsync(mockArgs1);
var list = merge_OnBeforeCacheAccessAsync.GetInvocationList();
if (merge_OnAfterCacheAccessAsync != null)
{
merge_OnAfterCacheAccessAsync(mockArgs1);
}
});
cache = new TokenCache(new InMemoryTokenCacheOptions(bytes), default, publicApplicationFactory: new Func <IPublicClientApplication>(() => mockPublicClient.Object));
public void SetAfterAccess(TokenCacheCallback afterAccess)
{
GuardOnMobilePlatforms();
AfterAccess = afterAccess;
}
public void SetBeforeWrite(TokenCacheCallback beforeWrite)
{
throw new NotImplementedException();
}
public void SetBeforeAccess(TokenCacheCallback beforeAccess)
{
_beforeAccess = beforeAccess;
}
public void SetAfterAccess(TokenCacheCallback afterAccess)
{
_afterAccess = afterAccess;
}
public async Task MergeOccursOnSecondUpdate()
{
var mockPublicClient = new Mock <IPublicClientApplication>();
var mergeMSALCache = new Mock <ITokenCache>();
TokenCacheNotificationArgs mockArgs1 = GetMockArgs(mockSerializer1, true);
TokenCacheNotificationArgs mockArgs2 = GetMockArgs(mockSerializer2, true);
mockMSALCache
.Setup(m => m.SetBeforeAccessAsync(It.IsAny <Func <TokenCacheNotificationArgs, Task> >()))
.Callback <Func <TokenCacheNotificationArgs, Task> >(beforeAccess => main_OnBeforeCacheAccessAsync = beforeAccess);
mockMSALCache
.Setup(m => m.SetAfterAccessAsync(It.IsAny <Func <TokenCacheNotificationArgs, Task> >()))
.Callback <Func <TokenCacheNotificationArgs, Task> >(afterAccess => main_OnAfterCacheAccessAsync = afterAccess);
mergeMSALCache
.Setup(m => m.SetBeforeAccess(It.IsAny <TokenCacheCallback>()))
.Callback <TokenCacheCallback>(beforeAccess =>
{
merge_OnBeforeCacheAccessAsync = beforeAccess;
});
mergeMSALCache
.Setup(m => m.SetAfterAccess(It.IsAny <TokenCacheCallback>()))
.Callback <TokenCacheCallback>(afterAccess => merge_OnAfterCacheAccessAsync = afterAccess);
mockSerializer1
.SetupSequence(m => m.SerializeMsalV3())
.Returns(bytes)
.Returns(mergedBytes);
mockSerializer2
.SetupSequence(m => m.SerializeMsalV3())
.Returns(updatedBytes);
mockPublicClient
.SetupGet(m => m.UserTokenCache).Returns(mergeMSALCache.Object);
mockPublicClient
.Setup(m => m.GetAccountsAsync())
.ReturnsAsync(() => new List <IAccount>())
.Callback(() =>
{
merge_OnBeforeCacheAccessAsync(mockArgs1);
var list = merge_OnBeforeCacheAccessAsync.GetInvocationList();
if (merge_OnAfterCacheAccessAsync != null)
{
merge_OnAfterCacheAccessAsync(mockArgs1);
}
});
cache = new TokenCache(bytes, new (() => mockPublicClient.Object));
await cache.RegisterCache(IsAsync, mockMSALCache.Object, default);
await cache.RegisterCache(IsAsync, mergeMSALCache.Object, default);
// Read the cache from consumer 1.
await main_OnBeforeCacheAccessAsync.Invoke(mockArgs1);
// Read and write the cache from consumer 2.
await main_OnBeforeCacheAccessAsync.Invoke(mockArgs2);
// Dealy to ensure that the timestamps are different between last read and last updated.
await Task.Delay(100);
await main_OnAfterCacheAccessAsync.Invoke(mockArgs2);
// Consumer 1 now writes, and must update its cache first.
await main_OnAfterCacheAccessAsync.Invoke(mockArgs1);
mockSerializer1.Verify(m => m.DeserializeMsalV3(bytes, true), Times.Exactly(1));
mockSerializer1.Verify(m => m.SerializeMsalV3(), Times.Exactly(2));
mockSerializer1.Verify(m => m.DeserializeMsalV3(bytes, false), Times.Exactly(1));
mockSerializer1.Verify(m => m.DeserializeMsalV3(updatedBytes, false), Times.Exactly(1));
mockSerializer2.Verify(m => m.DeserializeMsalV3(bytes, true), Times.Exactly(1));
mockSerializer2.Verify(m => m.SerializeMsalV3(), Times.Exactly(1));
// validate that we ended up with the merged cache.
Assert.That(cache.Data, Is.EqualTo(mergedBytes));
}
public void SetBeforeWrite(TokenCacheCallback beforeWrite) => throw new NotImplementedException(MsalErrorMessage.TokenCacheSetCallbackFunctionalityNotAvailableFromWithinCallback);
public void SetAfterAccess(TokenCacheCallback afterAccess)
{
throw new NotImplementedException();
}
public void SetAfterAccess(TokenCacheCallback afterAccess)
{
GuardOnMobilePlatforms();
ResetDefaultDelegates();
AfterAccess = afterAccess;
}
public void SetBeforeWrite(TokenCacheCallback beforeWrite)
{
GuardOnMobilePlatforms();
ResetDefaultDelegates();
BeforeWrite = beforeWrite;
}
public void SetBeforeWrite(TokenCacheCallback beforeWrite)
{
Validate();
ResetDefaultDelegates();
BeforeWrite = beforeWrite;
}
public void SetAfterAccess(TokenCacheCallback afterAccess)
{
Validate();
ResetDefaultDelegates();
AfterAccess = afterAccess;
}
public void SetBeforeAccess(TokenCacheCallback beforeAccess)
{
Validate();
ResetDefaultDelegates();
BeforeAccess = beforeAccess;
}
public void SetBeforeWrite(TokenCacheCallback beforeWrite)
{
GuardOnMobilePlatforms();
BeforeWrite = beforeWrite;
}
public void SetBeforeAccess(TokenCacheCallback beforeAccess)
{
throw new NotImplementedException();
}
public void SetBeforeAccess(TokenCacheCallback beforeAccess)
{
GuardOnMobilePlatforms();
BeforeAccess = beforeAccess;
}
public void SetAfterAccess(TokenCacheCallback afterAccess) => throw new NotImplementedException(MsalErrorMessage.TokenCacheSetCallbackFunctionalityNotAvailableFromWithinCallback);