public void GetParser_SupportedFileType_ReturnsParser()
        {
            var supportedFileType = _fixture.Create <string>();
            var parser            = new Mock <IThemeParser>();

            parser.Setup(x => x.SupportedFileTypes).Returns(new string[] { supportedFileType });
            var themeParserFactory = new ThemeParserFactory(new IThemeParser[] { parser.Object });

            var result = themeParserFactory.GetParser(supportedFileType);

            parser.Should().Be(parser);
        }
        public void AddToAssetService_Should_AddDaniel()
        {
            //arr
            var daniel = new Daniel(0, 0);
            var mockAssetServiceObject = new Mock <AssetService>().Object;

            //act
            mockAssetServiceObject.AddToAssets(daniel);

            //ass
            mockAssetServiceObject.GetAsset(daniel.Key).Should().BeOfType(typeof(Daniel));
            mockAssetServiceObject.GetAsset(daniel.Key).Should().Be(daniel);
            mockAssetServiceObject.Should().NotBeNull();
            mockAssetServiceObject.Items.Should().HaveCount(1);
        }
Esempio n. 3
0
        public void Inject_SetsSingleMock()
        {
            // Arrange.
            var moqzilla = new Mocker();

            // Act.
            var oldObj = moqzilla.Mock <IDisposable>();
            var newObj = new Mock <IDisposable>();

            moqzilla.Inject(newObj);
            var output = moqzilla.Mock <IDisposable>();

            // Assert.
            oldObj.Should().NotBeSameAs(newObj);
            newObj.Should().BeSameAs(output);
        }
Esempio n. 4
0
        public void MLOpsBuilder_BuildCreatesConfiguredLifeCycleManager()
        {
            var           metaDataStore = new Mock <IMetaDataStore>().Object;
            var           repository    = new Mock <IModelRepository>().Object;
            IMLOpsContext lcManager     = new MLOpsBuilder()
                                          .UseMetaDataStore(metaDataStore)
                                          .UseModelRepository(repository)
                                          .Build();

            lcManager.Should().BeOfType <MLOpsContext>("Because the default IMLLifeCycleManager is MLLifeCycleManager");
            var metaDataField   = typeof(MLOpsContext).GetField("metaDataStore", BindingFlags.Instance | BindingFlags.NonPublic);
            var repositoryField = typeof(MLOpsContext).GetField("modelRepository", BindingFlags.Instance | BindingFlags.NonPublic);

            metaDataStore.Should().BeSameAs(metaDataField.GetValue(lcManager), "Because UseMetaDataStore should set the IMetaDataStore instance via constructor");
            repository.Should().BeSameAs(repositoryField.GetValue(lcManager), "Because UseModelRepository should set the IModelRepository instance via constructor");
        }
        public void ValidateToken_ShouldThrowException_WhenIntrospectResponseIsNotActive()
        {
            var oktaId                    = "oktaId";
            var token                     = "expectedToken";
            var validatedToken            = new Mock <SecurityToken>().Object;
            var tokenValidationParameters = new TokenValidationParameters();
            var introspectResponse        = new IntrospectResponse
            {
                Active = false
            };
            var mockExpectedClaims = new Mock <ClaimsPrincipal>();
            var claims             = new List <Claim>();
            var claim = new Claim(MEClaimTypes.OktaUserId, oktaId);

            claims.Add(claim);
            mockExpectedClaims.Setup(cp => cp.Claims).Returns(claims);
            var identities = new List <ClaimsIdentity>();
            var identity   = new ClaimsIdentity();

            identities.Add(identity);
            mockExpectedClaims.Setup(cp => cp.Identities).Returns(identities);

            _mockUserSessionRetrievalByOktaIdService
            .Setup(service => service.Handle(It.IsAny <UserSessionRetrievalByOktaIdQuery>()))
            .Returns(Task.FromResult((MeUserSession)null))
            .Verifiable();

            _mockTokenService
            .Setup(ts => ts.IntrospectToken(token, It.IsAny <HttpClient>()))
            .Returns(Task.FromResult(introspectResponse));

            _mockTokenValidator.Setup(stv =>
                                      stv.ValidateToken(
                                          token,
                                          tokenValidationParameters,
                                          out validatedToken))
            .Returns(mockExpectedClaims.Object);

            Action action = () => _sut
                            .ValidateToken(token, tokenValidationParameters, out validatedToken)
                            .Should().Be(mockExpectedClaims.Object);

            action.Should().Throw <SecurityTokenValidationException>();

            validatedToken.Should().BeNull();
        }
        public void Given_a_Valid_Road_Id_Is_Specified_Return_Road_Name()
        {
            //Arrange
            responseFactory = new ResponseFactory();
            var _mock = new Mock <IResponseFactory>();

            _JObjectFactory = new Mock <IJObjectFactory>();

            //Act
            _mock.Setup(x => x.BuildResponse(It.IsAny <JObject>())).Returns(responseFactory.BuildResponse(MockResponse.ValidResponse("a4")));
            _JObjectFactory.Setup(o => o.ReturnAsJObect(MockResponse.ValidHttpResponseMock("A4"))).Equals(typeof(JObject));

            //Assert
            _JObjectFactory.Verify();

            _mock.Should().NotBeNull();

            //JB. Check that the Road name is returned.
            _mock.Object.BuildResponse(MockResponse.ValidResponse("a4")).Should().Contain("A4");
        }
        public void TestCallOrder6()
        {
            Thread thread = null;

            var subject = new Mock <IOrderInterface>();

            subject.Setup(x => x.MethodOrdered(It.IsAny <int>()))
            .Callback(() => { thread = Thread.CurrentThread; });

            const int servantId = 23;

            _server.CreateServant(servantId, subject.Object);
            var proxy = _client.CreateProxy <IOrderInterface>(servantId);

            proxy.MethodOrdered(42);
            thread.Should().NotBeNull();
            thread.Name.Should().Be("SharpRemote.Test.Types.Interfaces.IOrderInterface.MethodOrdered() (#23)");

            // This line exists to FORCE the GC to NOT collect the subject, which
            // in turn would unregister the servant from the server, thus making the test
            // fail.
            subject.Should().NotBeNull();
        }
Esempio n. 8
0
        public async Task Registering_church_with_argument_invalid()
        {
            //Arrange's
            var uow = new Mock <IUnitOfWork>();
            var bus = new Mock <IBus>();
            var domainNotification   = new Mock <DomainNotificationHandler>();
            var mockChurchRepository = new Mock <IChurchRepository>();

            var arguments = RegisterChurchCommand.Factory.Create(
                name: @"Richmond’s First Baptist ChurchRichmond’s First Baptist ChurchRichmond’s 
						First Baptist ChurchRichmond’s First Baptist ChurchRichmond’s First Baptist Church
						Richmond’s First Baptist Church"
                , email: "*****@*****.**"
                , photo: "1.jpg"
                , region: 55
                , prefix: 21
                , cellPhone: "123456789"
                , homePhone: "22222222");

            DomainNotification domainNotificationResult = null;

            bus.Setup(x => x.RaiseEvent(It.IsAny <DomainNotification>()))
            .Callback <DomainNotification>(notification => domainNotificationResult = notification);

            //Act's
            var commandHandler = new ChurchCommandHandler(
                uow.Object, bus.Object
                , domainNotification.Object, mockChurchRepository.Object);
            await commandHandler.Handle(arguments, CancellationToken.None);

            //Assert's
            domainNotification.Should().NotBeNull();
            domainNotificationResult.AggregateId.Should().Be(Guid.Empty);
            domainNotificationResult.Key.Should().Be("Name");
            domainNotificationResult.MessageType.Should().Be("DomainNotification");
            domainNotificationResult.Value.Should().Be("Name must be between 2 and 150 characters.");
        }
        public void ValidateToken_ShouldThrowException_WhenClaimsPrincipalMissingOktaId()
        {
            var token                     = "expectedToken";
            var validatedToken            = new Mock <SecurityToken>().Object;
            var tokenValidationParameters = new TokenValidationParameters();
            var introspectResponse        = new IntrospectResponse
            {
                Active = false
            };
            var mockExpectedClaims = new Mock <ClaimsPrincipal>();

            mockExpectedClaims
            .Setup(cp => cp.Claims)
            .Returns(Enumerable.Empty <Claim>());
            mockExpectedClaims
            .Setup(cp => cp.Identities)
            .Returns(Enumerable.Empty <ClaimsIdentity>());

            _mockTokenService
            .Setup(ts => ts.IntrospectToken(token, It.IsAny <HttpClient>()))
            .Returns(Task.FromResult(introspectResponse));

            _mockTokenValidator.Setup(stv =>
                                      stv.ValidateToken(
                                          token,
                                          tokenValidationParameters,
                                          out validatedToken))
            .Returns(mockExpectedClaims.Object);

            Action action = () => _sut
                            .ValidateToken(token, tokenValidationParameters, out validatedToken);

            action.Should().Throw <SecurityTokenValidationException>();

            validatedToken.Should().BeNull();
        }
Esempio n. 10
0
 public void MocksAreSingletons(Mock<IA> mock1, Mock<IA> mock2)
 {
     // Assert
       mock1.Should().BeSameAs(mock2);
 }
Esempio n. 11
0
        public void Mock_Should_Return_mock_assertion_for_futher_assertions()
        {
            var mockAssertion = _mock.Should().HaveCallCount(2).OrLess().To(x => x.TestMethod()).And.Mock;

            mockAssertion.Should().BeOfType <FluentMockAssertions <IMockable> >();
        }
        public void GivenTheMarketRulesReturnTheFollowingIntents(Table table)
        {
            MarketRulesManager manager = ScenarioContext.Current["MARKETRULEMANAGER"] as MarketRulesManager;

            manager.Should().NotBeNull();

            Fixture fixture = ScenarioContext.Current["FIXTURE"] as Fixture;

            fixture.Should().NotBeNull();

            foreach (var row in table.Rows)
            {
                var name = row["Rule"];
                Mock <IMarketRule> rule = ScenarioContext.Current["RULE-" + name] as Mock <IMarketRule>;
                rule.Should().NotBeNull();

                var mkt_name = row["Market"];
                var result   = row["Result"];
                var mkt      = fixture.Markets.FirstOrDefault(x => x.Id == mkt_name);
                mkt.Should().NotBeNull();


                if (!ScenarioContext.Current.ContainsKey("INTENT-RULE-" + name))
                {
                    MarketRuleResultIntent rule_intent = new MarketRuleResultIntent();
                    ScenarioContext.Current.Add("INTENT-RULE-" + name, rule_intent);
                    rule.Setup(x => x.Apply(It.IsAny <Fixture>(), It.IsAny <IMarketStateCollection>(), It.IsAny <IMarketStateCollection>())).Returns(rule_intent);
                }

                MarketRuleResultIntent intent = ScenarioContext.Current["INTENT-RULE-" + name] as MarketRuleResultIntent;
                intent.Should().NotBeNull();

                switch (result)
                {
                case "E":
                    Action <Market>      action      = x => x.AddOrUpdateTagValue("name", x.Name + " - E: " + name);
                    MarketRuleEditIntent edit_intent = new MarketRuleEditIntent(action, MarketRuleEditIntent.OperationType.CHANGE_DATA);
                    intent.EditMarket(mkt, edit_intent);
                    break;

                case "!E":
                    intent.MarkAsUnEditable(mkt);
                    break;

                case "R":
                    intent.MarkAsRemovable(mkt);
                    break;

                case "!R":
                    intent.MarkAsUnRemovable(mkt);
                    break;

                case "CS":
                    Action <Market>      edit_seln_action        = x => x.Selections.ForEach(y => y.Name = y.Name + name);
                    MarketRuleEditIntent change_seln_edit_intent = new MarketRuleEditIntent(edit_seln_action, MarketRuleEditIntent.OperationType.CHANGE_SELECTIONS);
                    intent.EditMarket(mkt, change_seln_edit_intent);
                    break;

                case "CD":
                    Action <Market>      change_data_action      = x => x.AddOrUpdateTagValue("name", x.Name + name);
                    MarketRuleEditIntent change_data_edit_intent = new MarketRuleEditIntent(change_data_action, MarketRuleEditIntent.OperationType.CHANGE_DATA);
                    intent.EditMarket(mkt, change_data_edit_intent);
                    break;

                case "AS":
                    Action <Market> add_seln_action = x => x.Selections.Add(new Selection {
                        Name = mkt.Name + (x.Selections.Count() + 1) + name, Id = mkt.Name + x.Selections.Count() + name
                    });
                    MarketRuleEditIntent add_seln_intent = new MarketRuleEditIntent(add_seln_action, MarketRuleEditIntent.OperationType.ADD_SELECTIONS);
                    intent.EditMarket(mkt, add_seln_intent);
                    break;

                case "RS":
                    Action <Market>      remove_seln_action = x => x.Selections.Clear();
                    MarketRuleEditIntent remove_seln_intent = new MarketRuleEditIntent(remove_seln_action, MarketRuleEditIntent.OperationType.REMOVE_SELECTIONS);
                    intent.EditMarket(mkt, remove_seln_intent);
                    break;

                default:
                    throw new Exception("Unknow status");
                }
            }
        }
 public void Mock_Should_should_return_FluentMockAssertions()
 {
     Assert.IsInstanceOfType(_mock.Should(), typeof(FluentMockAssertions <IMockable>));
 }
Esempio n. 14
0
 public void MockType(Mock<IA> mock)
 {
     // Assert
       mock.Should().BeOfType<Mock<IA>>();
 }