public void when_finding_non_existing_assignment_then_returns_null()
        {
            var storage = new Mock<IBlobStorage>();
            storage.SetReturnsDefault<byte[]>(null);
            var dao = new OrderDao(() => new ConferenceRegistrationDbContext("OrderDaoFixture"), storage.Object, Mock.Of<ITextSerializer>());

            var dto = dao.FindOrderSeats(Guid.NewGuid());

            Assert.Null(dto);
        }
        public void UseAutofacLifetimeScopeInjectorDoesntAddWrappedMiddlewareInstancesToAppBuilder()
        {
            var builder = new ContainerBuilder();
            builder.RegisterType<TestMiddleware>();
            var container = builder.Build();
            var app = new Mock<IAppBuilder>();
            app.Setup(mock => mock.Properties).Returns(new Dictionary<string, object>());
            app.SetReturnsDefault(app.Object);

            app.Object.UseAutofacLifetimeScopeInjector(container);

            app.Verify(mock => mock.Use(It.IsAny<AutofacMiddleware<TestMiddleware>>(), It.IsAny<object[]>()), Times.Never);
        }
Esempio n. 3
0
        public void RecordCalculation_ProvideCalcuation_Should_populate_stream_with_csv()
        {
            var calculation = new Calculation { Answer = 2.1, Operation = "theOperation", Probability1 = 0.3, Probability2 = 0.6 };
            var memoryStream = new MemoryStream();
            var mockClock = new Mock<IClock>();

            mockClock.SetReturnsDefault(new DateTime(2000, 1, 10, 10, 12, 30));

            var logger = new Logger(memoryStream, mockClock.Object);
            logger.RecordCalculation(calculation);

            byte[] buffer = memoryStream.ToArray();
            var result = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
            Assert.AreEqual("10/01/2000 10:12:30,0.3,0.6,2.1,theOperation\r\n", result);
        }
        public async Task CanPerformActivityAsync_PassDelegateParameter_ReturnTrue()
        {
            // Arrange
            var mockPredicate = new Mock<Func<UserAuthorisation, string, Task<bool>>>();
            mockPredicate.SetReturnsDefault(Task.FromResult(true));

            var user = new UserAuthorisation(userName);

            // Act
            var result = await user.CanPerformActivityAsync("READ", mockPredicate.Object);

            // Assert
            Assert.IsTrue(result);
            mockPredicate.Verify(p => p(user, "READ"), Times.Once);
        }
Esempio n. 5
0
        public void CreateShareLink_CreatedLinkAndToken()
        {
            // arrange
            var pathHelper = new Mock<IPathHelper>();
            var hashService = new HashService();
            var shareService = new ShareService(pathHelper.Object, hashService);

            pathHelper.SetReturnsDefault("/user/share");

            // act
            var link = shareService.CreateShareLink("*****@*****.**");

            // assert
            link.Should().Contain("/user/share/[email protected]?key=");
        }
        public void CanPerformActivity_MockDelegate_ReturnTrue()
        {
            // Arrange
            var mockCanPerformActivityHandler = new Mock<Func<UserAuthorisation,string, bool>>();
            mockCanPerformActivityHandler.SetReturnsDefault(true);

            var user = new UserAuthorisation(userName)
                .AddCanPerformActivityDelegate(mockCanPerformActivityHandler.Object);

            // Act
            var result = user.CanPerformActivity("READ");

            // Assert
            Assert.IsTrue(result);
            mockCanPerformActivityHandler.Verify(u => u(user, "READ"), Times.Once);
        }
Esempio n. 7
0
        public void UseAutofacMiddlewareAddsWrappedMiddlewareInstancesToAppBuilder()
        {
            var builder = new ContainerBuilder();

            builder.RegisterType <TestMiddleware>();
            var container = builder.Build();
            var app       = new Mock <IAppBuilder>();

            app.Setup(mock => mock.Properties).Returns(new Dictionary <string, object>());
            app.Setup(mock => mock.Use(typeof(AutofacMiddleware <TestMiddleware>)));
            app.SetReturnsDefault(app.Object);

            app.Object.UseAutofacMiddleware(container);

            app.VerifyAll();
        }
            public WhenGettingAConnectionFromAnNonEmptyPool()
            {
                _connection = new Mock <IConnection>();
                _connection.SetReturnsDefault(ConnectionState.Connected);
                _connectionFactory = new Mock <IConnectionCreator>();
                _connectionFactory
                .Setup(cf => cf.CreateOpenedAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
                .ReturnsAsync(_connection.Object);

                _connectionPool = new ConnectionPool(_config, _connectionFactory.Object);
                _connectionPool.GetConnectionAsync().Result.Dispose();

                _connectionFactory.ResetCalls();

                var connection = _connectionPool.GetConnectionAsync().Result;
            }
Esempio n. 9
0
        public void ValidateShareKey_WrongKey()
        {
            var pathHelper = new Mock<IPathHelper>();
            var hashService = new HashService();
            var shareService = new ShareService(pathHelper.Object, hashService);

            pathHelper.SetReturnsDefault("/user/share");

            var key = "dd12113dcb92ffeb0d7afaf0261fAAAA";

            // act
            var result = shareService.ValidateShareKey("*****@*****.**", key);

            // assert
            result.Should().Be.False();
        }
        public void UseRebus_WithAsyncDelegateAndNullProvider_Throws()
        {
            IServiceProvider          provider     = null;
            Mock <Func <IBus, Task> > onBusStarted = new Mock <Func <IBus, Task> >();

            onBusStarted.SetReturnsDefault(Task.CompletedTask);

            // Act
            void Act() => provider.UseRebus(onBusStarted.Object);

            // Assert
            var ex = Assert.Throws <ArgumentNullException>(Act);

            Assert.AreEqual(nameof(provider), ex.ParamName);
            _busStarterMock.Verify(m => m.Start(), Times.Never);
            onBusStarted.Verify(m => m.Invoke(It.IsAny <IBus>()), Times.Never);
        }
        internal void PresetGetValueOrDefault_IsCollection_Default(Mock <Type> typeMock, Mock <Type> type, Mock <IMemoryCache> memoryMock, string fullName)
        {
            (OracleUdtInfo Info, UdtPropertyNetPropertyMap[] Props, bool FuzzyMatch)expectedValue = default;
            object validParameter = null;

            typeMock.SetReturnsDefault(true);
            typeMock.Setup(t => t.GetGenericArguments()).Returns(new[] { type.Object });

            type.Setup(t => t.FullName).Returns(fullName);
            memoryMock.Setup(m => m.TryGetValue($"udt-{fullName}", out validParameter)).Returns(true);

            var cache = new ServForOracleCache(memoryMock.Object);

            var actualValue = cache.PresetGetValueOrDefault(typeMock.Object);

            Assert.Equal(expectedValue, actualValue);
        }
Esempio n. 12
0
        public CreateXHarnessAndroidWorkItemsTests()
        {
            _fileSystem        = new MockFileSystem();
            _zipArchiveManager = new();
            _zipArchiveManager.SetReturnsDefault(Task.CompletedTask);
            _zipArchiveManager
            .Setup(x => x.ArchiveFile(It.IsAny <string>(), It.IsAny <string>()))
            .Callback <string, string>((folder, zipPath) =>
            {
                _fileSystem.Files.Add(zipPath, "zip of " + folder);
            });

            _task = new CreateXHarnessAndroidWorkItems()
            {
                BuildEngine = new MockBuildEngine(),
            };
        }
Esempio n. 13
0
        public void TestExecutaComSucessoQuandoRepositorioNaoGrava()
        {
            var mockVenda = new Mock <VendaEntity>();

            mockVenda.SetReturnsDefault <bool>(true);
            VendaEntity venda = mockVenda.Object;

            var vendaRepositoryMock = new Mock <IVendaRepository>();

            vendaRepositoryMock.SetReturnsDefault <bool>(false);
            IVendaRepository vendaRepository = vendaRepositoryMock.Object;

            ISalvarVendaService salvarVendaService = new SalvarVendaService(vendaRepository);
            bool executadoComSucesso = salvarVendaService.Executar(venda);

            Assert.False(executadoComSucesso);
        }
Esempio n. 14
0
        public void TestExecutarServicoComSucesso()
        {
            var vendaMock = new Mock <VendaEntity>();

            vendaMock.SetReturnsDefault <bool>(true);
            VendaEntity venda = vendaMock.Object;

            var vendaRepositoryMock = new Mock <IVendaRepository>();

            vendaRepositoryMock.SetReturnsDefault <bool>(true);
            IVendaRepository vendaRepository = vendaRepositoryMock.Object;

            ISalvarVendaService salvarVendaService = new SalvarVendaService(vendaRepository);
            bool executadoComSucesso = salvarVendaService.Executar(venda);

            Assert.True(executadoComSucesso);
        }
Esempio n. 15
0
        private PushMetadataToBuildAssetRegistry GetPushMetadata()
        {
            Mock <IGetEnvProxy> getEnvMock = new Mock <IGetEnvProxy>();

            getEnvMock.Setup(a => a.GetEnv("BUILD_REPOSITORY_NAME")).Returns(buildRepoName);
            getEnvMock.Setup(b => b.GetEnv("BUILD_BUILDNUMBER")).Returns(buildNumber);
            getEnvMock.Setup(c => c.GetEnv("BUILD_SOURCEBRANCH")).Returns(sourceBranch);
            getEnvMock.Setup(d => d.GetEnv("BUILD_SOURCEVERSION")).Returns(commitSourceVersion);
            getEnvMock.SetReturnsDefault("MissingEnvVariableCheck!");

            PushMetadataToBuildAssetRegistry pushMetadata = new PushMetadataToBuildAssetRegistry
            {
                getEnvProxy = getEnvMock.Object
            };

            return(pushMetadata);
        }
Esempio n. 16
0
        /// <summary>
        /// Setup the mocked pyro ResourceService which mocks the response from the Pyro database when commiting the
        /// SoapRequest and SoapResponse FHIR Binary resources
        /// </summary>
        /// <returns></returns>
        private IResourceServices GetIResourceServices()
        {
            var FhirRequestUriForBinaryRequestPut = CommonTestSetup.TestSetupMocks.GetIPyroRequestUriFactory().CreateFhirRequestUri().FhirRequestUri = new Pyro.Common.Tools.UriSupport.PyroFhirUri(CommonTestSetup.TestSetupMocks.GetIPrimaryServiceRootCache());

            FhirRequestUriForBinaryRequestPut.Parse($"{StaticTestData.FhirEndpoint()}/{ResourceType.Binary.GetLiteral()}/{SoapRequestId}");

            Mock <IResourceServiceOutcome> MokIResourceServiceOutcomeOne = new Mock <IResourceServiceOutcome>();

            MokIResourceServiceOutcomeOne.Setup(x => x.FhirResourceId).Returns(SoapRequestId);
            MokIResourceServiceOutcomeOne.Setup(x => x.FormatMimeType).Returns((string)null);
            MokIResourceServiceOutcomeOne.Setup(x => x.HttpStatusCode).Returns(System.Net.HttpStatusCode.Created);
            MokIResourceServiceOutcomeOne.Setup(x => x.IsDeleted).Returns(false);
            MokIResourceServiceOutcomeOne.Setup(x => x.LastModified).Returns(DateTimeOffset.Now);
            MokIResourceServiceOutcomeOne.Setup(x => x.OperationType).Returns(RestEnum.CrudOperationType.Create);
            MokIResourceServiceOutcomeOne.Setup(x => x.RequestUri).Returns(FhirRequestUriForBinaryRequestPut);
            MokIResourceServiceOutcomeOne.Setup(x => x.ResourceResult).Returns(new Binary());
            MokIResourceServiceOutcomeOne.Setup(x => x.ResourceVersionNumber).Returns("1");
            MokIResourceServiceOutcomeOne.Setup(x => x.SuccessfulTransaction).Returns(true);
            MokIResourceServiceOutcomeOne.Setup(x => x.SummaryType).Returns((Hl7.Fhir.Rest.SummaryType?)null);

            var FhirRequestUriForBinaryResponsePut = CommonTestSetup.TestSetupMocks.GetIPyroRequestUriFactory().CreateFhirRequestUri().FhirRequestUri = new Pyro.Common.Tools.UriSupport.PyroFhirUri(CommonTestSetup.TestSetupMocks.GetIPrimaryServiceRootCache());

            FhirRequestUriForBinaryRequestPut.Parse($"{StaticTestData.FhirEndpoint()}/{ResourceType.Binary.GetLiteral()}/{SoapResponseId}");

            Mock <IResourceServiceOutcome> MokIResourceServiceOutcomeTwo = new Mock <IResourceServiceOutcome>();

            MokIResourceServiceOutcomeTwo.Setup(x => x.FhirResourceId).Returns(SoapResponseId);
            MokIResourceServiceOutcomeTwo.Setup(x => x.FormatMimeType).Returns((string)null);
            MokIResourceServiceOutcomeTwo.Setup(x => x.HttpStatusCode).Returns(System.Net.HttpStatusCode.Created);
            MokIResourceServiceOutcomeTwo.Setup(x => x.IsDeleted).Returns(false);
            MokIResourceServiceOutcomeTwo.Setup(x => x.LastModified).Returns(DateTimeOffset.Now);
            MokIResourceServiceOutcomeTwo.Setup(x => x.OperationType).Returns(RestEnum.CrudOperationType.Create);
            MokIResourceServiceOutcomeTwo.Setup(x => x.RequestUri).Returns(FhirRequestUriForBinaryResponsePut);
            MokIResourceServiceOutcomeTwo.Setup(x => x.ResourceResult).Returns(new Binary());
            MokIResourceServiceOutcomeTwo.Setup(x => x.ResourceVersionNumber).Returns("1");
            MokIResourceServiceOutcomeTwo.Setup(x => x.SuccessfulTransaction).Returns(true);
            MokIResourceServiceOutcomeTwo.Setup(x => x.SummaryType).Returns((Hl7.Fhir.Rest.SummaryType?)null);

            Mock <IResourceServices> MokIResourceServices = new Mock <IResourceServices>();

            MokIResourceServices.SetupSequence(x => x.Put(It.IsAny <string>(), It.IsAny <Binary>(), It.IsAny <IRequestMeta>()))
            .Returns(MokIResourceServiceOutcomeOne.Object)
            .Returns(MokIResourceServiceOutcomeTwo.Object);
            MokIResourceServices.SetReturnsDefault <IResourceServiceOutcome>(MokIResourceServiceOutcomeOne.Object);
            return(MokIResourceServices.Object);
        }
        public void TestarInserirVeiculo()
        {
            InserirVeiculoCommand command = new InserirVeiculoCommand()
            {
                Chassi      = "NOVOCHASSI123456",
                Cor         = "PRETA",
                TipoVeiculo = Domain.Enum.TipoVeiculoEnum.Caminhao
            };
            var rep = new Mock <IVeiculoRepository>();

            rep.SetReturnsDefault("Veiculo cadastrado com sucesso!");

            VeiculoHandler handler  = new VeiculoHandler(rep.Object, Mapper);
            var            response = handler.Handle(command, CancellationToken.None);

            Assert.True(response.Result == "Veiculo cadastrado com sucesso!");
        }
        protected override void SetUp()
        {
            _busMock = new Mock <IBus>
            {
                DefaultValue = DefaultValue.Mock
            };

            _busStarterMock = new Mock <IBusStarter>();
            _busStarterMock.SetReturnsDefault(_busMock.Object);

            _serviceProvider = new ServiceCollection()
                               .AddRebus(c => c)
                               .Replace(ServiceDescriptor.Singleton(_busStarterMock.Object))
                               .BuildServiceProvider();

            Using(_serviceProvider);
        }
        public void SetupGetBuildManifestMetadataTests()
        {
            Mock <IGetEnvProxy> getEnvMock = new Mock <IGetEnvProxy>();

            getEnvMock.Setup(a => a.GetEnv("BUILD_REPOSITORY_NAME")).Returns(RepoName);
            getEnvMock.Setup(b => b.GetEnv("BUILD_BUILDNUMBER")).Returns(AzureDevOpsBuildNumber1);
            getEnvMock.Setup(c => c.GetEnv("BUILD_SOURCEBRANCH")).Returns(AzureDevOpsBranch1);
            getEnvMock.Setup(d => d.GetEnv("BUILD_SOURCEVERSION")).Returns(Commit);
            getEnvMock.Setup(d => d.GetEnv("SYSTEM_TEAMFOUNDATIONCOLLECTIONURI")).Returns(SystemTeamCollectionUri);
            getEnvMock.Setup(d => d.GetEnv("BUILD_BUILDID")).Returns(AzureDevOpsBuildId1.ToString());
            getEnvMock.SetReturnsDefault("MissingEnvVariableCheck!");

            pushMetadata = new PushMetadataToBuildAssetRegistry
            {
                getEnvProxy = getEnvMock.Object
            };
        }
        public void RunBeforeAnyTest()
        {
            _tab          = new TabInfo();
            _tab.TabID    = _tabId;
            _tab.PortalID = _testPortalId;

            _portalSettings          = new PortalSettings();
            _portalSettings.PortalId = _testPortalId;

            _tabControllerMock   = new Mock <ITabController>();
            _securityServiceMock = new Mock <ISecurityService>();
            _contentVerifierMock = new Mock <IContentVerifier>();

            _tabControllerMock.SetReturnsDefault(_tab);
            _securityServiceMock.SetReturnsDefault(true);
            _contentVerifierMock.SetReturnsDefault(true);
        }
Esempio n. 21
0
        public AppInstallerTests()
        {
            _mainLog = new Mock <ILog>();

            _processManager = new Mock <IProcessManager>();
            _processManager.SetReturnsDefault(Task.FromResult(new ProcessExecutionResult()
            {
                ExitCode = 0
            }));

            _hardwareDeviceLoader = new Mock <IHardwareDeviceLoader>();
            _hardwareDeviceLoader
            .Setup(x => x.FindDevice(RunMode.iOS, _mainLog.Object, false, false))
            .ReturnsAsync(s_mockDevice);

            Directory.CreateDirectory(s_appPath);
        }
Esempio n. 22
0
        public void GetById()
        {
            // Arrange
            UserTask _userTask = new UserTask()
            {
                Task_ID       = 9,
                ParentTask_ID = null,
                Project_ID    = null,
                TaskDetail    = "This is task for akashganga",
                StartDate     = DateTime.Now,
                EndDate       = DateTime.Now,
                Priority      = 21,
                Status        = "Open"
            };
            var userMock = new List <UserTask> {
                _userTask
            }.AsQueryable();
            // Arrange

            var mockSet   = new Mock <TaskDataContext>();
            var usersMock = new Mock <DbSet <UserTask> >();

            usersMock.As <IQueryable <UserTask> >().Setup(m => m.Provider).Returns(userMock.Provider);
            usersMock.As <IQueryable <UserTask> >().Setup(m => m.Expression).Returns(userMock.Expression);
            usersMock.As <IQueryable <UserTask> >().Setup(m => m.ElementType).Returns(userMock.ElementType);
            usersMock.As <IQueryable <UserTask> >().Setup(m => m.GetEnumerator()).Returns(userMock.GetEnumerator());
            usersMock.SetReturnsDefault(userMock.GetEnumerator());
            usersMock.Setup(x => x.Add(It.IsAny <UserTask>())).Returns((UserTask u) => u);
            mockSet.Setup(p => p.Set <UserTask>().Add(It.IsAny <UserTask>())).Returns(_userTask);

            TaskOperationController controller = new TaskOperationController();

            controller.Request       = new HttpRequestMessage();
            controller.Configuration = new HttpConfiguration();


            // Act
            // var response = controller.GetTaskDetailsById(5);

            // Assert

            Assert.IsNotNull(controller);
            //Assert.AreEqual(10, product.Id);
            //  Assert.AreEqual("value", result);
        }
Esempio n. 23
0
        public void WhenTryToUseSameTransactionKeyTwice_NothingHappens()
        {
            var sameKeyFactoryMock = new Mock <ITransactionFactory>();

            sameKeyFactoryMock.SetReturnsDefault("X");
            var myActor    = MyAccount.GetActor(_network, sameKeyFactoryMock.Object);
            var otherActor = OtherAccount.GetActor(_network, sameKeyFactoryMock.Object);

            Interconnect(myActor, otherActor);

            var artefact = otherActor.CreateArtefact(Artefact.Name);

            MakeTransaction(otherActor, myActor, artefact);
            MakeTransaction(myActor, otherActor, MyAccount.GetArtefact(artefact.Id));

            Assert.True(MyAccount.Self.HasArtefact(artefact.Id));
            Assert.False(OtherAccount.Self.HasArtefact(artefact.Id));
        }
        internal void GetUdtInfoFromAttributeOrPresetCache_FromAttribute_IsCollection(IMemoryCache memory, Mock <Type> colTypeMock, string schema, string objectName, string collectionSchema, string collectionName)
        {
            colTypeMock.SetReturnsDefault(true);

            var type = udtInfoAttributeTests.GetTypeWithAttribute(schema, objectName, collectionSchema, collectionName);

            colTypeMock.Setup(t => t.GetGenericArguments()).Returns(new[] { type });

            var cache = new ServForOracleCache(memory);

            var udtInfo = cache.GetUdtInfoFromAttributeOrPresetCache(colTypeMock.Object);

            Assert.NotNull(udtInfo);
            Assert.Equal(schema, udtInfo.ObjectSchema, ignoreCase: true);
            Assert.Equal(objectName, udtInfo.ObjectName, ignoreCase: true);
            Assert.Equal(collectionSchema, udtInfo.CollectionSchema, ignoreCase: true);
            Assert.Equal(collectionName, udtInfo.CollectionName, ignoreCase: true);
        }
Esempio n. 25
0
        public async Task ShouldGetDefaultSymbolsList()
        {
            var mock = new Mock <ISecureStorageWrapper>();

            mock.SetReturnsDefault <string>(string.Empty);
            ISettingsService service = new SettingsService(mock.Object);

            var symbolsList = await service.LoadSymbolsListAsync();

            var defaultList = new List <CurrencyType>
            {
                CurrencyType.GBP,
                CurrencyType.USD,
                CurrencyType.CHF
            };

            Assert.That(symbolsList, Is.EquivalentTo(defaultList));
        }
Esempio n. 26
0
        public AddressParserTest()
        {
            TaggerMock = new Mock <ITagger>();
            TaggerMock.SetReturnsDefault(new int[0]);

            HMMMock = new Mock <IHiddenMarkovModelWrapper>();
            HMMMock.SetReturnsDefault(new int[0]);
            ModelLoaderMock = new Mock <IModelLoader>();
            ModelLoaderMock.Setup(m => m.LoadHMM()).Returns(HMMMock.Object);

            FormatterMock = new Mock <IFormatter <Address> >();
            FormatterMock.Setup(f => f.Format(It.IsAny <Address>())).Returns <Address>(addr => addr);

            Parser = new AddressParser(
                TaggerMock.Object,
                ModelLoaderMock.Object,
                FormatterMock.Object);
        }
        public void DeleteReturnsOkNegotiatedContentResultDTO()
        {
            // Arrange
            var mockRepository = new Mock <IRepository <ToDoItem> >();

            mockRepository.SetReturnsDefault(new ToDoItem()
            {
                Id = 10
            });

            var controller = new ToDoItemsController(mockRepository.Object, _mapper);

            // Act
            IHttpActionResult actionResult = controller.Delete(10);

            // Assert
            Assert.IsInstanceOfType(actionResult, typeof(OkNegotiatedContentResult <ToDoItemDTO>));
        }
Esempio n. 28
0
        public BookUserServiceTests()
        {
            bookId                 = new Guid("5489A967-9320-4350-E6FC-08D5CC8498F3");
            bookServiceMock        = new Mock <IBookService>();
            bookUserRepositoryMock = new Mock <IBookUserRepository>();
            bookEmailService       = new Mock <IBooksEmailService>();
            unitOfWorkMock         = new Mock <IUnitOfWork>();
            bookUsersEmailService  = new Mock <IBookUsersEmailService>();
            muambatorServiceMock   = new Mock <IMuambatorService>();
            bookRepositoryMock     = new Mock <IBookRepository>();

            bookServiceMock.SetReturnsDefault(true);

            bookServiceMock.Setup(s => s.GetBookWithAllUsers(It.IsAny <Guid>())).Returns(() =>
            {
                return(BookMock.GetLordTheRings());
            });
        }
Esempio n. 29
0
        public async void ExecuteAsync_DoesNotApplyExtensionOptionTwice_WhenChangingLanguage_IfOptionIsSentWithLanguageChange()
        {
            var extensionMock = new Mock <ISetOptionsFromClientExtension>();

            extensionMock.SetReturnsDefault(true);

            var driver = MirrorSharpTestDriver.New(new MirrorSharpOptions().EnableVisualBasic(), new MirrorSharpServices {
                SetOptionsFromClient = extensionMock.Object
            });

            await driver.SendAsync(SetOptions, "x-testkey=testvalue");

            extensionMock.Invocations.Clear();
            await driver.SendAsync(SetOptions, "language=" + LanguageNames.VisualBasic + ",x-testkey=testvalue");

            extensionMock.Verify(x => x.TrySetOption(driver.Session, "x-testkey", "testvalue"), Times.Once);
            extensionMock.VerifyNoOtherCalls();
        }
            public IEnumerator <object[]> GetEnumerator()
            {
                var moq = new Mock <IPuzzleSolverDay1>();

                moq.SetReturnsDefault(new List <ulong>()
                {
                    0, 0
                });

                yield return(new object[] {
                    new List <ulong>()
                    {
                        1, 2, 3, 4, 5, 6, 7, 8, 9
                    },
                    3,
                    moq.Object,
                });
            }
Esempio n. 31
0
        public async Task Delete_custom_domain_should_send_all_keys_to_consul_when_success()
        {
            // Arrange
            var fixture      = new Fixture();
            var domainName   = fixture.Create <string>();
            var httpsBaseUrl = $"/v1/kv/traefik/http/routers/https_{domainName}";
            var httpBaseUrl  = $"/v1/kv/traefik/http/routers/http_{domainName}";

            var consulHttpClientMock = new Mock <IConsulHttpClient>();

            consulHttpClientMock.SetReturnsDefault(Task.CompletedTask);

            using var appFactory = _factory.WithBypassAuthorization();

            var client = appFactory
                         .WithWebHostBuilder((e) => e.ConfigureTestServices(services =>
            {
                services.RemoveAll <IConsulHttpClient>();
                services.AddSingleton(consulHttpClientMock.Object);
            })).CreateClient();

            var request = new HttpRequestMessage(HttpMethod.Delete, $"http://localhost/{domainName}");

            // Act
            var response = await client.SendAsync(request);

            // Assert
            Assert.NotNull(response);
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);

            consulHttpClientMock.Verify(
                x => x.DeleteRecurseAsync($"{httpsBaseUrl}"),
                Times.Once);

            consulHttpClientMock.Verify(
                x => x.DeleteRecurseAsync($"{httpBaseUrl}"),
                Times.Once());

            consulHttpClientMock.Verify(
                x => x.DeleteRecurseAsync($"{httpBaseUrl}/middlewares"),
                Times.Once());

            consulHttpClientMock.VerifyNoOtherCalls();
        }
Esempio n. 32
0
        public void RunBeforeAnyTest()
        {
            _message = string.Empty;

            _tab          = new TabInfo();
            _tab.TabID    = _tabId;
            _tab.PortalID = _testPortalId;

            _portalSettings          = new PortalSettings();
            _portalSettings.PortalId = _testPortalId;

            _tabControllerMock        = new Mock <ITabController>();
            _recyclebinControllerMock = new Mock <IRecyclebinController>();
            _contentVerifierMock      = new Mock <IContentVerifier>();

            _tabControllerMock.SetReturnsDefault(_tab);
            _contentVerifierMock.SetReturnsDefault(true);
            _recyclebinControllerMock.Setup(r => r.RestoreTab(_tab, out _message));
        }
Esempio n. 33
0
        public async Task AddingItemsToIndex_ShouldUseProvidedTextExtractor()
        {
            var textExtractor = new Mock <ITextExtractor>();

            textExtractor.SetReturnsDefault <IEnumerable <DocumentTextFragment> >(
                new[]
            {
                new DocumentTextFragment(0, "MOCKED".AsMemory())
            });

            var index = new FullTextIndexBuilder <int>()
                        .WithIntraNodeTextSupportedAfterIndexDepth(0)
                        .WithTextExtractor(textExtractor.Object)
                        .Build();

            await index.AddAsync(1, "Hello");

            index.Root.IntraNodeText.ToString().Should().BeEquivalentTo("MOCKED");
        }
            public FactBase()
            {
                _symbolService         = new Mock <ISymbolsValidatorService>();
                _validatorStateService = new Mock <IValidatorStateService>();
                _validationEnqueuer    = new Mock <IPackageValidationEnqueuer>();
                _featureFlagService    = new Mock <IFeatureFlagService>();
                _logger = new Mock <ILogger <SymbolsValidatorMessageHandler> >();

                _featureFlagService.SetReturnsDefault(true);

                Target = new SymbolsValidatorMessageHandler(
                    _symbolService.Object,
                    _validatorStateService.Object,
                    _validationEnqueuer.Object,
                    _featureFlagService.Object,
                    _logger.Object);

                _message = new SymbolsValidatorMessage(Guid.NewGuid(), 42, "TestPackage", "1.1.1", "url");
            }
        public AzureStorageQueueFluentConfigTest()
        {
            _messageSerializer = new Mock <IMessageSerializer>().Object;
            // TODO Figure out how to mock the generic Create method
            var TestCommandDeserializerMock = new Mock <IMessageDeserializer <TestCommand1> >();

            TestCommandDeserializerMock.SetReturnsDefault <TestCommand1>(new TestCommand1());
            TestCommandDeserializerMock.Setup(x => x.GetTypeName()).Returns(typeof(TestCommand1).Name);
            var messageDeserializerFactoryMock = new Mock <IMessageDeserializerFactory>();

            messageDeserializerFactoryMock.Setup(x => x.Create <TestCommand1, TestMessage>(
                                                     It.Is <Func <Assembly, bool> >(null),
                                                     It.Is <Func <Type, bool> >(null)))
            .Returns(
                Obvs.Configuration.MessageTypes.Get <TestCommand1, TestMessage>(null, null)
                .Select(type => type.MakeGenericType(type))
                .Select(genericDeserializer => Activator.CreateInstance(genericDeserializer) as IMessageDeserializer <TestCommand1>));
            _messageDeserializerFactory = new TestMessageDeserializerFactory();
        }
Esempio n. 36
0
    public AppInstallerTests()
    {
        _mainLog = new Mock <ILog>();

        _processManager = new Mock <IMlaunchProcessManager>();
        _processManager.SetReturnsDefault(Task.FromResult(new ProcessExecutionResult()
        {
            ExitCode = 0
        }));

        Directory.CreateDirectory(s_appPath);
        _appBundleInformation = new AppBundleInformation(
            appName: "AppName",
            bundleIdentifier: s_appIdentifier,
            appPath: s_appPath,
            launchAppPath: s_appPath,
            supports32b: false,
            extension: null);
    }
            public WhenDisconnecting()
            {
                _clientFactory = new Mock <IClientFactory>();
                _client        = new Mock <IClient>();
                _client.Setup(s => s.SendAsync(new RedisArray(RedisBulkString.FromString("PING", Encoding.ASCII)), It.IsAny <CancellationToken>()))
                .ReturnsAsync(new RedisString("PONG"));
                _client.Setup(s => s.SendAsync(new RedisArray(RedisBulkString.FromString("QUIT", Encoding.ASCII)), It.IsAny <CancellationToken>()))
                .ReturnsAsync(new RedisString("OK"));

                _clientFactory.SetReturnsDefault(Task.FromResult(_client.Object));

                var connection = new BasicConnection(new IPEndPoint(IPAddress.Loopback, 6379), _clientFactory.Object);

                connection.OpenAsync(CancellationToken.None).Wait();

                _client.ResetCalls();

                connection.DisconnectAsync(CancellationToken.None).Wait();
            }
Esempio n. 38
0
        public void SendAfterOpenDoesBehavesCorrectlyForConfiguredQueuingBehavior(QueuingBehavior queuingBehavior, int expectedCounter)
        {
            var perfCounters = new Mock<IPerformanceCounterManager>();
            var queueLengthCounter = new Mock<IPerformanceCounter>();
            var counterIncrementCount = 0;
            queueLengthCounter.Setup(c => c.Increment()).Callback(() => counterIncrementCount++);
            perfCounters.DefaultValue = DefaultValue.Mock;
            perfCounters.SetReturnsDefault(new NoOpPerformanceCounter());
            perfCounters.SetupAllProperties();
            perfCounters.Setup(pc => pc.ScaleoutSendQueueLength).Returns(queueLengthCounter.Object);

            var stream = new ScaleoutStream(new TraceSource("Queue"), "0", queuingBehavior, 1000, perfCounters.Object);

            stream.Send(_ => TaskAsyncHelper.Empty, null);

            stream.Open();

            stream.Send(_ => TaskAsyncHelper.Empty, null).Wait();

            Assert.Equal(expectedCounter, counterIncrementCount);
        }
        public void Should_Delete_Media_With_Access_Rules()
        {
            RunActionInTransaction(session =>
                {
                    var uow = new DefaultUnitOfWork(session);
                    var repository = new DefaultRepository(uow);
                    var accessControlService = new Mock<IAccessControlService>().Object;
                    var commandContext = new Mock<ICommandContext>().Object;
                    var cmsConfiguration = Container.Resolve<ICmsConfiguration>();
                    var httpContextAccessor = new Mock<IHttpContextAccessor>();
                    httpContextAccessor.SetReturnsDefault("http://wwww.bcms.com/uploads/trash");

                    var file = TestDataProvider.CreateNewMediaFileWithAccessRules(3);
                    session.SaveOrUpdate(file);
                    session.Flush();
                    session.Clear();

                    var mediaService = new DefaultMediaService(repository, uow, accessControlService, cmsConfiguration);
                    var command = new DeleteMediaCommand(mediaService);
                    command.Repository = repository;
                    command.UnitOfWork = uow;
                    command.Context = commandContext;

                    var result = command.Execute(new DeleteMediaCommandRequest
                                        {
                                            Id = file.Id,
                                            Version = file.Version
                                        });

                    Assert.IsTrue(result);

                    session.Clear();

                    var deletedFile = session.Query<MediaFile>().FirstOrDefault(f => f.Id == file.Id && !f.IsDeleted);
                    Assert.IsNull(deletedFile);
                });
        }
        public void UseAutofacMiddlewareAddsWrappedMiddlewareInstancesToAppBuilder()
        {
            var builder = new ContainerBuilder();
            builder.RegisterType<TestMiddleware>();
            var container = builder.Build();
            var app = new Mock<IAppBuilder>();
            app.Setup(mock => mock.Properties).Returns(new Dictionary<string, object>());
            app.Setup(mock => mock.Use(typeof(AutofacMiddleware<TestMiddleware>)));
            app.SetReturnsDefault(app.Object);

            app.Object.UseAutofacMiddleware(container);

            app.VerifyAll();
        }
        public void UseMiddlewareFromContainerAddsSingleWrappedMiddlewareInstanceToAppBuilder()
        {
            var app = new Mock<IAppBuilder>();
            app.Setup(mock => mock.Properties).Returns(new Dictionary<string, object>());
            app.SetReturnsDefault(app.Object);

            var container = new ContainerBuilder().Build();
            app.Object.UseAutofacLifetimeScopeInjector(container);
            app.Object.UseMiddlewareFromContainer<TestMiddleware>();

            app.Verify(mock => mock.Use(typeof(AutofacMiddleware<TestMiddleware>)), Times.Once);
        }
Esempio n. 42
0
 public void Blah()
 {
     Mock myMock = new Mock<IComparable>();
     myMock.SetReturnsDefault(true);
     var myMock2 = new Mock<Mock>();
 }
        public void UseMiddlewareFromContainerRequiresInjectorRegistrationFirst()
        {
            var app = new Mock<IAppBuilder>();
            app.Setup(mock => mock.Properties).Returns(new Dictionary<string, object>());
            app.SetReturnsDefault(app.Object);

            Assert.Throws<InvalidOperationException>(() => app.Object.UseMiddlewareFromContainer<TestMiddleware>());
        }
        public void UseAutofacLifetimeScopeInjectorShowsInjectorRegistered()
        {
            var app = new Mock<IAppBuilder>();
            app.Setup(mock => mock.Properties).Returns(new Dictionary<string, object>());
            app.SetReturnsDefault(app.Object);

            var container = new ContainerBuilder().Build();
            app.Object.UseAutofacLifetimeScopeInjector(container);
            Assert.True(app.Object.IsAutofacLifetimeScopeInjectorRegistered());
        }
Esempio n. 45
0
        public void Setup()
        {
            //var path = @"D:\Program Files\Microsoft SQL Server\MSSQL.2\MSSQL\Data\Sicemed_Snapshot.ss";
            var path = @"C:\Program Files\Microsoft SQL Server\MSSQL10.MSSQLSERVER\MSSQL\DATA\Sicemed_Snapshot.ss";
            CreateDatabaseSnapshot("Sicemed_Snapshot", "SicemedTest", path);
            var logLevel = LogManager.GetRepository().Threshold;
            LogManager.GetRepository().Threshold = Level.Off;

            CurrentSessionContext.Bind(SessionFactory.OpenSession());

            var installer = new ApplicationInstaller();
            installer.SessionFactory = SessionFactory;

            var membershipMailerMock = new Mock<IMembershipMailer>();
            membershipMailerMock.SetReturnsDefault(new MailMessage("*****@*****.**", "*****@*****.**"));

            installer.MembershipService = new MembershipService(SessionFactory,
                                                                membershipMailerMock.Object,
                                                                new Mock<IFormAuthenticationStoreService>().Object);
            installer.Install(DatabaseConfiguration);

            LogManager.GetRepository().Threshold = logLevel;

            new RijndaelEngine("WAL");
            _membershipMailer = new Mock<IMembershipMailer>();
            _membershipMailer.SetReturnsDefault(new MailMessage("*****@*****.**", "*****@*****.**"));
            var formsService = new Mock<IFormAuthenticationStoreService>();
            _membershipService = new MembershipService(SessionFactory,
                                                       _membershipMailer.Object,
                                                       formsService.Object);
        }
Esempio n. 46
0
		public void ReturnsDefaultValueOnProperty()
		{
			var mock = new Mock<IFoo>();
			mock.SetReturnsDefault(int.MinValue);

			Assert.Equal(int.MinValue, mock.Object.Value);
		}
Esempio n. 47
0
		public void ReturnsDefaultReferenceValue()
		{
			var mock = new Mock<IFoo>();
			mock.SetReturnsDefault<IList<int>>(new List<int>());

			Assert.NotNull(mock.Object.ReturnIntList());
		}
Esempio n. 48
0
		public void ReturnsDefaultValueType()
		{
			var mock = new Mock<IFoo>();
			mock.SetReturnsDefault(true);

			Assert.Equal(true, mock.Object.ReturnBool());
		}
        public async Task IsInRoleAsync_AddDelegateDuringInitialisation_ReturnTrue()
        {
            // Arrange
            var mockPredicate = new Mock<Func<UserAuthorisation, string, Task<bool>>>();
            mockPredicate.SetReturnsDefault(Task.FromResult(true));

            var user = new UserAuthorisation(userName)
                .AddAsyncIsInRoleDelegate(mockPredicate.Object);

            // Act
            var result = await user.IsInRoleAsync("DATAREADER");

            // Assert
            Assert.IsTrue(result);
            mockPredicate.Verify(p => p(user, "DATAREADER"), Times.Once);
        }
        public void IsInRole_MockDelegate_ReturnFalse()
        {
            // Arrange
            var mockIsInRoleHandler = new Mock<Func<UserAuthorisation, string, bool>>();
            mockIsInRoleHandler.SetReturnsDefault(false);

            var user = new UserAuthorisation(userName)
                .AddIsInRoleDelegate(mockIsInRoleHandler.Object);

            // Act
            var result = user.IsInRole("DATAREADER");

            // Assert
            Assert.IsFalse(result);
            mockIsInRoleHandler.Verify(u => u(user, "DATAREADER"), Times.Once);
        }
        public void IsInRole_PassMockDelegateIntoCall_ReturnTrue()
        {
            // Arrange
            var mockIsInRoleHandler = new Mock<Func<UserAuthorisation, string, bool>>();
            mockIsInRoleHandler.SetReturnsDefault(true);

            var user = new UserAuthorisation(userName);

            // Act
            var result = user.IsInRole("DATAREADER", mockIsInRoleHandler.Object);

            // Assert
            Assert.IsTrue(result);
            mockIsInRoleHandler.Verify(u => u(user, "DATAREADER"), Times.Once);
        }
 public void Given()
 {
     gateway = new Mock<Gateway>();
     gateway.SetReturnsDefault(true);
     obj = new Mock<StatefulObject>();
     obj.SetReturnsDefault(obj.Object);
 }