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