public void CallsOnErrorOnException()
{
// Arrange
var mre = new ManualResetEventSlim(false);
var onErrorCalled = false;
var dbProviderFactory = new MockDbProviderFactory();
var dbBehavior = new Mock <IDbBehavior>();
dbBehavior.Setup(db => db.UpdateLoopRetryDelays).Returns(_defaultRetryDelays);
dbBehavior.Setup(db => db.StartSqlDependencyListener()).Returns(false);
dbProviderFactory.MockDataReader.Setup(r => r.Read()).Throws(new ApplicationException("test"));
var operation = new ObservableDbOperation("test", "test", new TraceSource("test"), dbProviderFactory, dbBehavior.Object);
operation.Faulted += _ =>
{
onErrorCalled = true;
mre.Set();
};
// Act
ThreadPool.QueueUserWorkItem(_ => operation.ExecuteReaderWithUpdates((record, o) => { }));
mre.Wait();
operation.Dispose();
// Assert
Assert.True(onErrorCalled);
}
public void RemoveRegistrationDependency()
{
var fakeOracleDependencyManager = A.Fake <IOracleDependencyManager>();
var fakeOracleDependencyManagerRegistryDepCall = A.CallTo(() => fakeOracleDependencyManager.RegisterDependency(null)).WithAnyArguments();
var fakeOracleDependencyManagerRemoveRegistrationCall =
A.CallTo(() => fakeOracleDependencyManager.RemoveRegistration(string.Empty)).WithAnyArguments();
var fakeSignalrDbDependencyFactory = A.Fake <ISignalrDbDependencyFactory>();
var fakeSignalrDbDependencyFactoryCreateDepCall = A.CallTo(() => fakeSignalrDbDependencyFactory.CreateDbDependency(null, false, 0, false)).WithAnyArguments();
var fakeSignalrDependency = new FakeSignalrDependency();
fakeSignalrDbDependencyFactoryCreateDepCall.Returns(fakeSignalrDependency);
ObservableDbOperation dbOperation = new ObservableDbOperation(string.Empty, string.Empty, new TraceSource("ss"),
null,
A.Fake <IDbProviderFactory>(),
fakeOracleDependencyManager,
fakeSignalrDbDependencyFactory,
true);
dbOperation.ExecuteReaderWithUpdates(A.Fake <Action <IDataRecord, IDbOperation> >());
fakeSignalrDependency.FireEvent(OracleNotificationType.Subscribe, OracleNotificationInfo.Error);
fakeOracleDependencyManagerRegistryDepCall.MustHaveHappened(Repeated.Exactly.Once);
fakeSignalrDbDependencyFactoryCreateDepCall.MustHaveHappened(Repeated.Exactly.Once);
fakeOracleDependencyManagerRemoveRegistrationCall.MustHaveHappened(Repeated.Exactly.Once);
}
public void ExecuteReaderWithUpdates_Fail()
{
var fakeOracleDependencyManager = A.Fake <IOracleDependencyManager>();
var fakeSignalrDbDependencyFactory = A.Fake <ISignalrDbDependencyFactory>();
ObservableDbOperation dbOperation = new ObservableDbOperation(string.Empty, string.Empty,
new TraceSource("ss"),
null,
A.Fake <IDbProviderFactory>(),
fakeOracleDependencyManager,
fakeSignalrDbDependencyFactory,
true);
dbOperation.Queried += () => { throw new Exception(); };
int counter = 0;
dbOperation.Faulted += (ex) => { counter++; };
using (var cts = new CancellationTokenSource())
{
Task.Run(() => dbOperation.ExecuteReaderWithUpdates(A.Fake <Action <IDataRecord, IDbOperation> >()),
cts.Token);
Thread.Sleep(1000);
dbOperation.Dispose();
cts.Cancel();
}
Assert.IsTrue(counter > 0);
}
public void DependencyFault()
{
var fakeOracleDependencyManager = A.Fake <IOracleDependencyManager>();
var fakeOracleDependencyManagerRegistryDepCall = A.CallTo(() => fakeOracleDependencyManager.RegisterDependency(null)).WithAnyArguments();
var fakeSignalrDbDependencyFactory = A.Fake <ISignalrDbDependencyFactory>();
var fakeSignalrDbDependencyFactoryCreateDepCall = A.CallTo(() => fakeSignalrDbDependencyFactory.CreateDbDependency(null, false, 0, false)).WithAnyArguments();
var fakeSignalrDependency = new FakeSignalrDependency();
fakeSignalrDbDependencyFactoryCreateDepCall.Returns(fakeSignalrDependency);
ObservableDbOperation dbOperation = new ObservableDbOperation(string.Empty, string.Empty, new TraceSource("ss"),
null,
A.Fake <IDbProviderFactory>(),
fakeOracleDependencyManager,
fakeSignalrDbDependencyFactory,
true);
dbOperation.ExecuteReaderWithUpdates(A.Fake <Action <IDataRecord, IDbOperation> >());
int faultCounter = 0;
dbOperation.Faulted += ex => { if (ex != null)
{
faultCounter++;
}
};
fakeSignalrDependency.FireEvent(OracleNotificationType.Change, OracleNotificationInfo.Error);
Assert.AreEqual(1, faultCounter);
fakeOracleDependencyManagerRegistryDepCall.MustHaveHappened(Repeated.Exactly.Once);
fakeSignalrDbDependencyFactoryCreateDepCall.MustHaveHappened(Repeated.Exactly.Once);
}
public void ExecuteReaderSetsNotificationStateCorrectlyUpToAwaitingNotification()
{
// Arrange
var retryLoopDelays = new[] { Tuple.Create(0, 1) };
var dbProviderFactory = new MockDbProviderFactory();
var dbBehavior = new Mock <IDbBehavior>();
var logger = new Mock <ILogger>();
dbBehavior.Setup(db => db.UpdateLoopRetryDelays).Returns(retryLoopDelays);
dbBehavior.Setup(db => db.StartSqlDependencyListener()).Returns(true);
dbBehavior.Setup(db => db.AddSqlDependency(It.IsAny <IDbCommand>(), It.IsAny <Action <SqlNotificationEventArgs> >()));
var operation = new ObservableDbOperation("test", "test", logger.Object, dbProviderFactory, dbBehavior.Object);
operation.Queried += () =>
{
// Currently in the query loop
Assert.Equal(ObservableDbOperation.NotificationState.ProcessingUpdates, operation.CurrentNotificationState);
};
// Act
operation.ExecuteReaderWithUpdates((_, __) => { });
// Assert
Assert.Equal(ObservableDbOperation.NotificationState.AwaitingNotification, operation.CurrentNotificationState);
operation.Dispose();
}
public void CreateDependency_Success()
{
ObservableDbOperation dbOperation = new ObservableDbOperation(string.Empty, string.Empty, new TraceSource("ss"),
null,
A.Fake <IDbProviderFactory>(),
A.Fake <IOracleDependencyManager>(),
A.Fake <ISignalrDbDependencyFactory>(),
true);
dbOperation.ExecuteReaderWithUpdates(A.Fake <Action <IDataRecord, IDbOperation> >());
}
public void ExecuteReaderSetsNotificationStateCorrectlyWhenNotificationReceivedBeforeChangingStateToAwaitingNotification()
{
// Arrange
var mre = new ManualResetEventSlim(false);
var retryLoopDelays = new[] { Tuple.Create(0, 1) };
var dbProviderFactory = new MockDbProviderFactory();
var sqlDependencyAdded = false;
var dbBehavior = new Mock <IDbBehavior>();
var logger = new Mock <ILogger>();
dbBehavior.Setup(db => db.UpdateLoopRetryDelays).Returns(retryLoopDelays);
dbBehavior.Setup(db => db.StartSqlDependencyListener()).Returns(true);
dbBehavior.Setup(db => db.AddSqlDependency(It.IsAny <IDbCommand>(), It.IsAny <Action <SqlNotificationEventArgs> >()))
.Callback(() => sqlDependencyAdded = true);
var operation = new ObservableDbOperation("test", "test", logger.Object, dbProviderFactory, dbBehavior.Object);
dbProviderFactory.MockDataReader.Setup(r => r.Read()).Returns(() =>
{
if (sqlDependencyAdded)
{
// Fake the SQL dependency firing while we're setting it up
operation.CurrentNotificationState = ObservableDbOperation.NotificationState.NotificationReceived;
sqlDependencyAdded = false;
}
return(false);
});
long?stateOnLoopRestart = null;
var queriedCount = 0;
operation.Queried += () =>
{
queriedCount++;
if (queriedCount == 3)
{
// First query after the loop starts again, capture the state
stateOnLoopRestart = operation.CurrentNotificationState;
mre.Set();
}
};
// Act
ThreadPool.QueueUserWorkItem(_ => operation.ExecuteReaderWithUpdates((__, ___) => { }));
mre.Wait();
Assert.True(stateOnLoopRestart.HasValue);
Assert.Equal(ObservableDbOperation.NotificationState.ProcessingUpdates, stateOnLoopRestart.Value);
operation.Dispose();
}
public void Basic_Success()
{
var fakeDbBehavior = A.Fake <IDbBehavior>();
A.CallTo(() => fakeDbBehavior.UpdateLoopRetryDelays).Returns(_updateLoopRetryDelays);
ObservableDbOperation dbOperation = new ObservableDbOperation(string.Empty, string.Empty, new TraceSource("ss"),
fakeDbBehavior,
A.Fake <IDbProviderFactory>(),
A.Fake <IOracleDependencyManager>(),
A.Fake <ISignalrDbDependencyFactory>(),
true);
dbOperation.ExecuteReaderWithUpdates(A.Fake <Action <IDataRecord, IDbOperation> >());
}
public void UpdateDependency()
{
var fakeOracleDependencyManager = A.Fake <IOracleDependencyManager>();
var fakeOracleDependencyManagerRegistryDepCall =
A.CallTo(() => fakeOracleDependencyManager.RegisterDependency(null)).WithAnyArguments();
var fakeSignalrDbDependencyFactory = A.Fake <ISignalrDbDependencyFactory>();
var fakeSignalrDbDependencyFactoryCreateDepCall =
A.CallTo(() => fakeSignalrDbDependencyFactory.CreateDbDependency(null, false, 0, false))
.WithAnyArguments();
var fakeSignalrDependency = new FakeSignalrDependency();
fakeSignalrDbDependencyFactoryCreateDepCall.Returns(fakeSignalrDependency);
TraceSource trace = new TraceSource("Fault");
FakeTraceListener fakeListener = new FakeTraceListener();
trace.Listeners.Add(fakeListener);
trace.Switch.Level = SourceLevels.All;
ObservableDbOperation dbOperation = new ObservableDbOperation(string.Empty, string.Empty, trace,
null,
A.Fake <IDbProviderFactory>(),
fakeOracleDependencyManager,
fakeSignalrDbDependencyFactory,
true);
dbOperation.ExecuteReaderWithUpdates(A.Fake <Action <IDataRecord, IDbOperation> >());
fakeSignalrDependency.FireEvent(OracleNotificationType.Change, OracleNotificationInfo.Update);
int counter = 0;
dbOperation.Faulted += (ex) => { counter++; };
Assert.AreEqual(0, counter);
Assert.IsTrue(fakeListener.Traces.Exists(item => item.StartsWith("Oracle notification details:")));
fakeSignalrDependency.FireEvent(OracleNotificationType.Change, OracleNotificationInfo.End);
Assert.AreEqual(0, counter);
Assert.IsTrue(fakeListener.Traces.Exists(item => item.StartsWith("Oracle notification timed out")));
fakeSignalrDependency.FireEvent(OracleNotificationType.Change, OracleNotificationInfo.Drop);
Assert.AreEqual(1, counter);
Assert.IsTrue(fakeListener.Traces.Exists(item => item.StartsWith("Unexpected Oracle notification details:")));
fakeOracleDependencyManagerRegistryDepCall.MustHaveHappened(Repeated.AtLeast.Once);
fakeSignalrDbDependencyFactoryCreateDepCall.MustHaveHappened(Repeated.AtLeast.Once);
}
public void CatchQLreceiveloop()
{
// Configure IDbBehaviour to issue OracleException during AddOracleDependency
var fakeDbBehavior = A.Fake <IDbBehavior>();
A.CallTo(() => fakeDbBehavior.AddOracleDependency(null, null))
.WithAnyArguments()
.Throws(new Exception("Hello, World!"));
A.CallTo(() => fakeDbBehavior.UpdateLoopRetryDelays).Returns(_updateLoopRetryDelays);
// Define trace source with our listener to collect trace messages
var traceSource = new TraceSource("ss");
FakeTraceListener fakeListener = new FakeTraceListener();
traceSource.Listeners.Add(fakeListener);
traceSource.Switch.Level = SourceLevels.All;
var fakeOracleDependencyManager = A.Fake <IOracleDependencyManager>();
var fakeSignalrDbDependencyFactory = A.Fake <ISignalrDbDependencyFactory>();
var fakeDbProviderFactory = A.Fake <IDbProviderFactory>();
ObservableDbOperation dbOperation = new ObservableDbOperation(string.Empty, string.Empty, traceSource,
fakeDbBehavior,
fakeDbProviderFactory,
fakeOracleDependencyManager,
fakeSignalrDbDependencyFactory,
useOracleDependency: true);
Action <object> action = (object obj) =>
{
dbOperation.ExecuteReaderWithUpdates(A.Fake <Action <IDataRecord, IDbOperation> >());
};
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken token = source.Token;
Task task = new Task(action, "ss", token);
task.Start();
task.Wait(TimeSpan.FromMilliseconds(5000));
source.Cancel();
Assert.IsNull(task.Exception);
// Don`t know why it is here
// Assert.IsNotInstanceOfType(task.Exception, typeof(AggregateException));
Assert.IsTrue(fakeListener.Traces.Exists(item => item.StartsWith("Error in SQL receive loop")));
}
public void DoesRetryLoopConfiguredNumberOfTimes(int?length1, int?length2, int?length3)
{
// Arrange
var retryLoopCount = 0;
var mre = new ManualResetEventSlim();
var retryLoopArgs = new List <int?>(new[] { length1, length2, length3 }).Where(l => l.HasValue);
var retryLoopTotal = retryLoopArgs.Sum().Value;
var retryLoopDelays = new List <Tuple <int, int> >(retryLoopArgs.Select(l => new Tuple <int, int>(0, l.Value)));
var sqlDependencyCreated = false;
var dbProviderFactory = new MockDbProviderFactory();
var dbBehavior = new Mock <IDbBehavior>();
var logger = new Mock <ILogger>();
dbBehavior.Setup(db => db.UpdateLoopRetryDelays).Returns(retryLoopDelays);
dbBehavior.Setup(db => db.StartSqlDependencyListener()).Returns(true);
dbBehavior.Setup(db => db.AddSqlDependency(It.IsAny <IDbCommand>(), It.IsAny <Action <SqlNotificationEventArgs> >()))
.Callback(() =>
{
sqlDependencyCreated = true;
mre.Set();
});
var operation = new ObservableDbOperation("test", "test", logger.Object, dbProviderFactory, dbBehavior.Object);
operation.Faulted += _ => mre.Set();
operation.Queried += () =>
{
if (!sqlDependencyCreated)
{
// Only update the loop count if the SQL dependency hasn't been created yet (we're still in the loop)
retryLoopCount++;
}
if (retryLoopCount == retryLoopTotal)
{
mre.Set();
}
};
// Act
ThreadPool.QueueUserWorkItem(_ => operation.ExecuteReaderWithUpdates((record, o) => { }));
mre.Wait();
operation.Dispose();
// Assert
Assert.Equal(retryLoopTotal, retryLoopCount);
}
public void ExecuteReaderSetsNotificationStateCorrectlyWhenRecordsReceivedWhileSettingUpSqlDependency()
{
// Arrange
var mre = new ManualResetEventSlim(false);
var retryLoopDelays = new[] { Tuple.Create(0, 1) };
var dbProviderFactory = new MockDbProviderFactory();
var readCount = 0;
var sqlDependencyAddedCount = 0;
dbProviderFactory.MockDataReader.Setup(r => r.Read()).Returns(() => ++ readCount == 2 && sqlDependencyAddedCount == 1);
var dbBehavior = new Mock <IDbBehavior>();
dbBehavior.Setup(db => db.UpdateLoopRetryDelays).Returns(retryLoopDelays);
dbBehavior.Setup(db => db.StartSqlDependencyListener()).Returns(true);
dbBehavior.Setup(db => db.AddSqlDependency(It.IsAny <IDbCommand>(), It.IsAny <Action <SqlNotificationEventArgs> >())).Callback(() => sqlDependencyAddedCount++);
var operation = new ObservableDbOperation("test", "test", new TraceSource("test"), dbProviderFactory, dbBehavior.Object);
long?stateOnLoopRestart = null;
var queriedCount = 0;
operation.Queried += () =>
{
queriedCount++;
if (queriedCount == 3)
{
// First query after the loop starts again, check the state is reset
stateOnLoopRestart = operation.CurrentNotificationState;
mre.Set();
}
};
// Act
ThreadPool.QueueUserWorkItem(_ => operation.ExecuteReaderWithUpdates((__, ___) => { }));
Assert.True(mre.Wait(5000));
Assert.True(stateOnLoopRestart.HasValue);
Assert.Equal(ObservableDbOperation.NotificationState.ProcessingUpdates, stateOnLoopRestart.Value);
operation.Dispose();
}
public void UseSqlNotificationsIfAvailable(bool supportSqlNotifications)
{
// Arrange
var sqlDependencyAdded = false;
var retryLoopCount = 0;
var mre = new ManualResetEventSlim();
var dbProviderFactory = new MockDbProviderFactory();
var dbBehavior = new Mock <IDbBehavior>();
var logger = new Mock <ILogger>();
dbBehavior.Setup(db => db.UpdateLoopRetryDelays).Returns(_defaultRetryDelays);
dbBehavior.Setup(db => db.StartSqlDependencyListener()).Returns(supportSqlNotifications);
dbBehavior.Setup(db => db.AddSqlDependency(It.IsAny <IDbCommand>(), It.IsAny <Action <SqlNotificationEventArgs> >()))
.Callback(() =>
{
sqlDependencyAdded = true;
mre.Set();
});
var operation = new ObservableDbOperation("test", "test", logger.Object, dbProviderFactory, dbBehavior.Object);
operation.Faulted += _ => mre.Set();
operation.Queried += () =>
{
retryLoopCount++;
if (retryLoopCount > 1)
{
mre.Set();
}
};
// Act
ThreadPool.QueueUserWorkItem(_ => operation.ExecuteReaderWithUpdates((record, o) => { }));
mre.Wait();
operation.Dispose();
// Assert
Assert.Equal(supportSqlNotifications, sqlDependencyAdded);
}
public void Pooling_Success()
{
var fakeDbReader = A.Fake <IDataReader>();
var fakeDbReaderReadCall = A.CallTo(() => fakeDbReader.Read());
fakeDbReaderReadCall.ReturnsNextFromSequence(true, true, false);
var fakeEmptyDbReader = A.Fake <IDataReader>();
A.CallTo(() => fakeEmptyDbReader.Read()).Returns(false);
var fakeDbCommand = A.Fake <IDbCommand>();
A.CallTo(() => fakeDbCommand.ExecuteReader()).ReturnsNextFromSequence(fakeDbReader, fakeEmptyDbReader);
var fakeDbConnection = A.Fake <IDbConnection>();
A.CallTo(() => fakeDbConnection.CreateCommand()).Returns(fakeDbCommand);
var fakeDbConnectionDisposeCall = A.CallTo(() => fakeDbConnection.Dispose());
var fakeDbProviderFactory = A.Fake <IDbProviderFactory>();
A.CallTo(() => fakeDbProviderFactory.CreateConnection()).Returns(fakeDbConnection);
var fakeProcessRecordAction = A.Fake <Action <IDataRecord, IDbOperation> >();
var fakeProcessRecordActionInvokeCall = A.CallTo(() => fakeProcessRecordAction.Invoke(null, null)).WithAnyArguments();
var fakeDbBehavior = A.Fake <IDbBehavior>();
A.CallTo(() => fakeDbBehavior.UpdateLoopRetryDelays).Returns(_updateLoopRetryDelays);
var fakeOracleDependencyManager = A.Fake <IOracleDependencyManager>();
var fakeOracleDependencyManagerRegistryDepCall = A.CallTo(() => fakeOracleDependencyManager.RegisterDependency(null)).WithAnyArguments();
var fakeOracleDependencyManagerRemoveRegistrationCall =
A.CallTo(() => fakeOracleDependencyManager.RemoveRegistration(string.Empty)).WithAnyArguments();
var fakeSignalrDbDependencyFactory = A.Fake <ISignalrDbDependencyFactory>();
var fakeSignalrDbDependencyFactoryCreateDepCall = A.CallTo(() => fakeSignalrDbDependencyFactory.CreateDbDependency(null, false, 0, false)).WithAnyArguments();
ObservableDbOperation dbOperation = new ObservableDbOperation(string.Empty, string.Empty, new TraceSource("ss"),
fakeDbBehavior,
fakeDbProviderFactory,
fakeOracleDependencyManager,
fakeSignalrDbDependencyFactory,
false);
using (var cts = new CancellationTokenSource())
{
Task.Run(() => dbOperation.ExecuteReaderWithUpdates(fakeProcessRecordAction),
cts.Token);
Thread.Sleep(1000);
cts.Cancel();
}
Thread.Sleep(1000);
fakeOracleDependencyManagerRegistryDepCall.MustNotHaveHappened();
fakeSignalrDbDependencyFactoryCreateDepCall.MustNotHaveHappened();
fakeProcessRecordActionInvokeCall.MustHaveHappened();
fakeDbReaderReadCall.MustHaveHappened(Repeated.Exactly.Times(3));
fakeDbConnectionDisposeCall.MustHaveHappened();
dbOperation.Dispose();
fakeOracleDependencyManagerRemoveRegistrationCall.MustHaveHappened(Repeated.Exactly.Once);
}