public void Setup() { this.Options = new ProcessorOptions( new[] { new OptionInstance( new Option('r', "test"), "face"), }); this.ApplicationEnvironment = new StubApplicationEnvironment(); this.ProcessorEnvironment = Any.ProcessorEnvironment(); this.TableDescriptorToBuildAction = new Dictionary <TableDescriptor, Action <ITableBuilder, IDataExtensionRetrieval> > { [Any.TableDescriptor()] = (tableBuilder, cookedData) => { }, [Any.TableDescriptor()] = (tableBuilder, cookedData) => { }, [Any.TableDescriptor()] = (tableBuilder, cookedData) => { }, [Any.MetadataTableDescriptor()] = (tableBuilder, cookedData) => { }, [Any.MetadataTableDescriptor()] = (tableBuilder, cookedData) => { }, }; this.MetadataTables = this.TableDescriptorToBuildAction.Keys.Where(x => x.IsMetadataTable).ToList(); this.Sut = new MockProcessor( this.Options, this.ApplicationEnvironment, this.ProcessorEnvironment, this.TableDescriptorToBuildAction, this.MetadataTables); }
void StartListener() { _processor = new MockProcessor(); _listener = new AsyncListener(_processor, TestPort); _listener.MessageLogged += _listener_MessageLogged; _listener.Start(); }
private void SetProcessingResult(PaymentStatus status) { MockProcessor.Setup(x => x.SubmitAsync(It.IsAny <ProcessOrder>())) .Returns(Task.FromResult(new PaymentResult(status) { TransactionId = "888" })); }
public void Test_Null() { MockProcessor mock = new MockProcessor(); Processors proc = new Processors {new MockProcessor(), new TestProcessor(), new NullProcessor(), mock}; Assert.IsNull(proc.Process("something")); Assert.AreEqual(0, mock.Count); }
public async Task ProcessAsync_NoPaymentMethod_ReturnsDeclined() { var contact = CreateContact(paymentMethod: PaymentMethod.None); var plans = CreatePlanProcess(true, 100); var result = await Model.ProcessAsync(contact, plans, _now); Assert.Equal(PaymentStatus.Declined, result.Status); MockProcessor.Verify(x => x.SubmitAsync(It.IsAny <ProcessOrder>()), Times.Never); }
public void Test_Null() { MockProcessor mock = new MockProcessor(); Processors proc = new Processors { new MockProcessor(), new TestProcessor(), new NullProcessor(), mock }; Assert.IsNull(proc.Process("something")); Assert.AreEqual(0, mock.Count); }
public async Task ProcessAsync_PayWithCredits_SuccessNoProcess() { var contact = CreateContact(credits: ProductPrice); var plans = CreatePlanProcess(true); var result = await Model.ProcessAsync(contact, plans, _now); Assert.Equal(PaymentStatus.Approved, result.Status); MockProcessor.Verify(x => x.SubmitAsync(It.IsAny <ProcessOrder>()), Times.Never); }
public void LoadTest2() { var processorMock = new MockProcessor(); var assetLoaderMock = new Mock<IAssetLoader>(); assetLoaderMock.Setup(i => i.FindProcessors(It.IsAny<AssetFile>())) .Returns(new List<IAssetProcessor>{processorMock}); Asset target = new Asset(assetLoaderMock.Object, Path.Combine(_assetsRootDir, "scripts2/test2.a.js.coffee"), _assetsRootDir); target.Load(); Assert.AreEqual("coffee", target.Content.Trim()); }
public void ProcessorReaderCanReadToEnd() { string xml = "<root>foo</root>"; XmlProcessorReader reader = new XmlProcessorReader(GetReader(xml)); MockProcessor processor = new MockProcessor(); reader.Processors.Add(processor); reader.ReadToEnd(); Assert.AreEqual(3, processor.Calls); }
public void Test_Mock() { MockProcessor mock = new MockProcessor(); Processors proc = new Processors {mock}; Assert.AreEqual("something", proc.Process("something")); Assert.AreEqual(1, mock.Count); Assert.AreEqual("something", proc.Process("something")); Assert.AreEqual(2, mock.Count); }
public async Task When_There_Is_Nothing_To_Process_Returns_Null() { MockProgressService .Setup(s => s.GetNextBlockRangeToProcessAsync(MaxBlocksPerBatch)) .ReturnsAsync((BlockRange?)null); var processedRange = await Service.ProcessLatestBlocksAsync(); Assert.Null(processedRange); MockProcessor.Verify(p => p.ProcessAsync(It.IsAny <BlockRange>()), Times.Never); }
public async Task ProcessAsync_PayWithPayPal_ReturnApproved() { var contact = CreateContact(paymentMethod: PaymentMethod.PayPal); var plans = CreatePlanProcess(true, 100); SetProcessingResult(PaymentStatus.Approved); var result = await Model.ProcessAsync(contact, plans, _now); Assert.Equal(PaymentStatus.Approved, result.Status); MockProcessor.Verify(x => x.SubmitAsync(It.IsAny <ProcessOrder>()), Times.Once); }
public async Task ProcessAsync_PartialPayWithCredits_ReduceCreditsAndProcess() { var contact = CreateContact(credits: 20); var plans = CreatePlanProcess(true, 100); SetProcessingResult(PaymentStatus.Approved); await Model.ProcessAsync(contact, plans, _now); Assert.Equal(0, contact.AccountCredits); MockProcessor.Verify(x => x.SubmitAsync(It.IsAny <ProcessOrder>()), Times.Once); }
public void XmlProcessorCalledOnEachReadAndAttributes() { string xml = "<root id='1'>foo</root>"; XmlProcessorReader reader = new XmlProcessorReader(GetReader(xml)); MockProcessor processor = new MockProcessor(); reader.Processors.Add(processor); string output = ReadToEnd(reader); WriteIfDebugging(output); Assert.AreEqual(4, processor.Calls); }
public void Test_Mock() { MockProcessor mock = new MockProcessor(); Processors proc = new Processors { mock }; Assert.AreEqual("something", proc.Process("something")); Assert.AreEqual(1, mock.Count); Assert.AreEqual("something", proc.Process("something")); Assert.AreEqual(2, mock.Count); }
public void CanChainMultipleProcessors() { string xml = "<root>foo</root>"; XmlProcessorReader reader = new XmlProcessorReader(GetReader(xml)); MockProcessor processor = new MockProcessor(); reader.Processors.Add(new MutateMockProcessor()); reader.Processors.Add(new SkipReaderMockProcessor()); reader.Processors.Add(processor); string output = ReadToEnd(reader); WriteIfDebugging(output); Assert.AreEqual("<Root />", output); Assert.AreEqual(1, processor.Calls); }
public async Task Catches_Too_Many_Records_Exception_And_Retries_With_Reduced_Batch_Size() { var largeRange = new BlockRange(0, 10); //expect the batch size to be reduced by half var smallerRange = new BlockRange(0, 5); //expect max of 10 blocks to be requested MockProgressService .Setup(s => s.GetNextBlockRangeToProcessAsync(MaxBlocksPerBatch)) .ReturnsAsync(largeRange); // mock a too-many-records exception MockProcessor .Setup(p => p.ProcessAsync(largeRange, It.IsAny <CancellationToken>())) .ThrowsAsync(new TooManyRecordsException()); //expect max of 5 blocks to be requested MockProgressService .Setup(s => s.GetNextBlockRangeToProcessAsync(5)) .ReturnsAsync(smallerRange); // mock a successfull process attempt MockProcessor .Setup(p => p.ProcessAsync(smallerRange, It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); // expect progress to be updated MockProgressService .Setup(s => s.SaveLastBlockProcessedAsync(smallerRange.To)) .Returns(Task.CompletedTask); var processedRange = await Service.ProcessOnceAsync(); Assert.Equal(smallerRange, processedRange.Value); Assert.Equal((ulong)5, Service.MaxNumberOfBlocksPerBatch); MockProcessor.Verify(); MockProgressService.Verify(); }
public async Task Requests_Range_Processes_And_Records_Progress() { var range = new BlockRange(0, 10); MockProgressService .Setup(s => s.GetNextBlockRangeToProcessAsync(MaxBlocksPerBatch)) .ReturnsAsync(range); MockProcessor .Setup(p => p.ProcessAsync(range, It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); MockProgressService .Setup(s => s.SaveLastBlockProcessedAsync(range.To)) .Returns(Task.CompletedTask); var processedRange = await Service.ProcessLatestBlocksAsync(); Assert.Equal(range, processedRange); MockProcessor.Verify(); MockProgressService.Verify(); }
public async Task Catches_Too_Many_Records_Exception_Will_Throw_If_Max_Blocks_Reaches_One() { var largeRange = new BlockRange(0, 10); var rangesAttempted = new List <BlockRange>(); MockProgressService .Setup(s => s.GetNextBlockRangeToProcessAsync(It.IsAny <uint>())) .Returns <uint>((newMax) => Task.FromResult(new BlockRange?(new BlockRange(0, newMax)))); // mock a too-many-records exception for every call MockProcessor .Setup(p => p.ProcessAsync(It.IsAny <BlockRange>(), It.IsAny <CancellationToken>())) .Callback <BlockRange, CancellationToken>((range, token) => rangesAttempted.Add(range)) .ThrowsAsync(new TooManyRecordsException()); await Assert.ThrowsAsync <TooManyRecordsException>(async() => await Service.ProcessOnceAsync()); Assert.Equal(10, rangesAttempted[0].To.Value); Assert.Equal(5, rangesAttempted[1].To.Value); Assert.Equal(2, rangesAttempted[2].To.Value); Assert.Equal(1, rangesAttempted[3].To.Value); Assert.Equal((uint)1, Service.MaxNumberOfBlocksPerBatch); }
public async Task Processes_Ranges_And_Waits_Until_Next_Range_Is_Available() { var mockWaitStategy = new Mock <IWaitStrategy>(); Service.WaitForBlockStrategy = mockWaitStategy.Object; var waits = new List <uint>(); var cancellationSource = new CancellationTokenSource(); var range1 = new BlockRange(0, 9); var nullRange = new BlockRange?(); var range2 = new BlockRange(10, 19); var rangeQueue = new Queue <BlockRange?>(); //initial range to process rangeQueue.Enqueue(range1); //simulate being up to date for 3 iterations rangeQueue.Enqueue(nullRange); rangeQueue.Enqueue(nullRange); rangeQueue.Enqueue(nullRange); //simulate new range becoming available rangeQueue.Enqueue(range2); //get next range from queue MockProgressService .Setup(s => s.GetNextBlockRangeToProcessAsync(MaxBlocksPerBatch)) .ReturnsAsync(() => rangeQueue.Dequeue()); //process range 1 MockProcessor .Setup(p => p.ProcessAsync(range1, It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); //when range is null expect wait strategy to be invoked mockWaitStategy .Setup(s => s.Apply(It.IsAny <uint>())) .Callback <uint>((attemptCount) => waits.Add(attemptCount)) .Returns(Task.CompletedTask); //process range 2 MockProcessor .Setup(p => p.ProcessAsync(range2, It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); //update progress range 1 MockProgressService .Setup(s => s.SaveLastBlockProcessedAsync(range1.To)) .Returns(Task.CompletedTask); //update progress range 2 MockProgressService .Setup(s => s.SaveLastBlockProcessedAsync(range2.To)) .Returns(Task.CompletedTask); //short circuit callback used to exit process var shortCircuit = new Action <uint, BlockRange>((rangesProcessed, lastRange) => { if (lastRange.Equals(range2)) { cancellationSource.Cancel(); } }); var blocksProcessed = await Service.ProcessContinuallyAsync( cancellationSource.Token, shortCircuit); Assert.Equal((ulong)20, blocksProcessed); Assert.Equal(3, waits.Count); //wait strategy is sent an attempt count so it can adjust wait time accordingly Assert.True(waits.SequenceEqual(new uint[] { 1, 2, 3 })); MockProcessor.Verify(); MockProgressService.Verify(); }