public void WrapsParameters()
{
var mockCommand = new Mock <IAdomdCommand>();
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
Assert.That(cmd.Parameters, Is.EqualTo(null));
mockCommand.VerifyGet(p => p.Parameters, Times.Once);
}
public void WrapsPrepare()
{
var mockCommand = new Mock <IAdomdCommand>();
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
cmd.Prepare();
mockCommand.Verify(p => p.Prepare(), Times.Once);
}
public void WrapsCommandTimeout()
{
var mockCommand = new Mock <IAdomdCommand>();
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
Assert.That(cmd.CommandTimeout, Is.EqualTo(0));
mockCommand.VerifyGet(p => p.CommandTimeout, Times.Once);
cmd.CommandTimeout = 30;
mockCommand.VerifySet(command => command.CommandTimeout = It.Is <int>(i => i == 30), Times.Once);
}
public void WrapsCommandText()
{
var mockCommand = new Mock <IAdomdCommand>();
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
Assert.That(cmd.CommandText, Is.Null);
mockCommand.VerifyGet(p => p.CommandText, Times.Once);
cmd.CommandText = "ABC";
mockCommand.VerifySet(command => command.CommandText = It.Is <string>(s => s == "ABC"), Times.Once);
}
public void Constructor_ConnectionMatches_And_CommandIdIsSetToDefault()
{
var connectionId = Guid.NewGuid();
var connection = new Mock <IAdomdConnection>().Object;
var cmd = new GlimpseAdomdCommand(new Mock <IAdomdCommand>().Object, connection, connectionId);
Assert.That(cmd.ConnectionId, Is.EqualTo(connectionId));
Assert.That(cmd.Connection, Is.Not.Null);
Assert.That(cmd.Connection, Is.EqualTo(connection));
Assert.That(cmd.CommandId, Is.EqualTo(new Guid()));
}
public void WrapsExecuteScalar()
{
var mockCommand = new Mock <IAdomdCommand>();
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
var result = cmd.ExecuteScalar();
Assert.That(result, Is.Null);
mockCommand.Verify(p => p.ExecuteScalar(), Times.Once);
}
public void WrapsConnection()
{
var mockCommand = new Mock <IAdomdCommand>();
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
Assert.That(cmd.Connection, Is.EqualTo(mockConnection.Object));
Assert.That(
() => cmd.Connection = new Mock <IDbConnection>().Object,
Throws.InstanceOf <NotImplementedException>().With.Message.EqualTo("This behavior is not yet implemented."));
}
public void WrapsUpdatedRowSource()
{
var mockCommand = new Mock <IAdomdCommand>();
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
Assert.That(cmd.UpdatedRowSource, Is.EqualTo(UpdateRowSource.None));
mockCommand.VerifyGet(p => p.UpdatedRowSource, Times.Once);
cmd.UpdatedRowSource = UpdateRowSource.Both;
mockCommand.VerifySet(command => command.UpdatedRowSource = It.Is <UpdateRowSource>(t => t == UpdateRowSource.Both), Times.Once);
}
public void WrapsCommandType()
{
var mockCommand = new Mock <IAdomdCommand>();
mockCommand.SetupGet(p => p.CommandType).Returns(CommandType.StoredProcedure);
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
Assert.That(cmd.CommandType, Is.EqualTo(CommandType.StoredProcedure));
mockCommand.VerifyGet(p => p.CommandType, Times.Once);
cmd.CommandType = CommandType.Text;
mockCommand.VerifySet(command => command.CommandType = It.Is <CommandType>(i => i == CommandType.Text), Times.Once);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandExecutor"/> class.
/// </summary>
/// <param name="command">The glimpse command.</param>
/// <param name="messagePublisher">The message publisher.</param>
public CommandExecutor(GlimpseAdomdCommand command, ITimedMessagePublisher messagePublisher)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
if (messagePublisher == null)
{
throw new ArgumentNullException("messagePublisher");
}
_command = command;
_messagePublisher = messagePublisher;
}
public void WrapsTransaction()
{
var mockCommand = new Mock <IAdomdCommand>();
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
Assert.That(cmd.Transaction, Is.EqualTo(null));
mockCommand.VerifyGet(p => p.Transaction, Times.Once);
var mockTx = new Mock <IDbTransaction>().Object;
cmd.Transaction = mockTx;
mockCommand.VerifySet(command => command.Transaction = It.Is <IDbTransaction>(t => t == mockTx), Times.Once);
}
public void WrapsCreateParameter()
{
var mockCommand = new Mock <IAdomdCommand>();
var mockParameter = new Mock <IDbDataParameter>().Object;
mockCommand.Setup(p => p.CreateParameter()).Returns(mockParameter);
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
var parameter = cmd.CreateParameter();
Assert.That(parameter, Is.EqualTo(mockParameter));
mockCommand.Verify(p => p.CreateParameter(), Times.Once);
}
public void WrapsExecuteReader()
{
var mockCommand = new Mock <IAdomdCommand>();
var mockConnection = new Mock <IAdomdConnection>();
var cmd = new GlimpseAdomdCommand(mockCommand.Object, mockConnection.Object, Guid.NewGuid());
var result = cmd.ExecuteReader();
Assert.That(result, Is.Null);
mockCommand.Verify(p => p.ExecuteReader(), Times.Once);
result = cmd.ExecuteReader(CommandBehavior.SchemaOnly);
Assert.That(result, Is.Null);
mockCommand.Verify(p => p.ExecuteReader(It.Is <CommandBehavior>(x => x == CommandBehavior.SchemaOnly)), Times.Once);
}
public void WrapsCreateCommandWithExplicitInterfaceCall()
{
var mockCmd = new Mock <IAdomdCommand>();
var mockConn = new Mock <IAdomdConnection>();
mockConn.Setup(p => p.CreateCommand()).Returns(mockCmd.Object);
var conn = new GlimpseAdomdConnection(mockConn.Object, new Mock <ITimedMessagePublisher>().Object);
var cmd = ((IDbConnection)conn).CreateCommand();
Assert.That(cmd, Is.Not.Null);
Assert.That(cmd, Is.InstanceOf <GlimpseAdomdCommand>());
GlimpseAdomdCommand command = (GlimpseAdomdCommand)cmd;
Assert.That(conn, Is.EqualTo(command.Connection));
Assert.That(conn.ConnectionId, Is.EqualTo(command.ConnectionId));
mockConn.Verify(p => p.CreateCommand(), Times.Once);
}
public void CommandExecutor_ExecuteWithErrorsEmitsStartsAndStopMessages()
{
var mockCommand = new Mock <IAdomdCommand>();
mockCommand.Setup(p => p.Execute()).Throws <NotSupportedException>();
mockCommand.SetupAllProperties();
var command = mockCommand.Object;
var mockConnection = new Mock <IAdomdConnection>();
var guidConnection = Guid.NewGuid();
var glimpseCommand = new GlimpseAdomdCommand(command, mockConnection.Object, guidConnection)
{
CommandText = "ABC"
};
var mockTimedMessagePublisher = new Mock <ITimedMessagePublisher>();
var commandExecutor = new CommandExecutor(glimpseCommand, mockTimedMessagePublisher.Object);
Assert.That(() => commandExecutor.Execute(c => c.Execute(), "Execute"), Throws.InstanceOf <NotSupportedException>());
Assert.That(glimpseCommand.CommandId, Is.Not.Null);
mockTimedMessagePublisher.Verify(p => p.EmitStartMessage(
It.Is <CommandExecutedMessage>(c =>
c.CommandId == glimpseCommand.CommandId &&
c.ConnectionId == guidConnection &&
c.CommandText == "ABC" &&
c.HasTransaction == false &&
c.IsAsync == false
)), Times.Once);
mockTimedMessagePublisher.Verify(p => p.EmitStopMessage(
It.Is <CommandErrorMessage>(c =>
c.CommandId == glimpseCommand.CommandId &&
c.ConnectionId == guidConnection &&
c.Exception != null && c.Exception.GetType() == typeof(NotSupportedException) &&
c.EventCategory == AdomdTimelineCategory.Command &&
c.EventName == "Command: Error" &&
c.EventSubText == "Execute" &&
c.IsAsync == false)), Times.Once);
}
public void CommandExecutor_ExecuteNormalCallEmitsStartAndStopMessages()
{
var mockCommand = new Mock <IAdomdCommand>();
mockCommand.Setup(p => p.Execute()).Returns(13);
mockCommand.SetupAllProperties();
var command = mockCommand.Object;
var mockConnection = new Mock <IAdomdConnection>();
var guidConnection = Guid.NewGuid();
var glimpseCommand = new GlimpseAdomdCommand(command, mockConnection.Object, guidConnection)
{
CommandText = "ABC"
};
var mockTimedMessagePublisher = new Mock <ITimedMessagePublisher>();
var commandExecutor = new CommandExecutor(glimpseCommand, mockTimedMessagePublisher.Object);
var result = commandExecutor.Execute(c => c.Execute(), "Execute");
Assert.That(result, Is.EqualTo(13));
Assert.That(glimpseCommand.CommandId, Is.Not.Null);
mockTimedMessagePublisher.Verify(p => p.EmitStartMessage(
It.Is <CommandExecutedMessage>(c =>
c.CommandId == glimpseCommand.CommandId &&
c.ConnectionId == guidConnection &&
c.CommandText == "ABC" &&
c.HasTransaction == false &&
c.IsAsync == false
)), Times.Once);
mockTimedMessagePublisher.Verify(p => p.EmitStopMessage(
It.Is <CommandDurationMessage>(c =>
c.CommandId == glimpseCommand.CommandId &&
c.ConnectionId == guidConnection &&
c.EventCategory == AdomdTimelineCategory.Command &&
c.EventName == "Command: Executed" &&
c.EventSubText == "Execute" &&
c.IsAsync == false)), Times.Once);
}
public void CommandExecutor_ExecuteWithErrorsEmitsStartsAndStopMessages()
{
var mockCommand = new Mock<IAdomdCommand>();
mockCommand.Setup(p => p.Execute()).Throws<NotSupportedException>();
mockCommand.SetupAllProperties();
var command = mockCommand.Object;
var mockConnection = new Mock<IAdomdConnection>();
var guidConnection = Guid.NewGuid();
var glimpseCommand = new GlimpseAdomdCommand(command, mockConnection.Object, guidConnection)
{
CommandText = "ABC"
};
var mockTimedMessagePublisher = new Mock<ITimedMessagePublisher>();
var commandExecutor = new CommandExecutor(glimpseCommand, mockTimedMessagePublisher.Object);
Assert.That(() => commandExecutor.Execute(c => c.Execute(), "Execute"), Throws.InstanceOf<NotSupportedException>());
Assert.That(glimpseCommand.CommandId, Is.Not.Null);
mockTimedMessagePublisher.Verify(p => p.EmitStartMessage(
It.Is<CommandExecutedMessage>(c =>
c.CommandId == glimpseCommand.CommandId
&& c.ConnectionId == guidConnection
&& c.CommandText == "ABC"
&& c.HasTransaction == false
&& c.IsAsync == false
)), Times.Once);
mockTimedMessagePublisher.Verify(p => p.EmitStopMessage(
It.Is<CommandErrorMessage>(c =>
c.CommandId == glimpseCommand.CommandId
&& c.ConnectionId == guidConnection
&& c.Exception != null && c.Exception.GetType() == typeof(NotSupportedException)
&& c.EventCategory == AdomdTimelineCategory.Command
&& c.EventName == "Command: Error"
&& c.EventSubText == "Execute"
&& c.IsAsync == false)), Times.Once);
}
public void CommandExecutor_ExecuteNormalCallEmitsStartAndStopMessages()
{
var mockCommand = new Mock<IAdomdCommand>();
mockCommand.Setup(p => p.Execute()).Returns(13);
mockCommand.SetupAllProperties();
var command = mockCommand.Object;
var mockConnection = new Mock<IAdomdConnection>();
var guidConnection = Guid.NewGuid();
var glimpseCommand = new GlimpseAdomdCommand(command, mockConnection.Object, guidConnection)
{
CommandText = "ABC"
};
var mockTimedMessagePublisher = new Mock<ITimedMessagePublisher>();
var commandExecutor = new CommandExecutor(glimpseCommand, mockTimedMessagePublisher.Object);
var result = commandExecutor.Execute(c => c.Execute(), "Execute");
Assert.That(result, Is.EqualTo(13));
Assert.That(glimpseCommand.CommandId, Is.Not.Null);
mockTimedMessagePublisher.Verify(p => p.EmitStartMessage(
It.Is<CommandExecutedMessage>(c =>
c.CommandId == glimpseCommand.CommandId
&& c.ConnectionId == guidConnection
&& c.CommandText == "ABC"
&& c.HasTransaction == false
&& c.IsAsync == false
)), Times.Once);
mockTimedMessagePublisher.Verify(p => p.EmitStopMessage(
It.Is<CommandDurationMessage>(c =>
c.CommandId == glimpseCommand.CommandId
&& c.ConnectionId == guidConnection
&& c.EventCategory == AdomdTimelineCategory.Command
&& c.EventName == "Command: Executed"
&& c.EventSubText == "Execute"
&& c.IsAsync == false)), Times.Once);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandExecutor"/> class.
/// </summary>
/// <param name="command">The glimpse command.</param>
public CommandExecutor(GlimpseAdomdCommand command)
: this(command, new TimedMessagePublisher())
{
}
