public void shouldGetCalorieHistory() { var expectedUserIngredients = GetExpectedUserIngredients(todaysDate); var repositoryMock = new Mock<IUserIngredientRepository>(); var nutrientRepositoryMock = new Mock<INutrientRepository>(); var nutrientMock = new Mock<Nutrient>(); var expectedNutrientId = 3; nutrientMock.Setup(x => x.Id).Returns(expectedNutrientId); var firstDate = todaysDate.AddDays(-100).Date; var lastDate = todaysDate; nutrientRepositoryMock.Setup(x => x.GetByName(NutrientEntity.EnergyInKcal.ToString())).Returns(nutrientMock.Object); repositoryMock.Setup(x => x.GetUserIngredientsByUser(It.IsAny<int>(), firstDate, lastDate.AddDays(1))).Returns(expectedUserIngredients); var returnedValues = new UserIngredientBusinessLogic(repositoryMock.Object, null, nutrientRepositoryMock.Object).GetNutrientHistory(NutrientEntity.EnergyInKcal, new User()); repositoryMock.VerifyAll(); nutrientRepositoryMock.VerifyAll(); var todaysUserIngredients = (from ui in expectedUserIngredients where ui.Date == todaysDate select ui); var oldUserIngredients = (from ui in expectedUserIngredients where ui.Date == todaysDate.AddDays(-100) select ui); Assert.That(returnedValues.Id, Is.EqualTo(expectedNutrientId)); Assert.That(returnedValues.GetValue(firstDate).Value, Is.EqualTo(oldUserIngredients.Sum(x => x.GetActualCalorieCount(y => y.GetNutrient(NutrientEntity.EnergyInKcal).Value)))); Assert.That(returnedValues.GetValue(lastDate).Value, Is.EqualTo(todaysUserIngredients.Sum(x => x.GetActualCalorieCount(y => y.GetNutrient(NutrientEntity.EnergyInKcal).Value)))); }
public void ShouldCallSetBackgroundColorOnlyOnceWithNestedCallsToOnAndOff() { // GIVEN var domContainer = new Mock<DomContainer>().Object; var nativeElementMock = new Mock<INativeElement>(); var element = new Element(domContainer, nativeElementMock.Object); Settings.HighLightColor = "myTestColor"; var highLight = new HighlightAction(element); nativeElementMock.Expect(nativeElement => nativeElement.IsElementReferenceStillValid()).Returns(true); nativeElementMock.Expect(nativeElement => nativeElement.GetStyleAttributeValue("backgroundColor")).Returns("initialColor").AtMostOnce(); nativeElementMock.Expect(nativeElement => nativeElement.SetStyleAttributeValue("backgroundColor", "myTestColor")).AtMostOnce(); nativeElementMock.Expect(nativeElement => nativeElement.SetStyleAttributeValue("backgroundColor", "initialColor")).AtMostOnce(); // WHEN highLight.On(); highLight.On(); highLight.On(); highLight.Off(); highLight.Off(); highLight.Off(); // THEN nativeElementMock.VerifyAll(); }
public void CalculateFrequencyTest() { var view = new Mock<IMainGameView>(); var controller = new MainGameController(view.Object); controller.LoadKeysResources(TestKeyFileResource); view.Setup(x => x.PlaySound(It.Is<int>(f => f == 110), 100)); controller.ProcessKey(Keys.Q); //key#0 view.VerifyAll(); view.Reset(); view.Setup(x => x.PlaySound(It.Is<int>(f => f == 117), 100)); controller.ProcessKey(Keys.W); //key#0 view.VerifyAll(); view.Reset(); view.Setup(x => x.PlaySound(It.Is<int>(f => f == 175), 100)); controller.ProcessKey(Keys.O); //key#8 view.VerifyAll(); view.Reset(); view.Setup(x => x.PlaySound(It.Is<int>(f => f == 185), 100)); controller.ProcessKey(Keys.P); //key#9 view.VerifyAll(); }
public void Test_ExecuteScripts_TwoFileContent() { const bool expectedResult = true; const string fileContent = @"create table BackendUser (BackendUserId int, Username nvarchar(30)) ; insert into BackendUser values(1, ""I must go home."")) ;"; var dbConnectionMock = new Mock<IDbConnection>(); var databaseMock = new Mock<IDatabase>(); var dbCommandMock = new Mock<IDbCommand>(); databaseMock.Setup(t => t.GetDbConnection()).Returns(dbConnectionMock.Object); databaseMock.Setup(t => t.GetDbCommand()).Returns(dbCommandMock.Object); dbConnectionMock.Setup(t => t.Open()); dbCommandMock.Setup(t => t.ExecuteNonQuery()); IDbProvider provider = new FireBirdDbProvider(databaseMock.Object); var actualResult = provider.ExecuteScript(fileContent); dbCommandMock.VerifyAll(); databaseMock.VerifyAll(); dbCommandMock.VerifyAll(); Assert.Equal(expectedResult, actualResult); }
public void Test_ExecuteScripts_TwoFileContent_WithGo() { const string fileContent = @"create table BackendUser (BackendUserId int, Username nvarchar(30)) go create table Company (CompanyId int, Name nvarchar(30)) go"; const bool expectedResult = true; var dbConnectionMock = new Mock<IDbConnection>(); var databaseMock = new Mock<IDatabase>(); var dbCommandMock = new Mock<IDbCommand>(); databaseMock.Setup(t => t.GetDbConnection()).Returns(dbConnectionMock.Object); databaseMock.Setup(t => t.GetDbCommand()).Returns(dbCommandMock.Object); dbConnectionMock.Setup(t => t.Open()); dbCommandMock.Setup(t => t.ExecuteNonQuery()); IDbProvider provider = new MsSqlDbProvider(databaseMock.Object); var actualResult = provider.ExecuteScript(fileContent); dbCommandMock.VerifyAll(); databaseMock.VerifyAll(); dbCommandMock.VerifyAll(); Assert.Equal(expectedResult, actualResult); }
public void CreatesMockForAccessedPropertyWithSetterWithValue() { var mock = new Mock<IFoo>(); mock.SetupSet(m => m.Bar.Value = 5); Assert.NotNull(mock.Object.Bar); Assert.Throws<MockVerificationException>(() => mock.VerifyAll()); mock.Object.Bar.Value = 5; mock.VerifyAll(); }
public void ShouldBeAbleToPullExistingInfoFromCache() { var monitorConfig = new MonitorConfig { Name = "Test" }; var reduceLevels = new List<ReduceLevel>(); var connection = new Mock<IDbConnection>(); var connectionInstance = connection.Object; var storageCommands = new Mock<IStorageCommands>(); storageCommands.Setup(x => x.CreateConfigAndReduceLevels(monitorConfig, reduceLevels, connectionInstance)); var setupSystemTables = new Mock<ISetupSystemTables>(); setupSystemTables.Setup(x => x.ValidateAndCreateDataTables(connectionInstance)).Verifiable(); var monitorConfigsDictionary = new ConcurrentDictionary<string, MonitorConfig>(); var cache = new Mock<IDataCache>(); cache.SetupGet(x => x.MonitorConfigs).Returns(monitorConfigsDictionary).Verifiable(); var storageFactory = new Mock<IStorageFactory>(); storageFactory.Setup(x => x.CreateConnection()).Returns(connectionInstance).Verifiable(); var settings = BuildSettings(); var defaults = new SetupMonitorConfig(storageCommands.Object, setupSystemTables.Object, cache.Object, storageFactory.Object, settings.Object); defaults.CreateDefaultReduceLevels(monitorConfig, reduceLevels); Assert.Equal(1, monitorConfigsDictionary.Count); Assert.True(monitorConfigsDictionary.ContainsKey("Test")); storageCommands.VerifyAll(); setupSystemTables.VerifyAll(); storageFactory.VerifyAll(); cache.VerifyAll(); }
public void ListAll_PerformsCorrectRequest() { //Setup var request = new CategoriesStub("DevKey", "api.careerbuilder.com", "", ""); //Mock crap var response = new RestResponse<List<Category>> {Data = new List<Category>()}; var restReq = new Mock<IRestRequest>(); restReq.Setup(x => x.AddParameter("DeveloperKey", "DevKey")); restReq.Setup(x => x.AddParameter("CountryCode", "NL")); restReq.SetupSet(x => x.RootElement = "Categories"); var restClient = new Mock<IRestClient>(); restClient.SetupSet(x => x.BaseUrl = "https://api.careerbuilder.com/v1/categories"); restClient.Setup(x => x.Execute<List<Category>>(It.IsAny<IRestRequest>())).Returns(response); request.Request = restReq.Object; request.Client = restClient.Object; //Assert List<Category> cats = request.WhereCountryCode(CountryCode.NL).ListAll(); Assert.IsTrue(cats.Count == 0); restReq.VerifyAll(); restClient.VerifyAll(); }
public void GetRecommendations_PerformsCorrectRequest() { //Setup UserReqStub request = new UserReqStub("ExternalID", "DevKey", "api.careerbuilder.com", "", ""); //Mock crap RestResponse<List<RecommendJobResult>> response = new RestResponse<List<RecommendJobResult>>(); response.Data = new List<RecommendJobResult>(); var restReq = new Mock<IRestRequest>(); restReq.Setup(x => x.AddParameter("DeveloperKey", "DevKey")); restReq.Setup(x => x.AddParameter("ExternalID", "ExternalID")); restReq.SetupSet(x => x.RootElement = "RecommendJobResults"); var restClient = new Mock<IRestClient>(); restClient.SetupSet(x => x.BaseUrl = "https://api.careerbuilder.com/v1/recommendations/foruser"); restClient.Setup(x => x.Execute<List<RecommendJobResult>>(It.IsAny<IRestRequest>())).Returns(response); request.Request = restReq.Object; request.Client = restClient.Object; //Assert// List<RecommendJobResult> resp = request.GetRecommendations(); restReq.VerifyAll(); restClient.VerifyAll(); }
public void AssociationSetDiscoveryConvention_AddsBindingForBaseAndDerivedNavigationProperties() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration vehicle = builder.AddEntity(typeof(Vehicle)); EntityTypeConfiguration car = builder.AddEntity(typeof(Car)).DerivesFrom(vehicle); NavigationPropertyConfiguration carNavigationProperty = car.AddNavigationProperty(typeof(Car).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne); EntityTypeConfiguration motorcycle = builder.AddEntity(typeof(Motorcycle)).DerivesFrom(vehicle); NavigationPropertyConfiguration motorcycleNavigationProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne); EntityTypeConfiguration manufacturer = builder.AddEntity(typeof(Manufacturer)); EntityTypeConfiguration motorcycleManufacturer = builder.AddEntity(typeof(MotorcycleManufacturer)).DerivesFrom(manufacturer); EntityTypeConfiguration carManufacturer = builder.AddEntity(typeof(CarManufacturer)).DerivesFrom(manufacturer); EntitySetConfiguration manufacturers = builder.AddEntitySet("manufacturers", manufacturer); Mock<EntitySetConfiguration> entitySet = new Mock<EntitySetConfiguration>(MockBehavior.Strict); entitySet.Setup(v => v.EntityType).Returns(vehicle); entitySet.Setup(v => v.AddBinding(motorcycleNavigationProperty, manufacturers)).Returns<NavigationPropertyConfiguration>(null); entitySet.Setup(v => v.AddBinding(carNavigationProperty, manufacturers)).Returns<NavigationPropertyConfiguration>(null); // Act _convention.Apply(entitySet.Object, builder); // Assert entitySet.VerifyAll(); }
public void Build_Parameters_ContenstOfFilesAreCorrect() { var filePersisterMockFactory = new Mock<IFilePersister>(); //Project file filePersisterMockFactory.Setup(fp => fp.Save(It.IsAny<string>() , It.Is<string>(content => content.Contains("<testProject") && content.Contains("applicationBaseDirectory=\"..\\..\\..\\\"") && content.Contains(@"<file>..\..\..\ts.NBi.NUnit.Runtime.dll</file>") && content.Contains(@"<hintDirectory>..\..\..\Framework\Version\</hintDirectory>") ) )); // filePersisterMockFactory.Setup(fp => fp.Save(It.IsAny<string>() , It.Is<string>(content => content.Contains("<nbi testSuite=\"TestSuites\\Serie\\Alpha\\ts.nbits\"/>") ) )); var filePersister = filePersisterMockFactory.Object; var builder = new GallioRunnerConfigBuilder(filePersister); builder.Build( @"C:\QA\", @"..\..\..\", @"Framework\Version\", @"TestSuites\Serie\Alpha\", "ts"); filePersisterMockFactory.VerifyAll(); }
public void TestAccessUsingBasicAuthentication() { var permissions = new Mock<AbstractSystemPermissionsProvider>(); permissions.Setup( p => p.HasPermissions(It.Is<IUserIdentity>(x => x != null && x.UserName.Equals("alice")), SystemPermissions.ListStores)) .Returns(true); var userValidator = new Mock<IUserValidator>(); userValidator.Setup(v => v.Validate("alice", "password")) .Returns(new MockUserIdentity("alice", new string[0])); var mockBrightstar = new Mock<IBrightstarService>(); mockBrightstar.Setup(s => s.ListStores()).Returns(new string[0]); var bootstrapper = new FakeNancyBootstrapper(mockBrightstar.Object, new BasicAuthAuthenticationProvider(new BasicAuthenticationConfiguration(userValidator.Object, "test")), new FallbackStorePermissionsProvider(StorePermissions.All), permissions.Object); var app = new Browser(bootstrapper); var response = app.Get("/", c => { c.BasicAuth("alice", "password"); c.Accept(MediaRange.FromString("application/json")); }); Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK)); permissions.VerifyAll(); userValidator.VerifyAll(); mockBrightstar.VerifyAll(); }
public void WhenMeetingsAreReturned_ThenViewModelIsPopulated() { var asyncResultMock = new Mock<IAsyncResult>(); var calendarServiceMock = new Mock<ICalendarService>(MockBehavior.Strict); AsyncCallback callback = null; calendarServiceMock .Setup(svc => svc.BeginGetMeetings(It.IsAny<AsyncCallback>(), null)) .Callback<AsyncCallback, object>((ac, o) => callback = ac) .Returns(asyncResultMock.Object); var meeting = new Meeting { }; calendarServiceMock .Setup(svc => svc.EndGetMeetings(asyncResultMock.Object)) .Returns(new[] { meeting }); var viewModel = new CalendarViewModel(calendarServiceMock.Object, new Mock<IRegionManager>().Object); this.EnqueueConditional(() => callback != null); this.EnqueueCallback( () => { callback(asyncResultMock.Object); }); this.EnqueueCallback( () => { CollectionAssert.AreEqual(viewModel.Meetings, new[] { meeting }); calendarServiceMock.VerifyAll(); }); this.EnqueueTestComplete(); }
public void TestExecuteClearsDataIfElementIsFound() { var propData = new Mock<IPropertyData>(MockBehavior.Strict); propData.Setup(p => p.ClearData()); // ReSharper disable once RedundantAssignment IPropertyData element = null; var locator = new Mock<IElementLocator>(MockBehavior.Strict); locator.Setup(p => p.TryGetElement("myitem", out element)).Returns(false); locator.Setup(p => p.GetProperty("myitem")).Returns(propData.Object); var getItemAction = new ClearDataAction { ElementLocator = locator.Object }; var context = new ClearDataAction.ClearDataContext("myitem"); var result = getItemAction.Execute(context); Assert.AreEqual(true, result.Success); locator.VerifyAll(); propData.VerifyAll(); }
public void TestGivenNavigateToPageStepWithArguments() { var testPage = new Mock<IPage>(); var pipelineService = new Mock<IActionPipelineService>(MockBehavior.Strict); pipelineService.Setup(p => p.PerformAction<PageNavigationAction>( null, It.Is<PageNavigationAction.PageNavigationActionContext>(c => c.PropertyName == "mypage" && c.PageAction == PageNavigationAction.PageAction.NavigateToPage && c.PageArguments != null && c.PageArguments.Count == 2))) .Returns(ActionResult.Successful(testPage.Object)); var scenarioContext = new Mock<IScenarioContextHelper>(MockBehavior.Strict); scenarioContext.Setup(s => s.SetValue(It.IsAny<IPage>(), PageStepBase.CurrentPageKey)); var tokenManager = new Mock<ITokenManager>(MockBehavior.Strict); tokenManager.Setup(t => t.GetToken(It.IsAny<string>())).Returns<string>(s => s); var steps = new PageNavigationSteps(scenarioContext.Object, pipelineService.Object, tokenManager.Object); var table = new Table("Id", "Part"); table.AddRow("1", "A"); steps.GivenNavigateToPageWithArgumentsStep("mypage", table); scenarioContext.VerifyAll(); pipelineService.VerifyAll(); }
public void Fetch() { var person = EntityCreator.Create<E.Person>(); var people = new InMemoryDbSet<E.Person> { person }; var context = new Mock<IEntityContext>(MockBehavior.Strict); context.Setup(_ => _.People).Returns(people); context.Setup(_ => _.Dispose()); var personViewFactory = new Mock<IObjectFactory<IPersonView>>(MockBehavior.Strict); personViewFactory .Setup(_ => _.FetchChild(It.Is<int>(__ => __ == person.Id))) .Returns(Mock.Of<IPersonView>()); var container = new ContainerBuilder(); container.Register<IEntityContext>(_ => context.Object); container.Register<IObjectFactory<IPersonView>>(_ => personViewFactory.Object); using (container.Build().Bind(() => IoC.Container)) { var actual = DataPortal.Fetch<PersonCollectionView>(); Assert.IsNotNull(actual); Assert.AreEqual(1, actual.Count, "Count"); } context.VerifyAll(); personViewFactory.VerifyAll(); }
public void op_Verify_IRepository() { var key = AlphaDecimal.Random(); var obj = new RepositoryMatchKey<RandomObject> { Record1 = { Key = key } }; var repository = new Mock<IRepository<RandomObject>>(); repository .Setup(x => x.Insert(obj.Record1)) .Returns(obj.Record1) .Verifiable(); repository .Setup(x => x.Match(key, obj.Record1.Etag)) .Returns(true) .Verifiable(); obj.Verify(repository.Object); repository.VerifyAll(); }
public void Add_ValidModelLicenseTypeWithResultPost_ReturnsRedirect() { var computerFake = new Computer { LicenseType = "WinXP", }; var computerDataService = new Mock<IDataService<Computer>>(); computerDataService.Setup(c => c.Insert(It.IsAny<Computer>(), It.IsAny<Guid>())).Verifiable(); var windowsLicenseDataServiceMock = new Mock<IDataService<WindowsLicense>>(); windowsLicenseDataServiceMock.Setup(w => w.SelectOne(It.IsAny<Expression<Func<WindowsLicense, bool>>>())) .Returns(new WindowsLicense { Id = "123456", LicenseType = computerFake.LicenseType, }); var controller = new ComputerController(computerDataService.Object, new Mock<IFormsAuthenticationService>().Object, windowsLicenseDataServiceMock.Object, new Mock<IDataService<Volunteer>>().Object, new Mock<IDataService<Recipient>>().Object); ActionResult result = controller.Add(computerFake); Assert.IsInstanceOf<RedirectToRouteResult>(result); computerDataService.VerifyAll(); }
public void ShouldCallExceptionHandlerOnUncaughtException() { var ex = new Exception(); var exceptionHandlerMock = new Mock<IExceptionHandler<object>>(); _batchEventProcessor.SetExceptionHandler(exceptionHandlerMock.Object); _batchHandlerMock.Setup(bh => bh.OnEvent(_ringBuffer[0], 0, true)) .Throws(ex); // OnNext raises an expcetion exceptionHandlerMock.Setup(bh => bh.HandleEventException(ex, 0, _ringBuffer[0])) .Callback(() => _countDownEvent.Signal()); // Exception should be handled here and signal the CDE var thread = new Thread(_batchEventProcessor.Run); thread.Start(); _ringBuffer.Publish(_ringBuffer.Next()); _countDownEvent.Wait(50); _batchEventProcessor.Halt(); thread.Join(); _batchHandlerMock.VerifyAll(); exceptionHandlerMock.VerifyAll(); }
public void Given_that_request_is_valid_When_mark_hazard_as_deleted_Then_should_call_correct_methods() { //Given var target = CreateNonEmployeeervice(); var hazard = new Mock<Hazard>(); hazard.Setup(x => x.MarkForDelete(_user.Object)); var request = new MarkCompanyDefaultAsDeletedRequest(1, 2, Guid.NewGuid()); _userRepository .Setup(x => x.GetByIdAndCompanyId(request.UserId, request.CompanyId)) .Returns(_user.Object); _repo .Setup(x => x.GetByIdAndCompanyId(request.CompanyDefaultId, request.CompanyId)) .Returns(hazard.Object); //When target.MarkHazardAsDeleted(request); //Then hazard.VerifyAll(); _repo.Verify(x => x.SaveOrUpdate(It.IsAny<Hazard>())); }
public async Task EditCommentTest( EditCommentMode mode, string fileExtension, string commentStart, string commentEnd = null) { // Arrange string commentName = "CommentName"; string filePath = @"C:\Project\File" + fileExtension; Mock<IFileSystemService> fileSystemServiceMock = new Mock<IFileSystemService>(MockBehavior.Strict); fileSystemServiceMock .Setup(x => x.FileExists(It.Is<string>(y => string.Equals(y, filePath)))) .Returns(true); fileSystemServiceMock .Setup(x => x.FileReadAllLines(It.Is<string>(y => string.Equals(y, filePath)))) .Returns(Task.FromResult(GetInputLines(commentName, commentStart, commentEnd))); fileSystemServiceMock .Setup(x => x.FileWriteAllLines( It.Is<string>(y => string.Equals(y, filePath)), It.Is<IEnumerable<string>>(y => Enumerable.SequenceEqual(y, GetOutputLines(mode, commentStart, commentEnd))))) .Returns(Task.FromResult<object>(null)); IProjectService projectService = new ProjectService(fileSystemServiceMock.Object, @"C:\Project\Project.xproj"); // Act await projectService.EditComment(commentName, mode, "File" + fileExtension); // Assert fileSystemServiceMock.VerifyAll(); }
public void RepositoryDecoratorBase_Delegate_Calls_To_Surrogate() { Mock<IRepository<Product>> realRepo = new Mock<IRepository<Product>>(); realRepo.Setup(rr => rr.AsQueryable()).Returns(new List<Product>{new Product()}.AsQueryable); realRepo.Setup(rr => rr.Delete(It.IsAny<Product>())); realRepo.Setup(rr => rr.Find(It.IsAny<Expression<Func<Product, bool>>>())); realRepo.Setup(rr => rr.GetAll()); realRepo.Setup(rr => rr.Insert(It.IsAny<Product>())); realRepo.Setup(rr => rr.Single(It.IsAny<Expression<Func<Product, bool>>>())); realRepo.Setup(rr => rr.Update(It.IsAny<Product>())); Mock<RepositoryDecoratorBase<Product>> deco = new Mock<RepositoryDecoratorBase<Product>>(realRepo.Object) {CallBase = true}; deco.Object.AsQueryable(); deco.Object.Delete(new Product()); deco.Object.Find(p => p.Id > 0); deco.Object.GetAll(); deco.Object.Insert(new Product()); deco.Object.Single(p => p.Id > 0); deco.Object.Update(new Product()); realRepo.VerifyAll(); }
public void LogActivity_Complete_writes_current_method_name() { var methodName = MethodBase.GetCurrentMethod().Name; var observer = new Mock<IObserver<LogEntry>>(); observer .Setup( o => o.OnNext( It.Is<LogEntry>( e => e.CallingMethod == methodName && e.EventType == TraceEventType.Stop))); var helper = new AsyncTestHelper(); using (var activity = Log.Enter(() => { })) using (TestHelper.LogToConsole()) using (observer.Object.SubscribeToLogEvents()) { var result = helper.BeginSomething( _ => activity.Complete(() => { }), activity); helper.EndSomething(result); } observer.VerifyAll(); }
public async Task OnValidatePrincipalTestSuccess(bool isPersistent) { var user = new TestUser("test"); var userManager = MockHelpers.MockUserManager<TestUser>(); var claimsManager = new Mock<IUserClaimsPrincipalFactory<TestUser>>(); var identityOptions = new IdentityOptions { SecurityStampValidationInterval = TimeSpan.Zero }; var options = new Mock<IOptions<IdentityOptions>>(); options.Setup(a => a.Options).Returns(identityOptions); var httpContext = new Mock<HttpContext>(); var contextAccessor = new Mock<IHttpContextAccessor>(); contextAccessor.Setup(a => a.HttpContext).Returns(httpContext.Object); var signInManager = new Mock<SignInManager<TestUser>>(userManager.Object, contextAccessor.Object, claimsManager.Object, options.Object, null); signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny<ClaimsPrincipal>(), user.Id)).ReturnsAsync(user).Verifiable(); signInManager.Setup(s => s.SignInAsync(user, isPersistent, null)).Returns(Task.FromResult(0)).Verifiable(); var services = new ServiceCollection(); services.AddInstance(options.Object); services.AddInstance(signInManager.Object); services.AddInstance<ISecurityStampValidator>(new SecurityStampValidator<TestUser>()); httpContext.Setup(c => c.RequestServices).Returns(services.BuildServiceProvider()); var id = new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationScheme); id.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id)); var ticket = new AuthenticationTicket(new ClaimsPrincipal(id), new AuthenticationProperties { IssuedUtc = DateTimeOffset.UtcNow, IsPersistent = isPersistent }, IdentityOptions.ApplicationCookieAuthenticationScheme); var context = new CookieValidatePrincipalContext(httpContext.Object, ticket, new CookieAuthenticationOptions()); Assert.NotNull(context.Properties); Assert.NotNull(context.Options); Assert.NotNull(context.Principal); await SecurityStampValidator.ValidatePrincipalAsync(context); Assert.NotNull(context.Principal); signInManager.VerifyAll(); }
public void op_Verify_IRepository() { var key = AlphaDecimal.Random(); var obj = new RepositoryModifiedSinceKey<RandomObject> { Record1 = { Key = key } }; var repository = new Mock<IRepository<RandomObject>>(); repository .Setup(x => x.Insert(obj.Record1)) .Returns(obj.Record1) .Verifiable(); repository .Setup(x => x.ModifiedSince(key, DateTime.MaxValue)) .Returns(false) .Verifiable(); repository .Setup(x => x.ModifiedSince(key, DateTime.MinValue)) .Returns(true) .Verifiable(); obj.Verify(repository.Object); repository.VerifyAll(); }
public void Dicovery_Source_Empty() { // Setup var request = new Mock<HttpRequestBase>(MockBehavior.Strict); string request_content = String.Format("<?xml version=\"1.0\"?><methodCall><methodName>pingback.ping</methodName><params><param><value><string>{0}</string></value></param><param><value><string>{1}</string></value></param></params></methodCall>", "http://source/1", "http://target/1"); request.SetupGet(x => x.InputStream).Returns(new MemoryStream(new UTF8Encoding().GetBytes(request_content))); var webRequest = new Mock<IHttpWebRequestImplementation>(MockBehavior.Strict); var webResponse = new Mock<IHttpWebResponseImplementation>(MockBehavior.Strict); webRequest.Setup(x => x.Create(new Uri("http://source/1", UriKind.Absolute))).Returns(webRequest.Object); webRequest.Setup(x => x.GetResponse()).Returns(webResponse.Object); webResponse.Setup(x => x.Close()); webResponse.SetupGet(x => x.IsHttpStatusCode2XX).Returns(true); webResponse.Setup(x => x.GetResponseStream()).Returns(new MemoryStream(new UTF8Encoding().GetBytes(""))); // Test var pingback = new Pingback(webRequest.Object); var result = pingback.Receive(request.Object, null); // Verify request.VerifyAll(); webRequest.VerifyAll(); webResponse.VerifyAll(); Assert.False(result.Valid); Assert.Equal("http://source/1", result.SourceUri.ToString().ToLowerInvariant()); Assert.Equal("http://target/1", result.TargetUri.ToString().ToLowerInvariant()); }
public void AddPostValidModel_ReturnsRedirect() { var volunteerFake = new Volunteer { Id = Guid.NewGuid(), }; var recipientFake = new Recipient { Active = true, FirstName = "Dan", Id = Guid.NewGuid(), }; var dataServiceMock = new Mock<IDataService<Recipient>>(); dataServiceMock.Setup(d => d.Insert(It.IsAny<Recipient>(), It.IsAny<Guid>())).Verifiable(); var formsAuthenticationServiceMock = new Mock<IFormsAuthenticationService>(); formsAuthenticationServiceMock.Setup(f => f.GetVolunteerID(null)) .Returns(volunteerFake.Id); var controller = new RecipientController(dataServiceMock.Object, new Mock<IDataService<Volunteer>>().Object, formsAuthenticationServiceMock.Object); ActionResult result = controller.Add(recipientFake); dataServiceMock.VerifyAll(); Assert.IsInstanceOf(typeof (RedirectToRouteResult), result); }
public void ReturnsNullValueIfNullFunc() { var mock = new Mock<IFoo>(); mock.Setup(foo => foo.Execute("Whatever")).Returns((Func<string>)null); Assert.Null(mock.Object.Execute("Whatever")); mock.VerifyAll(); }
public void TestExecuteWhenPageIsFoundAndUrlMatchesReturnsSuccess() { var page = new Mock<IPage>(MockBehavior.Strict); var pageMapper = new Mock<IPageMapper>(MockBehavior.Strict); pageMapper.Setup(p => p.GetTypeFromName("SamplePage")).Returns(typeof(SamplePage)); var browser = new Mock<IBrowser>(MockBehavior.Strict); browser.Setup(b => b.Page(typeof(SamplePage))).Returns(page.Object); browser.Setup(b => b.EnsureOnPage(page.Object)); var logger = new Mock<ILogger>(); var action = new WaitForPageAction(pageMapper.Object, browser.Object, logger.Object); var context = new WaitForPageAction.WaitForPageActionContext("SamplePage", TimeSpan.FromSeconds(1)); var result = action.Execute(context); Assert.AreEqual(true, result.Success); Assert.AreSame(page.Object, result.Result); pageMapper.VerifyAll(); browser.VerifyAll(); page.VerifyAll(); }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="isDisposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool isDisposing) { if (isDisposing) { _database.VerifyAll(); _migrationTarget.VerifyAll(); _migrationLocator.VerifyAll(); _migrationStatus.VerifyAll(); _logger.VerifyAll(); _appliedMigration?.VerifyAll(); foreach (var migration in _migrationsToApply) { migration.VerifyAll(); } foreach (var newAppliedMigration in _newAppliedMigrations) { newAppliedMigration.VerifyAll(); } } }
public void TestValidateItemAsList() { var element = new BaseElement(); var parentElement = new BaseElement(); var listMock = new Mock <IElementList <BaseElement, BaseElement> >(MockBehavior.Strict); listMock.SetupGet(l => l.Parent).Returns(parentElement); var pageBase = new Mock <IPageElementHandler <BaseElement> >(MockBehavior.Strict); pageBase.Setup(p => p.GetElementText(parentElement)).Returns("My Data"); var propertyData = CreatePropertyData(pageBase, element, (p, f) => f(listMock.Object)); string actualValue; var result = propertyData.ValidateItem(ItemValidationHelper.Create("MyProperty", "My Data"), out actualValue); Assert.IsTrue(result); pageBase.VerifyAll(); listMock.VerifyAll(); }
public void SaveOrder_CallAcceptOrderAndAdd_WithNullFlightScheduled() { var mockFlightSchedule = new Mock <IFlightScheduleService>(); mockFlightSchedule.Setup(x => x.GetNextAvailableFlightSchedule("XYZ")).Returns(flightSchedule).Verifiable(); var mockRepo = new Mock <IRepository <Order> >(); mockRepo.Setup(x => x.Add(It.IsAny <Order>())); OrderService orderService = new OrderService(mockFlightSchedule.Object, mockRepo.Object); //Call service for different destination orderService.SaveOrder("O001", new Airport { Destination = "ABC" }.Destination); mockFlightSchedule.Verify(x => x.GetNextAvailableFlightSchedule("ABC"), Times.Once); mockRepo.VerifyAll(); //mockRepo.Verify(x => x.Add(It.IsAny<Order>()), Times.Once); mockRepo.Verify(x => x.Add(new Order("O001") { FlightSchedule = null }), Times.Once); }
public async Task PopToRootAsync_TargetImplementsIRemoved_ExecutesOnRemovedAsync() { var vm = new Mock <IOnViewRemoved>(); vm.Setup(o => o.OnViewRemovedAsync()).Verifiable(); var page = new Mock <Page>(); page.Object.BindingContext = vm.Object; var navigation = new Mock <INavigation>(); var fakestack = new List <Page> { null, page.Object, new Page() }; navigation.SetupGet(o => o.NavigationStack).Returns(fakestack); navigation.Setup(o => o.PopAsync(true)).Callback(() => fakestack.RemoveAt(fakestack.Count - 1)); var ns = new NavigationService(navigation.Object); await ns.PopToRootAsync(); vm.VerifyAll(); }
public void TestGetElementWhenElementGetIsSuccessful() { var resultPropertyData = new Mock <IPropertyData>().Object; var page = new Mock <IPage>(MockBehavior.Strict); page.Setup(p => p.TryGetElement("MyElement", out resultPropertyData)).Returns(true); var locatorAction = new Mock <ILocatorAction>(MockBehavior.Strict); locatorAction.Setup(p => p.OnLocate("MyElement")); locatorAction.Setup(p => p.OnLocateComplete("MyElement", resultPropertyData)); var locator = new ElementLocator(page.Object, new[] { locatorAction.Object }); var propertyData = locator.GetElement("MyElement"); Assert.IsNotNull(propertyData); Assert.AreSame(resultPropertyData, propertyData); page.VerifyAll(); locatorAction.VerifyAll(); }
public void CheckBonus_NoBonus() { var mockIReel = new Mock <IReel>(); var mockITransactionHistoryDataStore = new Mock <ITransactionHistoryDataStore>(); var mockIAccountCreditsDataStore = new Mock <IAccountCreditsDataStore>(); var mockIStatisticDataStore = new Mock <IStatisticsDataStore>(); var mockIWin = new Mock <IWin>(); var game = new Game(mockIReel.Object, mockITransactionHistoryDataStore.Object, mockIAccountCreditsDataStore.Object, mockIStatisticDataStore.Object, mockIWin.Object); var slots = new string[3, 5]; slots[1, 0] = "S0"; slots[1, 1] = "S1"; slots[1, 2] = "S2"; slots[1, 3] = "S3"; slots[1, 4] = "S4"; game.CheckIfPlayerSpinHasFreeBonusSpin(slots, It.IsAny <int>()); mockIAccountCreditsDataStore.VerifyAll(); }
public void AddMvcCore_GetsPartsForApplication() { // Arrange var services = new ServiceCollection(); var environment = new Mock <IWebHostEnvironment>(); var assemblyName = typeof(MvcCoreServiceCollectionExtensionsTest).Assembly.GetName(); var applicationName = assemblyName.FullName; environment.SetupGet(e => e.ApplicationName).Returns(applicationName).Verifiable(); services.AddSingleton <IWebHostEnvironment>(environment.Object); // Act var builder = services.AddMvcCore(); // Assert Assert.NotNull(builder.PartManager); Assert.Contains( builder.PartManager.ApplicationParts, part => string.Equals(assemblyName.Name, part.Name, StringComparison.Ordinal)); Assert.Contains(builder.PartManager.FeatureProviders, provider => provider is ControllerFeatureProvider); environment.VerifyAll(); }
public async Task AddProductToBasketShouldReturn404NotFoundForProduct() { var basketServiceMock = new Mock <IBasketService>(MockBehavior.Strict); basketServiceMock.Setup(service => service.Exists(null)).ReturnsAsync(true); var productServiceMock = new Mock <IProductService>(MockBehavior.Strict); productServiceMock.Setup(service => service.Exists(0)).ReturnsAsync(false); var controller = new BasketsController(basketServiceMock.Object, productServiceMock.Object); var result = await controller.AddProductToBasket(null, 0); Assert.IsType <NotFoundObjectResult>(result); productServiceMock.Verify(service => service.Exists(0), Times.Once); productServiceMock.VerifyAll(); basketServiceMock.Verify(service => service.AddProductToBasket(null, 0), Times.Never); basketServiceMock.Verify(service => service.Exists(null), Times.Once); basketServiceMock.VerifyAll(); }
public void ReturnGlobalSingleton_ShouldRegisterGenericValues() { // Arrange var identifier = new Identifier(typeof(string)); var mockContainer = new Mock <IContainer>(MockBehavior.Strict); mockContainer .Setup(c => c.Register(identifier, It.Is <StaticLifetime>(l => l.Factory is ConstructorInjectionFactory && l.Factory.Container == mockContainer.Object && l.Factory.ImplementationType == typeof(string)))); // Act var result = (mockContainer.Object, identifier).ReturnGlobalSingleton <string>(); // Assert result.ShouldNotBeNull(); result.Container.ShouldBeSameAs(mockContainer.Object); result.Identifier.ShouldBeSameAs(identifier); mockContainer.VerifyAll(); }
public void TestShippingAddressGetById() { // Arrange var expectedShippingAddress = FakeShippingAddresses().First(); var mockBusinessLogic = new Mock <ISportStoreBusinessLogic>(); mockBusinessLogic .Setup(bl => bl.ShippingAddress.GetById(expectedShippingAddress.Id)) .Returns(expectedShippingAddress); var controller = new ShippingAddressController(mockBusinessLogic.Object); // Act var result = controller.Get(expectedShippingAddress.Id); var obtainedShippingAddress = (result as OkNegotiatedContentResult <ShippingAddress>).Content; // Assert mockBusinessLogic.VerifyAll(); Assert.IsNotNull(obtainedShippingAddress); Assert.AreEqual(expectedShippingAddress.Id, obtainedShippingAddress.Id); }
public async Task UpdateDocumentAsync() { Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict); UpdateDocumentRequest expectedRequest = new UpdateDocumentRequest { Document = new Document(), UpdateMask = new DocumentMask(), }; Document expectedResponse = new Document { Name = "name3373707", }; mockGrpcClient.Setup(x => x.UpdateDocumentAsync(expectedRequest, It.IsAny <CallOptions>())) .Returns(new Grpc.Core.AsyncUnaryCall <Document>(Task.FromResult(expectedResponse), null, null, null, null)); FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null); Document document = new Document(); DocumentMask updateMask = new DocumentMask(); Document response = await client.UpdateDocumentAsync(document, updateMask); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public void TestTryDeriveAddressFailsWithNoValidProperties() { string address; var testTemplate = new Dictionary <string, string>() { ["Test"] = "a/{b}/c", }; var config = new MessageAddressConversionConfiguration( DontCareInput, testTemplate ); Mock <IMessage> message = CreateMessageWithSystemProps(new Dictionary <string, string>() { ["a"] = "123" }); var converter = new MessageAddressConverter(config); bool result = converter.TryBuildProtocolAddressFromEdgeHubMessage("Test", message.Object, EmptyProperties, out address); Assert.False(result); Assert.Null(address); message.VerifyAll(); }
public void Should_HaveStatusError_When_PasswordFormatIsNotCorrect() { // arrange... // Mocks... var mockDbs = Mock.Of <IDatabaseService>(); Mock.Get(mockDbs).Setup(_ => _.ExecuteAndGetTableFromFile(It.IsAny <string>())).Returns(this.MakeData(false, 2, 0)); var mockInstanceInfo = new Mock <IInstanceInfo>(MockBehavior.Strict); mockInstanceInfo.Setup(_ => _.DBService).Returns(mockDbs); // Real Module under test... PasswordPolicyModule mod = new PasswordPolicyModule(); // act... var result = mod.GetResults(mockInstanceInfo.Object); // assert... StringAssert.Equals(result.ResultComment, "The CMSPasswordFormat should be set to 'SHA2SALT'."); Assert.AreEqual(Status.Error, result.Status); mockInstanceInfo.VerifyAll(); Mock.Get(mockDbs).VerifyAll(); }
public void CreateDocument() { Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict); CreateDocumentRequest request = new CreateDocumentRequest { Parent = new AnyPathName("[PROJECT]", "[DATABASE]", "[DOCUMENT]", "[ANY_PATH]").ToString(), CollectionId = "collectionId-821242276", DocumentId = "documentId506676927", Document = new Document(), }; Document expectedResponse = new Document { Name = "name3373707", }; mockGrpcClient.Setup(x => x.CreateDocument(request, It.IsAny <CallOptions>())) .Returns(expectedResponse); FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null); Document response = client.CreateDocument(request); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public void ContainerMustReturnServiceInstance() { var mockFactory = new Mock <IFactory>(); var container = new ServiceContainer(); var serviceType = typeof(ISerializable); var instance = new object(); container.AddFactory(serviceType, mockFactory.Object); // The container must call the IFactory.CreateInstance method mockFactory.Expect( f => f.CreateInstance(It.Is <IFactoryRequest>(request => request.ServiceType == serviceType && request.Container == container))).Returns( instance); var result = container.GetService(serviceType); Assert.IsNotNull(result, "The container failed to return the given service instance"); Assert.AreSame(instance, result, "The service instance returned does not match the given instance"); mockFactory.VerifyAll(); }
public void UpdateDocument() { Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict); UpdateDocumentRequest expectedRequest = new UpdateDocumentRequest { Document = new Document(), UpdateMask = new DocumentMask(), }; Document expectedResponse = new Document { Name = "name3373707", }; mockGrpcClient.Setup(x => x.UpdateDocument(expectedRequest, It.IsAny <CallOptions>())) .Returns(expectedResponse); FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null); Document document = new Document(); DocumentMask updateMask = new DocumentMask(); Document response = client.UpdateDocument(document, updateMask); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public void Should_HaveStatusGood_When_PasswordPolicyDataIsGood() { // arrange... // Mocks... var mockDbs = Mock.Of <IDatabaseService>(); Mock.Get(mockDbs).Setup(_ => _.ExecuteAndGetTableFromFile(It.IsAny <string>())).Returns(this.MakeData(true, 3, 0)); var mockInstanceInfo = new Mock <IInstanceInfo>(MockBehavior.Strict); mockInstanceInfo.Setup(_ => _.DBService).Returns(mockDbs); // Real Module under test... PasswordPolicyModule mod = new PasswordPolicyModule(); // act... var result = mod.GetResults(mockInstanceInfo.Object); // assert... StringAssert.Equals(result.ResultComment, "Password settings look good."); Assert.AreEqual(Status.Good, result.Status); mockInstanceInfo.VerifyAll(); Mock.Get(mockDbs).VerifyAll(); }
public async Task GivenEventWhenPublishShouldCallEachRegisteredHandler() { var handlerMock = new Mock <IEventHandler <ITestEvent> >(MockBehavior.Strict); var eventMock = new Mock <ITestEvent>(); var scope = _mediatorFixture.CreateScope(); scope.Register(handlerMock.Object); var mediator = scope.GetMediator(); handlerMock.Setup(x => x.HandleAsync(eventMock.Object, It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask) .Verifiable(); scope.EventHandlerMock.Setup(x => x.HandleAsync(eventMock.Object, It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask) .Verifiable(); await mediator.PublishAsync(eventMock.Object, It.IsAny <CancellationToken>()); handlerMock.VerifyAll(); scope.EventHandlerMock.VerifyAll(); }
public async Task TestCreateTokenClient() { var mockApp = new Mock <IAssemblyInformationProvider>(); mockApp.SetupGet(x => x.ProductInfoHeaderValue).Returns(new ProductInfoHeaderValue("TGSTests", "1.2.3")).Verifiable(); var mockOptions = new Mock <IOptions <GeneralConfiguration> >(); mockOptions.SetupGet(x => x.Value).Returns(new GeneralConfiguration()); var factory = new GitHubClientFactory(mockApp.Object, mockOptions.Object); Assert.ThrowsException <ArgumentNullException>(() => factory.CreateClient(null)); var client = factory.CreateClient("asdf"); Assert.IsNotNull(client); var credentials = await client.Connection.CredentialStore.GetCredentials().ConfigureAwait(false); Assert.AreEqual(AuthenticationType.Oauth, credentials.AuthenticationType); mockApp.VerifyAll(); }
public async void GetUsers_Should_Call_UserService() { // Arrange var users = Fixture.CreateMany <UserModel>(); _mockUserService.Setup(_ => _.GetUsersAsync()) .ReturnsAsync(users); var result = await _userController.GetUsers(); var message = await result.ExecuteAsync(new CancellationToken()); message.StatusCode.Should().Be(HttpStatusCode.OK); IEnumerable <UserModel> models; message.TryGetContentValue(out models).Should().BeTrue(); message.StatusCode.Should().Be(HttpStatusCode.OK); Mock.VerifyAll(); models.ShouldBeEquivalentTo(users); }
public void Should_HaveStatusWarning_When_PasswordPolicyIsFalseForAnySite() { // arrange... // Mocks... var mockDbs = Mock.Of <IDatabaseService>(); Mock.Get(mockDbs).Setup(_ => _.ExecuteAndGetTableFromFile(It.IsAny <string>())).Returns(this.MakeData(true, 2, 1)); var mockInstanceInfo = new Mock <IInstanceInfo>(MockBehavior.Strict); mockInstanceInfo.Setup(_ => _.DBService).Returns(mockDbs); // Real Module under test... PasswordPolicyModule mod = new PasswordPolicyModule(); // act... var result = mod.GetResults(mockInstanceInfo.Object); // assert... StringAssert.Equals(result.ResultComment, "It is recommended that you have CMSUsePasswordPolicy set to 'True'."); Assert.AreEqual(Status.Warning, result.Status); mockInstanceInfo.VerifyAll(); Mock.Get(mockDbs).VerifyAll(); }
public void HasQualifyingStartMeetsExpectation(string candidate, bool expectation) { var delivery = new Mock <ILearningDelivery>(); var testDate = DateTime.Parse(candidate); var handler = new Mock <IValidationErrorHandler>(MockBehavior.Strict); var ddRule22 = new Mock <IDerivedData_22Rule>(MockBehavior.Strict); var dateTimeQS = new Mock <IDateTimeQueryService>(MockBehavior.Strict); dateTimeQS .Setup(x => x.IsDateBetween(delivery.Object.LearnStartDate, testDate, DateTime.MaxValue, true)) .Returns(expectation); var sut = new LearnStartDate_15Rule(handler.Object, ddRule22.Object, dateTimeQS.Object); var result = sut.HasQualifyingStart(delivery.Object, testDate); Assert.Equal(expectation, result); handler.VerifyAll(); ddRule22.VerifyAll(); dateTimeQS.VerifyAll(); }
public void Should_HaveStatusError_When_NoRecordsAreRetrieved() { // arrange... // Mocks... var mockDbs = Mock.Of <IDatabaseService>(); Mock.Get(mockDbs).Setup(_ => _.ExecuteAndGetTableFromFile(It.IsAny <string>())).Returns(this.MakeEmptyTable()); var mockInstanceInfo = new Mock <IInstanceInfo>(MockBehavior.Strict); mockInstanceInfo.Setup(_ => _.DBService).Returns(mockDbs); // Real Module under test... PasswordPolicyModule mod = new PasswordPolicyModule(); // act... var result = mod.GetResults(mockInstanceInfo.Object); // assert... StringAssert.Equals(result.ResultComment, "Failed to check settings as expected."); Assert.AreEqual(Status.Error, result.Status); mockInstanceInfo.VerifyAll(); Mock.Get(mockDbs).VerifyAll(); }
public async Task TimerFlush_CalledOnExpectedInterval() { int flushInterval = 10; Mock <IEventGenerator> mockGenerator = new Mock <IEventGenerator>(); Mock <MetricsEventManager> mockEventManager = new Mock <MetricsEventManager>(new TestEnvironment(), mockGenerator.Object, flushInterval, flushInterval) { CallBase = true }; MetricsEventManager eventManager = mockEventManager.Object; int numFlushes = 0; mockEventManager.Protected().Setup("TimerFlush", ItExpr.IsAny <object>()) .Callback <object>((state) => { numFlushes++; }); // here we're just verifying that we're called multiple times await TestHelpers.Await(() => numFlushes >= 5, timeout : 2000, pollingInterval : 100, userMessageCallback : () => $"Expected numFlushes >= 5; Actual: {numFlushes}"); mockEventManager.VerifyAll(); }
public async Task Invoke_TraceException() { var context = CreateHttpContext(); var tracerMock = CreateIManagedTracerMock(context); tracerMock.Setup(t => t.SetStackTrace(It.IsAny <StackTrace>())); var delegateMock = new Mock <RequestDelegate>(); delegateMock.Setup(d => d(context)).Throws(new DivideByZeroException()); Func <TraceHeaderContext, IManagedTracer> fakeFactory = f => tracerMock.Object; var middleware = new CloudTraceMiddleware(delegateMock.Object, fakeFactory); await Assert.ThrowsAsync <DivideByZeroException>( () => middleware.Invoke(context, _traceHeaderContext)); Assert.True(context.Response.Headers.ContainsKey(TraceHeaderContext.TraceHeader)); Assert.Equal(_traceHeaderContext.ToString(), context.Response.Headers[TraceHeaderContext.TraceHeader]); delegateMock.VerifyAll(); tracerMock.VerifyAll(); }
public void OpenFileWithBucketPrefix() { //Arrange var stream = new MemoryStream(Encoding.UTF8.GetBytes("Test123")); var response = new GetObjectResponse { ResponseStream = stream }; var clientMock = new Mock <IAmazonS3>(); clientMock.Setup(p => p.GetObject(It.Is <GetObjectRequest>(req => req.Key == "media/1001/media.jpg"))) .Returns(response); var provider = CreateProvider(clientMock); //Act var actual = provider.OpenFile("/media/1001/media.jpg"); //Assert Assert.AreEqual(new StreamReader(actual).ReadToEnd(), "Test123"); clientMock.VerifyAll(); }
public async Task BeginTransactionAsync() { Mock <Spanner.SpannerClient> mockGrpcClient = new Mock <Spanner.SpannerClient>(MockBehavior.Strict); BeginTransactionRequest expectedRequest = new BeginTransactionRequest { SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"), Options = new TransactionOptions(), }; Transaction expectedResponse = new Transaction { Id = ByteString.CopyFromUtf8("27"), }; mockGrpcClient.Setup(x => x.BeginTransactionAsync(expectedRequest, It.IsAny <CallOptions>())) .Returns(new Grpc.Core.AsyncUnaryCall <Transaction>(Task.FromResult(expectedResponse), null, null, null, null)); SpannerClient client = new SpannerClientImpl(mockGrpcClient.Object, null); SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"); TransactionOptions options = new TransactionOptions(); Transaction response = await client.BeginTransactionAsync(session, options); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public void TestShippingAddressCreate() { // Arrange var fakeShippingAddress = FakeShippingAddresses().First(); var mockBusinessLogic = new Mock <ISportStoreBusinessLogic>(); mockBusinessLogic .Setup(bl => bl.ShippingAddress.Create(fakeShippingAddress)) .Returns(fakeShippingAddress.Id); var controller = new ShippingAddressController(mockBusinessLogic.Object); // Act var result = controller.Post(fakeShippingAddress); var createdShippingAddressId = (result as OkNegotiatedContentResult <Guid>).Content; // Assert mockBusinessLogic.VerifyAll(); Assert.IsNotNull(createdShippingAddressId); Assert.AreEqual(fakeShippingAddress.Id, createdShippingAddressId); }
public void Search_DefaultParams_ReturnsList() { IEnumerable <Review> expected = new List <Review> { new Review { Id = 1, UserId = 2, RestaurantId = 3 }, new Review { Id = 2, UserId = 4, RestaurantId = 7 } }; var reviewRepository = new Mock <IReviewRepository>(); reviewRepository.Setup(x => x.GetReviewsAsync(1, 1000, null)).Returns(Task.FromResult <IEnumerable <Review> >(expected)); var sut = new ReviewsController(reviewRepository.Object); var actual = sut.Post(null, null, null).Result; Assert.AreEqual(expected, actual); reviewRepository.VerifyAll(); }
public async Task Delete_DefaultWorkflow() { // arrange var idToDelete = 13; var countryService = new Mock <ICountryService>(MockBehavior.Strict); var controller = new CountryController(countryService.Object) { TempData = new Mock <ITempDataDictionary>().Object }; countryService.Setup(s => s.ExistsAsync(idToDelete)).ReturnsAsync(true); countryService.Setup(s => s.DeleteAsync(idToDelete)).ReturnsAsync(true); // act var result = await controller.Delete(idToDelete); // assert Assert.IsAssignableFrom <RedirectToActionResult>(result); var actionName = (result as RedirectToActionResult)?.ActionName; Assert.True(string.Equals(actionName, nameof(CountryController.Add), System.StringComparison.InvariantCultureIgnoreCase)); countryService.VerifyAll(); }
public void Search_PerformsCorrectRequest() { //Setup JobSearchStub request = new JobSearchStub("DevKey", "api.careerbuilder.com","",""); //Mock crap RestResponse<ResponseJobSearch> response = new RestResponse<ResponseJobSearch>(); response.Data = new ResponseJobSearch(); var restReq = new Mock<IRestRequest>(); restReq.Setup(x => x.AddParameter("DeveloperKey", "DevKey")); restReq.Setup(x => x.AddParameter("CountryCode", "NL")); restReq.SetupSet(x => x.RootElement = "ResponseJobSearch"); var restClient = new Mock<IRestClient>(); restClient.SetupSet(x => x.BaseUrl = "https://api.careerbuilder.com/v1/jobsearch"); restClient.Setup(x => x.Execute<ResponseJobSearch>(It.IsAny<IRestRequest>())).Returns(response); request.Request = restReq.Object; request.Client = restClient.Object; //Assert ResponseJobSearch resp = request.WhereCountryCode(CountryCode.NL).Search(); restReq.Verify(); restClient.VerifyAll(); }