private static IDataReader MockReader(TestMetadata metadata)
{
var mock = new Mock <IDataReader>(MockBehavior.Strict);
mock.Setup(m => m.GetSchemaTable()).Returns(CreateTable(metadata));
return(mock.Object);
}
public void when_converting_to_a_storage_event_it_succeeds()
{
var id = Guid.NewGuid();
var body = new OrderCreated("TEST-ORDER");
var metadata = new TestMetadata {
Value = "TEST-VALUE"
};
var sut = new DocumentDbStorageEvent
{
StreamId = "TEST-STREAM",
Body = JObject.FromObject(body),
BodyType = "OrderCreated",
Metadata = JObject.FromObject(metadata),
MetadataType = "TestMetadata",
EventNumber = 1,
EventId = id
};
var typeMap = new ConfigurableSerializationTypeMap().RegisterTypes(
typeof(OrderCreated).GetTypeInfo().Assembly,
t => t.Namespace != null && t.Namespace.EndsWith("Events"),
t => t.Name);
var result = sut.ToStorageEvent(typeMap);
Assert.That(result.StreamId, Is.EqualTo(sut.StreamId));
Assert.That(((OrderCreated)result.EventBody).OrderId, Is.EqualTo(body.OrderId));
Assert.That(((TestMetadata)result.Metadata).Value, Is.EqualTo(metadata.Value));
Assert.That(result.EventNumber, Is.EqualTo(sut.EventNumber));
Assert.That(result.EventId, Is.EqualTo(sut.EventId));
}
public void MetadataBuilder_FromReader()
{
var metadata = new TestMetadata();
var test = new MetadataBuilder();
// Repeat build to ensure proper reset
for (int i = 0; i < 2; i++)
{
var reader = MockReader(metadata);
test.Build(reader);
}
var expected = metadata.Columns.OrderBy(c => c.Ordinal).ToArray();
var actual = test.Columns.OrderBy(c => c.Ordinal).ToArray();
// Dynamic complete testing for coverage
Assert.AreEqual(expected.Length, actual.Length);
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i].Name, actual[i].Name);
Assert.AreEqual(expected[i].Ordinal, actual[i].Ordinal);
Assert.AreEqual(expected[i].DataType, actual[i].DataType);
}
// Static partial testing just to be sure
Assert.AreEqual("StringColumn", actual[0].Name);
Assert.AreEqual(typeof(int), actual[1].DataType);
Assert.AreEqual(2, actual[2].Ordinal);
}
/// <summary>
/// Get the view content for a given razor file on disk
/// </summary>
/// <param name="org">The Organization code for the service owner</param>
/// <param name="service">The service code for the current service</param>
/// <param name="includeContent">Controls if the test content should be included. Default is false.</param>
/// /// <param name="filterPattern">Pattern to filter the returned tests</param>
/// <returns>All the tests</returns>
public IList <TestMetadata> GetTests(string org, string service, bool includeContent = false, string filterPattern = "*")
{
IList <TestMetadata> tests = new List <TestMetadata>();
string dirName = _settings.GetTestPath(org, service, AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext));
if (!Directory.Exists(dirName))
{
return(tests);
}
string[] files = Directory.GetFiles(dirName, filterPattern);
foreach (string filename in files)
{
var test = new TestMetadata
{
Name = Path.GetFileNameWithoutExtension(filename),
FileName = filename
};
if (includeContent)
{
test.Content = File.ReadAllText(filename);
}
tests.Add(test);
}
return(tests);
}
public CommandHandlerTester(
ICommandHandler <TCommand> handler)
{
this.handler = handler;
this.handlerMetadata = new TestMetadata(handler);
this.events = new List <object>();
}
public string GetName(TestMetadata metadata)
{
return(CalamariFixture.GetFixtureResource(
metadata.TestFixture.GetType(),
"Approved",
$"{metadata.TestFixture.GetType().Name}.{metadata.TestName}"
));
}
public string GetName(TestMetadata metadata)
{
var targetName = target.ToString().Replace(" ", "");
var dir = Path.GetDirectoryName(metadata.FilePath);
var filename = $"{metadata.TestFixture.GetType().Name}.{testName}.{targetName}";
return(Path.Combine(dir, "ApprovalFiles", filename));
}
public void GetMetadata_ReturnsMetadataAddedToCollection()
{
var metaadata = new TestMetadata();
m_Collection.AddMetadata(metaadata);
Assert.IsTrue(m_Collection.MetadataEntries.Contains(metaadata), "Expected metadata to be added to the List.");
Assert.AreEqual(metaadata, m_Collection.GetMetadata <TestMetadata>(), "Expected metadata to be returned when calling GetMetadata");
}
public void NameIsCorrect()
{
var metadata = new TestMetadata(this, "MyTest", @"c:\temp\source.cs");
Func <TestMetadata, string> namer = m => m.FilePath;
new DelegateNamer(namer)
.GetName(metadata)
.Should()
.Be(namer(metadata));
}
/// <summary>
/// Action for editing a specific test
/// </summary>
/// <param name="org">The service owner code</param>
/// <param name="service">The service code</param>
/// <param name="id">The name of the test</param>
/// <returns>The contents of the test identified by the given <paramref name="id"/></returns>
public IActionResult Edit(string org, string service, string id)
{
var meta = new TestMetadata
{
Name = id,
};
string test = _testingRepository.GetTest(org, service, id);
return(View(meta));
}
public void RemoveMetadata_RemovesMetadataFromCollection()
{
var metaadata = new TestMetadata();
m_Collection.AddMetadata(metaadata);
Assert.IsTrue(m_Collection.RemoveMetadata(metaadata), "Expected remove to return true when removing the metadata.");
Assert.IsFalse(m_Collection.RemoveMetadata(metaadata), "Expected remove to return false when the metadata was already removed.");
Assert.IsEmpty(m_Collection.MetadataEntries, "Expected a metadata to be removed.");
}
public void ReturnsFalseForMissingKey()
{
// Given
TestMetadata metadata = new TestMetadata();
// When
bool result = metadata.TryGetValue <object>("Foo", out object value);
// Then
result.ShouldBeFalse();
value.ShouldBeNull();
}
public virtual string GetName(TestMetadata metadata)
{
var dir = Path.GetDirectoryName(metadata.FilePath);
var filename = $"{metadata.TestFixture.GetType().Name}.{metadata.TestName}";
if (_postfix != null)
{
filename += "." + _postfix;
}
return(Path.Combine(dir, _subdirectory, filename));
}
public void EvaluatesSimpleScript()
{
// Given
TestExecutionContext context = new TestExecutionContext();
context.ScriptHelper = new ScriptHelper(context);
TestMetadata metadata = new TestMetadata();
// When
bool result = metadata.TryGetValue("=> 1 + 2", out int value);
// Then
result.ShouldBeTrue();
value.ShouldBe(3);
}
public void ReturnsObjectValue()
{
// Given
TestMetadata metadata = new TestMetadata()
{
{ "Foo", 2 }
};
// When
bool result = metadata.TryGetValue <object>("Foo", out object value);
// Then
result.ShouldBeTrue();
value.ShouldBeOfType <int>().ShouldBe(2);
}
public void ReturnsConvertedValue()
{
// Given
TestMetadata metadata = new TestMetadata()
{
{ "Foo", "2" }
};
// When
bool result = metadata.TryGetValue("Foo", out int value);
// Then
result.ShouldBeTrue();
value.ShouldBe(2);
}
public void ReturnsFalseIfNoConversion()
{
// Given
TestMetadata metadata = new TestMetadata()
{
{ "Foo", "abc" }
};
// When
bool result = metadata.TryGetValue("Foo", out TryGetValueTests value);
// Then
result.ShouldBeFalse();
value.ShouldBeNull();
}
public void EvaluatesSimpleScriptWhenConversionFails()
{
// Given
TestExecutionContext context = new TestExecutionContext();
context.ScriptHelper = new ScriptHelper(context);
TestMetadata metadata = new TestMetadata();
// When
bool result = metadata.TryGetValue("=> 1 + 2", out TryGetValueTests value);
// Then
result.ShouldBeFalse();
value.ShouldBeNull();
}
public async Task ToC_is_not_included_if_input_document_has_no_ToC_metadata()
{
// ARRANGE
var metadata = new TestMetadata();
var bootstrapper = CreateBootstrapper(DocsTemplateThemeNames.Default, "<p>Some Content</p>", metadata);
// ACT
var result = await bootstrapper.RunTestAsync();
// ASSERT
result.ExitCode.Should().Be(0);
GetHtmlOutput()
.QuerySelectorAll("#toc")
.Should().BeEmpty();
}
public IActionResult Create(string org, string service, TestMetadata test)
{
if (!ModelState.IsValid)
{
return(View("Create", test));
}
if (_testingRepository.UpdateTest(org, service, test))
{
return(RedirectToAction("Edit", new { org, service, id = test.Name }));
}
else
{
return(View("Create", test));
}
}
public async Task when_appending_to_a_new_stream_the_event_metadata_is_saved()
{
var streamId = Guid.NewGuid().ToString();
var subject = await GetEventStore();
var metadata = new TestMetadata {
Value = "Hello"
};
var @event = new EventData(Guid.NewGuid(), new OrderCreated(streamId), metadata);
await subject.AppendToStream(streamId, 0, @event);
var stream = await subject.ReadStreamForwards(streamId);
Assert.That(((TestMetadata)stream.Single().Metadata).Value, Is.EqualTo(metadata.Value));
}
public void EvaluatesScriptWithMetadataAccess()
{
// Given
TestExecutionContext context = new TestExecutionContext();
context.ScriptHelper = new ScriptHelper(context);
TestMetadata metadata = new TestMetadata()
{
{ "Foo", 3 }
};
// When
bool result = metadata.TryGetValue("=> 1 + (int)Foo", out int value);
// Then
result.ShouldBeTrue();
value.ShouldBe(4);
}
public void GetMetadatas_ReturnsMetadatasAddedToCollection()
{
var metaadata1 = new TestMetadata();
var metaadata2 = new TestMetadata();
m_Collection.AddMetadata(metaadata1);
m_Collection.AddMetadata(metaadata2);
var foundItems = m_Collection.GetMetadatas <TestMetadata>();
var providedList = new List <TestMetadata>();
m_Collection.GetMetadatas <TestMetadata>(providedList);
Assert.AreEqual(foundItems, providedList, "Expected GetMetadatas to return the same list for both versions of the function.");
Assert.AreEqual(2, foundItems.Count, "Expected found metadatas count to be 2, one for each metadata item.");
Assert.IsTrue(foundItems.Contains(metaadata1), "Expected metadata 1 to be in the found metadatas List.");
Assert.IsTrue(foundItems.Contains(metaadata2), "Expected metadata 1 to be in the found metadatas List.");
}
public void UsesAbsoluteLinkIfProvided(string value, bool includeHost, string expected)
{
// Given
TestExecutionContext context = new TestExecutionContext();
context.Settings[Keys.Host] = "domain.com";
TestMetadata metadata = new TestMetadata
{
{ "Path", value }
};
metadata.AddTypeConversion <string, FilePath>(x => new FilePath(x));
// When
string result = context.GetLink(metadata, "Path", includeHost);
// Then
result.ShouldBe(expected);
}
private static DataTable CreateTable(TestMetadata metadata)
{
var table = new DataTable();
for (int i = 0; i <= 12; i++)
{
table.Columns.Add(CreateColumn(i));
}
foreach (var column in metadata.Columns)
{
var row = table.NewRow();
row[ColumnNameIndex] = column.Name;
row[ColumnOrdinalIndex] = column.Ordinal;
row[DataTypeIndex] = column.DataType;
table.Rows.Add(row);
}
return(table);
}
/// <summary>
/// Create Test metadata for a service
/// </summary>
/// <param name="org">The Organization code for the service owner</param>
/// <param name="service">The service code for the current service</param>
/// <param name="test">The test metadata</param>
/// <returns>A boolean indicating if saving was ok</returns>
public bool UpdateTest(string org, string service, TestMetadata test)
{
string dirName = _settings.GetTestPath(org, service, AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext));
bool updated = false;
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
if (string.IsNullOrEmpty(test.FileName))
{
// TODO: Use type
test.FileName = test.Name + ".cs";
}
File.WriteAllText(dirName + test.FileName, test.Content ?? "");
updated = true;
return(updated);
}
/// <summary>
/// Запуск теста.
/// </summary>
/// <param name="metadata">Информация о тестовом методе.</param>
/// <param name="methods">Коллекции данных, содержащих информацию о методах типа.</param>
/// <param name="type">Тип, содержащий тестовые методы.</param>
/// <returns>Информация о результате выполнения теста.</returns>
private static ITestExecutionInfo RunTest(TestMetadata metadata, MethodsClassification methods, Type type)
{
try
{
CheckMethod(metadata.MethodInfo);
}
catch (IncorrectMethodException exception)
{
return(new IndefiniteTestExecutionInfo(GetFullName(metadata.MethodInfo, type), exception));
}
object instanceOfType = Activator.CreateInstance(type);
var beforeMethodException = ExecuteAuxiliaryMethods(methods.BeforeMethods, instanceOfType);
if (beforeMethodException != null)
{
return(new IndefiniteTestExecutionInfo(GetFullName(metadata.MethodInfo, type), beforeMethodException));
}
if (metadata.Attribute.Ignore != null)
{
var afterMethodExceptionIgnoreTest = ExecuteAuxiliaryMethods(methods.AfterMethods, instanceOfType);
if (afterMethodExceptionIgnoreTest != null)
{
return(new IndefiniteTestExecutionInfo(GetFullName(metadata.MethodInfo, type),
afterMethodExceptionIgnoreTest));
}
return(new IgnoreTestExecutionInfo(GetFullName(metadata.MethodInfo, type), metadata.Attribute.Ignore));
}
var stopwatch = new Stopwatch();
Exception testException = null;
bool isCaughtException = false;
try
{
stopwatch.Start();
metadata.MethodInfo.Invoke(instanceOfType, null);
}
catch (Exception exception)
{
isCaughtException = true;
if (metadata.Attribute.Expected != exception.InnerException.GetType())
{
testException = exception.InnerException;
}
}
finally
{
stopwatch.Stop();
}
if (metadata.Attribute.Expected != null && (!isCaughtException || testException != null))
{
testException = new ExpectedExceptionWasNotThrown();
}
var afterMethodException = ExecuteAuxiliaryMethods(methods.AfterMethods, instanceOfType);
if (afterMethodException != null)
{
return(new IndefiniteTestExecutionInfo(GetFullName(metadata.MethodInfo, type), afterMethodException));
}
return(new DefaultTestExecutionInfo(GetFullName(metadata.MethodInfo, type), stopwatch.ElapsedMilliseconds,
testException));
}
public string GetName(TestMetadata metadata)
{
return(_name);
}
public virtual string GetName(TestMetadata metadata)
{
var dir = Path.GetDirectoryName(metadata.FilePath);
return(Path.Combine(dir, $"{metadata.TestFixture.GetType().Name}.{metadata.TestName}"));
}
public override string GetName(TestMetadata metadata)
{
return(base.GetName(metadata) + "." + _postfix);
}
