public async Task AddOrUpdateAsyncTest()
{
DictionaryChange change = null;
TransactedConcurrentDictionary <int, string> d = new TransactedConcurrentDictionary <int, string>(
new Uri("test://mocks", UriKind.Absolute),
(c) =>
{
change = c;
return(true);
}
);
using (var tx = _stateManager.CreateTransaction())
{
await d.AddOrUpdateAsync(tx, 1, (k) => "One", (k, v) => "Two");
Assert.IsNull(change);
await tx.CommitAsync();
Assert.AreEqual("One", change.Added);
}
change = null;
using (var tx = _stateManager.CreateTransaction())
{
await d.AddOrUpdateAsync(tx, 1, (k) => "One", (k, v) => "Two");
Assert.IsNull(change);
await tx.CommitAsync();
Assert.AreEqual("Two", change.Added);
}
}
public MockReliableStateManager()
{
// Initialze _store to a TransactedConcurrentDictionary that fires the StateManagerChanged event in the OnDictionaryChanged callback.
_store = new TransactedConcurrentDictionary <Uri, IReliableState>(
new Uri("fabric://state", UriKind.Absolute),
(c) =>
{
if (StateManagerChanged != null)
{
NotifyStateManagerSingleEntityChangedEventArgs changeEvent;
switch (c.ChangeType)
{
case ChangeType.Added:
changeEvent = new NotifyStateManagerSingleEntityChangedEventArgs(c.Transaction, c.Added, NotifyStateManagerChangedAction.Add);
break;
case ChangeType.Removed:
changeEvent = new NotifyStateManagerSingleEntityChangedEventArgs(c.Transaction, c.Removed, NotifyStateManagerChangedAction.Remove);
break;
default:
return(false);
}
StateManagerChanged.Invoke(this, changeEvent);
}
return(true);
}
);
}
private async Task <long> GetCount(TransactedConcurrentDictionary <int, string> d)
{
using (var tx = _stateManager.CreateTransaction())
{
return(await d.GetCountAsync(tx));
}
}
private async Task <ConditionalValue <string> > GetValue(TransactedConcurrentDictionary <int, string> d, int key, TimeSpan timeout = default(TimeSpan))
{
using (var tx = _stateManager.CreateTransaction())
{
return(await d.TryGetValueAsync(tx, key, LockMode.Default, timeout : timeout));
}
}
public async Task TryGetValueAsyncTest()
{
DictionaryChange change = null;
TransactedConcurrentDictionary <int, string> d = new TransactedConcurrentDictionary <int, string>(
new Uri("test://mocks", UriKind.Absolute),
(c) =>
{
change = c;
return(true);
}
);
using (var tx = _stateManager.CreateTransaction())
{
Assert.IsFalse((await d.TryGetValueAsync(tx, 1, LockMode.Default)).HasValue);
Assert.IsTrue(await d.TryAddAsync(tx, 1, "One"));
using (var tx2 = _stateManager.CreateTransaction())
{
await Assert.ThrowsExceptionAsync <TimeoutException>(
async() =>
{
await d.TryGetValueAsync(tx2, 1, LockMode.Default, timeout: TimeSpan.FromMilliseconds(20));
}
);
}
await tx.CommitAsync();
Assert.AreEqual("One", change.Added);
}
}
private async Task <bool> ContainsKey(TransactedConcurrentDictionary <int, string> d, int key, TimeSpan timeout = default(TimeSpan))
{
using (var tx = _stateManager.CreateTransaction())
{
return(await d.ContainsKeyAsync(tx, 1, LockMode.Default, timeout : timeout));
}
}
public async Task ContainsKeyAsyncTest()
{
DictionaryChange change = null;
TransactedConcurrentDictionary <int, string> d = new TransactedConcurrentDictionary <int, string>(
new Uri("test://mocks", UriKind.Absolute),
(c) =>
{
change = c;
return(true);
}
);
using (var tx = _stateManager.CreateTransaction())
{
await d.AddAsync(tx, 1, "One");
await Assert.ThrowsExceptionAsync <TimeoutException>(
async() =>
{
await ContainsKey(d, 1, TimeSpan.FromMilliseconds(20));
}
);
await tx.CommitAsync();
Assert.IsTrue(await ContainsKey(d, 1));
}
}
public async Task ClearAsyncTest()
{
DictionaryChange change = null;
TransactedConcurrentDictionary <int, string> d = new TransactedConcurrentDictionary <int, string>(
new Uri("test://mocks", UriKind.Absolute),
(c) =>
{
change = c;
return(true);
}
);
using (var tx = _stateManager.CreateTransaction())
{
await d.AddAsync(tx, 1, "One");
await tx.CommitAsync();
Assert.AreEqual(1, await GetCount(d));
}
change = null;
await d.ClearAsync();
Assert.AreEqual(0, await GetCount(d));
Assert.IsNull(change);
}
public async Task GetOrAddAsyncTest()
{
DictionaryChangedEvent <int, string> change = null;
TransactedConcurrentDictionary <int, string> d = new TransactedConcurrentDictionary <int, string>(
new Uri("test://mocks", UriKind.Absolute),
(s, e) =>
{
change = e;
}
);
using (var tx = _stateManager.CreateTransaction())
{
await d.GetOrAddAsync(tx, 1, (k) => "One");
await d.GetOrAddAsync(tx, 1, (k) => "Two");
Assert.IsNull(change);
await tx.CommitAsync();
Assert.IsNotNull(change);
Assert.AreEqual("One", change.Added);
Assert.AreEqual("One", (await GetValue(d, 1)).Value);
}
}
public async Task AddAsyncTest()
{
DictionaryChange change = null;
TransactedConcurrentDictionary <int, string> d = new TransactedConcurrentDictionary <int, string>(
new Uri("test://mocks", UriKind.Absolute),
(c) =>
{
change = c;
return(true);
}
);
using (var tx = _stateManager.CreateTransaction())
{
await d.AddAsync(tx, 1, "One");
await Assert.ThrowsExceptionAsync <ArgumentException>(
async() =>
{
await d.AddAsync(tx, 1, "Two");
}
);
Assert.IsNull(change);
using (var tx2 = _stateManager.CreateTransaction())
{
await Assert.ThrowsExceptionAsync <TimeoutException>(
async() =>
{
await d.AddAsync(tx2, 1, "Three", TimeSpan.FromMilliseconds(20));
}
);
}
Assert.IsNull(change);
await tx.CommitAsync();
}
Assert.AreEqual("One", change.Added);
Assert.IsNull(change.Removed);
Assert.AreEqual("One", (await GetValue(d, 1)).Value);
}
public async Task TryAddAsyncTest()
{
DictionaryChange change = null;
TransactedConcurrentDictionary <int, string> d = new TransactedConcurrentDictionary <int, string>(
new Uri("test://mocks", UriKind.Absolute),
(c) =>
{
change = c;
return(true);
}
);
using (var tx = _stateManager.CreateTransaction())
{
Assert.IsTrue(await d.TryAddAsync(tx, 1, "One"));
Assert.IsFalse(await d.TryAddAsync(tx, 1, "Two"));
using (var tx2 = _stateManager.CreateTransaction())
{
await Assert.ThrowsExceptionAsync <TimeoutException>(
async() =>
{
await d.TryAddAsync(tx2, 1, "Three", timeout: TimeSpan.FromMilliseconds(20));
}
);
}
await tx.CommitAsync();
Assert.AreEqual("One", change.Added);
}
using (var tx = _stateManager.CreateTransaction())
{
Assert.IsFalse(await d.TryAddAsync(tx, 1, "Three"));
Assert.IsTrue(await d.TryAddAsync(tx, 4, "Four"));
Assert.IsTrue(await d.TryAddAsync(tx, 5, "Five"));
await tx.CommitAsync();
}
Assert.AreEqual(3, await GetCount(d));
Assert.AreEqual("One", (await GetValue(d, 1)).Value);
Assert.AreEqual("Four", (await GetValue(d, 4)).Value);
Assert.AreEqual("Five", (await GetValue(d, 5)).Value);
}
public async Task TryUpdateAsyncTest()
{
DictionaryChangedEvent <int, string> change = null;
TransactedConcurrentDictionary <int, string> d = new TransactedConcurrentDictionary <int, string>(
new Uri("test://mocks", UriKind.Absolute),
(s, e) =>
{
change = e;
}
);
using (var tx = _stateManager.CreateTransaction())
{
Assert.IsFalse((await d.TryUpdateAsync(tx, 1, "Two", "One")));
Assert.IsTrue(await d.TryAddAsync(tx, 1, "One"));
using (var tx2 = _stateManager.CreateTransaction())
{
await Assert.ThrowsExceptionAsync <TimeoutException>(
async() =>
{
await d.TryRemoveAsync(tx2, 1, timeout: TimeSpan.FromMilliseconds(20));
}
);
}
await tx.CommitAsync();
Assert.AreEqual("One", change.Added);
}
using (var tx = _stateManager.CreateTransaction())
{
Assert.IsFalse((await d.TryUpdateAsync(tx, 1, "Three", "Two")));
using (_stateManager.CreateTransaction())
{
Assert.IsTrue((await d.TryUpdateAsync(tx, 1, "Two", "One")));
}
await tx.CommitAsync();
Assert.AreEqual("Two", change.Added);
}
}
public async Task SetAsyncTest()
{
DictionaryChange change = null;
TransactedConcurrentDictionary <int, string> d = new TransactedConcurrentDictionary <int, string>(
new Uri("test://mocks", UriKind.Absolute),
(c) =>
{
change = c;
return(true);
}
);
using (var tx = _stateManager.CreateTransaction())
{
await Assert.ThrowsExceptionAsync <ArgumentException>(
async() =>
{
await d.SetAsync(tx, 1, "One");
}
);
await d.AddAsync(tx, 2, "Two");
await tx.CommitAsync();
}
using (var tx = _stateManager.CreateTransaction())
{
await d.SetAsync(tx, 2, "Three");
await tx.CommitAsync();
Assert.AreEqual("Two", change.Removed);
Assert.AreEqual("Three", change.Added);
}
Assert.AreEqual(1, await GetCount(d));
}
public MockReliableStateManager(TransactedConcurrentDictionary <Uri, IReliableState> store = null)
{
_store = store ?? new TransactedConcurrentDictionary <Uri, IReliableState>(new Uri("fabric://state", UriKind.Absolute));
_store.InternalDictionaryChanged +=
(sender, args) =>
{
if (StateManagerChanged != null)
{
NotifyStateManagerSingleEntityChangedEventArgs changeEvent = null;
switch (args.ChangeType)
{
case ChangeType.Added:
changeEvent = new NotifyStateManagerSingleEntityChangedEventArgs(args.Transaction, args.Added, NotifyStateManagerChangedAction.Add);
break;
case ChangeType.Removed:
changeEvent = new NotifyStateManagerSingleEntityChangedEventArgs(args.Transaction, args.Removed, NotifyStateManagerChangedAction.Remove);
break;
}
StateManagerChanged.Invoke(this, changeEvent);
}
};
}
private IReliableStateManagerReplica2 CreateStateManagerReplica(StatefulServiceContext ctx, TransactedConcurrentDictionary <Uri, IReliableState> states)
{
return(new MockReliableStateManager(states));
}
public async Task SetAsyncTest()
{
DictionaryChange change = null;
TransactedConcurrentDictionary <int, string> d = new TransactedConcurrentDictionary <int, string>(
new Uri("test://mocks", UriKind.Absolute),
(c) =>
{
change = c;
return(true);
}
);
using (var tx = _stateManager.CreateTransaction())
{
await d.SetAsync(tx, 1, "Zero");
}
using (var tx = _stateManager.CreateTransaction())
{
ConditionalValue <string> value = await d.TryGetValueAsync(tx, 1, LockMode.Default);
Assert.IsFalse(value.HasValue);
}
using (var tx = _stateManager.CreateTransaction())
{
await d.SetAsync(tx, 1, "One");
await tx.CommitAsync();
Assert.AreEqual("One", change.Added);
Assert.AreEqual(null, change.Removed);
}
using (var tx = _stateManager.CreateTransaction())
{
await d.SetAsync(tx, 1, "Two");
}
using (var tx = _stateManager.CreateTransaction())
{
ConditionalValue <string> value = await d.TryGetValueAsync(tx, 1, LockMode.Default);
Assert.AreEqual("One", value.Value);
}
using (var tx = _stateManager.CreateTransaction())
{
await d.AddAsync(tx, 2, "Two");
await tx.CommitAsync();
}
using (var tx = _stateManager.CreateTransaction())
{
await d.SetAsync(tx, 2, "Three");
await tx.CommitAsync();
Assert.AreEqual("Two", change.Removed);
Assert.AreEqual("Three", change.Added);
}
Assert.AreEqual(2, await GetCount(d));
}
