public void StepGeneratorCreatesOneScenarioOneStepTwoParametersAndOneRow() { IList <NodeFeature> features; features = new List <NodeFeature>(); //Add parameter 1 Parameter p1 = new Parameter(); p1.Name = "Parameter1"; p1.Type = "string"; p1.Value = "ValueOfParameter1"; //Add parameter 2 Parameter p2 = new Parameter(); p2.Name = "Parameter2"; p2.Type = "int"; p2.Value = "2"; //Add step NodeStep step1 = new NodeStep("GivenMethod1"); step1.Parameters.Add(p1); step1.Parameters.Add(p2); step1.Rows = new List <string[]> { new string[] { "a", "b", "c" } }; //Add scenario NodeScenario scenario1 = new NodeScenario("Scenario1"); scenario1.Steps.Add(step1); //Add feature NodeFeature feature1 = new NodeFeature("Feature1"); feature1.Scenarios.Add(scenario1); features.Add(feature1); var files = GeneratorFactory.Generate(GeneratorType.StepDefinitionGenerator, features); string[] stringsExpected = new string[] { "#include \"Feature1.h\"", "", "namespace CppUnitTest", "{", "\tvoid Feature1::GivenMethod1(std::vector<std::vector<std::string>> table, int rows, int cols, string Parameter1, int Parameter2)", "\t{", "\t\tAssert::Fail(L\"Pending implementation...\");", "\t}", "}" }; AssertExt.ContentsOfStringArray(stringsExpected, files[0]); }
public async Task ExistingQuestionCanBeDeleted(long id) { var response = await client.DeleteAsync($"{EndpointName}/{id}/"); AssertExt.EnsureSuccessStatusCode(response); var context = factory.GetService <TestCreationDbContext>(); var question = context.Questions.IgnoreQueryFilters().Where(x => x.QuestionId == id).FirstOrDefault(); Assert.AreEqual(true, question.IsDeleted); }
private async Task WhenAnyShouldBeCanceledIfFirstItemOfTheTasksIsCancledAsync() { var tcs = new TaskCompletionSource <object>(); Task.Delay(10).ContinueWith(_ => tcs.SetCanceled()); var t2 = Task.Delay(500); var r = await Task.WhenAny(tcs.Task, t2); AssertExt.AreSame(r, tcs.Task); }
public void It_should_allow_writing_more_documents() { var expected1 = new Fixture().Create <YamlOctopusModel>(); var expected2 = new Fixture().Create <YamlOctopusModel>(); var content = Write(expected1, expected2); var actual = new YamlSystemModelReader().Read(new MemoryStream(Encoding.UTF8.GetBytes(content))); Assert.That(actual.Length, Is.EqualTo(2)); AssertExt.AssertDeepEqualsTo(actual[0], expected1); AssertExt.AssertDeepEqualsTo(actual[1], expected2); }
public async Task WhenCartAndItemExists_DeletesAndReturnsSuccess(Guid cartId, Guid itemId) { this.repository.DeleteCartItem( Arg.Is <Guid>(p => p == cartId), Arg.Is <Guid>(p => p == itemId)).Returns(true); var result = await this.client.DeleteAsync($"/v1/carts/{cartId}/items/{itemId}"); AssertExt.ReturnsStatusCode_NoContent(result); await AssertExt.ReturnsEmptyContent(result); }
public async Task WhenCartOrItemDoesNotExist_ReturnsFailure(Guid cartId, Guid itemId) { this.repository.DeleteCartItem( Arg.Is <Guid>(p => p == cartId), Arg.Is <Guid>(p => p == itemId)).Returns(false); var result = await this.client.DeleteAsync($"/v1/carts/{cartId}/items/{itemId}"); AssertExt.ReturnsStatusCode_NotFound(result); await AssertExt.ReturnsEmptyContent(result); }
public async Task ExistingTestCanBeDeleted(long testId) { var response = await client.DeleteAsync($"{EndpointName}/{testId}/"); AssertExt.EnsureSuccessStatusCode(response); var context = factory.GetService <TestCreationDbContext>(); var test = context.Tests.IgnoreQueryFilters().FirstOrDefault(x => x.TestId == testId); Assert.AreEqual(true, test.IsDeleted); }
public async Task WhenQuantityIncorrect_ReturnsBadRequest( int quantity, Guid cartId, Guid itemId) { var result = await this.client.PutAsync( $"/v1/carts/{cartId}/items/{itemId}/quantity/{quantity}", null); AssertExt.ReturnsStatusCode_BadRequest(result); }
public void Repository_should_save_and_load_model() { var repository = new YamlSystemModelRepository(new NullLoggerFactory()); var expected = _fixture.Create <SystemModel>(); repository.Save(expected, _directory); var actual = repository.Load(_directory); AssertExt.AssertDeepEqualsTo(actual, expected); }
public async Task WhenItemEmpty_ReturnsBadRequest(Guid cartId) { this.repository.AddCartItem( Arg.Is <Guid>(p => p == cartId), Arg.Any <DataAccess.Models.Item>()).Returns(Guid.Empty); var result = await this.client.PostAsJsonAsync <Item>( $"/v1/carts/{cartId}/items", default); AssertExt.ReturnsStatusCode_BadRequest(result); }
public void TestBalanceWeights() { var weights = BalanceWeights(new[] { 0, 0, 1, 1 }); AssertExt.ArrayEqual(new[] { 1.0, 1.0, 1.0, 1.0 }, weights); weights = BalanceWeights(new[] { 0, 1, 1, 1, 1 }); AssertExt.ArrayEqual(new[] { 1.0, 0.25, 0.25, 0.25, 0.25 }, weights); weights = BalanceWeights(new[] { 0, 0 }); AssertExt.ArrayEqual(new[] { 1.0, 1.0 }, weights); }
public void ReplaceParameterTest_New() { var expression = CreateExpression(x => new { Value = x, x.Length }); var expected = GetDemoQuery() .Select(x => new { Value = x, x.Length }); var rdo = GetDemoQuery() .Select(expression); AssertExt.AreEqual(expected, rdo); }
public async Task QuestionsFromGivenCatalogCanBeRead(long catalogId) { var response = await client.GetAsync($"{EndpointName}/?catalogId={catalogId}"); AssertExt.EnsureSuccessStatusCode(response); var actualQuestions = response.GetContent <OffsetPagedResults <QuestionOnListDTO> >().Value; var context = factory.GetService <TestCreationDbContext>(); var expectedQuestions = context.Questions.Where(x => x.CatalogId == catalogId).ToList(); AssertExt.AreEquivalent(expectedQuestions, actualQuestions.Result); }
public async Task WhenHandlingAnything_ThenThrowsWellKnownException() { var handler = new ThrowsExceptionHandler(); var body = new byte[] { }; var headers = new Dictionary <string, string>(); var context = new ProcessingContext("", "", ""); await AssertExt.ThrowsAsync <JustForTestingException>( () => handler.ExecuteAsync(context, body, headers) ); }
public async Task CatalogCanBeRead(long catalogId) { var response = await client.GetAsync($"{EndpointName}/{catalogId}"); AssertExt.EnsureSuccessStatusCode(response); var catalog = response.GetContent <CatalogDTO>().Value; var context = factory.GetService <TestCreationDbContext>(); var expectedCatalog = context.QuestionsCatalogs.FirstOrDefault(x => x.CatalogId == catalogId); AssertExt.AreEquivalent(expectedCatalog, catalog); }
public async Task TestsCanBeReadForGivenOwner() { var response = await client.GetAsync($"{EndpointName}/?ownerId={TestUtils.OwnerId}"); AssertExt.EnsureSuccessStatusCode(response); var actualTests = response.GetContent <OffsetPagedResults <TestOnListDTO> >().Value; var context = factory.GetService <TestCreationDbContext>(); var expectedTests = context.Tests.Where(x => x.OwnerId == TestUtils.OwnerId).ToList(); AssertExt.AreEquivalent(expectedTests, actualTests.Result); }
public async Task TestCanBeRead(long testId) { var response = await client.GetAsync($"{EndpointName}/{testId}"); AssertExt.EnsureSuccessStatusCode(response); var actualTest = response.GetContent <TestDTO>().Value; var context = factory.GetService <TestCreationDbContext>(); var expectedTest = context.Tests.Include(x => x.Questions).ThenInclude(x => x.Question).FirstOrDefault(x => x.TestId == testId); AssertExt.AreEquivalent(expectedTest, actualTest); }
public async Task TestItemsCanBeReadForGivenTest(long testId) { var response = await client.GetAsync($"{EndpointName}/{testId}/questions/"); AssertExt.EnsureSuccessStatusCode(response); var actualTestItems = response.GetContent <List <TestItemDTO> >().Value; var context = factory.GetService <TestCreationDbContext>(); var expectedTest = context.Tests.Where(x => x.TestId == testId).Include(x => x.Questions).FirstOrDefault(); AssertExt.AreEquivalent(expectedTest.Questions, actualTestItems); }
public async Task TestItemCanBeDeleted(long testId, long questionItemId) { var response = await client.DeleteAsync($"{EndpointName}/{testId}/questions/{questionItemId}"); AssertExt.EnsureSuccessStatusCode(response); var context = factory.GetService <TestCreationDbContext>(); var test = context.Tests.Include(x => x.Questions).ThenInclude(x => x.Question).First(x => x.TestId == testId); var questionItem = test.Questions.FirstOrDefault(x => x.QuestionItemId == questionItemId); Assert.AreEqual(null, questionItem); }
public async Task WhenHandlingAnything_ThenDelaysTheSpecifiedDuration() { var duration = TimeSpan.FromSeconds(2); var handler = new LongRunningHandler(duration); var context = new ProcessingContext("", "", ""); var body = new byte[] { }; var headers = new Dictionary <string, string>(); await AssertExt.TaskRanForAtLeast(() => handler.ExecuteAsync(context, body, headers), duration); }
public async Task QuestionCanBeRead(long questionId) { var response = await client.GetAsync($"{EndpointName}/{questionId}/"); AssertExt.EnsureSuccessStatusCode(response); var actualQuestion = response.GetContent <QuestionWithAnswersDTO>().Value; var context = factory.GetService <TestCreationDbContext>(); var expectedQuestion = context.Questions.Include(x => x.Answers).FirstOrDefault(x => x.QuestionId == questionId); AssertExt.AreEquivalent(expectedQuestion, actualQuestion); }
public async Task Should_build_the_certificate_chain_when_root() { var caRoot = await File.ReadAllTextAsync("Content\\ca_root.pem"); var expected = caRoot; var client = new HttpClient(); var x509 = new X509ChainComposer(client); var result = await x509.ComposeChain(caRoot); AssertExt.Equal(expected, result.ToPem()); }
public void TestClassesShape() { foreach (var name in CLF_TREES) { // Classification, single output var clf = CreateClassifier <double>(name, random: new Random(0)); clf.Fit(X, y); Assert.AreEqual(1, clf.NClasses.Count); Assert.AreEqual(2U, clf.NClasses[0]); AssertExt.ArrayEqual(new [] { -1.0, 1.0 }, clf.Classes); } }
public void HandleRequest_NoMatchingSkillRequestHandler_ReturnsRequestContextFallbackResponse() { SkillResponse response = ResponseBuilder.Tell("Test"); RequestListener.SkillRequestHandlerFactory = new DefaultSkillRequestHandlerFactory(); RequestContext.FallbackResponse = response; SkillRequest request = new SkillRequest(); request.Request = new IntentRequest(); AssertExt.IsEmpty(RequestListener.SkillRequestHandlerFactory.SkillRequestHandlers); Assert.AreSame(response, RequestListener.HandleRequest(request, null)); }
public void ParseAdvancedGuidArray() { var jsonText = LoadTestInputFile("guid.json"); var watchReader = Stopwatch.StartNew(); var reader = new JSonReader(jsonText); var result = reader.ReadAsJSonObject(); watchReader.Stop(); Assert.IsNotNull(result); AssertExt.IsInstanceOf <Guid>(result[0].GuidValue, "Read element should be Guid"); Console.WriteLine("Parsing taken: {0}", watchReader.Elapsed); }
public async Task WhenCartExists_AddsItemAndReturnsSuccess(Guid cartId, Item item) { this.repository.AddCartItem( Arg.Is <Guid>(p => p == cartId), Arg.Any <DataAccess.Models.Item>()).Returns(item.Id); var result = await this.client.PostAsJsonAsync( $"/v1/carts/{cartId}/items", item); AssertExt.ReturnsStatusCode_Created(result); await AssertExt.ReturnsIdOfCreatedItem(item.Id, result); }
public async Task WhenCartDoesNotExist_ReturnsFailure(Guid cartId, Item item) { this.repository.AddCartItem( Arg.Is <Guid>(p => p == cartId), Arg.Any <DataAccess.Models.Item>()).Returns(Guid.Empty); var result = await this.client.PostAsJsonAsync( $"/v1/carts/{cartId}/items", item); AssertExt.ReturnsStatusCode_NotFound(result); await AssertExt.ReturnsEmptyContent(result); }
public async Task WhenCachedBlocksHitTripLevel_ThenStallsUntilWriteOperationSucceeds() { var blocks = new List <IList <BlockData> >(); Action <IReadOnlyCollection <BlockData>, CancellationToken> saveBlocks = (d, ct) => blocks.Add(d.ToList()); var failWrite = true; _writerMock .Setup(w => w.WriteAsync(It.IsAny <IReadOnlyCollection <BlockData> >(), It.IsAny <CancellationToken>())) .Returns(() => TaskHelpers.CreateCompletedTask(!Volatile.Read(ref failWrite))) .Callback(saveBlocks); var context = MockPartitionContext.CreateWithNoopCheckpoint("0"); await _processor.OpenAsync(context); // first N requests fail but go through (the first batch will not fill a frame so it won't result in a write operation) for (int i = 0; i < CircuitBreakerStallLevel + 1; i++) { var batch = new[] { CreateEventData((byte)('a' + i), MaxBlockSize - 200 - i), }; Task processTask = _processor.ProcessEventsAsync(context, batch); await AssertExt.CompletesBeforeTimeoutAsync(processTask, TimeoutInterval); } // N+1th stalls and waits for cached frames to be flushed { var batch = new[] { CreateEventData((byte)('a' + CircuitBreakerStallLevel + 2), 10), }; Task processTask = _processor.ProcessEventsAsync(context, batch); await AssertExt.DoesNotCompleteBeforeTimeoutAsync(processTask, TimeoutInterval); // let the write operation through Volatile.Write(ref failWrite, false); await AssertExt.CompletesBeforeTimeoutAsync(processTask, TimeoutInterval); // check the stalled entries were written var bufferedBlocks = blocks.Last(); Assert.Equal(CircuitBreakerStallLevel, bufferedBlocks.Count); for (int i = 0; i < CircuitBreakerStallLevel; i++) { var lines = GetPayloadsFromBlock(bufferedBlocks[i]); Assert.Equal(1, lines.Length); Assert.Equal( new string((char)('a' + i), MaxBlockSize - 200 - i), lines[0]); } } }
public async Task WhenSuccessfullyCreated_ReturnsId(Guid id) { // Given this.repository.CreateCart().Returns(id); // When var result = await this.client.PostAsJsonAsync( "/v1/carts", default(object)); // Then AssertExt.ReturnsStatusCode_Created(result); await AssertExt.ReturnsIdOfCreatedCart(id, result); }
private async Task WhenAnyShouldHaveExceptionIfFirstItemOfTheTasksGetErrorAsync() { var tcs = new TaskCompletionSource <object>(); var plannedException = new Exception("planned exception"); Task.Delay(10).ContinueWith(_ => tcs.SetException(plannedException)); var t2 = Task.Delay(500); var r = await Task.WhenAny(tcs.Task, t2); AssertExt.AreSame(r, tcs.Task); AssertExt.AreSame(r.Exception.InnerException, plannedException); Assert.AreEqual(1, r.Exception.InnerExceptions.Count); }