public async Task WhenAddFailsReturnsMessage()
{
var user = TestUtils.GetRandomUser();
var lobbyMessage = new LobbyMessage
{
Id = 1,
MessageDateTime = DateTime.UtcNow,
MessageText = "Test Message",
Sender = user
};
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(user);
MessageServiceMock.Setup(ms => ms.AddMessageAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(lobbyMessage);
var result = await Controller.AddMessage(new AddMessageRequest());
var response = TestUtils.GetResponseFromResult <AddMessageResponse>(result);
Assert.IsTrue(response.Success);
Assert.AreEqual(lobbyMessage.Id, response.NewMessage.Id);
Assert.AreEqual(lobbyMessage.MessageText, response.NewMessage.Message);
Assert.AreEqual(lobbyMessage.MessageDateTime, response.NewMessage.Time);
Assert.AreEqual(lobbyMessage.Sender.UserName, response.NewMessage.User);
SubscriberMock.Verify(s => s.PublishAsync(It.IsAny <RedisChannel>(), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Once);
}
public void ShouldNotPrintShortOptionIfItIsNullOrEmpty()
{
// Arrange
var command = new HelpCommand();
var createCommand = new Mock <IConsoleCommand>();
var messageService = new MessageServiceMock();
createCommand.Setup(c => c.Name).Returns("create");
createCommand.Setup(c => c.Description).Returns("Creates or upgrades a database");
createCommand.Setup(c => c.Usage).Returns("dbversion create [options]");
createCommand.Setup(c => c.Parameters).Returns(
new[]
{
new CommandParameter(null, "--archive", "Specifies the path to the archive."),
new CommandParameter(string.Empty, "--connectionString", "Specifies the database connection string."),
new CommandParameter("-s", "--saved-connection", "Specifies the saved connection to use.")
});
command.Commands = new[] { createCommand.Object };
command.MessageService = messageService;
// Act
command.Execute(new[] { "help", "create" });
// Assert
string expected =
"Usage: dbversion create [options]" + Environment.NewLine + Environment.NewLine +
"Options:" + Environment.NewLine +
" --archive Specifies the path to the archive." + Environment.NewLine +
" --connectionString Specifies the database connection string." + Environment.NewLine +
" -s, --saved-connection Specifies the saved connection to use." + Environment.NewLine;
Assert.Equal(expected, messageService.Contents);
}
public void ShouldBeAbleToUpdateExistingSavedConnection()
{
// Arrange
var command = new SavedConnectionCommand();
var service = new Mock <ISavedConnectionService>();
var messageService = new MessageServiceMock();
command.SavedConnectionService = service.Object;
command.MessageService = messageService;
service.Setup(s => s.SavedConnections).Returns(
new[] { new SavedConnection("connection1", "connString", "provider", "driver", "dialect", true) });
service.Setup(s => s.CreateSavedConnection("connection1", "newConnString", "provider", "driver", "dialect"))
.Returns(new SavedConnection("connection1", "newConnString", "provider", "driver", "dialect", true));
// Act
command.Execute(
new[]
{
"saved-connection",
"-n", "connection1",
"-c", "newConnString"
});
// Assert
service.Verify(s => s.CreateSavedConnection("connection1", "newConnString", "provider", "driver", "dialect"));
service.Verify(s => s.SaveConnections());
}
public async Task CopiesPackageToPublicStorageAndSendsEmailUponSuccess()
{
AddValidation("validation1", ValidationStatus.Succeeded);
Package.PackageStatusKey = PackageStatus.Validating;
var stream = new MemoryStream();
PackageFileServiceMock
.Setup(pfs => pfs.DownloadValidationPackageFileAsync(Package))
.ReturnsAsync(stream)
.Verifiable();
PackageFileServiceMock
.Setup(pfs => pfs.SavePackageFileAsync(Package, stream))
.Returns(Task.FromResult(0))
.Verifiable();
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, Package);
PackageFileServiceMock
.Verify(pfs => pfs.DownloadValidationPackageFileAsync(Package), Times.Once());
PackageFileServiceMock
.Verify(pfs => pfs.DownloadValidationPackageFileAsync(It.IsAny <Package>()), Times.Once());
PackageFileServiceMock
.Verify(pfs => pfs.SavePackageFileAsync(Package, stream), Times.Once());
PackageFileServiceMock
.Verify(pfs => pfs.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>()), Times.Once());
MessageServiceMock
.Verify(ms => ms.SendPackagePublishedMessage(Package), Times.Once());
MessageServiceMock
.Verify(ms => ms.SendPackagePublishedMessage(It.IsAny <Package>()), Times.Once());
}
public void ShouldPrintListOfCommandsAndDescriptions()
{
// Arrange
var command = new HelpCommand();
var createCommand = new Mock <IConsoleCommand>();
var versionCommand = new Mock <IConsoleCommand>();
var helpCommand = new Mock <IConsoleCommand>();
var messageService = new MessageServiceMock();
createCommand.Setup(c => c.Name).Returns("create");
createCommand.Setup(c => c.Description).Returns("Creates or upgrades a database.");
versionCommand.Setup(c => c.Name).Returns("version");
versionCommand.Setup(c => c.Description).Returns("Displays the application version.");
helpCommand.Setup(c => c.Name).Returns("help");
helpCommand.Setup(c => c.Description).Returns("Provides help on using the application.");
command.Commands = new[] { createCommand.Object, versionCommand.Object, helpCommand.Object };
command.MessageService = messageService;
// Act
command.Execute(new[] { "help" });
// Assert
string expected =
" create Creates or upgrades a database." + Environment.NewLine +
" help Provides help on using the application." + Environment.NewLine +
" version Displays the application version." + Environment.NewLine + Environment.NewLine +
" Use dbversion help [command] for more help on a command." + Environment.NewLine;
Assert.Equal(expected, messageService.Contents);
}
public void ShouldPrintErrorIfTemplateCannotBeFound()
{
// Arrange
var command = new SavedConnectionCommand();
var service = new Mock <ISavedConnectionService>();
var messageService = new MessageServiceMock();
command.SavedConnectionService = service.Object;
command.MessageService = messageService;
service.Setup(s => s.SavedConnections).Returns(CreateConnections());
// Act
command.Execute(
new[]
{
"saved-connection",
"-n", "connection5",
"-t", "missingConnection",
"-c", "newConnString"
});
// Assert
var expectedMessage =
"Template connection \"missingConnection\" could not be found." + Environment.NewLine;
Assert.Equal(expectedMessage, messageService.Contents);
}
private List <string> RecordOperationOrder()
{
var operations = new List <string>();
PackageStateProcessorMock
.Setup(x => x.SetStatusAsync(It.IsAny <IValidatingEntity <Package> >(), It.IsAny <PackageValidationSet>(), It.IsAny <PackageStatus>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IStatusProcessor <Package> .SetStatusAsync)));
ValidationStorageServiceMock
.Setup(x => x.UpdateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationStorageService.UpdateValidationSetAsync)));
MessageServiceMock
.Setup(x => x.SendPublishedMessageAsync(It.IsAny <Package>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IMessageService <Package> .SendPublishedMessageAsync)));
MessageServiceMock
.Setup(x => x.SendValidationFailedMessageAsync(It.IsAny <Package>(), It.IsAny <PackageValidationSet>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IMessageService <Package> .SendValidationFailedMessageAsync)));
TelemetryServiceMock
.Setup(x => x.TrackTotalValidationDuration(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <TimeSpan>(), It.IsAny <bool>()))
.Callback(() => operations.Add(nameof(ITelemetryService.TrackTotalValidationDuration)));
PackageFileServiceMock
.Setup(x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationFileService.DeletePackageForValidationSetAsync)));
return(operations);
}
public async Task DoesNotSendValidatingTooLongMessageOnRevalidations()
{
const int postponeMinutes = 1;
AddValidation("validation1", ValidationStatus.Incomplete);
Configuration.TimeoutValidationSetAfter = TimeSpan.FromDays(1);
Configuration.ValidationSetNotificationTimeout = TimeSpan.FromMinutes(20);
Configuration.ValidationMessageRecheckPeriod = TimeSpan.FromMinutes(postponeMinutes);
ValidationSet.Created = DateTime.UtcNow - TimeSpan.FromMinutes(21);
ValidationSet.Updated = DateTime.UtcNow - TimeSpan.FromMinutes(15);
ValidationStorageServiceMock
.Setup(s => s.UpdateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Callback <PackageValidationSet>(s => s.Updated = DateTime.UtcNow)
.Returns(Task.FromResult(0));
ValidationStorageServiceMock
.Setup(s => s.GetValidationSetCountAsync(PackageValidatingEntity))
.Returns(Task.FromResult(2));
// Process the outcome once - the "too long to validate" message should NOT be sent.
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
TelemetryServiceMock
.Verify(t => t.TrackSentValidationTakingTooLongMessage(Package.PackageRegistration.Id, Package.NormalizedVersion, ValidationSet.ValidationTrackingId), Times.Never);
MessageServiceMock
.Verify(m => m.SendValidationTakingTooLongMessageAsync(Package), Times.Never);
ValidationEnqueuerMock
.Verify(ve => ve.StartValidationAsync(It.IsAny <PackageValidationMessageData>(), It.IsAny <DateTimeOffset>()), Times.Once);
PackageFileServiceMock
.Verify(x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
}
public void ShouldListCorrectConnectionWhenConnectionNameIsSpecified()
{
// Arrange
var command = new SavedConnectionCommand();
var service = new Mock <ISavedConnectionService>();
var messageService = new MessageServiceMock();
command.SavedConnectionService = service.Object;
command.MessageService = messageService;
service.Setup(s => s.SavedConnections).Returns(CreateConnections());
// Act
command.Execute(new[] { "saved-connection", "-n", "connection1" });
// Assert
var expectedMessage = "connection1:" + Environment.NewLine +
" Connection String: connString" + Environment.NewLine +
" Driver Class: driver" + Environment.NewLine +
" Provider: provider" + Environment.NewLine +
" Dialect: dialect" + Environment.NewLine +
" Default: False" + Environment.NewLine + Environment.NewLine;
Assert.Equal(expectedMessage, messageService.Contents);
}
public async Task WhenMessageNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.FindByIdAsync(It.IsAny <int>())).ReturnsAsync((LobbyMessage)null);
var result = await Controller.RemoveMessage(1);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenAddFailsReturnsFailure()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.AddMessageAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync((LobbyMessage)null);
var result = await Controller.AddMessage(new AddMessageRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenRemoveFailsReturnsFailure()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.FindByIdAsync(It.IsAny <int>())).ReturnsAsync(new LobbyMessage());
MessageServiceMock.Setup(ms => ms.UpdateMessageAsync(It.IsAny <LobbyMessage>())).ReturnsAsync(false);
var result = await Controller.RemoveMessage(1);
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task DoesNotSendSuccessEmailIfPackageIsAlreadyAvailable()
{
AddValidation("validation1", ValidationStatus.Succeeded);
Package.PackageStatusKey = PackageStatus.Available;
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
MessageServiceMock.Verify(
x => x.SendPublishedMessageAsync(It.IsAny <Package>()),
Times.Never);
}
public async Task WhenCalledReturnsMessagesResponse()
{
MessageServiceMock.Setup(ns => ns.GetLatestLobbyMessagesAsync()).ReturnsAsync(new List <LobbyMessage> {
new LobbyMessage {
Sender = new GametekiUser()
}
});
var result = await Controller.GetMessages();
var response = TestUtils.GetResponseFromResult <GetMessagesResponse>(result);
Assert.IsTrue(response.Success);
Assert.AreEqual(1, response.Messages.Count);
}
public void OneTimeSetUp()
{
Setup.Bootstrap(SetupType.Test);
ApiClientMock = new ApiClientMock();
CatServiceMock = new CatServiceMock();
MessageBrokerMock = new MessageBrokerMock <Cat>();
MessageConsumerMock = new MessageConsumerMock <Cat>();
MessageConsumerServiceMock = new MessageServiceMock <Cat>();
LoggerFactoryMock = new LoggerFactoryMock();
CatService = new CatService(MessageBrokerMock.Instance, ApiClientMock.Instance);
MessageConsumer = new MessageConsumer <Cat>(ApiClientMock.Instance, LoggerFactoryMock.Instance);
MessageService = new MessageService <Cat>(MessageBrokerMock.Instance, MessageConsumerMock.Instance, LoggerFactoryMock.Instance);
ViewModel = new MainViewModel(CatServiceMock.Instance);
}
public async Task SendsFailureEmailOnFailedValidation(ValidationIssueCode[] issueCodes)
{
AddValidation("validation1", ValidationStatus.Failed);
ValidationSet.PackageValidations.First().PackageValidationIssues = issueCodes
.Select(ic => new PackageValidationIssue {
IssueCode = ic
})
.ToList();
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
MessageServiceMock
.Verify(ms => ms.SendValidationFailedMessageAsync(Package, ValidationSet), Times.Once());
MessageServiceMock
.Verify(ms => ms.SendValidationFailedMessageAsync(It.IsAny <Package>(), It.IsAny <PackageValidationSet>()), Times.Once());
}
public void ShouldDisplayMessageWhenNoSavedConnectionsExist()
{
// Arrange
var command = new SavedConnectionCommand();
var service = new Mock <ISavedConnectionService>();
var messageService = new MessageServiceMock();
command.SavedConnectionService = service.Object;
command.MessageService = messageService;
// Act
command.Execute(new[] { "saved-connection" });
// Assert
var expectedMessage = "There are no saved connections." + Environment.NewLine;
Assert.Equal(expectedMessage, messageService.Contents);
}
public async Task WhenRemoveSucceedsReturnsSuccess()
{
var lobbyMessage = new LobbyMessage();
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.FindByIdAsync(It.IsAny <int>())).ReturnsAsync(lobbyMessage);
MessageServiceMock.Setup(ms => ms.UpdateMessageAsync(It.IsAny <LobbyMessage>())).ReturnsAsync(true);
var result = await Controller.RemoveMessage(1);
var response = TestUtils.GetResponseFromResult <DeleteMessageResponse>(result);
Assert.IsTrue(response.Success);
Assert.IsTrue(lobbyMessage.Removed);
Assert.AreEqual(DateTime.UtcNow.Date, lobbyMessage.RemovedDateTime.Date);
Assert.AreEqual(1, response.MessageId);
SubscriberMock.Verify(s => s.PublishAsync(It.IsAny <RedisChannel>(), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Once);
}
public void ShouldDisplayMessageWhenSpecifiedConnectionDoesNotExist()
{
// Arrange
var command = new SavedConnectionCommand();
var service = new Mock <ISavedConnectionService>();
var messageService = new MessageServiceMock();
command.SavedConnectionService = service.Object;
command.MessageService = messageService;
service.Setup(s => s.SavedConnections).Returns(CreateConnections());
// Act
command.Execute(new[] { "saved-connection", "-n", "abc" });
// Assert
var expectedMessage = "There is no saved connection called \"abc\"." + Environment.NewLine;
Assert.Equal(expectedMessage, messageService.Contents);
}
public async Task DoesNotTakeDownAvailablePackages()
{
AddValidation("validation1", ValidationStatus.Failed);
Package.PackageStatusKey = PackageStatus.Available;
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Once);
PackageStateProcessorMock.Verify(
x => x.SetStatusAsync(It.IsAny <PackageValidatingEntity>(), It.IsAny <PackageValidationSet>(), It.IsAny <PackageStatus>()),
Times.Never);
MessageServiceMock.Verify(
x => x.SendValidationFailedMessageAsync(It.IsAny <Package>(), It.IsAny <PackageValidationSet>()),
Times.Never);
MessageServiceMock.Verify(
x => x.SendPublishedMessageAsync(It.IsAny <Package>()),
Times.Never);
}
public async Task MakesPackageAvailableAndSendsEmailUponSuccess()
{
AddValidation("validation1", ValidationStatus.Succeeded);
Package.PackageStatusKey = PackageStatus.Validating;
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
PackageStateProcessorMock.Verify(
x => x.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available),
Times.Once);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Once);
MessageServiceMock
.Verify(ms => ms.SendPublishedMessageAsync(Package), Times.Once());
MessageServiceMock
.Verify(ms => ms.SendPublishedMessageAsync(It.IsAny <Package>()), Times.Once());
}
public async Task SendsTooLongNotificationOnlyWhenItConcernsRequiredValidation(
ValidationStatus requiredValidationState,
ValidationStatus optionalValidationState,
bool requiredValidationSucceeded)
{
bool expectedNotification = requiredValidationState == ValidationStatus.Incomplete || requiredValidationState == ValidationStatus.NotStarted;
AddValidation("requiredValidation", requiredValidationState, ValidationFailureBehavior.MustSucceed);
AddValidation("optionalValidaiton", optionalValidationState, ValidationFailureBehavior.AllowedToFail);
ProcessorStats.AnyRequiredValidationSucceeded = requiredValidationSucceeded;
Configuration.TimeoutValidationSetAfter = TimeSpan.FromDays(1);
Configuration.ValidationSetNotificationTimeout = TimeSpan.FromMinutes(20);
Configuration.ValidationMessageRecheckPeriod = TimeSpan.FromMinutes(1);
ValidationSet.Created = DateTime.UtcNow - Configuration.ValidationSetNotificationTimeout - TimeSpan.FromMinutes(1);
ValidationSet.Updated = DateTime.UtcNow - TimeSpan.FromMinutes(15);
ValidationStorageServiceMock
.Setup(s => s.UpdateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Callback <PackageValidationSet>(s => s.Updated = DateTime.UtcNow)
.Returns(Task.CompletedTask);
ValidationStorageServiceMock
.Setup(s => s.GetValidationSetCountAsync(PackageValidatingEntity))
.Returns(Task.FromResult(1));
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
if (expectedNotification)
{
MessageServiceMock
.Verify(m => m.SendValidationTakingTooLongMessageAsync(Package), Times.Once());
}
else
{
MessageServiceMock
.Verify(m => m.SendValidationTakingTooLongMessageAsync(Package), Times.Never());
}
}
public async Task MarksPackageAsFailedAndSendsEmailOnFailedValidation()
{
AddValidation("validation1", ValidationStatus.Failed);
PackageServiceMock
.Setup(ps => ps.UpdatePackageStatusAsync(Package, PackageStatus.FailedValidation, true))
.Returns(Task.FromResult(0))
.Verifiable();
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, Package);
PackageServiceMock
.Verify(ps => ps.UpdatePackageStatusAsync(Package, PackageStatus.FailedValidation, true), Times.Once());
PackageServiceMock
.Verify(ps => ps.UpdatePackageStatusAsync(It.IsAny <Package>(), It.IsAny <PackageStatus>(), It.IsAny <bool>()), Times.Once());
MessageServiceMock
.Verify(ms => ms.SendPackageValidationFailedMessage(Package), Times.Once());
MessageServiceMock
.Verify(ms => ms.SendPackageValidationFailedMessage(It.IsAny <Package>()), Times.Once());
}
public void ShouldDisplayErrorMessageAndUsageIfCommandIsUnknown()
{
// Arrange
var command = new HelpCommand();
var createCommand = new Mock <IConsoleCommand>();
var messageService = new MessageServiceMock();
createCommand.Setup(c => c.Name).Returns("create");
command.Commands = new[] { createCommand.Object };
command.MessageService = messageService;
// Act
command.Execute(new[] { "help", "some-command" });
// Assert
string expected =
"Unknown command 'some-command'." + Environment.NewLine + Environment.NewLine +
"Usage: dbversion help [command]" + Environment.NewLine;
Assert.Equal(expected, messageService.Contents);
}
public void ShouldPrintAnErrorMessageIfDefaultingFails()
{
// Arrange
var command = new SavedConnectionCommand();
var service = new Mock <ISavedConnectionService>();
var messageService = new MessageServiceMock();
command.SavedConnectionService = service.Object;
command.MessageService = messageService;
service.Setup(s => s.SavedConnections).Returns(CreateConnections());
service.Setup(s => s.SetDefaultConnection("connection5")).Returns(false);
// Act
command.Execute(new[] { "saved-connection", "-n", "connection5", "--default" });
// Assert
var expectedMessage = "There is no saved connection called \"connection5\"." + Environment.NewLine;
Assert.Equal(expectedMessage, messageService.Contents);
service.Verify(s => s.SaveConnections(), Times.Never());
}
public void ShouldBeAbleToDefaultSavedConnection()
{
// Arrange
var command = new SavedConnectionCommand();
var service = new Mock <ISavedConnectionService>();
var messageService = new MessageServiceMock();
command.SavedConnectionService = service.Object;
command.MessageService = messageService;
service.Setup(s => s.SavedConnections).Returns(CreateConnections());
service.Setup(s => s.SetDefaultConnection("connection1")).Returns(true);
// Act
command.Execute(new[] { "saved-connection", "-n", "connection1", "--default" });
// Assert
var expectedMessage = "\"connection1\" is now the default connection." + Environment.NewLine;
Assert.Equal(expectedMessage, messageService.Contents);
service.Verify(s => s.SaveConnections());
}
public async Task PackageStillBecomesAvailableIfPublishedMessageFails()
{
var exception = new Exception("Something baaad happened");
MessageServiceMock
.Setup(ms => ms.SendPublishedMessageAsync(It.IsAny <Package>()))
.Throws(exception);
Package.PackageStatusKey = PackageStatus.Validating;
var processor = CreateProcessor();
var thrownException = await Record.ExceptionAsync(
async() => await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats));
Assert.NotNull(thrownException);
PackageStateProcessorMock.Verify(
x => x.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available),
Times.Once);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
}
public void ShouldBeAbleToCreateAConnectionFromATemplate()
{
// Arrange
var command = new SavedConnectionCommand();
var service = new Mock <ISavedConnectionService>();
var messageService = new MessageServiceMock();
command.SavedConnectionService = service.Object;
command.MessageService = messageService;
service.Setup(s => s.SavedConnections).Returns(CreateConnections());
service.Setup(s => s.CreateSavedConnection("connection5", "newConnString", "newProvider", "newDriver", "newDialect"))
.Returns(new SavedConnection("connection5", "newConnString", "newProvider", "newDriver", "newDialect", false));
// Act
command.Execute(
new[]
{
"saved-connection",
"-n", "connection5",
"-t", "connection1",
"-c", "newConnString",
"-d", "newDriver",
"-l", "newDialect",
"-p", "newProvider"
});
// Assert
var expectedMessage = "Created a new connection \"connection5\" based on \"connection1\"." + Environment.NewLine +
" Connection String: newConnString" + Environment.NewLine +
" Driver Class: newDriver" + Environment.NewLine +
" Provider: newProvider" + Environment.NewLine +
" Dialect: newDialect" + Environment.NewLine +
" Default: False" + Environment.NewLine + Environment.NewLine;
Assert.Equal(expectedMessage, messageService.Contents);
service.Verify(s => s.SaveConnections());
}
public void ShouldOnlyDisplayCommandUsageIfTheCommandHasNoParameters()
{
// Arrange
var command = new HelpCommand();
var createCommand = new Mock <IConsoleCommand>();
var messageService = new MessageServiceMock();
createCommand.Setup(c => c.Name).Returns("create");
createCommand.Setup(c => c.Description).Returns("Creates or upgrades a database");
createCommand.Setup(c => c.Usage).Returns("dbversion create [options]");
command.Commands = new[] { createCommand.Object };
command.MessageService = messageService;
// Act
command.Execute(new[] { "help", "create" });
// Assert
string expected =
"Usage: dbversion create [options]" + Environment.NewLine;
Assert.Equal(expected, messageService.Contents);
}
public void ShouldBeAbleToCreateNewSavedConnection()
{
// Arrange
var command = new SavedConnectionCommand();
var service = new Mock <ISavedConnectionService>();
var messageService = new MessageServiceMock();
command.SavedConnectionService = service.Object;
command.MessageService = messageService;
service.Setup(s => s.CreateSavedConnection("connection1", "connString", "provider", "driver", "dialect"))
.Returns(new SavedConnection("connection1", "connString", "provider", "driver", "dialect", true));
// Act
command.Execute(
new[]
{
"saved-connection",
"-n", "connection1",
"-c", "connString",
"-l", "dialect",
"-p", "provider",
"-d", "driver"
});
// Assert
var expectedMessage = "Created new saved connection \"connection1\":" + Environment.NewLine +
" Connection String: connString" + Environment.NewLine +
" Driver Class: driver" + Environment.NewLine +
" Provider: provider" + Environment.NewLine +
" Dialect: dialect" + Environment.NewLine +
" Default: True" + Environment.NewLine + Environment.NewLine;
Assert.Equal(expectedMessage, messageService.Contents);
service.Verify(s => s.CreateSavedConnection("connection1", "connString", "provider", "driver", "dialect"));
service.Verify(s => s.SaveConnections());
}
