public void NotAttached()
{
var dlSubscription = new ActiveSubsciptionManager();
var subs1 = new TestSubscription();
Assert.IsFalse(dlSubscription.IsActive(subs1));
}
public static TestSubscription GetInstance()
{
if (instance == null)
{
instance = new TestSubscription();
}
return(instance);
}
public IActionResult updateAthelete(TestSubscriptionVM testSubscription)
{
TestSubscription data = db.TestSubscriptions.Where(s => s.TestSubscriptionID == testSubscription.TestSubscriptionID).FirstOrDefault();
data.AthleteId = testSubscription.AtheleteId;
data.Distance = testSubscription.Distance;
db.SaveChanges();
return(RedirectToAction("Details", new { id = testSubscription.TestID }));
}
public IActionResult DeleteAtheleteTest(int id, TestSubscriptionVM testSubscription)
{
TestSubscription test = db.Set <TestSubscription>().SingleOrDefault(c => c.TestSubscriptionID == testSubscription.TestSubscriptionID);
if (test != null)
{
db.Entry(test).State = Microsoft.EntityFrameworkCore.EntityState.Deleted;
db.SaveChanges();
}
return(RedirectToAction("Details", new { id = testSubscription.TestID }));
}
public void AttachAndDetach()
{
var dlSubscription = new ActiveSubsciptionManager();
var subs = new TestSubscription();
dlSubscription.Attach(subs);
Assert.IsTrue(dlSubscription.IsActive(subs));
dlSubscription.Detach(subs);
Assert.IsFalse(dlSubscription.IsActive(subs));
}
public async Task NoItemsCompletesTask()
{
Func <MessageResult, object, Task <bool> > callback = (result, state) =>
{
return(TaskAsyncHelper.False);
};
var subscription = new TestSubscription("TestSub", new[] { "a" }, callback, 0);
using (subscription)
{
await subscription.Work().OrTimeout();
}
}
public void DetachTwiceInactive()
{
var dlSubscription = new ActiveSubsciptionManager();
var subs1 = new TestSubscription();
dlSubscription.Attach(subs1);
var subs2 = new TestSubscription();
dlSubscription.Attach(subs2);
dlSubscription.Detach(subs2);
dlSubscription.Detach(subs2);
Assert.IsTrue(dlSubscription.IsActive(subs1));
}
public void AttachManyAndDetachActive()
{
var dlSubscription = new ActiveSubsciptionManager();
var subs1 = new TestSubscription();
dlSubscription.Attach(subs1);
var subs2 = new TestSubscription();
dlSubscription.Attach(subs2);
var subs3 = new TestSubscription();
dlSubscription.Attach(subs3);
dlSubscription.Detach(subs1);
Assert.IsTrue(dlSubscription.IsActive(subs2) ^ dlSubscription.IsActive(subs3));
}
protected void RemoveEventListener(TestSubscription testSubscription)
{
var subscriptionsToRemove = new List <string>();
foreach (RTSubscription existingSubscription in subscriptions.Values)
{
if (testSubscription(existingSubscription))
{
rt.Unsubscribe(existingSubscription.Id);
subscriptionsToRemove.Add(existingSubscription.Id);
}
}
foreach (var id in subscriptionsToRemove)
#if NET_35
{ subscriptions.Remove(id); }
#else
{ subscriptions.TryRemove(id, out _); }
#endif
}
public async Task FaultedTaskShouldPropagateAsync()
{
Func <MessageResult, object, Task <bool> > callback = async(result, state) =>
{
await Task.Delay(500);
await TaskAsyncHelper.FromError(new Exception());
return(false);
};
var subscription = new TestSubscription("TestSub", new[] { "a" }, callback, 1);
using (subscription)
{
Task task = subscription.Work();
await Assert.ThrowsAsync <Exception>(() => task.OrTimeout());
Assert.True(task.IsFaulted);
}
}
public async Task CancelledTaskShouldThrowTaskCancelledAsync()
{
Func <MessageResult, object, Task <bool> > callback = async(result, state) =>
{
await Task.Yield();
var tcs = new TaskCompletionSource <bool>();
tcs.TrySetCanceled();
return(await tcs.Task);
};
var subscription = new TestSubscription("TestSub", new[] { "a" }, callback, 1);
using (subscription)
{
Task task = subscription.Work();
await Assert.ThrowsAsync <TaskCanceledException>(() => task.OrTimeout());
Assert.True(task.IsCanceled);
}
}
public IActionResult AddNewAthelete(TestSubscriptionVM testSubscription)
{
if (ModelState.IsValid)
{
TestSubscription Subscription = new TestSubscription
{
Distance = testSubscription.Distance,
AthleteId = testSubscription.AtheleteId,
TestID = testSubscription.TestID
};
db.Add(Subscription);
db.SaveChanges();
if (Subscription.TestID > 0)
{
return(RedirectToAction("Details", new { id = Subscription.TestID }));
}
}
ViewBag.ListOfTests = db.TestTypes.ToList();
ModelState.AddModelError("", "some thing went wrong");
return(View());
}
public void FaultedTaskShouldPropagateSync()
{
Func <MessageResult, object, Task <bool> > callback = async(result, state) =>
{
await TaskAsyncHelper.FromError(new Exception());
return(false);
};
var subscription = new TestSubscription("TestSub", new[] { "a" }, callback, 1);
using (subscription)
{
Task task = null;
TestUtilities.AssertUnwrappedException <Exception>(() =>
{
task = subscription.Work();
task.Wait();
});
Assert.True(task.IsFaulted);
}
}
public void CancelledTaskShouldThrowTaskCancelledSync()
{
Func <MessageResult, object, Task <bool> > callback = (result, state) =>
{
var tcs = new TaskCompletionSource <bool>();
tcs.TrySetCanceled();
return(tcs.Task);
};
var subscription = new TestSubscription("TestSub", new[] { "a" }, callback, 1);
using (subscription)
{
Task task = null;
TestUtilities.AssertUnwrappedException <TaskCanceledException>(() =>
{
task = subscription.Work();
task.Wait();
});
Assert.True(task.IsCanceled);
}
}
public async Task ReturningFalseFromCallbackCompletesTaskAndDisposesSubscription()
{
Func <MessageResult, object, Task <bool> > callback = (result, state) =>
{
return(TaskAsyncHelper.False);
};
var subscription = new TestSubscription("TestSub", new[] { "a" }, callback, 1);
var disposableMock = new Mock <IDisposable>();
subscription.Disposable = disposableMock.Object;
disposableMock.Setup(m => m.Dispose()).Verifiable();
using (subscription)
{
var task = subscription.Work();
Assert.True(task.IsCompleted);
await task.OrTimeout();
disposableMock.Verify(m => m.Dispose(), Times.Once());
}
}
