Skip to content

Commit

Permalink
chore: fix code/yaml warnings (#169)
Browse files Browse the repository at this point in the history 
* chore: fix code/yaml warnings

* pr-fix: correct sdk version

* pr-fix: correct sdk version

* pr-fix: add 'missingVarLog'

* pr-fix: use new inputs

* Update PollTests.cs

* pr-fix: more clear timeout/interval in polling tests
  • Loading branch information
@stijnmoreels
stijnmoreels authored Aug 2, 2024
1 parent 03328d0 commit 1fb9a6b
Show file tree
Hide file tree
Showing 4 changed files with 80 additions and 68 deletions.
85 changes: 49 additions & 36 deletions src/Arcus.Testing.Tests.Unit/Core/PollTests.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,7 +11,7 @@ namespace Arcus.Testing.Tests.Unit.Core
{
public class PollTests
{
private readonly TimeSpan _1s = TimeSpan.FromSeconds(1), _10ms = TimeSpan.FromMilliseconds(10);
private readonly TimeSpan _2s = TimeSpan.FromSeconds(2), _100ms = TimeSpan.FromMilliseconds(100);
private readonly object _expectedResult = Bogus.PickRandom((object) Bogus.Random.Int(), Bogus.Random.AlphaNumeric(10));

private static readonly Faker Bogus = new();
Expand All @@ -20,68 +20,68 @@ public class PollTests
public async Task PollAsync_WithTargetAvailableWithinTimeFrame_SucceedsByContinuing()
{
await Poll.UntilAvailableAsync(AlwaysSucceedsAsync);
await Poll.UntilAvailableAsync(SometimesSucceedsAsync, MinTimeFrame);
await Poll.UntilAvailableAsync(SometimesSucceedsAsync, ReasonableTimeFrame);
await Poll.UntilAvailableAsync<InvalidOperationException>(AlwaysSucceedsAsync);
await Poll.UntilAvailableAsync<TestPollException>(SometimesSucceedsAsync, MinTimeFrame);
await Poll.UntilAvailableAsync<TestPollException>(SometimesSucceedsAsync, ReasonableTimeFrame);

await Poll.Target(AlwaysSucceedsAsync);
await Poll.Target(SometimesSucceedsAsync).MinTimeFrame();
await Poll.Target(SometimesSucceedsAsync).ReasonableTimeFrame();
await Poll.Target<ArrayTypeMismatchException>(AlwaysSucceedsAsync);
await Poll.Target<TestPollException>(SometimesSucceedsAsync).MinTimeFrame();
await Poll.Target<TestPollException>(SometimesSucceedsAsync).ReasonableTimeFrame();

await GetsResultAsync(() => Poll.UntilAvailableAsync(AlwaysSucceedsResultAsync));
await GetsResultAsync(() => Poll.UntilAvailableAsync(SometimesSucceedsResultAsync, MinTimeFrame));
await GetsResultAsync(() => Poll.UntilAvailableAsync(SometimesSucceedsResultAsync, ReasonableTimeFrame));
await GetsResultAsync(() => Poll.UntilAvailableAsync<object, AggregateException>(AlwaysSucceedsResultAsync));
await GetsResultAsync(() => Poll.UntilAvailableAsync<object, TestPollException>(SometimesSucceedsResultAsync, MinTimeFrame));
await GetsResultAsync(() => Poll.UntilAvailableAsync<object, TestPollException>(SometimesSucceedsResultAsync, ReasonableTimeFrame));

await GetsResultAsync(async () => await Poll.Target(AlwaysSucceedsResultAsync));
await GetsResultAsync(async () => await Poll.Target(SometimesSucceedsResultAsync).MinTimeFrame());
await GetsResultAsync(async () => await Poll.Target(SometimesSucceedsResultAsync).LowestTimeFrame());
await GetsResultAsync(async () => await Poll.Target<object, DllNotFoundException>(AlwaysSucceedsResultAsync));
await GetsResultAsync(async () => await Poll.Target<object, TestPollException>(SometimesSucceedsResultAsync).MinTimeFrame());
await GetsResultAsync(async () => await Poll.Target<object, TestPollException>(SometimesSucceedsResultAsync).LowestTimeFrame());
}

[Fact]
public async Task PollSync_WithTargetAvailableWithinTimeFrame_SucceedsByContinuing()
{
await Poll.Target(AlwaysSucceeds);
await Poll.Target(SometimesSucceeds).MinTimeFrame();
await Poll.Target(SometimesSucceeds).ReasonableTimeFrame();
await Poll.Target<ArrayTypeMismatchException>(AlwaysSucceeds);
await Poll.Target<TestPollException>(SometimesSucceeds).MinTimeFrame();
await Poll.Target<TestPollException>(SometimesSucceeds).ReasonableTimeFrame();

await GetsResultAsync(async () => await Poll.Target(AlwaysSucceedsResult));
await GetsResultAsync(async () => await Poll.Target(SometimesSucceedsResult).MinTimeFrame());
await GetsResultAsync(async () => await Poll.Target(SometimesSucceedsResult).ReasonableTimeFrame());
await GetsResultAsync(async () => await Poll.Target<object, DllNotFoundException>(AlwaysSucceedsResult));
await GetsResultAsync(async () => await Poll.Target<object, TestPollException>(SometimesSucceedsResult).MinTimeFrame());
await GetsResultAsync(async () => await Poll.Target<object, TestPollException>(SometimesSucceedsResult).ReasonableTimeFrame());
}

[Fact]
public async Task Poll_WithTargetRemainsUnavailableWithinTimeFrame_FailsWithDescription()
{
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync(AlwaysFailsAsync, MinTimeFrame));
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync(AlwaysFailsResultAsync, MinTimeFrame));
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync<TestPollException>(AlwaysFailsAsync, MinTimeFrame));
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync<object, TestPollException>(AlwaysFailsResultAsync, MinTimeFrame));

await FailsByExceptionAsync(async () => await Poll.Target(AlwaysFailsAsync).MinTimeFrame());
await FailsByExceptionAsync(async () => await Poll.Target(AlwaysFailsResultAsync).Until(AlwaysTrue).MinTimeFrame());
await FailsByExceptionAsync(async () => await Poll.Target<TestPollException>(AlwaysFailsAsync).MinTimeFrame());
await FailsByExceptionAsync(async () => await Poll.Target<object, TestPollException>(AlwaysFailsResultAsync).Until(AlwaysTrue).MinTimeFrame());
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync(AlwaysFailsAsync, LowestTimeFrame));
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync(AlwaysFailsResultAsync, LowestTimeFrame));
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync<TestPollException>(AlwaysFailsAsync, LowestTimeFrame));
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync<object, TestPollException>(AlwaysFailsResultAsync, LowestTimeFrame));

await FailsByExceptionAsync(async () => await Poll.Target(AlwaysFailsAsync).LowestTimeFrame());
await FailsByExceptionAsync(async () => await Poll.Target(AlwaysFailsResultAsync).Until(AlwaysTrue).LowestTimeFrame());
await FailsByExceptionAsync(async () => await Poll.Target<TestPollException>(AlwaysFailsAsync).LowestTimeFrame());
await FailsByExceptionAsync(async () => await Poll.Target<object, TestPollException>(AlwaysFailsResultAsync).Until(AlwaysTrue).LowestTimeFrame());
}

[Fact]
public async Task Poll_WithDiffExceptionThanUnavailableTarget_FailsDirectlyWithDescription()
{
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync<InvalidOperationException>(AlwaysFailsAsync, MinTimeFrame));
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync<object, FileNotFoundException>(AlwaysFailsResultAsync, MinTimeFrame));
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync<InvalidOperationException>(AlwaysFailsAsync, LowestTimeFrame));
await FailsByExceptionAsync(() => Poll.UntilAvailableAsync<object, FileNotFoundException>(AlwaysFailsResultAsync, LowestTimeFrame));

await FailsByExceptionAsync(async () => await Poll.Target<AggregateException>(AlwaysFailsAsync).MinTimeFrame());
await FailsByExceptionAsync(async () => await Poll.Target<object, ApplicationException>(AlwaysFailsResultAsync).MinTimeFrame());
await FailsByExceptionAsync(async () => await Poll.Target<AggregateException>(AlwaysFailsAsync).LowestTimeFrame());
await FailsByExceptionAsync(async () => await Poll.Target<object, ApplicationException>(AlwaysFailsResultAsync).LowestTimeFrame());
}

[Fact]
public async Task PollFailure_WithoutResult_ShouldFail()
{
await Assert.ThrowsAsync<TimeoutException>(() => Poll.UntilAvailableAsync(async () => await AlwaysFailsAsync(), MinTimeFrame));
await Assert.ThrowsAsync<TimeoutException>(() => Poll.UntilAvailableAsync(async () => await AlwaysFailsAsync(), LowestTimeFrame));
}

[Fact]
Expand Down Expand Up @@ -113,15 +113,15 @@ public async Task Poll_WithNegativeUntilTargetPredicate_FailsWithDescription()
// Act / Assert
await FailsByResultAsync(async () =>
await Poll.Target(AlwaysSucceedsResultAsync)
.MinTimeFrame()
.LowestTimeFrame()
.Until(AlwaysTrue)
.Until(AlwaysFalse)
.Until(AlwaysTrue)
.FailWith(expected), errorParts: expected);

await FailsByResultAsync(async () =>
await Poll.Target<object, TestPollException>(AlwaysSucceedsResultAsync)
.MinTimeFrame()
.LowestTimeFrame()
.Until(AlwaysTrue)
.Until(AlwaysFalse)
.Until(AlwaysTrue)
Expand All @@ -145,20 +145,26 @@ private Action<PollOptions> WithMessage(string message)
return options =>
{
options.FailureMessage = message;
MinTimeFrame(options);
LowestTimeFrame(options);
};
}

private void MinTimeFrame(PollOptions options)
private void ReasonableTimeFrame(PollOptions options)
{
options.Timeout = _1s;
options.Interval = _10ms;
options.Timeout = _2s;
options.Interval = _100ms;
}

private void LowestTimeFrame(PollOptions options)
{
options.Timeout = _100ms;
options.Interval = TimeSpan.FromMilliseconds(10);
}

private static bool AlwaysTrue(object result) => true;
private static bool AlwaysFalse(object result) => false;
private static Task AlwaysFailsAsync() => throw new TestPollException();
private static void AlwaysSucceeds() { }
private static void AlwaysSucceeds() { /*Nothing here: explicitly ignore*/ }
private object AlwaysSucceedsResult() => _expectedResult;
private static Task<object> AlwaysFailsResultAsync() => throw new TestPollException();
private static Task AlwaysSucceedsAsync() => Task.CompletedTask;
Expand Down Expand Up @@ -266,11 +272,18 @@ public void Set_BlankFailureMessage_Fails(string blank)

public static class PollExtensions
{
public static Poll<TResult, TException> MinTimeFrame<TResult, TException>(
public static Poll<TResult, TException> ReasonableTimeFrame<TResult, TException>(
this Poll<TResult, TException> poll)
where TException : Exception
{
return poll.Every(TimeSpan.FromMilliseconds(100)).Timeout(TimeSpan.FromSeconds(2));
}

public static Poll<TResult, TException> LowestTimeFrame<TResult, TException>(
this Poll<TResult, TException> poll)
where TException : Exception
{
return poll.Every(TimeSpan.FromMilliseconds(10)).Timeout(TimeSpan.FromSeconds(1));
return poll.Every(TimeSpan.FromMilliseconds(10)).Timeout(TimeSpan.FromMilliseconds(100));
}
}

Expand Down
19 changes: 4 additions & 15 deletions src/Arcus.Testing.Tests.Unit/Logging/ILoggerBuilderExtensionsTests.cs
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,4 @@
using System;
using System.Collections.ObjectModel;
using System.IO;
using Arcus.Testing.Tests.Unit.Logging.Fixture;
using Bogus;
Expand All @@ -14,27 +13,27 @@ namespace Arcus.Testing.Tests.Unit.Logging
{
// ReSharper disable once InconsistentNaming
[Trait(name: "Category", value: "Unit")]
public class ILoggerBuilderExtensionsTests : ITestOutputHelper
public class ILoggerBuilderExtensionsTests
{
private readonly Collection<string> _xUnitTestOutput = new();
private static readonly Faker Bogus = new();

[Fact]
public void AddXunitTestLogging_WithInfoMessage_LogsInfoMessage()
{
// Arrange
var builder = new HostBuilder();
var testOutput = new InMemoryTestOutputWriter();

// Act
builder.ConfigureLogging(logging => logging.AddXunitTestLogging(this));
builder.ConfigureLogging(logging => logging.AddXunitTestLogging(testOutput));

// Assert
IHost host = builder.Build();
var logger = host.Services.GetRequiredService<ILogger<ILoggerBuilderExtensionsTests>>();

string exptected = Bogus.Lorem.Sentence();
logger.LogInformation(exptected);
Assert.Contains(_xUnitTestOutput, msg => msg.Contains(exptected));
Assert.Contains(testOutput.Contents, msg => msg.Contains(exptected));
}

[Fact]
Expand Down Expand Up @@ -157,15 +156,5 @@ public void AddXunitTestLogging_WithoutXunitTestLogger_Throws()
// Assert
Assert.ThrowsAny<ArgumentException>(() => builder.Build());
}

public void WriteLine(string message)
{
_xUnitTestOutput.Add(message);
}

public void WriteLine(string format, params object[] args)
{
_xUnitTestOutput.Add(string.Format(format, args));
}
}
}
23 changes: 23 additions & 0 deletions src/Arcus.Testing.Tests.Unit/Logging/InMemoryTestOutputWriter.cs
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,23 @@
using System.Collections.Generic;
using System.Collections.ObjectModel;
using Xunit.Abstractions;

namespace Arcus.Testing.Tests.Unit.Logging
{
public class InMemoryTestOutputWriter : ITestOutputHelper
{
private readonly Collection<string> _contents = new();

public IEnumerable<string> Contents => _contents;

public void WriteLine(string message)
{
_contents.Add(message);
}

public void WriteLine(string format, params object[] args)
{
_contents.Add(string.Format(format, args));
}
}
}
21 changes: 4 additions & 17 deletions src/Arcus.Testing.Tests.Unit/Logging/LoggerSinkConfigurationExtensionsTests.cs
View file
Original file line number Diff line number Diff line change
@@ -1,35 +1,32 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using Arcus.Testing.Tests.Unit.Logging.Fixture;
using Bogus;
using Serilog;
using Serilog.Configuration;
using Xunit;
using Xunit.Abstractions;

namespace Arcus.Testing.Tests.Unit.Logging
{
public class LoggerSinkConfigurationExtensionsTests : ITestOutputHelper
public class LoggerSinkConfigurationExtensionsTests
{
private readonly ICollection<string> _messages = new Collection<string>();
private static readonly Faker Bogus = new();

[Fact]
public void AddXunitTestLogging_WithXunitOutputWriter_Succeeds()
{
// Arrange
var config = new LoggerConfiguration();
var testOutput = new InMemoryTestOutputWriter();

// Act
config.WriteTo.XunitTestLogging(this);
config.WriteTo.XunitTestLogging(testOutput);

// Assert
ILogger logger = config.CreateLogger();
string expected = Bogus.Lorem.Sentence();
logger.Information(expected);
Assert.Single(_messages, expected);
Assert.Single(testOutput.Contents, expected);
}

[Fact]
Expand Down Expand Up @@ -149,15 +146,5 @@ public void XunitLogSink_WithoutOutputWriter_Fails()
{
Assert.ThrowsAny<ArgumentException>(() => new XunitLogEventSink(outputWriter: null));
}

public void WriteLine(string message)
{
_messages.Add(message);
}

public void WriteLine(string format, params object[] args)
{
_messages.Add(string.Format(format, args));
}
}
}

0 comments on commit 1fb9a6b

Please sign in to comment.