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)); }