Example #1
0
        public void TestAddingRecordingDeviceToSelected()
        {
            var configurationMoq = new Mock<ISoundSwitchConfiguration> {Name = "Configuration mock"};
            var audioMoqI = new Mock<IAudioDevice> {Name = "first audio dev"};
            audioMoqI.SetupGet(a => a.FriendlyName).Returns("Speakers (Test device)");
            audioMoqI.SetupGet(a => a.Type).Returns(AudioDeviceType.Recording);

            //Setup
            configurationMoq.Setup(c => c.SelectedRecordingDeviceList).Returns(new HashSet<string>());
            TestHelpers.SetConfigurationMoq(configurationMoq);

            //Action
            var eventCalled = false;
            AppModel.Instance.SelectedDeviceChanged += (sender, changed) => eventCalled = true;
            Assert.True(AppModel.Instance.SelectDevice(audioMoqI.Object));

            //Asserts
            configurationMoq.VerifyGet(c => c.SelectedRecordingDeviceList);
            configurationMoq.Verify(c => c.Save());
            audioMoqI.VerifyGet(a => a.FriendlyName);
            audioMoqI.VerifyGet(a => a.Type);
            Assert.That(configurationMoq.Object.SelectedRecordingDeviceList.Count == 1);
            Assert.That(configurationMoq.Object.SelectedRecordingDeviceList.Contains("Speakers (Test device)"));
            Assert.That(eventCalled, "SelectedDeviceChanged not called");
        }
            public void When_all_Rovers_deployed_requests_Rover_Positions_and_CardinalDirections()
            {
                var mockRover = new Mock<IRover>();
                mockRover.Setup(x => x.IsDeployed()).Returns(true);
                var rovers = new List<IRover> {mockRover.Object, mockRover.Object, mockRover.Object};

                var reportComposer = new ConsoleReportComposer();
                reportComposer.CompileReports(rovers);

                mockRover.VerifyGet(x => x.Position, Times.Exactly(3));
                mockRover.VerifyGet(x => x.CardinalDirection, Times.Exactly(3));
            }
Example #3
0
        public void AucunRafraichissementNestFaitSiLaValeurEstVide()
        {
            FiltrePresenter presenter = new FiltrePresenter(Vue, Repository.Object);
            Mock<IFiltreView> mock = new Mock<IFiltreView>();
            mock.SetupGet(vue => vue.BlockAffichageFiltres).Verifiable();
            mock.SetupGet(vue => vue.ListeBoxVille).Verifiable();

            presenter.ActualiseLaListeDeFiltre(string.Empty, mock.Object.ListeBoxVille);

            //On passe une fois par le get de la listBox lors du passage de param├Ętre
            mock.VerifyGet(vue => vue.ListeBoxVille, Times.Exactly(1));
            mock.VerifyGet(vue => vue.BlockAffichageFiltres, Times.Never());
        }
        public void CreateAssignedWorkStation_ValidCommand_Verify_WorkStationId_Get_From_ApplicationSettings_Using_Setup_Property()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockCustomerRepository = new Mock<ICustomerRepository>();
            var mockApplicationSettings = new Mock<IApplicationSettings>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny<Customer>()));
            //mockApplicationSettings.Setup(x => x.WorkStationId)
            //    .Returns(10);

            mockApplicationSettings.SetupProperty(x => x.WorkStationId, 123);

            //Can we set if from the object itself??
            //mockApplicationSettings.Object.WorkStationId = 345;

            //mockApplicationSettings.SetupAllProperties();

            CustomerService_8 customerService = new CustomerService_8(
                mockCustomerRepository.Object,
                mockApplicationSettings.Object
                );

            //Act
            customerService.CreateAssignedWorkStation(createCommmand);

            //Assert
            mockApplicationSettings.VerifyGet(x => x.WorkStationId);
        }
        public void CreateAssignedWorkStation_ValidCommand_Verify_WorkStationId_Get_From_ApplicationSettings()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockCustomerRepository = new Mock<ICustomerRepository>();
            var mockApplicationSettings = new Mock<IApplicationSettings>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny<Customer>()));
            mockApplicationSettings.Setup(x => x.WorkStationId)
                .Returns(10);

            CustomerService_8 customerService = new CustomerService_8(
                mockCustomerRepository.Object,
                mockApplicationSettings.Object
                );

            //Act
            customerService.CreateAssignedWorkStation(createCommmand);

            //Assert
            mockApplicationSettings.VerifyGet(x => x.WorkStationId);
        }
        private void Example()
        {
            var mock = new Mock<IFoo>();

            mock.Verify(foo => foo.Execute("ping"));

            // Verify with custom error message for failure
            mock.Verify(foo => foo.Execute("ping"), "When doing operation X, the service should be pinged always");

            // Method should never be called
            mock.Verify(foo => foo.Execute("ping"), Times.Never());

            // Called at least once
            mock.Verify(foo => foo.Execute("ping"), Times.AtLeastOnce());

            mock.VerifyGet(foo => foo.Name);

            // Verify setter invocation, regardless of value.
            mock.VerifySet(foo => foo.Name);

            // Verify setter called with specific value
            mock.VerifySet(foo => foo.Name = "foo");

            // Verify setter with an argument matcher
            mock.VerifySet(foo => foo.Value = It.IsInRange(1, 5, Range.Inclusive));
        }
        public void WatchedDirectoryConfigureWhenStrategyNotDefinedPullsValuesFromWatchDirectoryProperly()
        {
            // Arrange
            var testBundle = new WatchedDirectoryTestBundle();
            var mockWatchDirectory = new Mock<IWatchDirectory>();

            mockWatchDirectory.SetupGet(x => x.FileExtensions).Returns("abc");

            // Act
            testBundle.WatchedDirectory.Configure(mockWatchDirectory.Object);

            // Assert
            mockWatchDirectory.VerifyGet(x => x.Path, Times.Once());
            mockWatchDirectory.VerifyGet(x => x.IncludeSubDirectories, Times.Once());
            mockWatchDirectory.VerifyGet(x => x.Mode, Times.Once());
            mockWatchDirectory.VerifyGet(x => x.SortStrategy, Times.Once());
            mockWatchDirectory.VerifyGet(x => x.FileExtensions, Times.Once());
        }
 public void EqualityCheckAspect_Can_Be_Applied_To_ValueType()
 {
     var mock = new Mock<MockEqualityChecked> {CallBase = true};
     var underTest = mock.Object;
     underTest.Flag = true;
     underTest.Flag = true;
     mock.VerifyGet(x=>x.Flag, Times.AtLeast(2));
     mock.Verify(x=>x.SetFlag(It.IsAny<bool>()), Times.Once());
 }
        public void WrapsConnectionTimeout()
        {
            var mockConn = new Mock<IAdomdConnection>();
            mockConn.SetupGet(p => p.ConnectionTimeout).Returns(30);

            var conn = new GlimpseAdomdConnection(mockConn.Object, new Mock<ITimedMessagePublisher>().Object);
            Assert.That(conn.ConnectionTimeout, Is.EqualTo(30));
            mockConn.VerifyGet(p => p.ConnectionTimeout, Times.Once);
        }
        public void WrapsDatabase()
        {
            var mockConn = new Mock<IAdomdConnection>();
            mockConn.SetupGet(p => p.Database).Returns("TEST");

            var conn = new GlimpseAdomdConnection(mockConn.Object, new Mock<ITimedMessagePublisher>().Object);
            Assert.That(conn.Database, Is.EqualTo("TEST"));
            mockConn.VerifyGet(p => p.Database, Times.Once);
        }
		public void Integration()
		{
			var discountMock = new Mock<IOrderDiscount>();
			discountMock.SetupGet(m => m.MemberGroups).Returns(new List<string>());
			discountMock.SetupGet(m => m.AffectedOrderlines).Returns(new List<int>());

			_discountCalculationService.DiscountAmountForOrder(discountMock.Object, _order);

			discountMock.VerifyGet(m => m.AffectedProductTags);
		}
Example #12
0
        public void filereader_is_transparent()
        {
            var settings = new Mock<ISettingsReader>();
            settings.SetupGet(m => m["hue"]).Verifiable();

            var filereader = new FileReader(@"data\FileSettingsReaderTestData", settings.Object);

            filereader.EnsureKey("hue", "9");
            var crap = filereader["hue"];
            var stuff = filereader.Keys;
            filereader.Settings = "new settings";
            crap = filereader.Settings;

            settings.Verify(m => m.EnsureKey("hue", "9"), Times.AtLeastOnce());

            settings.VerifyGet(m => m.Keys, Times.AtLeastOnce());
            settings.VerifyGet(m => m.Settings, Times.AtLeastOnce());
            settings.VerifySet(m => { m.Settings = "new settings"; }, Times.AtLeastOnce());
            settings.Verify();
        }
        public void WrapsConnectionString()
        {
            var mockConn = new Mock<IAdomdConnection>();
            mockConn.SetupProperty(p => p.ConnectionString, "TEST");

            var conn = new GlimpseAdomdConnection(mockConn.Object, new Mock<ITimedMessagePublisher>().Object);
            Assert.That(conn.ConnectionString, Is.EqualTo("TEST"));
            mockConn.VerifyGet(p => p.ConnectionString, Times.Once);
            conn.ConnectionString = "ABC";
            Assert.That(conn.ConnectionString, Is.EqualTo("ABC"));
            mockConn.VerifySet(p => p.ConnectionString = It.Is<string>(s => s == "ABC"), Times.Once);
        }
        public void CallingTableReturnsRenameTableExpressionBuilder()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();
            var contextMock = new Mock<IMigrationContext>();
            contextMock.SetupGet(x => x.Expressions).Returns(collectionMock.Object);

            var root = new RenameExpressionRoot(contextMock.Object);
            var builder = root.Table("Bacon");

            builder.ShouldBeOfType<RenameTableExpressionBuilder>();
            contextMock.VerifyGet(x => x.Expressions);
        }
        public void CallingColumnReturnsDeleteColumnExpressionBuilder()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();
            var contextMock = new Mock<IMigrationContext>();
            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);

            var root = new DeleteExpressionRoot(contextMock.Object);
            var builder = root.Column("Bacon");

            builder.ShouldBeOfType<DeleteColumnExpressionBuilder>();
            contextMock.VerifyGet(x => x.Expressions);
        }
        public void CallingColumnReturnsAlterColumnExpression()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();
            var contextMock = new Mock<IMigrationContext>();
            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);
            contextMock.VerifyGet(x => x.Expressions, Times.AtMostOnce());

            var root = new AlterExpressionRoot(contextMock.Object);
            var builder = root.Column("Bacon");

            builder.ShouldBeOfType<AlterColumnExpressionBuilder>();
            contextMock.VerifyAll();
        }
        public void CallingTableAddsRenameTableExpressionToContextWithSpecifiedOldName()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();

            var contextMock = new Mock<IMigrationContext>();
            contextMock.SetupGet(x => x.Expressions).Returns(collectionMock.Object);

            var root = new RenameExpressionRoot(contextMock.Object);
            root.Table("Bacon");

            collectionMock.Verify(x => x.Add(It.Is<RenameTableExpression>(e => e.OldName.Equals("Bacon"))));
            contextMock.VerifyGet(x => x.Expressions);
        }
        public void TestIfOnTargetGetItUsesTheFuncOnTheParentField()
        {
            // Arrange
              var parentMock = new Mock<Parent>();
              var target = new ItsAssertable<Parent, Child>(p => p.Child);
              target.SetFieldValue("mParent", parentMock.Object);

              // Act
              var result = target.Target;

              // Assert
              parentMock.VerifyGet(m => m.Child, Times.Once());
        }
        public void CallingToTableSetsPrimaryTableName()
        {
            var foreignKeyMock = new Mock<ForeignKeyDefinition>();

            var expressionMock = new Mock<DeleteForeignKeyExpression>();
            expressionMock.SetupGet(e => e.ForeignKey).Returns(foreignKeyMock.Object);

            var builder = new DeleteForeignKeyExpressionBuilder(expressionMock.Object);
            builder.ToTable("Bacon");

            foreignKeyMock.VerifySet(f => f.PrimaryTable = "Bacon");
            expressionMock.VerifyGet(e => e.ForeignKey);
        }
        public void CallingOnTableSetsForeignTableName()
        {
            var foreignKeyMock = new Mock<ForeignKeyDefinition>();

            var expressionMock = new Mock<DeleteForeignKeyExpression>();
            expressionMock.SetupGet(e => e.ForeignKey).Returns(foreignKeyMock.Object);

            var builder = new DeleteForeignKeyExpressionBuilder(expressionMock.Object);
            ((IDeleteForeignKeyOnTableSyntax)builder).OnTable(("Bacon"));

            foreignKeyMock.VerifySet(f => f.ForeignTable = "Bacon");
            expressionMock.VerifyGet(e => e.ForeignKey);
        }
        public void CanRead_should_call_wrapped_stream(
            [Values(false, true)]
            bool canRead)
        {
            var mockStream = new Mock<Stream>();
            var subject = new BsonStreamAdapter(mockStream.Object);
            mockStream.SetupGet(s => s.CanRead).Returns(canRead);

            var result = subject.CanRead;

            result.Should().Be(canRead);
            mockStream.VerifyGet(s => s.CanRead, Times.Once);
        }
        public void Create_ArgumentValid_ReturnsTrue()
        {
            // ARRANGE
            var objectUnderTest = new CustomerRepository();
            var mockCustomer = new Mock<ICustomer>();

            mockCustomer.SetupGet(context => context.firstName).Returns("Eric");
            mockCustomer.SetupGet(context => context.lastName).Returns("Brunner");
            mockCustomer.SetupGet(context => context.streetAddress).Returns("my street");
            mockCustomer.SetupGet(context => context.city).Returns("Vienna");

            // ACT
            var result = objectUnderTest.Create(mockCustomer.Object);

            // ASSERT
            Assert.True(result, "Result has an unexpected value");

            mockCustomer.VerifyGet(context => context.firstName, Times.Exactly(1));
            mockCustomer.VerifyGet(context => context.lastName, Times.Exactly(1));
            mockCustomer.VerifyGet(context => context.streetAddress, Times.Exactly(1));
            mockCustomer.VerifyGet(context => context.city, Times.Exactly(1));
        }
        public void CallingColumnAddsDeleteColumnExpressionToContextWithSpecifiedName()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();

            var contextMock = new Mock<IMigrationContext>();
            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);

            var root = new DeleteExpressionRoot(contextMock.Object);
            root.Column("Bacon");

            collectionMock.Verify(x => x.Add(It.Is<DeleteColumnExpression>(e => e.ColumnName.Equals("Bacon"))));
            contextMock.VerifyGet(x => x.Expressions);
        }
        public void CallingIntoTableSetsTableName()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();

            var contextMock = new Mock<IMigrationContext>();
            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);

            var root = new InsertExpressionRoot(contextMock.Object);
            root.IntoTable("Bacon");

            collectionMock.Verify(x => x.Add(It.Is<InsertDataExpression>(e => e.TableName.Equals("Bacon"))));
            contextMock.VerifyGet(x => x.Expressions);
        }
        public void CallingFromTableSetsForeignTableName()
        {
            var foreignKeyMock = new Mock<ForeignKeyDefinition>();

            var expressionMock = new Mock<CreateForeignKeyExpression>();
            expressionMock.SetupGet(e => e.ForeignKey).Returns(foreignKeyMock.Object);

            var builder = new CreateForeignKeyExpressionBuilder(expressionMock.Object);
            builder.FromTable("Bacon");

            foreignKeyMock.VerifySet(f => f.ForeignTable = "Bacon");
            expressionMock.VerifyGet(e => e.ForeignKey);
        }
        public void CallingForeignKeyAddsDeleteForeignKeyExpressionToContext()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();

            var contextMock = new Mock<IMigrationContext>();
            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);

            var root = new DeleteExpressionRoot(contextMock.Object);
            root.ForeignKey();

            collectionMock.Verify(x => x.Add(It.IsAny<DeleteForeignKeyExpression>()));
            contextMock.VerifyGet(x => x.Expressions);
        }
        public void CallingForeignKeyAddsCreateForeignKeyExpressionToContextWithSpecifiedNameSet()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();

            var contextMock = new Mock<IMigrationContext>();
            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);

            var root = new CreateExpressionRoot(contextMock.Object);
            root.ForeignKey("FK_Bacon");

            collectionMock.Verify(x => x.Add(It.Is<CreateForeignKeyExpression>(e => e.ForeignKey.Name.Equals("FK_Bacon"))));
            contextMock.VerifyGet(x => x.Expressions);
        }
        public void CallingDeleteUniqueConstraintCreatesADeleteConstraintExpression()
        {
            var collectionMock = new Mock<ICollection<IMigrationExpression>>();

            var contextMock = new Mock<IMigrationContext>();
            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);

            var root = new DeleteExpressionRoot(contextMock.Object);
            root.UniqueConstraint("TestUniqueConstraintName");

            collectionMock.Verify(x => x.Add(It.Is<DeleteConstraintExpression>(e => e.Constraint.IsUniqueConstraint == true)));
            collectionMock.Verify(x => x.Add(It.Is<DeleteConstraintExpression>(e => e.Constraint.ConstraintName == "TestUniqueConstraintName")));
            contextMock.VerifyGet(x => x.Expressions);
        }
        public void CallingOnTableSetsTableNameToSpecifiedValue()
        {
            var indexMock = new Mock<IndexDefinition>();


            var expressionMock = new Mock<CreateIndexExpression>();
            expressionMock.SetupGet(e => e.Index).Returns(indexMock.Object);

            var builder = new CreateIndexExpressionBuilder(expressionMock.Object);
            builder.OnTable("Bacon");

            indexMock.VerifySet(x => x.TableName = "Bacon");
            expressionMock.VerifyGet(e => e.Index);
        }
Example #30
0
        public void TestCorrectSequenceOfOrdering()
        {
            var mockBa = new Mock<BankAccount>();
            var mockSi = new Mock<StockItem>();

            mockBa.Setup(ba => ba.Balance).Returns(50.0);

            this._Manager.BankAccounts.Add(mockBa.Object);
            this._Manager.StockItems.Add(mockSi.Object);
            this._Manager.OrderItem(mockSi.Object, mockBa.Object, 0);

            mockBa.VerifyGet(ba => ba.Balance);
            mockBa.Verify(ba => ba.Transfer(0, 10.0), Times.AtMostOnce());
        }
Example #31
0
        public void MessageTypeIsProbedWhenUnknown()
        {
            using (var inputStream = new MemoryStream(Encoding.UTF8.GetBytes("non xml payload")))
            {
                MessageMock.Object.BodyPart.Data = inputStream;
                MessageMock.Setup(m => m.GetProperty(BtsProperties.OutboundTransportLocation)).Returns("outbound-transport-location");

                var probeStreamMock = new Mock <IProbeStream>();
                StreamExtensions.StreamProberFactory = stream => probeStreamMock.Object;

                var sut = new SBMessagingContextPropagator();
                sut.Execute(PipelineContextMock.Object, MessageMock.Object);

                probeStreamMock.VerifyGet(ps => ps.MessageType, Times.Once);
            }
        }
Example #32
0
        public void CallingOnTableSetsTableNameToSpecifiedValue()
        {
            var indexMock = new Mock <IndexDefinition>();


            var expressionMock = new Mock <CreateIndexExpression>();

            expressionMock.SetupGet(e => e.Index).Returns(indexMock.Object);

            var builder = new CreateIndexExpressionBuilder(expressionMock.Object);

            builder.OnTable("Bacon");

            indexMock.VerifySet(x => x.TableName = "Bacon");
            expressionMock.VerifyGet(e => e.Index);
        }
Example #33
0
        public void Can_read_write_property()
        {
            var value = DateTime.Now;

            Mock.SetupGet(x => x.Property).Returns(value);
            Mock.SetupSet(x => x.Property = value);

            RunQmlTest(
                "test",
                @"
                    test.property = test.property
                ");

            Mock.VerifyGet(x => x.Property, Times.Once);
            Mock.VerifySet(x => x.Property = value, Times.Once);
        }
Example #34
0
        public void ScrumTeamNames_AllEmpty_ReturnsZeroTeams()
        {
            // Arrange
            var repository = new Mock <IScrumTeamRepository>(MockBehavior.Strict);

            repository.SetupGet(r => r.ScrumTeamNames).Returns(Enumerable.Empty <string>());
            var target = CreatePlanningPokerController(repository: repository.Object);

            // Act
            var result = target.ScrumTeamNames;

            // Verify
            repository.VerifyGet(r => r.ScrumTeamNames);
            Assert.IsNotNull(result);
            CollectionAssert.AreEquivalent(Array.Empty <string>(), result.ToList());
        }
Example #35
0
        public void it_should_build_the_api_documentation_using_a_Shacl_profile()
        {
            Mock <ITypeDescriptionBuilder> shaclTypeDescriptionBuilder = SetupTypeDescriptionBuilder(_entityContext, EntityConverter.Shacl);
            var apiDescriptionBuilder = new ApiDescriptionBuilder <TestController>(
                _descriptionBuilder,
                _xmlDocProvider.Object,
                new[] { _typeDescriptionBuilder.Object, shaclTypeDescriptionBuilder.Object },
                new IServerBehaviorAttributeVisitor[0],
                _namedGraphSelectorFactory.Object);

            apiDescriptionBuilder.BuildDescription(_apiDocumentation.Object, new[] { EntityConverter.Shacl });

            _typeDescriptionBuilder.VerifyGet(instance => instance.SupportedProfiles, Times.Once);
            shaclTypeDescriptionBuilder.VerifyGet(instance => instance.SupportedProfiles, Times.Once);
            _typeDescriptionBuilder.Verify(instance => instance.BuildTypeDescription(It.IsAny <DescriptionContext>()), Times.Never);
        }
Example #36
0
        public void DraggingUnsupportedFilesDoesNothing()
        {
            // Arrange
            var vm       = new ComposeTweetViewModel(null);
            var dropInfo = new Mock <IDropInfo>();

            dropInfo.SetupGet(d => d.Data).Returns(new DataObject(DataFormats.FileDrop, new[] { "file1.txt", "file2.exe" }));
            dropInfo.SetupSet(d => d.Effects = DragDropEffects.Copy).Verifiable();

            // Act
            vm.DragOver(dropInfo.Object);

            // Assert
            dropInfo.VerifyGet(d => d.Data, Times.Once());
            dropInfo.VerifySet(d => d.Effects = DragDropEffects.Copy, Times.Never());
        }
Example #37
0
        public void CheckLicenseKeyForLowIncomeApplications()
        {
            var mockValidator = new Mock <IFrequentFlyerNumberValidator>();

            mockValidator.Setup(x => x.ServiceInformation.License.LicenseKey).Returns("OK");

            var sut = new CreditCardApplicationEvaluator(mockValidator.Object);

            var application = new CreditCardApplication {
                GrossAnnualIncome = 99_000
            };

            sut.Evaluate(application);

            mockValidator.VerifyGet(x => x.ServiceInformation.License.LicenseKey, Times.Once);
        }
Example #38
0
        public void Can_get_and_set_byte_array()
        {
            Mock.SetupGet(x => x.Array).Returns(new byte[] { 3, 5 });

            RunQmlTest(
                "test",
                @"
                    var v = test.array
                    var data = new Uint8Array(v)
                    data.set([4], 0)
                    test.array = v
                ");

            Mock.VerifyGet(x => x.Array, Times.Once);
            Mock.VerifySet(x => x.Array = new byte[] { 4, 5 });
        }
Example #39
0
        public void CallingDeleteUniqueConstraintCreatesADeleteConstraintExpression()
        {
            var collectionMock = new Mock <ICollection <IMigrationExpression> >();

            var contextMock = new Mock <IMigrationContext>();

            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);

            var root = new DeleteExpressionRoot(contextMock.Object);

            root.UniqueConstraint("TestUniqueConstraintName");

            collectionMock.Verify(x => x.Add(It.Is <DeleteConstraintExpression>(e => e.Constraint.IsUniqueConstraint == true)));
            collectionMock.Verify(x => x.Add(It.Is <DeleteConstraintExpression>(e => e.Constraint.ConstraintName == "TestUniqueConstraintName")));
            contextMock.VerifyGet(x => x.Expressions);
        }
        public void JobLogger_Test_INFO_Only_Console()
        {
            // arrange
            var Mensaje           = "Hi!";
            var mockConfiguration = new Mock <ILogConfiguration>();

            mockConfiguration.Setup(x => x.AllowLevels).Returns(LogLevel.INFO);
            mockConfiguration.Setup(x => x.AllowSource).Returns(LogSource.CONSOLE);
            JobLogger.SetLogConfiguration(mockConfiguration.Object);

            // act
            JobLogger.Info(Mensaje).Wait();

            // assert
            mockConfiguration.VerifyGet(x => x.AllowLevels);
        }
        public void GetSigningCredentials_ShouldAccessTokenSettingsSecretOnce()
        {
            //arrange
            var appSettings = new Mock <AppSettings> {
                CallBase = true
            };

            appSettings.SetupGet(i => i.TokenSettings.Secret).Returns("ThisIsATest").Verifiable();
            var tokenManager = new TokenManager(Options.Create(appSettings.Object));

            //act
            var result = tokenManager.GetSigningCredentials();

            //assert
            appSettings.VerifyGet(i => i.TokenSettings.Secret, Times.Once);
        }
        public void ConstructorShouldNotAddProvidersWithEmptyMetadataToDictionary()
        {
            // Arrange
            var providerMock = new Mock <IFilterMetadataProvider>(MockBehavior.Strict);

            providerMock.SetupGet(p => p.Metadata).Returns(new List <FilterMetadata>());

            _providers.Add(providerMock.Object);

            // Act
            new PredicateFactory(_providersMock.Object);

            // Assert
            _providersMock.Verify(m => m.GetEnumerator(), Times.Once);
            providerMock.VerifyGet(p => p.Metadata, Times.Exactly(2));
        }
Example #43
0
        public void GetSiteTest_NoParameters_None()
        {
            var siteServiceMock = new Mock <ISiteService>();

            var businessLayer = new GetCmsSiteBusiness()
            {
                WriteDebug   = Assert.NotNull,
                WriteVerbose = Assert.NotNull,

                SiteService = siteServiceMock.Object,
            };

            businessLayer.GetSites().Should().BeEmpty();

            siteServiceMock.VerifyGet(x => x.Sites);
        }
Example #44
0
        public void ScrumTeamNames_2TeamsInRepository_Returns2Teams()
        {
            // Arrange
            var repository = new Mock <IScrumTeamRepository>(MockBehavior.Strict);

            repository.SetupGet(r => r.ScrumTeamNames).Returns(new string[] { "team1", "team2" });
            var target = CreatePlanningPokerController(repository: repository.Object);

            // Act
            var result = target.ScrumTeamNames;

            // Verify
            repository.VerifyGet(r => r.ScrumTeamNames);
            Assert.IsNotNull(result);
            CollectionAssert.AreEquivalent(new string[] { "team1", "team2" }, result.ToList());
        }
        public void Stop_Client_Without_Start_First_OK()
        {
            var tcpclientmock = new Mock <ITcpClient>();

            tcpclientmock.SetupGet(c => c.IsConnected).Returns(() => false);

            var client = new NikoClient(tcpclientmock.Object);

            client.StopClient();

            client.Should().NotBeNull();
            tcpclientmock.Verify(c => c.Start(), Times.Never);
            tcpclientmock.Verify(c => c.Stop(), Times.Never);
            tcpclientmock.VerifyGet(c => c.IsConnected, Times.Once);
            client.IsConnected.Should().BeFalse();
        }
Example #46
0
            public void the_workstation_id_should_be_used()
            {
                //Arrange
                var mockCustomerRepository  = new Mock <ICustomerRepository>();
                var mockApplicationSettings = new Mock <IApplicationSettings>();

                mockApplicationSettings.Setup(x => x.WorkstationId).Returns(123);

                var customerService = new CustomerService(mockCustomerRepository.Object, mockApplicationSettings.Object);

                //Act
                customerService.Create(new CustomerToCreateDto());

                //Assert
                mockApplicationSettings.VerifyGet(x => x.WorkstationId);
            }
Example #47
0
        public void RepositoryPropertyCallOnce()
        {
            var mock = new Mock <IRepository>();

            mock.SetupGet(m => m.Products).Returns(new[] { new Product {
                                                               Name = "P1", Price = 100M
                                                           } });

            var controller = new HomeController {
                Repository = mock.Object
            };

            var result = controller.Index();

            mock.VerifyGet(m => m.Products, Times.Once);
        }
Example #48
0
        public void DraggingNonFileContentDoesNothing()
        {
            // Arrange
            var vm       = new ComposeTweetViewModel(null);
            var dropInfo = new Mock <IDropInfo>();

            dropInfo.SetupGet(d => d.Data).Returns(new DataObject());
            dropInfo.SetupSet(d => d.Effects = DragDropEffects.Copy).Verifiable();

            // Act
            vm.DragOver(dropInfo.Object);

            // Assert
            dropInfo.VerifyGet(d => d.Data, Times.Once());
            dropInfo.VerifySet(d => d.Effects = DragDropEffects.Copy, Times.Never());
        }
        public async Task SendAsync_HostInErrorState_Returns503Immediately()
        {
            _managerMock.SetupGet(p => p.State).Returns(ScriptHostState.Error);
            _managerMock.SetupGet(p => p.LastError).Returns(new Exception());

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://functions.test.com/api/test");
            var ex = await Assert.ThrowsAsync <HttpResponseException>(async() =>
            {
                await _invoker.SendAsync(request, CancellationToken.None);
            });

            HttpResponseMessage response = ex.Response;

            Assert.Equal(HttpStatusCode.ServiceUnavailable, response.StatusCode);
            _managerMock.VerifyGet(p => p.State, Times.Exactly(5));
        }
        public void AddProduct_Always_AddedSuccessfully()
        {
            // arrange
            var mock         = new Mock <IDatabase>();
            var productsList = new List <Product>();

            mock.Setup(repo => repo.Products).Returns(productsList);
            var repository = new Repository(mock.Object);

            // act
            repository.AddProduct("Box", 10);

            // assert
            mock.VerifyGet(x => x.Products);
            productsList.Should().HaveCount(1).And.BeEquivalentTo(new Product(1, "Box", 10));
        }
        public async Task WorkItemManager_Create_DoNotCreateWithoutProperties()
        {
            // arrange
            var providerMock = new Mock <IDataProvider>();

            providerMock.SetupGet(o => o.Write).Returns(true);
            var manager = new WorkItemManager(providerMock.Object, new CommonSdlcDescriptorProvider());

            // act
            var result = await manager.CreateAsync("FOO", "BAR", new Property[] { });

            // assert
            Assert.False(result.Success);
            providerMock.VerifyGet(o => o.Write);
            providerMock.VerifyNoOtherCalls();
        }
Example #52
0
        public async Task GetStatus()
        {
            var audioEngine     = new Mock <IAudioEngine>();
            var settingsService = new Mock <ISettingsService>();

            audioEngine.SetupGet(x => x.IsRunning).Returns(true);

            var processor = new EngineProcessor(audioEngine.Object, settingsService.Object);

            var result = await processor.ProcessAsync("getstatus", null).ConfigureAwait(false);

            audioEngine.VerifyGet(e => e.IsRunning, Times.Once);

            Assert.NotNull(result);
            Assert.True(result.IsSuccess);
        }
Example #53
0
            public void the_workstationid_should_be_retrieved()
            {
                //Arrange
                var mockCustomerRepository  = new Mock <ICustomerRepository>();
                var mockApplicationSettings = new Mock <IApplicationSettings>();


                var customerService = new CustomerService(mockCustomerRepository.Object, mockApplicationSettings.Object);

                //Act
                customerService.Create(new CustomerToCreateDto());

                //Assert
                mockApplicationSettings.VerifyGet(
                    x => x.SystemConfiguration.AuditingInformation.WorkstationId);
            }
Example #54
0
        public void ChannelEventReceived_Rssi_TriggersRssiEvent()
        {
            // Setup
            var routeEventArgs = new RouteMyoEventArgs(
                new IntPtr(123),
                new IntPtr(789),
                MyoEventType.Rssi,
                DateTime.UtcNow);

            var channelListener = new Mock <IChannelListener>(MockBehavior.Strict);

            var myoDeviceDriver = new Mock <IMyoDeviceDriver>(MockBehavior.Strict);

            myoDeviceDriver
            .SetupGet(x => x.Handle)
            .Returns(new IntPtr(123));
            myoDeviceDriver
            .Setup(x => x.GetEventRssi(routeEventArgs.Event))
            .Returns(123);

            var myo = Myo.Create(
                channelListener.Object,
                myoDeviceDriver.Object);

            RssiEventArgs actualEventArgs = null;
            object        actualSender    = null;

            myo.Rssi += (sender, args) =>
            {
                actualSender    = sender;
                actualEventArgs = args;
            };

            // Execute
            channelListener.Raise(
                x => x.EventReceived += null,
                routeEventArgs);

            // Assert
            Assert.Equal(myo, actualSender);
            Assert.Equal(myo, actualEventArgs.Myo);
            Assert.Equal(routeEventArgs.Timestamp, actualEventArgs.Timestamp);
            Assert.Equal(123, actualEventArgs.Rssi);

            myoDeviceDriver.VerifyGet(x => x.Handle, Times.Once);
            myoDeviceDriver.Verify(x => x.GetEventRssi(routeEventArgs.Event), Times.Once);
        }
        public async Task ValidationCacheService_GetValidKeyWithListWithTwoValues_ShouldReturnANewCopyOfTheLastUpdatedOne()
        {
            // Arrange
            string key = "some key";
            var    now = DateTime.Now;

            var value1Mock = new Mock <IValidationCacheEntity>();

            value1Mock
            .SetupGet(v => v.LastUpdate)
            .Returns(now);

            var value2Mock = new Mock <IValidationCacheEntity>();

            value2Mock
            .SetupGet(v => v.LastUpdate)
            .Returns(now + TimeSpan.FromHours(1));

            var expectedValue = value2Mock.Object;

            var list = new IValidationCacheEntity[] { value1Mock.Object, value2Mock.Object };

            var repositoryMock = new Mock <IValidationCacheDataRepository>();

            repositoryMock
            .Setup(r => r.GetAll(key))
            .Returns(list);

            var dateTimeProviderMock = new Mock <IDateTimeProvider>();

            var service = new ValidationCacheService(repositoryMock.Object, dateTimeProviderMock.Object);

            // Act
            var result = await service.Get(key);

            // Asset
            Assert.IsNotNull(result);
            Assert.AreNotSame(value1Mock.Object, result);
            Assert.AreNotSame(value2Mock.Object, result);

            Assert.AreEqual(expectedValue.Content, result.Content);
            Assert.AreEqual(expectedValue.LastUpdate, result.LastUpdate);
            Assert.AreEqual(expectedValue.Status, result.Status);

            repositoryMock.Verify(r => r.GetAll(key), Times.Once);
            dateTimeProviderMock.VerifyGet(p => p.Now, Times.Never);
        }
Example #56
0
        public async Task CallCorrectServiceMethod()
        {
            //Arrange
            const string uID  = "213123";
            const string pass = "******";
            var          user = new User {
                Id = uID
            };
            var userManagerMock        = new Mock <IUserManager <User> >();
            var passwordValidatorMock  = new Mock <IPasswordValidator <User> >();
            var passwordValidatorMock2 = new Mock <IPasswordValidator <User> >();

            passwordValidatorMock
            .Setup(pvm => pvm.ValidateAsync(It.IsAny <UserManager <User> >(), user, pass))
            .ReturnsAsync(IdentityResult.Success);
            passwordValidatorMock2
            .Setup(pvm => pvm.ValidateAsync(It.IsAny <UserManager <User> >(), user, pass))
            .ReturnsAsync(IdentityResult.Success);
            userManagerMock
            .SetupGet(umm => umm.Users)
            .Returns(new List <User> {
                user
            }.AsQueryable());
            userManagerMock
            .SetupGet(umm => umm.PasswordValidators)
            .Returns(new List <IPasswordValidator <User> > {
                passwordValidatorMock.Object, passwordValidatorMock2.Object
            });
            userManagerMock
            .Setup(umm => umm.RemovePasswordAsync(It.IsAny <User>()))
            .ReturnsAsync(IdentityResult.Success);
            userManagerMock
            .Setup(umm => umm.AddPasswordAsync(It.IsAny <User>(), pass))
            .ReturnsAsync(IdentityResult.Success);

            var sut = new UsersController(userManagerMock.Object);
            //Act
            var result = await sut.ChangePassword(new UserModalModelView { ID = uID, ConfirmPassword = pass, NewPassword = pass }) as RedirectToActionResult;

            //Assert
            userManagerMock.Verify(umm => umm.Users, Times.Once);
            userManagerMock.VerifyGet(umm => umm.PasswordValidators, Times.Once);
            passwordValidatorMock.Verify(pvm => pvm.ValidateAsync(It.IsAny <UserManager <User> >(), user, pass), Times.Once);
            passwordValidatorMock2.Verify(pvm => pvm.ValidateAsync(It.IsAny <UserManager <User> >(), user, pass), Times.Once);
            userManagerMock.Verify(s => s.RemovePasswordAsync(user), Times.Once);
            userManagerMock.Verify(s => s.AddPasswordAsync(user, pass), Times.Once);
        }
        public void Accept()
        {
            LoanProduct product     = new LoanProduct(99, "Loan", 5.25m);
            LoanAmount  amount      = new LoanAmount("USD", 200_000);
            var         application = new LoanApplication(42, product, amount, "Sarah", 25, "133 Pluralsight Drive, Draper, Utah", 65_000);

            // setting up a mock method return
            var mockIdentityVerifier = new Mock <IIdentityVerifier>();

            mockIdentityVerifier.Setup(x => x.Validate(It.IsAny <string>(), It.IsAny <int>(), "133 Pluralsight Drive, Draper, Utah")).Returns(true);

            // setting up a mock property
            var mockCreditScorer = new Mock <ICreditScorer>();

            mockCreditScorer.Setup(x => x.Score).Returns(300);

            // manully setting up a mock property hierarchy
            // CreditScorer -> ScoreResult -> ScoreValue
            //var mockScoreValue = new Mock<ScoreValue>();
            //mockScoreValue.Setup(x => x.Score).Returns(300);
            //var mockScoreResult = new Mock<ScoreResult>();
            //mockScoreResult.Setup(x => x.ScoreValue).Returns(mockScoreValue.Object);
            //mockCreditScorer.Setup(x => x.ScoreResult).Returns(mockScoreResult.Object);

            // Getting moq to create the hierarchy of object
            // Moq creates each of the objects in the hierarchy, all the properties in hierarchy must be virtual
            mockCreditScorer.Setup(x => x.ScoreResult.ScoreValue.Score).Returns(300);

            // Tracking changes to properties
            // Can provide an initial value with a second argument
            mockCreditScorer.SetupProperty(x => x.Count);
            // Can use the below to setup all properties but it will overwrite any previous setup, so use it first!
            //mockCreditScorer.SetupAllProperties();

            var sut = new LoanApplicationProcessor(mockIdentityVerifier.Object, mockCreditScorer.Object);

            sut.Process(application);

            // Check property was accessed, number of times is optional
            mockCreditScorer.VerifyGet(x => x.ScoreResult.ScoreValue.Score, Times.Once);
            // Check property was set
            mockCreditScorer.VerifySet(x => x.Count = It.IsAny <int>());

            Assert.That(application.GetIsAccepted(), Is.True);

            Assert.That(mockCreditScorer.Object.Count, Is.EqualTo(1));
        }
Example #58
0
        public void AddGameAchievements()
        {
            const int          gameId           = 99;
            List <Achievement> gameAchievements = new List <Achievement>();

            for (int i = 0; i < 10; i++)
            {
                Achievement achievement = new Achievement
                {
                    ImageUrl         = "http://example.com/achievement" + i + ".gif",
                    ApiName          = i.ToString(),
                    AchievementNames = new EntitySet <AchievementName>
                    {
                        new AchievementName
                        {
                            Name        = "Achievement " + i,
                            Description = "Achievement " + i
                        }
                    }
                };
                gameAchievements.Add(achievement);
            }

            _repositoryMock.SetupGet(rep => rep.Achievements).Returns(_achievements);

            _manager.AddAchievements(99, gameAchievements);

            _repositoryMock.VerifyGet(rep => rep.Achievements);
            _repositoryMock.Verify(rep => rep.InsertOnSubmit(It.IsAny <Achievement>()),
                                   Times.Exactly(gameAchievements.Count));
            _repositoryMock.Verify(rep => rep.SubmitChanges());

            List <Achievement> expectedAchievements = new List <Achievement>(_achievements);

            expectedAchievements.AddRange(gameAchievements);
            _repositoryMock.SetupGet(rep => rep.Achievements).Returns(expectedAchievements.AsQueryable());

            Assert.That(_repositoryMock.Object.Achievements.Count(a => a.GameId == gameId), Is.EqualTo(10));
        }
Example #59
0
        public void CallingColumnAddsAlterColumnExpressionToContextWithSpecifiedNameSet()
        {
            var collectionMock = new Mock <ICollection <IMigrationExpression> >();


            var contextMock = new Mock <IMigrationContext>();

            contextMock.Setup(x => x.Expressions).Returns(collectionMock.Object);


            var root = new AlterExpressionRoot(contextMock.Object);

            root.Column("Bacon");

            collectionMock.Verify(x => x.Add(It.Is <AlterColumnExpression>(e => e.Column.Name.Equals("Bacon"))));
            contextMock.VerifyGet(x => x.Expressions);
        }
Example #60
0
        public void JenkinsLookup2_Implementation_Constructor_Config_IsCloned()
        {
            var jenkinsLookupConfigMock = new Mock <IJenkinsLookup2Config>();

            {
                jenkinsLookupConfigMock.Setup(jlc => jlc.Clone())
                .Returns(() => new JenkinsLookup2Config());
            }

            GC.KeepAlive(
                new JenkinsLookup2_Implementation(jenkinsLookupConfigMock.Object));


            jenkinsLookupConfigMock.Verify(jlc => jlc.Clone(), Times.Once);

            jenkinsLookupConfigMock.VerifyGet(jlc => jlc.Seed, Times.Never);
        }