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); }
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); }
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); }
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; }
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); }
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(), }; }
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); }
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); }
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); }
/// <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); }
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); }
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); }
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); }
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)); }
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>)); }
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()); }); }
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, }); }
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(); }
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)); }
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(); }
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(); }
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); }
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()); }
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); }
public void ReturnsDefaultValueOnProperty() { var mock = new Mock<IFoo>(); mock.SetReturnsDefault(int.MinValue); Assert.Equal(int.MinValue, mock.Object.Value); }
public void ReturnsDefaultReferenceValue() { var mock = new Mock<IFoo>(); mock.SetReturnsDefault<IList<int>>(new List<int>()); Assert.NotNull(mock.Object.ReturnIntList()); }
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); }