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);
}
