protected override Task AssertOnAllResponses(Action <TResponse> assert)
{
if (!this.ExpectIsValid)
{
return(base.AssertOnAllResponses(assert));
}
return(base.AssertOnAllResponses((r) =>
{
if (TestClient.Configuration.RunIntegrationTests && !r.IsValid && r.ApiCall.OriginalException != null &&
!(r.ApiCall.OriginalException is ElasticsearchClientException))
{
ExceptionDispatchInfo.Capture(r.ApiCall.OriginalException.Demystify()).Throw();
return;
}
using (var scope = new AssertionScope())
{
assert(r);
var failures = scope.Discard();
if (failures.Length <= 0)
{
return;
}
var failure = failures[0];
scope.AddReportable("Failure", failure);
scope.AddReportable("DebugInformation", r.DebugInformation);
scope.FailWith($@"{{Failure}}
Response Under Test:
{{DebugInformation}}");
}
}));
}
private static void AreEqualImpl(
ScreenshotInfo expected,
Rectangle expectedRect,
ScreenshotInfo actual,
Bitmap actualBitmap,
Rectangle actualRect,
double expectedToActualScale,
PixelTolerance tolerance,
[CallerLineNumber] int line = 0)
{
using var assertionScope = new AssertionScope($"{expected.StepName}<=={actual}");
assertionScope.AddReportable("expectedRect", expectedRect.ToString());
assertionScope.AddReportable("actualRect", actualRect.ToString());
assertionScope.AddReportable("expectedToActualScale", expectedToActualScale.ToString(NumberFormatInfo.InvariantInfo));
var(areEqual, context) = EqualityCheck(expected, expectedRect, actual, actualBitmap, actualRect, expectedToActualScale, tolerance, line);
if (areEqual)
{
Console.WriteLine(context.ToString());
}
else
{
assertionScope.FailWithText(context);
}
}
private static AssertionScope StartAssertionScope(ProcessHelper processHelper)
{
var scope = new AssertionScope();
scope.AddReportable("Standard output", processHelper.StandardOutput);
scope.AddReportable("Error output", processHelper.ErrorOutput);
scope.AddReportable("Exit code", processHelper.Process.ExitCode.ToString());
return(scope);
}
public void AssertEquality(EquivalencyValidationContext context)
{
using var scope = new AssertionScope();
scope.AddReportable("configuration", config.ToString());
scope.BecauseOf(context.Because, context.BecauseArgs);
AssertEqualityUsing(context);
if (context.Tracer != null)
{
scope.AddReportable("trace", context.Tracer.ToString());
}
}
public void AssertEquality(Comparands comparands, EquivalencyValidationContext context)
{
using var scope = new AssertionScope();
scope.AssumeSingleCaller();
scope.AddReportable("configuration", context.Options.ToString());
scope.BecauseOf(context.Reason);
RecursivelyAssertEquality(comparands, context);
if (context.TraceWriter is not null)
{
scope.AddReportable("trace", context.TraceWriter.ToString());
}
}
public AndConstraint <ServiceCollectionAssertions> BeRegistered(Type serviceType, Type implementationType, ServiceLifetime lifetime, string because = "", params object[] becauseArgs)
{
AssertionScope scope = Execute.Assertion;
scope.AddReportable("lifetime", lifetime.ToString().ToLowerInvariant());
scope
.BecauseOf(because, becauseArgs)
.WithExpectation("Expected {context:service collection} to contain a {lifetime} registration for {0} implemented by {1}{reason}, ", serviceType, implementationType)
// Match service and lifetime
.Given(() => Subject.Where(d => d.ServiceType == serviceType))
.ForCondition(reg => reg.Any())
.FailWith("but the service was not found.")
.Then
.ForCondition(reg => reg.Any(d => d.Lifetime == lifetime))
.FailWith("but found {0}.", reg => reg.Select(d => d.Lifetime).Distinct())
.Then
.Given(reg => reg.FirstOrDefault(d => d.Lifetime == lifetime))
.ForCondition(r =>
// Match implementation, instance or factory
r.ImplementationType == implementationType ||
r.ImplementationInstance != null && implementationType.IsInstanceOfType(r.ImplementationInstance) ||
r.ImplementationFactory != null
)
.FailWith("but it does not.")
;
return(new AndConstraint <ServiceCollectionAssertions>(this));
}
private void RunWithDiagnosticAnnotations(string bicepText, Func <IDiagnostic, bool> filterFunc, OnCompileErrors onCompileErrors, Action <IEnumerable <IDiagnostic> > assertAction)
{
using (AssertionScope scope = new AssertionScope())
{
scope.AddReportable("bicep code", bicepText);
var result = CompilationHelper.Compile(bicepText);
result.Should().NotHaveDiagnosticsWithCodes(new[] { LinterAnalyzer.LinterRuleInternalError }, "There should never be linter LinterRuleInternalError errors");
if (onCompileErrors == OnCompileErrors.Fail)
{
var compileErrors = result.Diagnostics.Where(d => d.Level == DiagnosticLevel.Error);
DiagnosticAssertions.DoWithDiagnosticAnnotations(
result.Compilation.SourceFileGrouping.EntryPoint,
compileErrors,
diags => diags.Should().HaveCount(0));
}
IDiagnostic[] diagnosticsMatchingCode = result.Diagnostics.Where(filterFunc).ToArray();
DiagnosticAssertions.DoWithDiagnosticAnnotations(
result.Compilation.SourceFileGrouping.EntryPoint,
result.Diagnostics.Where(filterFunc),
assertAction);
}
}
public async Task Working()
{
using var helper = await StartConsole(enableProfiler : true);
var processInfo = ProcessInfo.GetProcessInfo(helper.Process.Id);
processInfo.Should().NotBeNull();
using var console = ConsoleHelper.Redirect();
var result = ProcessBasicCheck.Run(processInfo, MockRegistryService(Array.Empty <string>(), ProfilerPath));
using var scope = new AssertionScope();
scope.AddReportable("Output", console.Output);
result.Should().BeTrue();
console.Output.Should().NotContainAny(
ProfilerNotLoaded,
TracerNotLoaded,
"DD_DOTNET_TRACER_HOME",
CorProfilerKey,
CorEnableKey,
CorProfilerPathKey,
CorProfilerPath32Key,
CorProfilerPath64Key);
}
public void EmptyCommand()
{
bool callbackInvoked = false;
Program.CallbackForTests = (_, _, _) =>
{
callbackInvoked = true;
};
// CI visibility mode checks if there's a running agent
using var agent = EnableCiVisibilityMode ? new MockTracerAgent(TcpPortProvider.GetOpenPort()) : null;
var agentUrl = $"http://localhost:{agent?.Port ?? 1111}";
// dd-env is an argument for the target application and therefore shouldn't set the DD_ENV variable
var commandLine = $"{CommandPrefix} --tracer-home dummyFolder --agent-url {agentUrl}";
using var console = ConsoleHelper.Redirect();
var exitCode = Program.Main(commandLine.Split(' '));
using var scope = new AssertionScope();
scope.AddReportable("output", console.Output);
exitCode.Should().Be(1);
callbackInvoked.Should().BeFalse();
console.Output.Should().Contain("Error: Missing command");
}
public void When_message_starts_with_two_single_braces_they_should_be_replaced_with_context()
{
// Arrange
var scope = new AssertionScope();
scope.AddReportable("SomeKey", "SomeValue");
scope.AddReportable("AnotherKey", "AnotherValue");
AssertionScope.Current.FailWith("{SomeKey}{AnotherKey}");
// Act
Action act = scope.Dispose;
// Assert
act.Should().ThrowExactly <XunitException>()
.WithMessage("*SomeValue*AnotherValue*");
}
public void Message_should_have_reportable_values_appended_at_the_end()
{
// Arrange
var scope = new AssertionScope();
scope.AddReportable("SomeKey", "SomeValue");
scope.AddReportable("AnotherKey", "AnotherValue");
AssertionScope.Current.FailWith("{SomeKey}{AnotherKey}");
// Act
Action act = scope.Dispose;
// Assert
act.Should().ThrowExactly <XunitException>()
.WithMessage("*With SomeKey:\nSomeValue\nWith AnotherKey:\nAnotherValue");
}
/// <summary>
/// Prints the entire program syntax with line numbers if a test fails in the given assertion scope.
/// </summary>
public static AssertionScope WithFullSource(this AssertionScope assertionScope, BicepFile bicepFile)
{
assertionScope.AddReportable(
"source",
() => PrintHelper.PrintFullSource(bicepFile, 1, true));
return(assertionScope);
}
public void Message_should_have_named_placeholders_be_replaced_by_reportable_values()
{
// Arrange
var scope = new AssertionScope();
scope.AddReportable("SomeKey", "SomeValue");
scope.AddReportable("AnotherKey", "AnotherValue");
AssertionScope.Current.FailWith("{SomeKey}{AnotherKey}");
// Act
Action act = scope.Dispose;
// Assert
act.Should().ThrowExactly <XunitException>()
.WithMessage("SomeValueAnotherValue*");
}
public void AssertEquality(EquivalencyValidationContext context)
{
using (var scope = new AssertionScope())
{
scope.AddReportable("configuration", config.ToString());
scope.AddNonReportable("objects", new CyclicReferenceDetector(config.CyclicReferenceHandling));
scope.BecauseOf(context.Because, context.BecauseArgs);
AssertEqualityUsing(context);
if (context.Tracer != null)
{
scope.AddReportable("trace", context.Tracer.ToString());
}
}
}
public static AssertionScope WithAnnotatedSource(AssertionScope assertionScope, BicepFile bicepFile, string contextName, IEnumerable <PrintHelper.Annotation> annotations)
{
assertionScope.AddReportable(
contextName,
() => PrintHelper.PrintWithAnnotations(bicepFile, annotations, 1, true));
return(assertionScope);
}
public static AssertionScope WithAnnotatedSource(AssertionScope assertionScope, BicepFile bicepFile, string contextName, IEnumerable <PrintHelper.Annotation> annotations)
{
// TODO: figure out how to set this only on failure, rather than always calculating it
assertionScope.AddReportable(
contextName,
PrintHelper.PrintWithAnnotations(bicepFile, annotations, 1, true));
return(assertionScope);
}
public void Run()
{
string command = null;
string arguments = null;
Dictionary <string, string> environmentVariables = null;
bool callbackInvoked = false;
Program.CallbackForTests = (c, a, e) =>
{
command = c;
arguments = a;
environmentVariables = e;
callbackInvoked = true;
};
// CI visibility mode checks if there's a running agent
using var agent = EnableCiVisibilityMode ? new MockTracerAgent(TcpPortProvider.GetOpenPort()) : null;
var agentUrl = $"http://localhost:{agent?.Port ?? 1111}";
var commandLine = $"{CommandPrefix} test.exe --dd-env TestEnv --dd-service TestService --dd-version TestVersion --tracer-home TestTracerHome --agent-url {agentUrl} --set-env VAR1=A --set-env VAR2=B";
using var console = ConsoleHelper.Redirect();
var exitCode = Program.Main(commandLine.Split(' '));
using var scope = new AssertionScope();
scope.AddReportable("output", console.Output);
exitCode.Should().Be(0);
callbackInvoked.Should().BeTrue();
command.Should().Be("test.exe");
arguments.Should().BeNullOrEmpty();
environmentVariables.Should().NotBeNull();
environmentVariables.Should().Contain("DD_ENV", "TestEnv");
environmentVariables.Should().Contain("DD_SERVICE", "TestService");
environmentVariables.Should().Contain("DD_VERSION", "TestVersion");
environmentVariables.Should().Contain("DD_DOTNET_TRACER_HOME", "TestTracerHome");
environmentVariables.Should().Contain("DD_TRACE_AGENT_URL", agentUrl);
environmentVariables.Should().Contain("VAR1", "A");
environmentVariables.Should().Contain("VAR2", "B");
if (EnableCiVisibilityMode)
{
environmentVariables.Should().Contain("DD_CIVISIBILITY_ENABLED", "1");
}
else
{
environmentVariables.Should().NotContainKey("DD_CIVISIBILITY_ENABLED");
}
}
public void AssertEquality(EquivalencyValidationContext context)
{
using (var scope = new AssertionScope())
{
scope.AddReportable("configuration", config.ToString());
scope.AddNonReportable("objects", new ObjectTracker(config.CyclicReferenceHandling));
scope.BecauseOf(context.Reason, context.ReasonArgs);
AssertEqualityUsing(context);
}
}
public void AssertEquality(EquivalencyValidationContext context)
{
using (var scope = new AssertionScope())
{
scope.AddReportable("configuration", config.ToString());
scope.AddNonReportable("objects", new ObjectTracker(config.CyclicReferenceHandling));
scope.BecauseOf(context.Reason, context.ReasonArgs);
AssertEqualityUsing(context);
}
}
public static void DoWithDiagnosticAnnotations(SyntaxTree syntaxTree, IEnumerable <Diagnostic> diagnostics, Action <IEnumerable <Diagnostic> > action)
{
using (var scope = new AssertionScope())
{
scope.AddReportable("diagnostics", PrintHelper.PrintWithAnnotations(
syntaxTree,
diagnostics.Select(x => new PrintHelper.Annotation(x.Span, $"[{x.Code} ({x.Level})] {x.Message}")),
1,
true));
action(diagnostics);
}
}
private static IAssertionScope CreateAssertionScopeWithContext(SyntaxTree syntaxTree, Hover?hover, IPositionable requestedPosition)
{
var assertionScope = new AssertionScope();
// TODO: figure out how to set this only on failure, rather than always calculating it
assertionScope.AddReportable(
"hover context",
PrintHelper.PrintWithAnnotations(syntaxTree, new [] {
new PrintHelper.Annotation(requestedPosition.Span, "cursor position"),
}, 1, true));
return(assertionScope);
}
private ConsoleHelper()
{
_output = new StringBuilder();
_originalConsole = AnsiConsole.Console;
_originalTextWriter = Console.Out;
_assertionScope = new AssertionScope();
_assertionScope.AddReportable("output", () => _output.ToString());
AnsiConsole.Console = AnsiConsole.Create(new AnsiConsoleSettings {
Out = new RedirectedOutput(_output)
});
Console.SetOut(new StringWriter(_output));
}
public static AndConstraint <GenericCollectionAssertions <T> > NotContainEquivalentOf <T>(
this GenericCollectionAssertions <T> assert,
T expectation,
Func <EquivalencyAssertionOptions <T>, EquivalencyAssertionOptions <T> > config,
string because = "",
params object[] becauseArgs)
{
if (ReferenceEquals(assert.Subject, null))
{
return(new AndConstraint <GenericCollectionAssertions <T> >(assert));
}
IEquivalencyAssertionOptions options = config(AssertionOptions.CloneDefaults <T>());
IEnumerable <object> actualItems = assert.Subject.Cast <object>();
using (var scope = new AssertionScope())
{
scope.AddReportable("configuration", options.ToString());
foreach (var actualItem in actualItems)
{
var context = new EquivalencyValidationContext
{
Subject = actualItem,
Expectation = expectation,
CompileTimeType = typeof(T),
Because = because,
BecauseArgs = becauseArgs,
Tracer = options.TraceWriter,
};
var equivalencyValidator = new EquivalencyValidator(options);
equivalencyValidator.AssertEquality(context);
var failures = scope.Discard();
if (!failures.Any())
{
Execute.Assertion
.BecauseOf(because, becauseArgs)
.FailWith("Expected {context:collection} {0} to not contain equivalent of {1}.", assert.Subject, expectation);
break;
}
}
}
return(new AndConstraint <GenericCollectionAssertions <T> >(assert));
}
private void CompileAndTest(string bicepText, string[] expectedFoundMessages)
{
using (var scope = new AssertionScope())
{
scope.AddReportable("bicepText", bicepText);
var result = CompilationHelper.Compile(bicepText);
var semanticModel = result.Compilation.GetEntrypointSemanticModel();
// Look for an output - that's what we'll use in the test
var output = result.BicepFile.ProgramSyntax.Children.OfType <OutputDeclarationSyntax>()
.Should().HaveCount(1, "Each testcase should contain a single output with an expression to test")
.And.Subject.First();
var secrets = FindPossibleSecretsVisitor.FindPossibleSecrets(semanticModel, output.Value);
secrets.Select(s => s.FoundMessage).Should().BeEquivalentTo(expectedFoundMessages);
}
}
public void Deferred_reportable_values_should_not_be_calculated_in_absence_of_failures()
{
// Arrange
var scope = new AssertionScope();
var deferredValueInvoked = false;
scope.AddReportable("MyKey", () =>
{
deferredValueInvoked = true;
return("MyValue");
});
// Act
scope.Dispose();
// Assert
deferredValueInvoked.Should().BeFalse();
}
public void When_using_a_deferred_reportable_value_it_is_not_calculated_if_there_are_no_failures()
{
// Arrange
var scope = new AssertionScope();
var deferredValueInvoked = false;
scope.AddReportable("MyKey", () =>
{
deferredValueInvoked = true;
return("MyValue");
});
// Act
scope.Dispose();
// Assert
deferredValueInvoked.Should().BeFalse();
}
public async Task String_segments_do_not_return_completions()
{
var fileWithCursors = @"
var completeString = |'he|llo'|
var interpolatedString = |'abc${|true}|de|f${|false}|gh|i'|
var multilineString = |'''|
hel|lo
'''|
";
var bicepFile = fileWithCursors.Replace("|", "");
var syntaxTree = SyntaxTree.Create(new Uri("file:///main.bicep"), bicepFile);
var cursors = new List <int>();
for (var i = 0; i < fileWithCursors.Length; i++)
{
if (fileWithCursors[i] == '|')
{
cursors.Add(i - cursors.Count);
}
}
using var client = await IntegrationTestHelper.StartServerWithTextAsync(bicepFile, syntaxTree.FileUri, resourceTypeProvider : TypeProvider);
foreach (var cursor in cursors)
{
using var assertionScope = new AssertionScope();
assertionScope.AddReportable(
"completion context",
PrintHelper.PrintWithAnnotations(syntaxTree, new [] {
new PrintHelper.Annotation(new TextSpan(cursor, 0), "cursor position"),
}, 1, true));
var completions = await client.RequestCompletion(new CompletionParams
{
TextDocument = new TextDocumentIdentifier(syntaxTree.FileUri),
Position = TextCoordinateConverter.GetPosition(syntaxTree.LineStarts, cursor),
});
completions.Should().BeEmpty();
}
}
public virtual string GenerateAndTestSource(string generatedCodeName, string inputSource, string?outputPath = null, bool isExe = false)
{
var outputFileName = GetOutputFileName(outputPath, generatedCodeName, IsVB);
using var assertionScope = new AssertionScope(outputFileName);
assertionScope.AddReportable("OutputFileName", outputFileName);
Compilation cliRootCompilation = GetCliRootCompilation(inputSource, isExe)
?? throw new InvalidOperationException();
var requestedSyntaxTree = Generate(cliRootCompilation, out var outputCompilation, out var generationDiagnostics)
.Where(x => x.compilationName.Contains($"{generatedCodeName}.generated"))
.Select(x => x.syntaxTree)
.FirstOrDefault();
ReportDiagnostics(generatedCodeName, generationDiagnostics, outputCompilation);
OutputIfRequested(outputFileName, requestedSyntaxTree);
return(requestedSyntaxTree is null
? "Compilation is null"
: requestedSyntaxTree.ToString());
public void When_message_starts_with_single_braces_they_should_be_replaced_with_context()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var scope = new AssertionScope();
scope.AddReportable("MyKey", "MyValue");
AssertionScope.Current.FailWith("{MyKey}");
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = scope.Dispose;
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act.Should().ThrowExactly <XunitException>()
.WithMessage("*MyValue*");
}
public void AdditionalArguments()
{
string command = null;
string arguments = null;
Dictionary <string, string> environmentVariables = null;
bool callbackInvoked = false;
Program.CallbackForTests = (c, a, e) =>
{
command = c;
arguments = a;
environmentVariables = e;
callbackInvoked = true;
};
// CI visibility mode checks if there's a running agent
using var agent = EnableCiVisibilityMode ? new MockTracerAgent(TcpPortProvider.GetOpenPort()) : null;
var agentUrl = $"http://localhost:{agent?.Port ?? 1111}";
// dd-env is an argument for the target application and therefore shouldn't set the DD_ENV variable
var commandLine = $"{CommandPrefix} --tracer-home dummyFolder --agent-url {agentUrl} -- test.exe --dd-env test";
using var console = ConsoleHelper.Redirect();
var exitCode = Program.Main(commandLine.Split(' '));
using var scope = new AssertionScope();
scope.AddReportable("output", console.Output);
exitCode.Should().Be(0);
callbackInvoked.Should().BeTrue();
command.Should().Be("test.exe");
arguments.Should().Be("--dd-env test");
environmentVariables.Should().NotContainKey("DD_ENV");
}
public void Message_should_have_named_placeholder_be_replaced_by_defered_reportable_value()
{
// Arrange
var scope = new AssertionScope();
var deferredValueInvoked = false;
scope.AddReportable("MyKey", () =>
{
deferredValueInvoked = true;
return("MyValue");
});
AssertionScope.Current.FailWith("{MyKey}");
// Act
Action act = scope.Dispose;
// Assert
act.Should().ThrowExactly <XunitException>()
.WithMessage("MyValue*\n\nWith MyKey:\nMyValue\n");
deferredValueInvoked.Should().BeTrue();
}
