public Specification(string name, It it, bool isIgnored, FieldInfo fieldInfo) { _name = name; _it = it; _isIgnored = isIgnored; _fieldInfo = fieldInfo; }
public BehaviorSpecification(string name, It it, bool isIgnored, FieldInfo fieldInfo, Context context, Behavior behavior) : base(name, it, isIgnored, fieldInfo) { _contextInstance = context.Instance; _behaviorInstance = behavior.Instance; _mapper = new ConventionMapper(); }
/// <summary> /// Starts worker in separate thread. /// After worker finished its work it should call "done" function passed to it. /// After worker called done "callback" function will be called in unity thread. /// Parameter passed to "done" function will be available in "callback" function. /// Note: All Unity function are threade unsave. You are not allowed to use them in the worker. /// Though you can use any Unity functions in "callback" function. /// </summary> /// <param name="worker">Worker.</param> /// <param name="callback">Callback.</param> /// <returns>Thread id</returns> public static int Start(Worker worker, It.Action<object> callback, System.TimeSpan? timeout /*= null*/, It.Action timeoutCallback /*= null*/) { if (_instance == null) { _instance = new GameObject("Threading").AddComponent<Threading>(); } var id = _instance._id++; var info = new Info(); info.id = id; info.callback = callback; info.worker = worker; info.thread = new System.Threading.Thread(info.Run); if (timeout.HasValue) { info.timeout = System.DateTime.Now + timeout.Value; info.timeoutCallback = timeoutCallback; } _instance._threads[id] = info; info.thread.Start(); return id; }
public static int Start(Worker worker, It.Action<object> callback) { return Start(worker, callback, null, null); }
public async Task DeleteReturnsCorrectViewWhenUserIsOrgAdmin() { var controller = CampaignControllerWithSummaryQuery(UserType.OrgAdmin.ToString(), It.IsAny<int>()); Assert.IsType<ViewResult>(await controller.Delete(It.IsAny<int>())); }
public async Task EditPostAddsErrorToModelStateWhenInvalidImageFormatIsSupplied() { var controller = CampaignControllerWithSummaryQuery(UserType.OrgAdmin.ToString(), It.IsAny<int>()); var file = FormFile(""); await controller.Edit(new CampaignSummaryModel { Name = "Foo", OrganizationId = It.IsAny<int>() }, file); Assert.False(controller.ModelState.IsValid); Assert.True(controller.ModelState.ContainsKey("ImageUrl")); //TODO: test that the value associated with the key is correct }
public async Task EditPostReturnsHttpUnauthorizedResultWhenUserIsNotAnOrgAdmin() { var controller = CampaignControllerWithSummaryQuery(UserType.BasicUser.ToString(), It.IsAny<int>()); var result = await controller.Edit(new CampaignSummaryModel { OrganizationId = It.IsAny<int>() }, null); Assert.IsType<HttpUnauthorizedResult>(result); }
public async Task EditGetReturnsHttpUnauthorizedResultWhenUserIsNotAnOrgAdmin() { var controller = CampaignControllerWithSummaryQuery(UserType.BasicUser.ToString(), It.IsAny<int>()); Assert.IsType<HttpUnauthorizedResult>(await controller.Edit(It.IsAny<int>())); }
public async Task DetailsReturnsCorrectViewWhenViewModelIsNotNullAndUserIsOrgAdmin() { var controller = CampaignControllerWithDetailQuery(UserType.OrgAdmin.ToString(), It.IsAny<int>()); Assert.IsType<ViewResult>(await controller.Details(It.IsAny<int>())); }
public async Task DetailsReturnsHttpNotFoundResultWhenVieModelIsNull() { CampaignController controller; MockMediatorCampaignDetailQuery(out controller); Assert.IsType<HttpNotFoundResult>(await controller.Details(It.IsAny<int>())); }
public void Should_Success_Get_All_Data_UnitExpenditure_for_Preparing() { var mockFacade = new Mock<IGarmentUnitExpenditureNoteFacade>(); mockFacade.Setup(x => x.ReadForGPreparing(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string>(), null, It.IsAny<string>())) .Returns(new ReadResponse<object>(new List<object>(), 0, new Dictionary<string, string>())); var mockFacadeUnitDO = new Mock<IGarmentUnitDeliveryOrderFacade>(); var mockMapper = new Mock<IMapper>(); mockMapper.Setup(x => x.Map<List<GarmentUnitExpenditureNoteViewModel>>(It.IsAny<List<GarmentUnitExpenditureNote>>())) .Returns(new List<GarmentUnitExpenditureNoteViewModel> { ViewModel }); GarmentUnitExpenditureNoteController controller = GetController(mockFacade, mockFacadeUnitDO, null, mockMapper); var response = controller.GetForGarmentPreparing(); Assert.Equal((int)HttpStatusCode.OK, GetStatusCode(response)); }
public void Should_Error_Get_All_Data_By_User() { var mockFacade = new Mock<IGarmentUnitExpenditureNoteFacade>(); mockFacade.Setup(x => x.Read(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string>(), null, It.IsAny<string>())) .Returns(new ReadResponse<object>(new List<object>(), 0, new Dictionary<string, string>())); var mockMapper = new Mock<IMapper>(); mockMapper.Setup(x => x.Map<List<GarmentUnitExpenditureNoteViewModel>>(It.IsAny<List<GarmentUnitExpenditureNote>>())) .Returns(new List<GarmentUnitExpenditureNoteViewModel> { ViewModel }); var mockFacadeUnitDO = new Mock<IGarmentUnitDeliveryOrderFacade>(); GarmentUnitExpenditureNoteController controller = new GarmentUnitExpenditureNoteController(GetServiceProvider().Object, mockMapper.Object, mockFacade.Object, mockFacadeUnitDO.Object); var response = controller.GetByUser(); Assert.Equal((int)HttpStatusCode.InternalServerError, GetStatusCode(response)); }
private void Arrange() { var random = new Random(); _localChannelNumber = (uint)random.Next(0, int.MaxValue); _localWindowSize = (uint)random.Next(0, int.MaxValue); _localPacketSize = (uint)random.Next(0, int.MaxValue); _remoteChannelNumber = (uint)random.Next(0, int.MaxValue); _remoteWindowSize = (uint)random.Next(0, int.MaxValue); _remotePacketSize = (uint)random.Next(0, int.MaxValue); _channelClosedRegister = new List <ChannelEventArgs>(); _channelExceptionRegister = new List <ExceptionEventArgs>(); _initialSessionSemaphoreCount = random.Next(10, 20); _sessionSemaphore = new SemaphoreLight(_initialSessionSemaphoreCount); _sessionMock = new Mock <ISession>(MockBehavior.Strict); _connectionInfoMock = new Mock <IConnectionInfo>(MockBehavior.Strict); _sequence = new MockSequence(); _sessionMock.InSequence(_sequence).Setup(p => p.ConnectionInfo).Returns(_connectionInfoMock.Object); _connectionInfoMock.InSequence(_sequence).Setup(p => p.RetryAttempts).Returns(1); _sessionMock.Setup(p => p.SessionSemaphore).Returns(_sessionSemaphore); _sessionMock.InSequence(_sequence) .Setup( p => p.SendMessage( It.Is <ChannelOpenMessage>( m => m.LocalChannelNumber == _localChannelNumber && m.InitialWindowSize == _localWindowSize && m.MaximumPacketSize == _localPacketSize && m.Info is SessionChannelOpenInfo))); _sessionMock.InSequence(_sequence) .Setup(p => p.WaitOnHandle(It.IsNotNull <WaitHandle>())) .Callback <WaitHandle>( w => { _sessionMock.Raise( s => s.ChannelOpenConfirmationReceived += null, new MessageEventArgs <ChannelOpenConfirmationMessage>( new ChannelOpenConfirmationMessage( _localChannelNumber, _remoteWindowSize, _remotePacketSize, _remoteChannelNumber))); w.WaitOne(); }); _sessionMock.Setup(p => p.IsConnected).Returns(true); _sessionMock.InSequence(_sequence) .Setup( p => p.TrySendMessage(It.Is <ChannelCloseMessage>(c => c.LocalChannelNumber == _remoteChannelNumber))) .Returns(false); _channel = new ChannelSession(_sessionMock.Object, _localChannelNumber, _localWindowSize, _localPacketSize); _channel.Closed += (sender, args) => _channelClosedRegister.Add(args); _channel.Exception += (sender, args) => _channelExceptionRegister.Add(args); _channel.Open(); _sessionMock.Raise( p => p.ChannelCloseReceived += null, new MessageEventArgs <ChannelCloseMessage>(new ChannelCloseMessage(_localChannelNumber))); }
public async Task TestIfDocumentsAreUpserted() { Mock<IBulkExecutor> mockBulkExecutor = new Mock<IBulkExecutor>(); Mock<ILogger> mockLog = new Mock<ILogger>(); AsyncCollector<Document> postMortemCol = new AsyncCollector<Document>(); DocumentClient client = new DocumentClient(new Uri(configuration["EndPoint"]), configuration["AuthKey"]); DocumentCollection container = client.CreateDocumentCollectionQuery(UriFactory.CreateDatabaseUri(configuration["TargetDatabase"])) .Where(c => c.Id == configuration["TargetCollection"]).AsEnumerable().FirstOrDefault(); IBulkExecutor bulkExecutor = new BulkExecutor(client, container); await bulkExecutor.InitializeAsync(); IEnumerable<string> bulkDocs = Utilities.GenerateDocumentsWithRandomIdAndPk(5000); BulkImportResponse bulkImportResponse = await bulkExecutor.BulkImportAsync(bulkDocs, false); List<Document> fakeBadDocsBatch = new List<Document>(); Document doc = new Document(); doc.Id = "0f4adabc-d461-495f-bdd3-4f8877ae7f3f"; for (int i = 0; i < 10; i++) { fakeBadDocsBatch.Add(doc); } ReadOnlyCollection<Document> readOnlyDocs = fakeBadDocsBatch.AsReadOnly(); mockBulkExecutor.Setup(bulkExecutorFake => bulkExecutorFake.InitializeAsync()) .Verifiable(); mockBulkExecutor.Setup(bulkExecutorFake => bulkExecutorFake.BulkImportAsync(It.IsAny<ReadOnlyCollection<Document>>(), true, true, null, It.IsAny<int>(), It.IsAny<CancellationToken>())) .Returns(() => Task.FromResult(bulkImportResponse)) //Add docs to the badInputDocuments list to test whether the post-mortem queue is employed .Callback(() => bulkImportResponse.BadInputDocuments.AddRange(fakeBadDocsBatch)); DocumentFeedMigrator migrator = new DocumentFeedMigrator(mockBulkExecutor.Object); await migrator.Run(postMortemCol, readOnlyDocs, mockLog.Object); Assert.AreEqual(postMortemCol.Count(), 10); mockBulkExecutor.Verify( bulkExecutorFake => bulkExecutorFake.BulkImportAsync( It.IsAny<ReadOnlyCollection<Document>>(), true, true, null, It.IsAny<int>(), It.IsAny<CancellationToken>()), Times.Exactly(1)); }
public async Task Create_POST_on_successful_validate_creates_holidayPeriod() { var redirectToActionResult = await controller.Create(new HolidayPeriod()) as RedirectToActionResult; holidayPeriodsRepository.Verify(x => x.CreateAsync(It.IsAny<HolidayPeriod>()), Times.Once); }
public async Task AccountsAsync_WhenCalledWithStatusDate_AssertQueryAsyncWasCalledOnQueryBus() { Controller sut = CreateSut(); int accountingNumber = _fixture.Create <int>(); DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1); await sut.AccountsAsync(accountingNumber, statusDate); _queryBusMock.Verify(m => m.QueryAsync <IGetAccountCollectionQuery, IAccountCollection>(It.Is <IGetAccountCollectionQuery>(value => value.AccountingNumber == accountingNumber && value.StatusDate == statusDate.Date)), Times.Once); }
public void Observation(It observation) { if (Exception != null) throw Exception; observation(); }
public async Task AccountsAsync_WhenCalledWithoutStatusDate_AssertQueryAsyncWasCalledOnQueryBus() { Controller sut = CreateSut(); int accountingNumber = _fixture.Create <int>(); await sut.AccountsAsync(accountingNumber); _queryBusMock.Verify(m => m.QueryAsync <IGetAccountCollectionQuery, IAccountCollection>(It.Is <IGetAccountCollectionQuery>(value => value.AccountingNumber == accountingNumber && value.StatusDate == DateTime.Today)), Times.Once); }
public async Task GetTeamDataStreamAsyncSuccesTest() { // Arrange var activityInstance = GetDataStreamFacade(); var teamData = new TeamDataEntity(); sentNotificationDataRepository .Setup(x => x.GetStreamsAsync(notificationId, null)) .Returns(data.ToAsyncEnumerable()); teamDataRepository.Setup(x => x.GetAsync(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(teamData); // Act var userDataStream = activityInstance.GetTeamDataStreamAsync(notificationId); Func<Task> task = async () => await userDataStream.ForEachAsync(x => x.ToList()); // Assert await task.Should().NotThrowAsync(); sentNotificationDataRepository.Verify(x => x.GetStreamsAsync(It.Is<string>(x => x.Equals(notificationId)), null), Times.Once); teamDataRepository.Verify(x => x.GetAsync(It.Is<string>(x=>x.Equals(TeamDataTableNames.TeamDataPartition)),It.IsAny<string>()), Times.AtLeastOnce); }
public async Task DetailsReturnsHttpUnauthorizedResultIfUserIsNotOrgAdmin() { var controller = CampaignControllerWithDetailQuery(UserType.BasicUser.ToString(), It.IsAny<int>()); Assert.IsType<HttpUnauthorizedResult>(await controller.Details(It.IsAny<int>())); }
public async Task CreatesPackageOwnerRequestSendsEmailAndReturnsPendingState(Func <Fakes, User> getCurrentUser, Func <Fakes, User> getUserToAdd) { var fakes = Get <Fakes>(); var currentUser = getCurrentUser(fakes); var userToAdd = getUserToAdd(fakes); var controller = GetController <JsonApiController>(); controller.SetCurrentUser(currentUser); var packageOwnershipManagementServiceMock = GetMock <IPackageOwnershipManagementService>(); var messageServiceMock = GetMock <IMessageService>(); var pending = !(ActionsRequiringPermissions.HandlePackageOwnershipRequest.CheckPermissions(currentUser, userToAdd) == PermissionsCheckResult.Allowed); if (pending) { packageOwnershipManagementServiceMock .Setup(p => p.AddPackageOwnershipRequestAsync(fakes.Package, currentUser, userToAdd)) .Returns(Task.FromResult(new PackageOwnerRequest { ConfirmationCode = "confirmation-code" })) .Verifiable(); messageServiceMock .Setup(m => m.SendMessageAsync(It.IsAny <PackageOwnershipRequestMessage>(), false, false)) .Callback <IEmailBuilder, bool, bool>((msg, copySender, discloseSenderAddress) => { var message = msg as PackageOwnershipRequestMessage; Assert.Equal(currentUser, message.FromUser); Assert.Equal(userToAdd, message.ToUser); Assert.Equal(fakes.Package, message.PackageRegistration); Assert.Equal(TestUtility.GallerySiteRootHttps + "packages/FakePackage/", message.PackageUrl); Assert.Equal(TestUtility.GallerySiteRootHttps + $"packages/FakePackage/owners/{userToAdd.Username}/confirm/confirmation-code", message.ConfirmationUrl); Assert.Equal(TestUtility.GallerySiteRootHttps + $"packages/FakePackage/owners/{userToAdd.Username}/reject/confirmation-code", message.RejectionUrl); Assert.Equal("Hello World! Html Encoded <3", message.HtmlEncodedMessage); Assert.Equal(string.Empty, message.PolicyMessage); }) .Returns(Task.CompletedTask) .Verifiable(); foreach (var owner in fakes.Package.Owners) { messageServiceMock .Setup(m => m.SendMessageAsync( It.Is <PackageOwnershipRequestInitiatedMessage>( msg => msg.RequestingOwner == currentUser && msg.ReceivingOwner == owner && msg.NewOwner == userToAdd && msg.PackageRegistration == fakes.Package), false, false)) .Returns(Task.CompletedTask) .Verifiable(); } } else { packageOwnershipManagementServiceMock .Setup(p => p.AddPackageOwnerAsync(fakes.Package, userToAdd, true)) .Returns(Task.CompletedTask) .Verifiable(); foreach (var owner in fakes.Package.Owners) { messageServiceMock .Setup(m => m.SendMessageAsync( It.Is <PackageOwnerAddedMessage>( msg => msg.ToUser == owner && msg.NewOwner == userToAdd && msg.PackageRegistration == fakes.Package), false, false)) .Returns(Task.CompletedTask) .Verifiable(); } } JsonResult result = await controller.AddPackageOwner(fakes.Package.Id, userToAdd.Username, "Hello World! Html Encoded <3"); dynamic data = result.Data; PackageOwnersResultViewModel model = data.model; Assert.True(data.success); Assert.Equal(userToAdd.Username, model.Name); Assert.Equal(pending, model.Pending); packageOwnershipManagementServiceMock.Verify(); messageServiceMock.Verify(); }
public async Task EditGetReturnsHttpNotFoundResultWhenViewModelIsNull() { CampaignController controller; MockMediatorCampaignSummaryQuery(out controller); Assert.IsType<HttpNotFoundResult>(await controller.Edit(It.IsAny<int>())); }
public async Task RemovesExistingOwner(Func <Fakes, User> getCurrentUser, Func <Fakes, User> getUserToRemove) { // Arrange var fakes = Get <Fakes>(); var currentUser = getCurrentUser(fakes); var userToRemove = getUserToRemove(fakes); var package = fakes.Package; var controller = GetController <JsonApiController>(); controller.SetCurrentUser(currentUser); var packageOwnershipManagementService = GetMock <IPackageOwnershipManagementService>(); packageOwnershipManagementService .Setup(x => x.GetPackageOwnershipRequests(package, null, userToRemove)) .Returns(Enumerable.Empty <PackageOwnerRequest>()); // Act var result = await controller.RemovePackageOwner(package.Id, userToRemove.Username); dynamic data = result.Data; // Assert Assert.True(data.success); packageOwnershipManagementService.Verify(x => x.RemovePackageOwnerAsync(package, currentUser, userToRemove, It.IsAny <bool>())); GetMock <IMessageService>() .Verify(x => x.SendMessageAsync( It.Is <PackageOwnerRemovedMessage>( msg => msg.FromUser == currentUser && msg.ToUser == userToRemove && msg.PackageRegistration == package), false, false)); }
public async Task EditPostReturnsBadRequestWhenCampaignIsNull() { var controller = CampaignControllerWithSummaryQuery(UserType.OrgAdmin.ToString(), It.IsAny<int>()); var result = await controller.Edit(null, null); Assert.IsType<BadRequestResult>(result); }
public void HandleChannelException_should_update_topology_as_expected_on_network_error_or_timeout( string errorType, bool shouldUpdateTopology) { var serverId = new ServerId(_clusterId, _endPoint); var connectionId = new ConnectionId(serverId); Exception innerMostException; switch (errorType) { case "MongoConnectionExceptionWithSocketTimeout": innerMostException = new SocketException((int)SocketError.TimedOut); break; case nameof(MongoConnectionException): innerMostException = new SocketException((int)SocketError.NetworkUnreachable); break; default: throw new ArgumentException("Unknown error type."); } var operationUsingChannelException = new MongoConnectionException(connectionId, "Oops", new IOException("Cry", innerMostException)); var mockConnection = new Mock <IConnectionHandle>(); var helloResult = new HelloResult(new BsonDocument { { "compressors", new BsonArray() }, { "maxWireVersion", WireVersion.Server44 } }); mockConnection.SetupGet(c => c.Description) .Returns(new ConnectionDescription(new ConnectionId(serverId, 0), helloResult)); var mockConnectionPool = new Mock <IConnectionPool>(); mockConnectionPool.Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())).Returns(mockConnection.Object); mockConnectionPool.Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())).ReturnsAsync(mockConnection.Object); var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint, It.IsAny <IConnectionExceptionHandler>())) .Returns(mockConnectionPool.Object); var mockMonitorServerInitialDescription = new ServerDescription(serverId, _endPoint).With(reasonChanged: "Initial D", type: ServerType.Unknown); var mockServerMonitor = new Mock <IServerMonitor>(); mockServerMonitor.SetupGet(m => m.Description).Returns(mockMonitorServerInitialDescription); mockServerMonitor.SetupGet(m => m.Lock).Returns(new object()); var mockServerMonitorFactory = new Mock <IServerMonitorFactory>(); mockServerMonitorFactory.Setup(f => f.Create(It.IsAny <ServerId>(), _endPoint)).Returns(mockServerMonitor.Object); var subject = new DefaultServer(_clusterId, _clusterClock, _clusterConnectionMode, _connectionModeSwitch, _directConnection, _settings, _endPoint, mockConnectionPoolFactory.Object, mockServerMonitorFactory.Object, _capturedEvents, _serverApi); subject.Initialize(); var heartbeatDescription = mockMonitorServerInitialDescription.With(reasonChanged: "Heartbeat", type: ServerType.Standalone); mockServerMonitor.Setup(m => m.Description).Returns(heartbeatDescription); mockServerMonitor.Raise( m => m.DescriptionChanged += null, new ServerDescriptionChangedEventArgs(mockMonitorServerInitialDescription, heartbeatDescription)); subject.Description.Should().Be(heartbeatDescription); subject.HandleChannelException(mockConnection.Object, operationUsingChannelException); if (shouldUpdateTopology) { subject.Description.Type.Should().Be(ServerType.Unknown); subject.Description.ReasonChanged.Should().Contain("ChannelException"); } else { subject.Description.Should().Be(heartbeatDescription); } }
public async Task EditPostRedirectsToCorrectActionWithCorrectRouteValuesWhenModelStateIsValid() { var controller = CampaignControllerWithSummaryQuery(UserType.OrgAdmin.ToString(), It.IsAny<int>()); var result = await controller.Edit(new CampaignSummaryModel { Name = "Foo", OrganizationId = It.IsAny<int>() }, null); //TODO: test result for correct Action name and Route values Assert.IsType<RedirectToActionResult>(result); }
// private methods private Server SetupServer(bool exceptionOnConnectionOpen, bool exceptionOnConnectionAcquire) { var connectionId = new ConnectionId(new ServerId(_clusterId, _endPoint)); var mockConnectionHandle = new Mock <IConnectionHandle>(); mockConnectionHandle .Setup(c => c.Fork()) .Returns(mockConnectionHandle.Object); var mockConnectionPool = new Mock <IConnectionPool>(); if (exceptionOnConnectionAcquire) { mockConnectionPool .Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())) .Throws(new TimeoutException("Timeout")); mockConnectionPool .Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())) .Throws(new TimeoutException("Timeout")); mockConnectionPool.Setup(p => p.Clear()); } else if (exceptionOnConnectionOpen) { mockConnectionPool .Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())) .Throws(new MongoAuthenticationException(connectionId, "Invalid login.")); mockConnectionPool .Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())) .Throws(new MongoAuthenticationException(connectionId, "Invalid login.")); mockConnectionPool.Setup(p => p.Clear()); } else { mockConnectionPool .Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())) .Returns(mockConnectionHandle.Object); mockConnectionPool .Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())) .Returns(Task.FromResult(mockConnectionHandle.Object)); mockConnectionPool.Setup(p => p.Clear()); } var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint, It.IsAny <IConnectionExceptionHandler>())) .Returns(mockConnectionPool.Object); var server = new DefaultServer( _clusterId, _clusterClock, _clusterConnectionMode, _connectionModeSwitch, _directConnection, _settings, _endPoint, mockConnectionPoolFactory.Object, _mockServerMonitorFactory.Object, _capturedEvents, _serverApi); server.Initialize(); return(server); }
public async Task DeleteReturnsHttpNotFoundResultWhenCampaignIsNotFound() { CampaignController controller; MockMediatorCampaignSummaryQuery(out controller); Assert.IsType<HttpNotFoundResult>(await controller.Delete(It.IsAny<int>())); }
public new void SetUp() { _discountRepo = new Mock <IRepository <Discount> >(); _complexDiscountRepo = new Mock <IRepository <ComplexDiscount> >(); var discount1 = new Discount { Id = 1, DiscountType = DiscountType.AssignedToCategories, Name = "Discount 1", UsePercentage = true, DiscountPercentage = 10, DiscountAmount = 0, DiscountLimitation = DiscountLimitationType.Unlimited, LimitationTimes = 0 }; var discount2 = new Discount { Id = 2, DiscountType = DiscountType.AssignedToSkus, Name = "Discount 2", UsePercentage = false, DiscountPercentage = 0, DiscountAmount = 5, RequiresCouponCode = true, CouponCode = "SecretCode", DiscountLimitation = DiscountLimitationType.NTimesPerCustomer, LimitationTimes = 3 }; _discountRepo.Setup(x => x.Table).Returns(new List <Discount> { discount1, discount2 }.AsQueryable()); _eventPublisher = new Mock <IEventPublisher>(); _eventPublisher.Setup(x => x.Publish(It.IsAny <object>())); _storeContext = new Mock <IStoreContext>(); _customerService = new Mock <ICustomerService>(); _categoryRepo = new Mock <IRepository <Category> >(); _categoryRepo.Setup(x => x.Table).Returns(new List <Category>().AsQueryable()); _manufacturerRepo = new Mock <IRepository <Manufacturer> >(); _manufacturerRepo.Setup(x => x.Table).Returns(new List <Manufacturer>().AsQueryable()); _productRepo = new Mock <IRepository <Product> >(); _productRepo.Setup(x => x.Table).Returns(new List <Product>().AsQueryable()); var cacheManager = new TestMemoryCacheManager(new Mock <IMemoryCache>().Object); _discountRequirementRepo = new Mock <IRepository <DiscountRequirement> >(); _discountRequirementRepo.Setup(x => x.Table).Returns(new List <DiscountRequirement>().AsQueryable()); _discountUsageHistoryRepo = new Mock <IRepository <DiscountUsageHistory> >(); var pluginFinder = new PluginFinder(_eventPublisher.Object); _localizationService = new Mock <ILocalizationService>(); _categoryService = new Mock <ICategoryService>(); _discountService = new DiscountService(_categoryService.Object, _customerService.Object, _eventPublisher.Object, _localizationService.Object, pluginFinder, _categoryRepo.Object, _discountRepo.Object, _complexDiscountRepo.Object, _discountRequirementRepo.Object, _discountUsageHistoryRepo.Object, _manufacturerRepo.Object, _productRepo.Object, cacheManager, _storeContext.Object); }
public async Task DetailConfirmedReturnsHttpUnauthorizedResultWhenUserIsNotOrgAdmin() { var controller = CampaignControllerWithSummaryQuery(UserType.BasicUser.ToString(), It.IsAny<int>()); Assert.IsType<HttpUnauthorizedResult>(await controller.DeleteConfirmed(It.IsAny<int>())); }
public async Task Success() { // Arrange var challenges = CreateChallenges().ToList(); var mockChallengeService = new Mock <IChallengeService>(); mockChallengeService.Setup( challengeService => challengeService.GetMatchesAsync( Game.LeagueOfLegends, It.IsAny <PlayerId>(), It.IsAny <DateTime?>(), It.IsAny <DateTime?>(), It.IsAny <IImmutableSet <string> >())) .ReturnsAsync(CreateChallengeMatches().ToList()) .Verifiable(); var mockServiceBusPublisher = new Mock <IServiceBusPublisher>(); mockServiceBusPublisher.Setup(serviceBusPublisher => serviceBusPublisher.PublishAsync(It.IsAny <ChallengeSynchronizedIntegrationEvent>())) .Returns(Task.CompletedTask) .Verifiable(); using var challengesHost = new ChallengesHostFactory().WithWebHostBuilder( builder => { builder.ConfigureTestContainer <ContainerBuilder>( container => { container.RegisterInstance(mockServiceBusPublisher.Object).As <IServiceBusPublisher>().SingleInstance(); }); }); challengesHost.Server.CleanupDbContext(); await challengesHost.Server.UsingScopeAsync( async scope => { var repository = scope.GetRequiredService <IChallengeRepository>(); repository.Create(challenges); await repository.CommitAsync(false); }); using var gamesHost = new GamesHostFactory().WithWebHostBuilder( builder => { builder.ConfigureTestContainer <ContainerBuilder>( container => { container.RegisterInstance(mockChallengeService.Object).As <IChallengeService>().SingleInstance(); }); }); var recurringJob = new ChallengeRecurringJob( new ChallengeService.ChallengeServiceClient(challengesHost.CreateChannel()), new GameService.GameServiceClient(gamesHost.CreateChannel())); // Act await recurringJob.SynchronizeChallengesAsync(EnumGame.LeagueOfLegends); // Assert mockServiceBusPublisher.Verify( serviceBusPublisher => serviceBusPublisher.PublishAsync(It.IsAny <ChallengeSynchronizedIntegrationEvent>()), Times.Exactly(2)); mockChallengeService.Verify( challengeService => challengeService.GetMatchesAsync( Game.LeagueOfLegends, It.IsAny <PlayerId>(), It.IsAny <DateTime?>(), It.IsAny <DateTime?>(), It.IsAny <IImmutableSet <string> >()), Times.Exactly(4)); }
public void LlenarDTOEvento_AsignarValorPropiedadcExpresionTiempo_PropiedadcExpresionTiempoIgualA10Minutos() { //Arrange DateTime dtFechaBase = new DateTime(2020, 01, 10, 20, 45, 000); PaqueteEnviado Paquete = new PaqueteEnviado() { dtFechaActual = dtFechaBase, dtFechaEntrega = new DateTime(2020, 01, 10, 20, 55, 000) }; var DOCEvaluadorFechaAnterior = new Mock<IEvaluadorFechaAnterior>(); DOCEvaluadorFechaAnterior.Setup((s) => s.EvaluarFechaAnterior(It.IsAny<DateTime>(), It.IsAny<DateTime>())).Returns(false); var DOCRecuperadorTiempo = new Mock<IObtenedorTiempo>(); DOCRecuperadorTiempo.Setup((s) => s.RecuperarExpresionTiempo().ProcesarTiempo(Paquete.dtFechaActual, Paquete.dtFechaEntrega)).Returns("10 Minutos"); var SUT = new CompletadorDatosDTO(DOCEvaluadorFechaAnterior.Object, DOCRecuperadorTiempo.Object); //Act SUT.LlenarDTOPaquete(Paquete); //Assert Assert.AreEqual("10 Minutos", Paquete.cExpresionTiempo); }
public void IsValid_WhenPropertiesIsNotNull_ReturnsTrue() { // Arrange. decimal decimalValue = 111; float floatValue = 112; double doubleValue = 113; short shortValue = 114; int intValue = 115; long longValue = 116; ushort ushortValue = 117; uint uintValue = 118; ulong ulongValue = 119; var properties = new Dictionary <string, object> { { "property_1", "value1" }, { "property_2", new ParsedSplit() }, { "property_3", false }, { "property_4", null }, { "property_5", decimalValue }, { "property_6", floatValue }, { "property_7", doubleValue }, { "property_8", shortValue }, { "property_9", intValue }, { "property_10", longValue }, { "property_11", ushortValue }, { "property_12", uintValue }, { "property_13", ulongValue } }; var sizeExpected = 1024L; foreach (var item in properties) { sizeExpected += item.Key.Length; if (item.Value is string) { sizeExpected += ((string)item.Value).Length; } } // Act. var result = eventPropertiesValidator.IsValid(properties); // Assert. Assert.IsTrue(result.Success); Assert.IsNotNull(result.Value); var dicResult = (Dictionary <string, object>)result.Value; Assert.AreEqual("value1", dicResult["property_1"]); Assert.IsNull(dicResult["property_2"]); Assert.IsFalse((bool)dicResult["property_3"]); Assert.IsNull(dicResult["property_4"]); Assert.AreEqual(decimalValue, dicResult["property_5"]); Assert.AreEqual(floatValue, dicResult["property_6"]); Assert.AreEqual(doubleValue, dicResult["property_7"]); Assert.AreEqual(shortValue, dicResult["property_8"]); Assert.AreEqual(intValue, dicResult["property_9"]); Assert.AreEqual(longValue, dicResult["property_10"]); Assert.AreEqual(ushortValue, dicResult["property_11"]); Assert.AreEqual(uintValue, dicResult["property_12"]); Assert.AreEqual(ulongValue, dicResult["property_13"]); Assert.IsTrue(result.EventSize == sizeExpected); _log.Verify(mock => mock.Warn($"Property Splitio.Domain.ParsedSplit is of invalid type. Setting value to null"), Times.Exactly(1)); _log.Verify(mock => mock.Warn(It.IsAny <string>()), Times.Exactly(1)); _log.Verify(mock => mock.Error(It.IsAny <string>()), Times.Exactly(0)); }
public async Task Success2() { // Arrange using var gamesHost = new GamesHostFactory(); var gamesServiceClient = new GameService.GameServiceClient(gamesHost.CreateChannel()); var findChallengeScoringRequest = new FindChallengeScoringRequest { Game = EnumGame.LeagueOfLegends }; var findChallengeScoringResponse = await gamesServiceClient.FindChallengeScoringAsync(findChallengeScoringRequest); var createdAt = new DateTimeProvider( new DateTime( 2019, 12, 30, 21, 9, 22, DateTimeKind.Utc)); var startedAt = new DateTimeProvider( new DateTime( 2019, 12, 30, 22, 42, 50, DateTimeKind.Utc)); var challenge = new Challenge( new ChallengeId(), new ChallengeName("TEST CHALLENGE"), Game.LeagueOfLegends, BestOf.One, Entries.Two, new ChallengeTimeline(createdAt, ChallengeDuration.OneDay), new Scoring( findChallengeScoringResponse.Scoring.Items.OrderBy(scoring => scoring.Order) .ToDictionary(scoring => scoring.StatName, scoring => scoring.StatWeighting))); var participant = new Participant( new ParticipantId(), new UserId(), PlayerId.Parse("V1R8S4W19KGdqSTn-rRO-pUGv6lfu2BkdVCaz_8wd-m6zw"), new DateTimeProvider(createdAt.DateTime + TimeSpan.FromMinutes(5))); challenge.Register(participant); challenge.Register( new Participant( new ParticipantId(), new UserId(), new PlayerId(), new DateTimeProvider(createdAt.DateTime + TimeSpan.FromMinutes(10)))); challenge.Start(startedAt); var mockServiceBusPublisher = new Mock <IServiceBusPublisher>(); mockServiceBusPublisher.Setup(serviceBusPublisher => serviceBusPublisher.PublishAsync(It.IsAny <ChallengeSynchronizedIntegrationEvent>())) .Returns(Task.CompletedTask) .Verifiable(); using var challengesHost = new ChallengesHostFactory().WithWebHostBuilder( builder => { builder.ConfigureTestContainer <ContainerBuilder>( container => { container.RegisterInstance(mockServiceBusPublisher.Object).As <IServiceBusPublisher>().SingleInstance(); }); }); challengesHost.Server.CleanupDbContext(); await challengesHost.Server.UsingScopeAsync( async scope => { var repository = scope.GetRequiredService <IChallengeRepository>(); repository.Create(challenge); await repository.CommitAsync(false); }); var recurringJob = new ChallengeRecurringJob( new ChallengeService.ChallengeServiceClient(challengesHost.CreateChannel()), new GameService.GameServiceClient(gamesHost.CreateChannel())); // Act await recurringJob.SynchronizeChallengesAsync(EnumGame.LeagueOfLegends); // Assert await challengesHost.Server.UsingScopeAsync( async scope => { var repository = scope.GetRequiredService <IChallengeRepository>(); var persistentChallenge = await repository.FindChallengeAsync(challenge.Id); persistentChallenge.FindParticipant(participant.PlayerId).Matches.Should().HaveCount(2); }); mockServiceBusPublisher.Verify( serviceBusPublisher => serviceBusPublisher.PublishAsync(It.IsAny <ChallengeSynchronizedIntegrationEvent>()), Times.Exactly(1)); }
private Controller CreateSut(IAccountCollection accountCollection = null) { _queryBusMock.Setup(m => m.QueryAsync <IGetAccountCollectionQuery, IAccountCollection>(It.IsAny <IGetAccountCollectionQuery>())) .Returns(Task.FromResult(accountCollection ?? _fixture.BuildAccountCollectionMock().Object)); return(new Controller(_commandBusMock.Object, _queryBusMock.Object)); }