public void ObserverShouldOnlyReceiveSubscribedNotifications() { // Arrange var eventAggregator = new EventAggregator(); var observer1 = new Mock<IObserve<TestEvent>>(); var observer2 = new Mock<IObserve<OtherEvent>>(); eventAggregator.Subscribe(observer1.Object); eventAggregator.Subscribe(observer2.Object); var testEvent = new TestEvent(); var otherEvent = new OtherEvent(); // Act eventAggregator.Publish(testEvent); eventAggregator.Publish(otherEvent); // Assert observer1.Verify(x => x.OnNext(It.IsAny<IEvent>()), Times.Once); observer1.Verify(x => x.OnNext(testEvent), Times.Once); observer2.Verify(x => x.OnNext(otherEvent), Times.Once); }
public void EmitSummary_Logs_Expected_Messages_With_Valid_Results_That_Has_A_Warning_But_No_Errors() { // Arrange var loggerMock = new Mock<ILog>(); ConsoleEmitter.SetLogger(loggerMock.Object); var expectedCompiledCode = "CompiledCode" + Guid.NewGuid(); var compilerResults = new CompilerResults { OutputFilePath = string.Empty, Errors = null, Warnings = new List<CompilerError> { new CompilerError { Lineno = 0, Type = string.Empty, Error = string.Empty, Line = string.Empty, } }, CompiledCode = expectedCompiledCode, }; var emitter = new ConsoleEmitter(); // Act emitter.EmitSummary(compilerResults); // Assert loggerMock.Verify(m => m.Info(It.Is<string>(s => s == "----------------------------")), Times.Exactly(2)); loggerMock.Verify(m => m.Info(It.Is<string>(s => s == "Code Emitted:")), Times.Once); loggerMock.Verify(m => m.Info(It.Is<string>(s => s == expectedCompiledCode)), Times.Once); loggerMock.Verify(m => m.Info(It.Is<string>(s => s.Contains("1 Warnings"))), Times.Once); }
public async Task ExecuteAsync_calls_Commit_if_no_transaction() { var mockModificationCommandBatch = new Mock<ModificationCommandBatch>(); mockModificationCommandBatch.Setup(m => m.ModificationCommands.Count).Returns(1); var mockRelationalConnection = new Mock<IRelationalConnection>(); var transactionMock = new Mock<IDbContextTransaction>(); IDbContextTransaction currentTransaction = null; mockRelationalConnection.Setup(m => m.BeginTransaction()).Returns(() => currentTransaction = transactionMock.Object); mockRelationalConnection.Setup(m => m.CurrentTransaction).Returns(() => currentTransaction); var cancellationToken = new CancellationTokenSource().Token; var batchExecutor = new BatchExecutor(); await batchExecutor.ExecuteAsync(new[] { mockModificationCommandBatch.Object }, mockRelationalConnection.Object, cancellationToken); mockRelationalConnection.Verify(rc => rc.OpenAsync(cancellationToken)); mockRelationalConnection.Verify(rc => rc.Close()); transactionMock.Verify(t => t.Commit()); mockModificationCommandBatch.Verify(mcb => mcb.ExecuteAsync( It.IsAny<IRelationalConnection>(), cancellationToken)); }
public void CallTest() { //Arrange var domainStatProjectState1 = new DomainStatProjectState() { Producer = ProductName.TaggerIPhone, IsSuccessfulUpload = true }; var domainStatProjectState2 = new DomainStatProjectState() { Producer = ProductName.TaggerIPhone, IsSuccessfulUpload = false }; var domainStatProjectState3 = new DomainStatProjectState() { Producer = "ProductName", IsSuccessfulUpload = true }; var domainReport = new DomainReport(); var statProjectDeletionFilter = new Mock<IStatProjectDeletionFilter>(); var taggerIPhoneDeletionsFilter = new TaggerIPhoneDeletionsFilter(); taggerIPhoneDeletionsFilter.Set(statProjectDeletionFilter.Object); //Act taggerIPhoneDeletionsFilter.Call(domainStatProjectState1, domainReport); taggerIPhoneDeletionsFilter.Call(domainStatProjectState2, domainReport); taggerIPhoneDeletionsFilter.Call(domainStatProjectState3, domainReport); //Assert Assert.AreEqual(1, domainReport.TaggerIPhoneDeletions); statProjectDeletionFilter.Verify(m => m.Call(domainStatProjectState1, domainReport), Times.Once()); statProjectDeletionFilter.Verify(m => m.Call(domainStatProjectState2, domainReport), Times.Once()); statProjectDeletionFilter.Verify(m => m.Call(domainStatProjectState3, domainReport), Times.Once()); }
public void CallTest() { //Arrange var domainStatProjectState1 = new DomainStatProjectState() { Producer = ProductName.ImageShack, IsSuccessfulUpload = true }; var domainStatProjectState2 = new DomainStatProjectState() { Producer = ProductName.ImageShack, IsSuccessfulUpload = false }; var domainStatProjectState3 = new DomainStatProjectState() { Producer = ProductName.ImageShack, IsSuccessfulUpload = false }; var domainStatProjectState4 = new DomainStatProjectState() { Producer = "ProductName", IsSuccessfulUpload = true }; var domainReport = new DomainReport(); var statProjectDeletionFilter = new Mock<IStatProjectCancellationFilter>(); var imageShackCancellationFilter = new ImageShackCancellationFilter(); imageShackCancellationFilter.Set(statProjectDeletionFilter.Object); //Act imageShackCancellationFilter.Call(domainStatProjectState1, domainReport); imageShackCancellationFilter.Call(domainStatProjectState2, domainReport); imageShackCancellationFilter.Call(domainStatProjectState3, domainReport); imageShackCancellationFilter.Call(domainStatProjectState4, domainReport); //Assert Assert.AreEqual(2, domainReport.ImageShackUploadCancels); statProjectDeletionFilter.Verify(m => m.Call(domainStatProjectState1, domainReport), Times.Once()); statProjectDeletionFilter.Verify(m => m.Call(domainStatProjectState2, domainReport), Times.Once()); statProjectDeletionFilter.Verify(m => m.Call(domainStatProjectState3, domainReport), Times.Once()); statProjectDeletionFilter.Verify(m => m.Call(domainStatProjectState4, domainReport), Times.Once()); }
public void Add() { var lockKey = new DatasetLockKey(); var datasetLock = new Mock<ITrackDatasetLocks>(); { datasetLock.Setup(d => d.LockForWriting()) .Returns(lockKey) .Verifiable(); datasetLock.Setup(d => d.RemoveWriteLock(It.IsAny<DatasetLockKey>())) .Callback<DatasetLockKey>(key => Assert.AreSame(lockKey, key)) .Verifiable(); } var originalId = new GroupCompositionId(); var originalDefinition = new GroupDefinition("a"); var storage = new Mock<IStoreGroupsAndConnections>(); { storage.Setup(s => s.Add(It.IsAny<GroupCompositionId>(), It.IsAny<GroupDefinition>())) .Callback<GroupCompositionId, GroupDefinition>( (id, def) => { Assert.AreSame(originalId, id); Assert.AreSame(originalDefinition, def); }); } var commands = new CompositionCommands(datasetLock.Object, storage.Object); var task = commands.Add(originalId, originalDefinition); task.Wait(); datasetLock.Verify(d => d.LockForWriting(), Times.Once()); datasetLock.Verify(d => d.RemoveWriteLock(It.IsAny<DatasetLockKey>()), Times.Once()); }
public void Insert_Poco() { //Just a few props as it is just to test that it runs var user = TestDataHelper.GetUserList().First(); var newUser = new InsertUser { Id = Guid.NewGuid(), Name = user.Name }; var sessionMock = new Mock<ISession>(MockBehavior.Strict); sessionMock .Setup(s => s.ExecuteAsync(It.IsAny<BoundStatement>())) .Returns(TestHelper.DelayedTask(new RowSet())) .Verifiable(); sessionMock .Setup(s => s.PrepareAsync(It.IsAny<string>())) .Returns<string>(cql => TaskHelper.ToTask(GetPrepared(cql))) .Verifiable(); var mappingClient = GetMappingClient(sessionMock); //Execute mappingClient.Insert(newUser); sessionMock.Verify(s => s.ExecuteAsync(It.Is<BoundStatement>(stmt => stmt.QueryValues.Length == TestHelper.ToDictionary(newUser).Count && stmt.PreparedStatement.Cql.StartsWith("INSERT INTO users (") )), Times.Exactly(1)); sessionMock.Verify(); }
public void InitializationOfAmqpStuff() { const String queueName = "queue_name"; const String exchangeName = "exchange_name"; const String routingKey = "routing_key"; var configuration = new EnvironmentConfiguration(); configuration.Endpoint(new Uri("amqp://localhost:5672")); configuration.GeneratesMessageIdBy(new Mock<INewId>().Object); configuration.ResolveMessageTypeBy(new Mock<IMessageTypeResolver>().Object); var model = new Mock<IModel>(); var connectionBuilder = StubConnectionBuilder(model); var broker = new BrokerWrapper(connectionBuilder.Object, model.Object, configuration); var consumer = new FakeConsumer(_ => Task.Factory.StartNew(() => { })); var queue = broker.DeclareQueue(queueName); var exchange = broker.DeclareDirectExchange(exchangeName); broker.DeclareExchangeBinding(exchange, queue, routingKey); broker.SubscribeByAtLeastOnce(queue, _ => { _.Consumes(consumer); }); broker.Connect(); model.Verify(_ => _.QueueDeclare(queueName, false, false, false, It.IsAny<IDictionary<String, Object>>())); model.Verify(_ => _.ExchangeDeclare(exchangeName, "direct", false, false, It.IsAny<IDictionary<String, Object>>())); model.Verify(_ => _.QueueBind(queueName, exchangeName, routingKey, It.IsAny<IDictionary<String, Object>>())); }
public void TestILGenerator() { var generator = new ILGenProxyGenerator(); var proxyType = generator.CreateProxy<IAwesomeInterface>(); var instanceMock = new Mock<IAwesomeInterface>(); var proxyHandlerMock = new Mock<IProxyHandler<IAwesomeInterface>>(); var proxy = (IAwesomeInterface) Activator.CreateInstance(proxyType, instanceMock.Object, proxyHandlerMock.Object); proxy.FaulyCachedMethod(); var proxyRequest1 = ProxyRequest<IAwesomeInterface>.FromExpression(a => a.FaulyCachedMethod()); instanceMock.Verify(a => a.FaulyCachedMethod(), Times.Never()); proxyHandlerMock.Verify(a => a.HandleRequest(proxyRequest1), Times.Once()); proxy.VoidMethod(); instanceMock.Verify(a => a.VoidMethod(), Times.Once()); proxy.ParameteredMethod("", 1); var proxyRequest2 = ProxyRequest<IAwesomeInterface>.FromExpression(a => a.ParameteredMethod("", 1)); instanceMock.Verify(a => a.ParameteredMethod("", 1), Times.Never()); proxyHandlerMock.Verify(a => a.HandleRequest(proxyRequest2)); }
public void NoLocalReleasesFileMeansWeStartFromScratch() { string localPackagesDir = Path.Combine(".", "theApp", "packages"); string localReleasesFile = Path.Combine(localPackagesDir, "RELEASES"); var fileInfo = new Mock<FileInfoBase>(); fileInfo.Setup(x => x.Exists).Returns(false); var dirInfo = new Mock<DirectoryInfoBase>(); dirInfo.Setup(x => x.Exists).Returns(true); var fs = new Mock<IFileSystemFactory>(); fs.Setup(x => x.GetFileInfo(localReleasesFile)).Returns(fileInfo.Object); fs.Setup(x => x.CreateDirectoryRecursive(localPackagesDir)).Verifiable(); fs.Setup(x => x.DeleteDirectoryRecursive(localPackagesDir)).Verifiable(); fs.Setup(x => x.GetDirectoryInfo(localPackagesDir)).Returns(dirInfo.Object); var urlDownloader = new Mock<IUrlDownloader>(); var dlPath = IntegrationTestHelper.GetPath("fixtures", "RELEASES-OnePointOne"); urlDownloader.Setup(x => x.DownloadUrl(It.IsAny<string>(), It.IsAny<IObserver<int>>())) .Returns(Observable.Return(File.ReadAllText(dlPath, Encoding.UTF8))); var fixture = new UpdateManager("http://lol", "theApp", FrameworkVersion.Net40, ".", fs.Object, urlDownloader.Object); using (fixture) { fixture.CheckForUpdate().First(); } fs.Verify(x => x.CreateDirectoryRecursive(localPackagesDir), Times.Once()); fs.Verify(x => x.DeleteDirectoryRecursive(localPackagesDir), Times.Once()); }
public void EmitSummary_Logs_Expected_Messages_With_Valid_Results_That_Has_Empty_Errors_And_Null_Warnings() { // Arrange var loggerMock = new Mock<ILog>(); ConsoleEmitter.SetLogger(loggerMock.Object); var expectedCompiledCode = "CompiledCode" + Guid.NewGuid(); var compilerResults = new CompilerResults { OutputFilePath = string.Empty, Errors = new List<CompilerError>(), Warnings = null, CompiledCode = expectedCompiledCode, }; var emitter = new ConsoleEmitter(); // Act emitter.EmitSummary(compilerResults); // Assert loggerMock.Verify(m => m.Info(It.Is<string>(s => s == "----------------------------")), Times.Exactly(2)); loggerMock.Verify(m => m.Info(It.Is<string>(s => s == "No Errors or Warnings Found!")), Times.Once); loggerMock.Verify(m => m.Info(It.Is<string>(s => s == "Code Emitted:")), Times.Once); loggerMock.Verify(m => m.Info(It.Is<string>(s => s == expectedCompiledCode)), Times.Once); }
public void InstallPackageRunsInitAndInstallScripts() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectRepository = new MockProjectPackageRepository(localRepository); var fileSystem = new MockFileSystem(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(new MockProjectSystem()); var project = TestUtils.GetProject("Foo"); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock<IScriptExecutor>(); var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); var package = NuGet.Test.PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, tools: new[] { "init.ps1", "install.ps1" }); sourceRepository.AddPackage(package); var installer = new VsPackageInstaller(packageManagerFactory.Object, scriptExecutor.Object, new Mock<IPackageRepositoryFactory>().Object, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object); // Act installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false); // Assert scriptExecutor.Verify(e => e.Execute(It.IsAny<string>(), PowerShellScripts.Init, It.IsAny<IPackage>(), It.IsAny<Project>(), It.IsAny<ILogger>()), Times.Once()); scriptExecutor.Verify(e => e.Execute(It.IsAny<string>(), PowerShellScripts.Install, It.IsAny<IPackage>(), It.IsAny<Project>(), It.IsAny<ILogger>()), Times.Once()); }
public void RunBenchmarks_Should_LogExceptionsButNotResults_When_ClassAndMethodNameSpecifiedAndExceptionsAreThrown() { var assemblyInterrogator = new Mock<AssemblyInterrogator>(); assemblyInterrogator.Setup(p => p.AssemblyName).Returns("TestBenchmark.dll"); var items = new List<Object>(); var testObject = new TestBenchmarkClass1(); testObject.TestBenchy2ThrowException = true; items.Add(testObject); string errors; assemblyInterrogator.Setup(p => p.PopulateItemsToBench(out errors)).Returns(true); assemblyInterrogator.Setup(p => p.ItemsToBench).Returns(items); var outputWriter = new Mock<OutputWriter>(); var processStarter = new Mock<ProcessStarterFactory>(); var target = new BenchmarkExecuter( new Settings {BuildLabel = "Build1", BenchmarkClass = "TestBenchmarkClass1", BenchmarkMethod = "TestBenchy2"}, assemblyInterrogator.Object, outputWriter.Object, processStarter.Object); bool result = target.RunBenchmarks(out errors); Assert.IsFalse(result); Assert.IsTrue(testObject.SetUpCalled); Assert.IsTrue(testObject.TearDownCalled); Assert.IsFalse(testObject.TestBenchy1Called); Assert.IsTrue(testObject.TestBenchy2Called); outputWriter.Verify(o => o.WriteResults("TestBenchy2", "Build1", It.IsAny<long>()), Times.Never()); outputWriter.Verify(o => o.WriteError(It.IsAny<string>(), "TestBenchy2", "Build1"), Times.Once()); }
public async Task ExecuteAsync_does_not_call_Commit_if_existing_transaction() { var sqlGenerator = new Mock<IUpdateSqlGenerator>().Object; var mockModificationCommandBatch = new Mock<ModificationCommandBatch>(sqlGenerator); mockModificationCommandBatch.Setup(m => m.ModificationCommands.Count).Returns(1); var mockRelationalConnection = new Mock<IRelationalConnection>(); var transactionMock = new Mock<IRelationalTransaction>(); mockRelationalConnection.Setup(m => m.Transaction).Returns(transactionMock.Object); var cancellationToken = new CancellationTokenSource().Token; var relationalTypeMapper = new ConcreteTypeMapper(); var batchExecutor = new BatchExecutorForTest(relationalTypeMapper); await batchExecutor.ExecuteAsync(new[] { mockModificationCommandBatch.Object }, mockRelationalConnection.Object, cancellationToken); mockRelationalConnection.Verify(rc => rc.OpenAsync(cancellationToken)); mockRelationalConnection.Verify(rc => rc.Close()); mockRelationalConnection.Verify(rc => rc.BeginTransaction(), Times.Never); transactionMock.Verify(t => t.Commit(), Times.Never); mockModificationCommandBatch.Verify(mcb => mcb.ExecuteAsync( It.IsAny<IRelationalTransaction>(), relationalTypeMapper, It.IsAny<DbContext>(), null, cancellationToken)); }
public void ShouldCopyFilesInPathIfLastWriteTimeDiffersFromLastWriteTimeOfFileInBin() { var args = new ScriptCsArgs { Restore = true, ScriptName = "" }; var fs = new Mock<IFileSystem>(); var resolver = new Mock<IPackageAssemblyResolver>(); var executor = new Mock<IScriptExecutor>(); var scriptpackResolver = new Mock<IScriptPackResolver>(); var packageInstaller = new Mock<IPackageInstaller>(); var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, scriptpackResolver.Object, packageInstaller.Object); const string CurrentDirectory = @"C:\"; var sourceFilePath = Path.Combine(CurrentDirectory, "fileName.cs"); var sourceWriteTime = new DateTime(2013, 3, 7); var destFilePath = Path.Combine(CurrentDirectory, "bin", "fileName.cs"); var destWriteTime = new DateTime(2013, 2, 7); fs.Setup(x => x.GetWorkingDirectory(It.IsAny<string>())).Returns(CurrentDirectory); fs.Setup(x => x.GetLastWriteTime(sourceFilePath)).Returns(sourceWriteTime).Verifiable(); fs.Setup(x => x.GetLastWriteTime(destFilePath)).Returns(destWriteTime).Verifiable(); resolver.Setup(i => i.GetAssemblyNames(CurrentDirectory, It.IsAny<Action<string>>())).Returns(new[] { sourceFilePath }); var factory = new CommandFactory(root); var result = factory.CreateCommand(args); result.Execute(); fs.Verify(x => x.Copy(sourceFilePath, destFilePath, true), Times.Once()); fs.Verify(x => x.GetLastWriteTime(sourceFilePath), Times.Once()); fs.Verify(x => x.GetLastWriteTime(destFilePath), Times.Once()); }
public void GetVersionNumber_NoDeadlock() { // Using an asynchronous HttpClient request within an MVC Web API action may cause // a deadlock when we wait for the result synchronously. var context = new Mock<SynchronizationContext> { CallBase = true }; SynchronizationContext.SetSynchronizationContext(context.Object); try { var provider = new DefaultVersionProvider(); provider.GetVersion(ClusterHelper.GetBucket("beer-sample")); // If view queries are incorrectly awaiting on the current SynchronizationContext // We will see calls to Post or Send on the mock context.Verify(m => m.Post(It.IsAny<SendOrPostCallback>(), It.IsAny<object>()), Times.Never); context.Verify(m => m.Send(It.IsAny<SendOrPostCallback>(), It.IsAny<object>()), Times.Never); } finally { SynchronizationContext.SetSynchronizationContext(null); } }
public void ShouldCreateBinFolderIfItDoesNotExist() { var args = new ScriptCsArgs { Restore = true, ScriptName = "" }; var fs = new Mock<IFileSystem>(); var resolver = new Mock<IPackageAssemblyResolver>(); var executor = new Mock<IScriptExecutor>(); var scriptpackResolver = new Mock<IScriptPackResolver>(); var packageInstaller = new Mock<IPackageInstaller>(); var root = new ScriptServiceRoot(fs.Object, resolver.Object, executor.Object, scriptpackResolver.Object, packageInstaller.Object); const string CurrentDirectory = @"C:\"; const string BinFolder = @"C:\bin"; fs.Setup(x => x.GetWorkingDirectory(It.IsAny<string>())).Returns(CurrentDirectory); var binFolderCreated = false; fs.Setup(x => x.DirectoryExists(BinFolder)).Returns(() => binFolderCreated).Verifiable(); fs.Setup(x => x.CreateDirectory(BinFolder)).Callback(() => binFolderCreated = true).Verifiable(); var factory = new CommandFactory(root); var result = factory.CreateCommand(args); result.Execute(); fs.Verify(x => x.DirectoryExists(BinFolder), Times.AtLeastOnce()); fs.Verify(x => x.CreateDirectory(BinFolder), Times.Once()); }
public void TestWithChannelListener() { var mockConnectionFactory = new Mock<ConnectionFactory>(); var mockConnection = new Mock<IConnection>(); var mockChannel = new Mock<IModel>(); mockConnectionFactory.Setup(factory => factory.CreateConnection()).Returns(mockConnection.Object); mockConnection.Setup(c => c.IsOpen).Returns(true); mockConnection.Setup(connection => connection.CreateModel()).Returns(mockChannel.Object); var called = new AtomicInteger(0); var connectionFactory = this.CreateConnectionFactory(mockConnectionFactory.Object); var channelListeners = new List<IChannelListener>(); var mockChannelListener = new Mock<IChannelListener>(); mockChannelListener.Setup(listener => listener.OnCreate(It.IsAny<IModel>(), It.IsAny<bool>())).Callback(() => called.IncrementValueAndReturn()); channelListeners.Add(mockChannelListener.Object); connectionFactory.ChannelListeners = channelListeners; var con = connectionFactory.CreateConnection(); var channel = con.CreateChannel(false); Assert.AreEqual(1, called.Value); channel.Close(); con.Close(); mockConnection.Verify(c => c.Close(), Times.Never()); connectionFactory.CreateConnection(); con.CreateChannel(false); Assert.AreEqual(2, called.Value); connectionFactory.Dispose(); mockConnection.Verify(c => c.Close(), Times.AtLeastOnce()); mockConnectionFactory.Verify(c => c.CreateConnection()); }
public void CallTest() { //Arrange var domainStatUserRegistration1 = new DomainStatUserRegistration() { ProductName = ProductName.TaggerAndroid }; var domainStatUserRegistration2 = new DomainStatUserRegistration() { ProductName = "ProductName" }; var domainStatUserRegistration3 = new DomainStatUserRegistration(); var domainReport = new DomainReport(); var statUserRegistrationFilter = new Mock<IStatUserRegistrationFilter>(); var taggerAndroidRegistrationsFilter = new TaggerAndroidRegistrationsFilter(); taggerAndroidRegistrationsFilter.Set(statUserRegistrationFilter.Object); //Act taggerAndroidRegistrationsFilter.Call(domainStatUserRegistration1, domainReport); taggerAndroidRegistrationsFilter.Call(domainStatUserRegistration2, domainReport); taggerAndroidRegistrationsFilter.Call(domainStatUserRegistration3, domainReport); //Assert Assert.AreEqual(1, domainReport.TaggerAndroidRegistrations); statUserRegistrationFilter.Verify(m => m.Call(domainStatUserRegistration1, domainReport), Times.Once()); statUserRegistrationFilter.Verify(m => m.Call(domainStatUserRegistration2, domainReport), Times.Once()); statUserRegistrationFilter.Verify(m => m.Call(domainStatUserRegistration3, domainReport), Times.Once()); }
public void Only_Retrieve_Distributions_Once() { var cloudfrontClient = new Mock<AmazonCloudFront>(); var distributionId = Guid.NewGuid().ToString(); var bucket = Guid.NewGuid().ToString(); var distribution = bucket + ".s3.amazonaws.com"; var key = Guid.NewGuid().ToString(); var listDistributionsResponse = new ListDistributionsResponse(); listDistributionsResponse.Distribution.Add(new CloudFrontDistribution { Id = distributionId, DistributionConfig = new CloudFrontDistributionConfig { S3Origin = new S3Origin(distribution, null) } }); cloudfrontClient.Setup(cfc => cfc.ListDistributions()) .Returns(listDistributionsResponse); var invalidator = new CloudFrontInvalidator(cloudfrontClient.Object); invalidator.InvalidateObject(bucket, key); invalidator.InvalidateObject(bucket, key); cloudfrontClient.Verify(cfc => cfc.PostInvalidation(It.Is<PostInvalidationRequest>(pir => pir.DistributionId == distributionId && pir.InvalidationBatch.Paths.Count == 1 && pir.InvalidationBatch.Paths.First() == key)), Times.Exactly(2)); cloudfrontClient.Verify(cfc => cfc.ListDistributions(), Times.Once()); }
public void ShouldStartAndStopNoSports() { var settings = new Mock<ISettings>(); settings.Setup(x => x.EventStateFilePath).Returns("."); var streamListenerManager = new StreamListenerManager(settings.Object); streamListenerManager.StateManager = _state.Object; var service = new Mock<IServiceFacade>(); service.Setup(x => x.IsConnected).Returns(true); var connector = new Mock<IAdapterPlugin>(); var listener = new Mock<IListener>(); settings.Setup(s => s.FixtureCheckerFrequency).Returns(10000); service.Setup(s => s.Connect()); var adapter = new Adapter( settings.Object, service.Object, connector.Object, streamListenerManager); adapter.Start(); adapter.Stop(); service.VerifyAll(); listener.Verify(l => l.Start(), Times.Never()); listener.Verify(l => l.Stop(), Times.Never()); }
public void Persister_Can_Successfully_Persist_New_Items_In_Memory() { var items = this.BuildItems(numberOfFeeds: 10, numberOfTweets: 20); var oldItem = this.BuildItem(DateTime.MinValue); var savedItems = new List<Item>(); var fakeStreamAggregator = new Mock<IItemAggregator>(); fakeStreamAggregator.Setup(a => a.GetLatest(DateTime.MinValue)).Returns(items); var fakeStreamProcessor = new Mock<IItemProcessor>(MockBehavior.Loose); var fakeStreamStorage = new Mock<IStreamStorage>(); fakeStreamStorage.Setup(s => s.Top()).Returns(oldItem); fakeStreamStorage.Setup(s => s.Save(It.IsAny<IEnumerable<Item>>())).Callback<IEnumerable<Item>>(savedItems.AddRange); var streamPersister = new StreamPersister(fakeStreamAggregator.Object, fakeStreamProcessor.Object, fakeStreamStorage.Object); streamPersister.PersistLatest(); CollectionAssert.AreEquivalent(items, savedItems); fakeStreamAggregator.Verify(a => a.GetLatest(oldItem.Published), Times.Once()); fakeStreamProcessor.Verify(p => p.Process(It.IsAny<Item>()), Times.Exactly(items.Count)); fakeStreamStorage.Verify(s => s.Top(), Times.Once()); fakeStreamStorage.Verify(s => s.Save(It.IsAny<IEnumerable<Item>>()), Times.Once()); }
public void CallTest() { //Arrange var domainStatUserRegistration1 = new DomainStatUserRegistration() { IdentityProvider = IdentityType.Twitter.ToString() }; var domainStatUserRegistration2 = new DomainStatUserRegistration() { IdentityProvider = "IdentityProvider" }; var domainStatUserRegistration3 = new DomainStatUserRegistration(); var domainReport = new DomainReport(); var statUserRegistrationFilter = new Mock<IStatUserRegistrationFilter>(); var twitterRegistrationsFilter = new TwitterRegistrationsFilter(); twitterRegistrationsFilter.Set(statUserRegistrationFilter.Object); //Act twitterRegistrationsFilter.Call(domainStatUserRegistration1, domainReport); twitterRegistrationsFilter.Call(domainStatUserRegistration2, domainReport); twitterRegistrationsFilter.Call(domainStatUserRegistration3, domainReport); //Assert Assert.AreEqual(1, domainReport.TwitterRegistrations); statUserRegistrationFilter.Verify(m => m.Call(domainStatUserRegistration1, domainReport), Times.Once()); statUserRegistrationFilter.Verify(m => m.Call(domainStatUserRegistration2, domainReport), Times.Once()); statUserRegistrationFilter.Verify(m => m.Call(domainStatUserRegistration3, domainReport), Times.Once()); }
public void GetIpAddress_DnsEntry_NoDeadlock() { // Using an asynchronous view query within an MVC Web API action causes // a deadlock if you wait for the result synchronously. var context = new Mock<SynchronizationContext> { CallBase = true }; SynchronizationContext.SetSynchronizationContext(context.Object); try { var uri = new Uri("http://localhost/"); uri.GetIpAddress(false); // If view queries are incorrectly awaiting on the current SynchronizationContext // We will see calls to Post or Send on the mock context.Verify(m => m.Post(It.IsAny<SendOrPostCallback>(), It.IsAny<object>()), Times.Never); context.Verify(m => m.Send(It.IsAny<SendOrPostCallback>(), It.IsAny<object>()), Times.Never); } finally { SynchronizationContext.SetSynchronizationContext(null); } }
public async Task Write_WritesCharValues_ToUnderlyingStream_WhenNotBuffering() { // Arrange var unbufferedWriter = new Mock<TextWriter> { CallBase = true }; var writer = new RazorTextWriter(unbufferedWriter.Object, Encoding.UTF8); var buffer1 = new[] { 'a', 'b', 'c', 'd' }; var buffer2 = new[] { 'd', 'e', 'f' }; // Act writer.Flush(); writer.Write('x'); writer.Write(buffer1, 1, 2); writer.Write(buffer2); await writer.WriteAsync(buffer2, 1, 1); await writer.WriteLineAsync(buffer1); // Assert Assert.Empty(writer.BufferedWriter.Buffer.BufferEntries); unbufferedWriter.Verify(v => v.Write('x'), Times.Once()); unbufferedWriter.Verify(v => v.Write(buffer1, 1, 2), Times.Once()); unbufferedWriter.Verify(v => v.Write(buffer1, 0, 4), Times.Once()); unbufferedWriter.Verify(v => v.Write(buffer2, 0, 3), Times.Once()); unbufferedWriter.Verify(v => v.WriteAsync(buffer2, 1, 1), Times.Once()); unbufferedWriter.Verify(v => v.WriteLine(), Times.Once()); }
public void TestCloseInvalidConnection() { var mocker = new AutoMoqer(); var mockConnectionFactory = mocker.GetMock<RabbitMQ.Client.ConnectionFactory>(); var mockConnection1 = new Mock<RabbitMQ.Client.IConnection>(); var mockConnection2 = new Mock<RabbitMQ.Client.IConnection>(); mockConnectionFactory.Setup(c => c.CreateConnection()).ReturnsInOrder(mockConnection1.Object, mockConnection2.Object); // simulate a dead connection mockConnection1.Setup(c => c.IsOpen).Returns(false); var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); var connection = connectionFactory.CreateConnection(); // the dead connection should be discarded connection.CreateChannel(false); mockConnectionFactory.Verify(c => c.CreateConnection(), Times.Exactly(2)); mockConnection2.Verify(c => c.CreateModel(), Times.Exactly(1)); connectionFactory.Dispose(); mockConnection2.Verify(c => c.Close(), Times.Exactly(1)); }
public void Test_PatternCreator_GetEmbroidery() { var mockCanvasConverter = new Mock<ICanvasConverter>(); var mockPatternMapGenerator = new Mock<IPatternMapGenerator>(); var mockDecoratorCompositions = new Mock<IDecoratorsComposition>(); mockPatternMapGenerator.Setup(map => map.Generate(It.IsAny<Canvas>(), It.IsAny<Settings>())).Returns(new Canvas(3, 3)); mockCanvasConverter.Setup(conv => conv.ConvertBitmapToCanvas(It.IsAny<Bitmap>())).Returns(new Canvas(4, 3)); mockDecoratorCompositions.Setup(decor => decor.Decorate(It.IsAny<Canvas>(), It.IsAny<Canvas>(), It.IsAny<Settings>())); Settings settings = new Settings(); settings.CellsCount = 3; settings.Coefficient = 2; settings.Palette = new Palette(new Color[]{Color.Red, Color.Blue}); settings.DecoratorsComposition = mockDecoratorCompositions.Object; EmbroideryCreator creator = new EmbroideryCreator(); creator.CanvasConverter = mockCanvasConverter.Object; creator.PatternMapGenerator = mockPatternMapGenerator.Object; Bitmap image = new Bitmap(4, 3); creator.GetEmbroidery(image, settings); mockCanvasConverter.Verify(conv => conv.ConvertBitmapToCanvas(image)); mockPatternMapGenerator.Verify(pat => pat.Generate(It.IsAny<Canvas>(), settings)); mockDecoratorCompositions.Verify(decor => decor.Decorate(It.IsAny<Canvas>(), It.IsAny<Canvas>(), settings)); mockCanvasConverter.Verify(conv => conv.ConvertCanvasToBitmap(It.IsAny<Canvas>())); }
public void VisitRecursively_visits_all_child_contexts() { // Arrange var fixture = new Fixture(); new RenderingContextCustomisation().Customize(fixture); var sut = new Mock<ContextVisitorBase>() { CallBase = true }; sut .Setup(x => x.Visit(It.IsAny<RenderingContext>())) .Returns((RenderingContext ctx) => new [] { ctx }); var contexts = Enumerable.Range(0,3) .Select(x => fixture.Create<RenderingContext>()) .ToArray(); var topContext = contexts[0]; var secondLevelContexts = contexts.Skip(1).ToArray(); Mock.Get(topContext).Setup(x => x.GetChildContexts()).Returns(secondLevelContexts); // Act sut.Object.VisitRecursively(topContext); // Assert sut.Verify(x => x.Visit(topContext), Times.Once()); sut.Verify(x => x.Visit(contexts[1]), Times.Once()); sut.Verify(x => x.Visit(contexts[2]), Times.Once()); }
public void Transform_Invokes_All_Transformers_In_Order() { const string name = "some value"; const string value = "1"; var transformerMock1 = new Mock<IValueTransformer>(); transformerMock1.Setup(x => x.Transform(value, name, null)) .Returns(value); transformerMock1.Setup(x => x.Order) .Returns(20); var transformerMock2 = new Mock<IValueTransformer>(); transformerMock2.Setup(x => x.Transform(value, name, null)) .Returns(value); transformerMock2.Setup(x => x.Order) .Returns(10); var transformer = new AggregateTransformer(transformerMock1.Object, transformerMock2.Object); var result = transformer.Transform(value, name, null); transformerMock1.Verify(x => x.Transform(value, name, null), Times.Once); transformerMock1.Verify(x => x.Transform(value, name, null), Times.Once); Assert.AreEqual(value, result); }
public async Task ExecuteAsync_calls_Commit_if_no_transaction() { var sqlGenerator = new Mock<ISqlGenerator>().Object; var mockModificationCommandBatch = new Mock<ModificationCommandBatch>(sqlGenerator); var mockRelationalConnection = new Mock<IRelationalConnection>(); var transactionMock = new Mock<RelationalTransaction>( mockRelationalConnection.Object, Mock.Of<DbTransaction>(), false, Mock.Of<ILogger>()); RelationalTransaction currentTransaction = null; mockRelationalConnection.Setup(m => m.BeginTransaction()).Returns(() => currentTransaction = transactionMock.Object); mockRelationalConnection.Setup(m => m.Transaction).Returns(() => currentTransaction); var cancellationToken = new CancellationTokenSource().Token; var relationalTypeMapper = new RelationalTypeMapper(); var batchExecutor = new BatchExecutorForTest(relationalTypeMapper); await batchExecutor.ExecuteAsync(new[] { mockModificationCommandBatch.Object }, mockRelationalConnection.Object, cancellationToken); mockRelationalConnection.Verify(rc => rc.OpenAsync(cancellationToken)); mockRelationalConnection.Verify(rc => rc.Close()); transactionMock.Verify(t => t.Commit()); mockModificationCommandBatch.Verify(mcb => mcb.ExecuteAsync( It.IsAny<RelationalTransaction>(), relationalTypeMapper, It.IsAny<DbContext>(), null, cancellationToken)); }
public void IncomingCompleteCallsBufferSizeControlAdd(Mock <IBufferSizeControl> mockBufferSizeControl) { using (var memory = new MemoryPool()) using (var socketInput = new SocketInput(memory, null, mockBufferSizeControl?.Object)) { socketInput.IncomingComplete(5, null); mockBufferSizeControl?.Verify(b => b.Add(5)); } }
public void IncomingDataCallsBufferSizeControlAdd(Mock <IBufferSizeControl> mockBufferSizeControl) { using (var memory = new MemoryPool()) using (var socketInput = new SocketInput(memory, null, mockBufferSizeControl?.Object)) { socketInput.IncomingData(new byte[5], 0, 5); mockBufferSizeControl?.Verify(b => b.Add(5)); } }
public void ConsumingCompleteCallsBufferSizeControlSubtract(Mock <IBufferSizeControl> mockBufferSizeControl) { using (var kestrelEngine = new KestrelEngine(new MockLibuv(), new TestServiceContext())) { kestrelEngine.Start(1); using (var memory = new MemoryPool()) using (var socketInput = new SocketInput(memory, null, mockBufferSizeControl?.Object)) { socketInput.IncomingData(new byte[20], 0, 20); var iterator = socketInput.ConsumingStart(); iterator.Skip(5); socketInput.ConsumingComplete(iterator, iterator); mockBufferSizeControl?.Verify(b => b.Subtract(5)); } } }
public void SendMessage_PostToMqttServer_WhenInputValid() { var exporter = GetTransactionsExporter(); var transactions = new List <BankTransactionInfo>() { new BankTransactionInfo { Amount = 10, Currency = "грн", DateTimeUtc = new DateTime(2020, 11, 28, 7, 59, 0, DateTimeKind.Utc), Merchant = "Test", Type = "test2" } }; var result = exporter.SendMessage(transactions, CancellationToken.None); var data = JsonSerializer.Serialize(transactions); mqttClientMock?.Verify( foo => foo.PublishAsync(It.IsAny <MqttApplicationMessage>(), It.IsAny <CancellationToken>()), Times.Once); }
public void GetSchema_GetSchemaByName() { // Arrange mockSchemaRepository = new Mock<IRepository<Schema>>(); var list = new List<Schema>() { new Schema() { Id = "1", Data = "Data", Name = "Name" }, }; mockSchemaRepository.Setup(x => x.Get(It.IsAny<Expression<Func<Schema, bool>>>())).Returns(list); var schemaService = new SchemaService(mockSchemaRepository.Object, mapper); var schemaDomain = new SchemaDomain(); // Act var res = schemaService.GetSchema("Name"); // Assert mockSchemaRepository.Verify(x => x.Get(It.IsAny<Expression<Func<Schema, bool>>>()), Times.Once); }
public void ResumableLogReaderCanHandleFileAccessError() { var fileSystemMock = new Mock <IFileSystem>(); fileSystemMock .Setup(f => f.File.Open(It.IsAny <string>(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) .Throws <UnauthorizedAccessException>(); FileSystemHelpers.Instance = fileSystemMock.Object; var fileMock = new Mock <FileInfoBase>(); fileMock.SetupGet(p => p.LastWriteTimeUtc).Returns(new DateTime(2000, 1, 1)); var tracerMock = new Mock <ITracer>(MockBehavior.Strict); tracerMock.Setup(t => t.Trace("Error occurred", It.IsAny <Dictionary <string, string> >())).Verifiable(); var reader = new ApplicationLogsReader.ResumableLogFileReader(fileMock.Object, tracerMock.Object); var results = reader.ReadNextBatch(1); Assert.Equal(0, results.Count); tracerMock.Verify(); }
public void WhenNewIssuesAreFound_ButForIncorrectFile_FilterNotCalledAndListenersAreNotUpdated() { // Arrange var issues = new[] { new Issue { RuleKey = "S123", StartLine = 1, EndLine = 1 } }; // Add a couple of error list listeners var errorListSinkMock1 = RegisterNewErrorListSink(); var errorListSinkMock2 = RegisterNewErrorListSink(); // Act using (new AssertIgnoreScope()) { ((IIssueConsumer)testSubject).Accept("aRandomFile.xxx", issues); } // Assert CheckSinkNotNotified(errorListSinkMock1); CheckSinkNotNotified(errorListSinkMock2); issuesFilter.Verify(x => x.Filter(It.IsAny <IEnumerable <IFilterableIssue> >()), Times.Never); }
public void GetTargetById() { //Arrange var service = new Mock <ITargetService>(); service.Setup(s => s.GetTargetById(1)).Returns(new TargetViewModel() { TargetId = 1, Name = "їжа", OrganizationId = 1 }); var controller = new TargetController(service.Object); //Act var result = controller.GetTarget(1); var acceptedResult = controller.Accepted(); //Assert Assert.Equal(1, result.TargetId); Assert.Equal("їжа", result.Name); Assert.Equal(1, result.OrganizationId); Assert.True(202 == acceptedResult.StatusCode); service.Verify(); }
public void DeletePayment_Success_CallsRepositoryWithCorrectParameters() { //Arrenge var paymentViewModel = new PaymentViewModel() { Id = 1 }; var paymentRepoMock = new Mock <IPaymentRepository>(); paymentRepoMock.Setup(r => r.DeletePayment(It.IsAny <int>())).Returns(new Payment()); var mappingConfig = new MapperConfiguration(mc => { mc.AddProfile(new MappingProfile()); }); IMapper mapper = mappingConfig.CreateMapper(); var paymentService = new PaymentService(paymentRepoMock.Object, mapper); //Act var result = paymentService.DeletePayment(paymentViewModel.Id); //Assert paymentRepoMock.Verify(r => r.DeletePayment(It.Is <int>(id => id == paymentViewModel.Id)), Times.Once); }
public void TestCreateInlineInsert() { // Prepare var statementBuilder = new Mock <IStatementBuilder>(); var repository = new Mock <BaseRepository <StatementBuilderEntity, CustomDbConnection> >("ConnectionString", statementBuilder.Object); // Setup statementBuilder.Setup(builder => builder.CreateInlineInsert <StatementBuilderEntity>( It.IsAny <QueryBuilder <StatementBuilderEntity> >(), It.IsAny <IEnumerable <Field> >(), It.IsAny <bool>())); // Act repository.Object.InlineInsert(new { Id = 1 }); // Assert statementBuilder.Verify(builder => builder.CreateInlineInsert <StatementBuilderEntity>( It.IsAny <QueryBuilder <StatementBuilderEntity> >(), It.IsAny <IEnumerable <Field> >(), It.IsAny <bool>()), Times.Once); }
public void Cannot_Checkout_Invalid_ShippingDetails() { // Arrange - create a mock order repository Mock <IOrderRepository> mock = new Mock <IOrderRepository>(); // Arrange - create a cart with one item Cart cart = new Cart(); cart.AddItem(new Product(), 1); // Arrange - create an instance of the controller OrderController target = new OrderController(mock.Object, cart); // Arrange - add an error to the model target.ModelState.AddModelError("error", "error"); // Act - try to checkout ViewResult result = target.Checkout(new Order()) as ViewResult; // Assert - check that the order hasn't been passed stored mock.Verify(m => m.SaveOrder(It.IsAny <Order>()), Times.Never); // Assert - check that the method is returning the default view Assert.True(string.IsNullOrEmpty(result.ViewName)); // Assert - check that I am passing an invalid model to the view Assert.False(result.ViewData.ModelState.IsValid); }
public async Task Create_Profile_While_Registering_New_Admin() { // arrange const string email = "*****@*****.**"; const string firstName = "first name"; const string lastName = "last name"; var model = GetRegisterRequest(); model.Email = email; model.FirstName = firstName; model.LastName = lastName; // act await _service.RegisterAsync(model); // assert _customerProfileClientMock.Verify(o => o.AdminProfiles.AddAsync(It.Is <AdminProfileRequest>( request => request.Email == email && request.FirstName == firstName && request.LastName == lastName))); }
public void LikePhoto_ShouldAddLikeToPhotoAndCallUpdatePhoto() { _photoRepo = new Mock <IPhotoRepo>(); _userRepo = new Mock <IUserRepo>(); _userRepo.Setup(c => c.Users).Returns(_users); var photo = new Photo() { Id = 1, NumberOfLikes = 0, Likes = new List <Like>() }; var options = new DbContextOptionsBuilder <AppDbContext>() .UseInMemoryDatabase(databaseName: "ImageAlbumDb") .Options; using (var context = new AppDbContext(options)) { _photoService = new PhotoService(context, _photoRepo.Object, _userRepo.Object); _photoService.LikePhoto(photo, "1"); Assert.AreEqual(1, photo.NumberOfLikes); _photoRepo.Verify(c => c.UpdatePhoto(photo), Times.Once()); } }
public void CommandHasConnectionQueryOptions() { Mock<SpannerClient> spannerClientMock = SpannerClientHelpers .CreateMockClient(Logger.DefaultLogger, MockBehavior.Strict); spannerClientMock .SetupBatchCreateSessionsAsync() .SetupExecuteStreamingSql(); const string connOptimizerVersion = "1"; SpannerConnection connection = BuildSpannerConnection(spannerClientMock); var queryOptions = QueryOptions.Empty.WithOptimizerVersion(connOptimizerVersion); connection.QueryOptions = queryOptions; var command = connection.CreateSelectCommand("SELECT * FROM FOO"); using (var reader = command.ExecuteReader()) { Assert.True(reader.HasRows); } spannerClientMock.Verify(client => client.ExecuteStreamingSql( It.Is<ExecuteSqlRequest>(request => request.QueryOptions.OptimizerVersion == connOptimizerVersion), It.IsAny<CallSettings>()), Times.Once()); }
public void should_intercept_the_invocation_and_notify_subscribers_if_the_invocation_method_is_Execute() { // Arrange var task = new InterceptTaskExecution(); var mockInvocation = new Mock <IInvocation>(); var mockTask = new MockTask(); mockInvocation.Setup(invocation => invocation.Method.Name).Returns("Execute"); mockInvocation.Setup(invocation => invocation.InvocationTarget).Returns(mockTask); task.Invocation = mockInvocation.Object; var mockNotifySubscribers = new Mock <NotifySubscribersOfTaskExecution>(); task.NotifySubscribersOfTaskExecution = mockNotifySubscribers.Object; // Act task.Execute(); // Assert mockNotifySubscribers.VerifySet(notifySubscribers => notifySubscribers.ExecutingTask = mockTask); mockNotifySubscribers.Verify(notifySubscribers => notifySubscribers.Execute(), Times.Once()); }
public async Task Publish_ChangeTheJobOfferState_WhenItIsWorkingProgress() { //Arrange var jobOffer = new JobOffer { ContractInformation = new ContractCondition() { KindOfContract = "FullTime", StartingFrom = "As soon as possible", WorkingDays = "Montay to Friday" }, RecruiterId = Guid.NewGuid().ToString(), CompanyId = Guid.NewGuid().ToString(), State = JobOfferState.WorkInProgress }; _jobOfferRepositoryMock.Setup(mock => mock.UpsertAsync(It.IsAny <JobOffer>())).Returns(Task.CompletedTask); //Act await _service.PublishJobOffer(jobOffer); //Assert Assert.AreEqual(JobOfferState.Published, jobOffer.State); _jobOfferRepositoryMock.Verify(mock => mock.UpsertAsync(It.IsAny <JobOffer>()), Times.Once); }
public void CreateBucket_IndexReplicasTrue_SendsWithCorrectParameter() { // Arrange var mockServerConfig = new Mock <IServerConfig>(); var managerMock = new Mock <ClusterManager>(_clientConfiguration, mockServerConfig.Object, new JsonDataMapper(_clientConfiguration), new HttpClient(), "username", "password"); managerMock .Setup(x => x.PostFormDataAsync(It.IsAny <Uri>(), It.Is <Dictionary <string, string> >(p => p["replicaIndex"] == "1"))) .Returns(Task.FromResult((IResult) new DefaultResult(true, "success", null))); // Act managerMock.Object.CreateBucket("test", indexReplicas: true); // Assert managerMock.Verify( x => x.PostFormDataAsync(It.IsAny <Uri>(), It.Is <Dictionary <string, string> >(p => p["replicaIndex"] == "1")), Times.Once); }
public void Execute_UpdatesAccount() { // Arrange var mockAccount = new Mock <Account>( _fixture.Create <Guid>(), new User( _fixture.Create <Guid>(), _fixture.Create <string>(), _fixture.Create <string>()), _fixture.Create <decimal>(), _fixture.Create <decimal>(), _fixture.Create <decimal>() * -1); _mockAccountRepository .Setup(ar => ar.GetAccountById(mockAccount.Object.Id)) .Returns(mockAccount.Object); // Act _sut.Execute(mockAccount.Object.Id, _fixture.Create <decimal>()); // Assert _mockAccountRepository.Verify(ar => ar.Update(mockAccount.Object), Times.Once); }
public void AddsCollectionEventListener_WhenInitializing() { const string propertyName = "propertyName"; var source = new Mock <INotifyPropertyChanged>(); var collection = new Mock <INotifyCollectionChanged>(); var wem = new Mock <IWeakEventManager>(); var propertyInfo = new Mock <PropertyInfo>(); propertyInfo.Setup(x => x.Name).Returns(propertyName); propertyInfo.Setup(x => x.PropertyType).Returns(typeof(INotifyCollectionChanged)); propertyInfo.SetupSequence(x => x.GetValue(It.IsAny <INotifyPropertyChanged>(), null)) .Returns(collection.Object); var binding = new Binding(source.Object, propertyInfo.Object, wem.Object); binding.Initialize(); wem.Verify(x => x.AddWeakEventListener( It.IsAny <INotifyCollectionChanged>(), It.IsAny <Action <INotifyCollectionChanged, NotifyCollectionChangedEventArgs> >())); }
public void GameLoader_LoadGame_NormalLoad() { GameInfo info = new GameInfo(1, "test_name"); var bundlesManagerMock = new Mock <IBundlesManager>(); bundlesManagerMock.Setup(m => m.LoadBundle(info.Id)).Returns(Task.FromResult(new [] { testSceneName })); var sceneManagerMock = new Mock <ISceneManager>(); string loadedSceneName = ""; sceneManagerMock.Setup(c => c.LoadScene(It.IsAny <string>())) .Callback <string>((name) => loadedSceneName = name); IGameLoader gameLoader = new GameLoader(sceneManagerMock.Object, bundlesManagerMock.Object); gameLoader.LoadGame(info); sceneManagerMock.Verify(c => c.LoadScene(It.IsAny <string>()), Times.Once()); Assert.AreEqual(loadedSceneName, testSceneName); }
public void TestCreateUpdate() { // Prepare var statementBuilder = new Mock <IStatementBuilder>(); var repository = new Mock <BaseRepository <StatementBuilderEntity, CustomDbConnection> >("ConnectionString", statementBuilder.Object); // Setup statementBuilder.Setup(builder => builder.CreateUpdate <StatementBuilderEntity>( It.IsAny <QueryBuilder <StatementBuilderEntity> >(), It.IsAny <QueryGroup>())); // Act repository.Object.Update(new StatementBuilderEntity { Id = 1, Name = "Update" }); // Assert statementBuilder.Verify(builder => builder.CreateUpdate <StatementBuilderEntity>( It.IsAny <QueryBuilder <StatementBuilderEntity> >(), It.IsAny <QueryGroup>()), Times.Once); }
public void ExecuteResult() { // Arrange string script = "alert('foo');"; string contentType = "application/x-javascript"; // Arrange expectations Mock <ControllerContext> mockControllerContext = new Mock <ControllerContext>(MockBehavior.Strict); mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable(); mockControllerContext.Setup(c => c.HttpContext.Response.Write(script)).Verifiable(); JavaScriptResult result = new JavaScriptResult { Script = script }; // Act result.ExecuteResult(mockControllerContext.Object); // Assert mockControllerContext.Verify(); }
public void Should_AddPipelineTask() { //arrange string title = "New pipeline"; Mock<Pipeline> pipeline = new Mock<Pipeline>() { CallBase = true }; Mock<IPipelineTask> task = new Mock<IPipelineTask>() { CallBase = true }; Mock<Repository> repository = new Mock<Repository>() { CallBase = true }; Mock<RepositoryBranch> repositoryBranch = new Mock<RepositoryBranch>() { CallBase = true }; //act pipeline.Object.Name = title; pipeline.Object.Repository = repository.Object; pipeline.Object.Branch = repositoryBranch.Object; pipeline.Object.Add(task.Object); //assert pipeline.Verify(x => x.Add(It.IsAny<IPipelineTask>()), Times.Exactly(1)); Assert.Single(pipeline.Object.Tasks); Assert.Equal(title, pipeline.Object.Name); Assert.Equal(repository.Object, pipeline.Object.Repository); Assert.Equal(repositoryBranch.Object, pipeline.Object.Branch); Assert.Single(pipeline.Object.Tasks); }
public async Task InputDataOk_Called_ReturnViewModelWithCorrectValues() { // Arrange var fixture = new Fixture(); var createTweetInputModel = fixture.Create<CreateTweetInputModel>(); var userId = Guid.NewGuid(); var userRepository = new Mock<IUserRepository>(); userRepository.Setup(ur => ur.AddTweet(userId, It.IsAny<Tweet>())).Verifiable(); var createTweetCommand = new CreateTweetCommand(createTweetInputModel, userId); var createTweetCommandHandler = new CreateTweetCommandHandler(userRepository.Object); // Act var createTweetViewModel = await createTweetCommandHandler.Handle(createTweetCommand, new CancellationToken()); // Assert Assert.NotNull(createTweetViewModel); Assert.Equal(createTweetInputModel.Content, createTweetViewModel.Content); Assert.Equal(userId, createTweetViewModel.UserId); userRepository.Verify(ur => ur.AddTweet(userId, It.IsAny<Tweet>()), Times.Once); }
public void PoundToAud_Should_Return_Correct_Amount() { //Arrange const double toConvert = 1.2; var expected = Convert.ToDecimal(toConvert * Constants.AudRate); var mockedLogger = new Mock <ILogs>(); mockedLogger.Setup(x => x.Add(It.IsAny <KeyValuePair <DateTime, decimal> >())).Verifiable(); //Act var sut = new Currency(mockedLogger.Object); var result = sut.PoundToAud(toConvert); mockedLogger.Verify(); //Assert Assert.AreEqual(result, expected); }
public void EnvironmentShouldGetCalledClientOnly() { var environment = new Mock <IReactEnvironment>(); AssemblyRegistration.Container.Register(environment.Object); var config = new Mock <IReactSiteConfiguration>(); AssemblyRegistration.Container.Register(config.Object); var reactIdGenerator = new Mock <IReactIdGenerator>(); AssemblyRegistration.Container.Register(reactIdGenerator.Object); var component = ReactEnvironmentExtensions.CreateRouterComponent( environment.Object, "ComponentName", new { }, "/", null, true ); environment.Verify(x => x.CreateComponent(It.IsAny <IReactComponent>(), true)); }
public async Task HandleAsync_Should_Store_DomainEvent() { var flatForRentAnnouncementPreference = FlatForRentAnnouncementPreference.Builder() .SetId(Guid.NewGuid()) .SetCityId(Guid.NewGuid()) .SetPriceMin(1) .SetPriceMax(1000) .SetRoomNumbersMin(1) .SetRoomNumbersMax(1) .Build(); var domainEvent = new UserFlatForRentAnnouncementPreferenceAddedDomainEvent(Guid.NewGuid(), Guid.NewGuid(), flatForRentAnnouncementPreference); _domainEventStoreMock.Setup(x => x.Store(It.IsAny <IDomainEvent>())).Verifiable(); Func <Task> result = async() => await _domainEventHandler.HandleAsync(domainEvent); await result.Should().NotThrowAsync <Exception>(); _domainEventStoreMock.Verify(x => x.Store(It.Is <IDomainEvent>(e => e.GetType() == typeof(UserFlatForRentAnnouncementPreferenceAddedDomainEvent)))); }
public void Can_Save_Valid_Changes() { // Arrange - create mock repository Mock<IProductRepository> mock = new Mock<IProductRepository>(); // Arrange - create mock temp data Mock<ITempDataDictionary> tempData = new Mock<ITempDataDictionary>(); // Arrange - create the controller AdminController target = new AdminController(mock.Object) { TempData = tempData.Object }; // Arrange - create a product Product product = new Product { Name = "Test" }; // Act - try to save the product IActionResult result = target.Edit(product); // Assert - check that the repository was called mock.Verify(m => m.SaveProduct(product)); // Assert - check the result type is a redirection Assert.IsType<RedirectToActionResult>(result); Assert.Equal("Index", (result as RedirectToActionResult).ActionName); }
public async Task WatchIndexesAsync_Returns_When_Qeury_Failed() { var mockBucket = new Mock <IBucket>(); mockBucket.Setup(x => x.Name).Returns("default"); mockBucket.Setup(x => x.QueryAsync <IndexInfo>(It.IsAny <QueryRequest>())) .ReturnsAsync(new QueryResult <IndexInfo> { Success = false }); var indexNamesToWatch = new List <string> { "foo" }; var manager = new TestableBucketManager(mockBucket.Object); var result = await manager.WatchN1qlIndexesAsync(indexNamesToWatch, TimeSpan.FromSeconds(20)); Assert.IsFalse(result.Success); Assert.AreEqual(0, result.Value.Count); mockBucket.Verify(x => x.QueryAsync <IndexInfo>(It.IsAny <QueryRequest>()), Times.Exactly(1)); }
public void CreateActivator_InvokesIControllerActivator_IfItIsNotDefaultControllerActivator() { // Arrange var expected = new object(); var activator = new Mock <IControllerActivator>(); activator.Setup(a => a.Create(It.IsAny <ControllerContext>())) .Returns(expected) .Verifiable(); var activatorProvider = new ControllerActivatorProvider(activator.Object); var descriptor = new ControllerActionDescriptor { ControllerTypeInfo = typeof(object).GetTypeInfo(), }; // Act var activatorDelegate = activatorProvider.CreateActivator(descriptor); var result = activatorDelegate(new ControllerContext()); // Assert Assert.Same(expected, result); activator.Verify(); }