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