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);
        }
Ejemplo n.º 3
1
        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());
        }
Ejemplo n.º 6
0
        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());
        }
Ejemplo n.º 7
0
        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();
        }
Ejemplo n.º 8
0
        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>>()));
        }
Ejemplo n.º 9
0
        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));
        }
Ejemplo n.º 10
0
        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);
        }
Ejemplo n.º 12
0
        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());
        }
Ejemplo n.º 13
0
        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));
        }
Ejemplo n.º 15
0
            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);
            }
        }
Ejemplo n.º 17
0
            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());
        }
Ejemplo n.º 19
0
        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());
        }
Ejemplo n.º 21
0
        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());
        }
Ejemplo n.º 22
0
        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);
            }
        }
Ejemplo n.º 25
0
        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));
        }
Ejemplo n.º 27
0
        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>()));
        }
Ejemplo n.º 28
0
        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));
                    }
            }
        }
Ejemplo n.º 34
0
        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);
        }
Ejemplo n.º 35
0
        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);
        }
Ejemplo n.º 36
0
        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);
        }
Ejemplo n.º 38
0
        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);
        }
Ejemplo n.º 40
0
        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);
        }
Ejemplo n.º 41
0
        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);
        }
Ejemplo n.º 42
0
        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)));
        }
Ejemplo n.º 43
0
        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());
        }
Ejemplo n.º 45
0
        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());
        }
Ejemplo n.º 46
0
        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);
        }
Ejemplo n.º 49
0
        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> >()));
        }
Ejemplo n.º 50
0
        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);
        }
Ejemplo n.º 51
0
        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();
        }
Ejemplo n.º 53
0
        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);
        }
Ejemplo n.º 55
0
        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));
        }
Ejemplo n.º 57
0
        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))));
        }
Ejemplo n.º 58
0
        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);
        }
Ejemplo n.º 59
0
        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));
        }
Ejemplo n.º 60
0
    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();
    }