public async Task DiagnosticsAreReturned_ForNotFoundNullActionResults()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Mvc;
namespace Test
{
[ApiController]
[Route(""[controller]"")]
public class TestController : ControllerBase
{
[HttpGet]
public ActionResult<string> Test()
{
return NotFound(null);
}
}
}";
var testSource = TestSource.Read(source);
var expectedLocation = testSource.DefaultMarkerLocation;
// Act
var result = await Executor.GetDiagnosticsAsync(testSource.Source);
// Assert
Assert.Contains(result, d => d.Id == ApiDiagnosticDescriptors.API1000_ActionReturnsUndocumentedStatusCode.Id);
}
public async Task Local_declared_as_var___no_warning_or_error()
{
string library = @"
namespace MyLib.Services
{
public class Bar
{
public void Do() { }
}
}";
TestSource code = TestSource.Read(@"
using MyLib.Services;
namespace MyProgram
{
internal class Worker
{
public void Do()
{
var bar = new Bar();
}
}
}");
Diagnostic[] diagnostics = await this.GetDiagnosticsWithProjectReference(code.Source, library);
Assert.AreEqual(0, diagnostics.Length);
}
private static void Then_source_and_result_should_be_equal(TestSource source, TestTarget result)
{
Assert.Equal(source.BoolProp, result.BoolProp);
Assert.Equal(source.EnumProp, result.EnumProp);
Assert.Equal(source.IntProp, result.IntProp);
Assert.Equal(source.StringProp, result.StringProp);
}
public async Task DiagnosticsAreReturned_ForIncompleteActionResults()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Mvc;
namespace Test
{
[ApiController]
[Route(""[controller]/[action]"")
public class TestController : ControllerBase
{
public IActionResult Get(int id)
{
if (id == 0)
{
return /*MM*/NotFound();
}
return;
}
}
}";
var testSource = TestSource.Read(source);
var expectedLocation = testSource.DefaultMarkerLocation;
// Act
var result = await Executor.GetDiagnosticsAsync(testSource.Source);
// Assert
var diagnostic = Assert.Single(result, d => d.Id == ApiDiagnosticDescriptors.API1000_ActionReturnsUndocumentedStatusCode.Id);
AnalyzerAssert.DiagnosticLocation(expectedLocation, diagnostic.Location);
}
public void TestInterception()
{
List <ExceptionNotification> Received = new List <ExceptionNotification>();
var src = new TestSource
{
ExceptionHandler = (o, a) => Received.Add(a)
};
src.Test("Unintercepted");
Assert.AreEqual(1, Received.Count());
Assert.IsTrue(Received.All(r => r.Message == "Unintercepted"));
string intercepted = null;
using (src.Catch((_, args) => intercepted = args.Message))
{
src.Test("Intercepted-true");
}
Assert.AreEqual("Intercepted-true", intercepted);
Assert.AreEqual(1, Received.Count()); // since we've intercepted
Assert.IsFalse(Received.Any(r => r.Message == "Intercepted-true"));
src.Test("Unintercepted2");
Assert.AreEqual("Intercepted-true", intercepted); // should not have intercepted anymore
Assert.AreEqual(2, Received.Count()); // original sink remains active
Assert.AreEqual("Unintercepted2", Received.Last().Message);
}
static void Main(string[] args)
{
var x = new TestSource();
var y = new TestDestination();
x.Bind <string, string>(Name => y.Id);
}
public async Task Pubternal_type_in_nested_namespace_field___warning_GF0001()
{
string library = @"
namespace MyLib.Internal.Services
{
public class Bar
{
public void Do() { }
}
}";
TestSource code = TestSource.Read(@"
using MyLib.Internal.Services;
namespace MyProgram
{
internal class Worker
{
private /*MM*/Bar _bar = new Bar();
}
}");
Diagnostic[] diagnostics = await this.GetDiagnosticsWithProjectReference(code.Source, library);
Assert.AreEqual(0, diagnostics.Length);
}
public async Task Local___warning_GF0001()
{
string library = @"
namespace MyLib.Internal
{
public class Bar
{
public void Do() { }
}
}";
TestSource code = TestSource.Read(@"
using MyLib.Internal;
namespace MyProgram
{
internal class Worker
{
public void Do()
{
/*MM*/Bar bar = new Bar();
}
}
}");
Diagnostic[] diagnostics = await this.GetDiagnosticsWithProjectReference(code.Source, library);
Assert.AreEqual(0, diagnostics.Length);
}
public void GroupBy_must_fail_when_exceeding_maxSubstreams()
{
this.AssertAllStagesStopped(() =>
{
var f = Flow.Create <int>().GroupBy(1, x => x % 2).PrefixAndTail(0).MergeSubstreams();
var t = ((Flow <int, Tuple <IImmutableList <int>, Source <int, NotUsed> >, NotUsed>)f)
.RunWith(TestSource.SourceProbe <int>(this), TestSink.SinkProbe <Tuple <IImmutableList <int>, Source <int, NotUsed> > >(this), Materializer);
var up = t.Item1;
var down = t.Item2;
down.Request(2);
up.SendNext(1);
var first = down.ExpectNext();
var s1 = new StreamPuppet(first.Item2.RunWith(Sink.AsPublisher <int>(false), Materializer), this);
s1.Request(1);
s1.ExpectNext(1);
up.SendNext(2);
var ex = down.ExpectError();
ex.Message.Should().Contain("too many substreams");
s1.ExpectError(ex);
}, Materializer);
}
public async Task Pubternal_type_in_nested_namespace_field___warning_GF0001()
{
string library = @"
namespace gfoidl.Internal.Services
{
public class Bar
{
public void Do() { }
}
}";
TestSource code = TestSource.Read(@"
using gfoidl.Internal.Services;
namespace MyProgram
{
internal class Worker
{
private /*MM*/Bar _bar = new Bar();
}
}");
Diagnostic[] diagnostics = await this.GetDiagnosticsWithProjectReference(code.Source, library);
DiagnosticLocation expected = code.DefaultMarkerLocation;
Assert.Multiple(() =>
{
Assert.AreEqual(1, diagnostics.Length);
Diagnostic diagnostic = diagnostics[0];
Assert.AreEqual("GF0001", diagnostic.Id);
Assert.IsTrue(diagnostic.Location.IsInSource);
Assert.That(diagnostic.Location, Is.EqualTo(expected));
});
}
public async Task StartupAnalyzer_WorksWithOtherMethodsInProgram()
{
// Arrange
var source = TestSource.Read(@"using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
public class Program
{
public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMvc();
var app = builder.Build();
app.UseStaticFiles();
app.UseMiddleware<AuthorizationMiddleware>();
/*MM*/app.UseMvc();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
});
app.Run();
}
private static void MethodA()
{
}
private static void MethodB()
{
}
}");
// Act
var diagnostics = await Runner.GetDiagnosticsAsync(source.Source);
// Assert
var optionsAnalysis = Assert.Single(Analyses.OfType <OptionsAnalysis>());
Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));
var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>());
Assert.Collection(
middlewareAnalysis.Middleware,
item => Assert.Equal("UseStaticFiles", item.UseMethod.Name),
item => Assert.Equal("UseMiddleware", item.UseMethod.Name),
item => Assert.Equal("UseMvc", item.UseMethod.Name),
item => Assert.Equal("UseRouting", item.UseMethod.Name),
item => Assert.Equal("UseEndpoints", item.UseMethod.Name));
Assert.Collection(
diagnostics,
diagnostic =>
{
Assert.Same(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting, diagnostic.Descriptor);
AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location);
Assert.Contains("inside 'Main", diagnostic.GetMessage());
});
}
public static TestSource Read(string rawSource)
{
var testInput = new TestSource();
var lines = rawSource.Split(new[] { "\n", "\r\n" }, StringSplitOptions.None);
for (var i = 0; i < lines.Length; i++)
{
var line = lines[i];
while (true)
{
var markerStartIndex = line.IndexOf(MarkerStart, StringComparison.Ordinal);
if (markerStartIndex == -1)
{
break;
}
var markerEndIndex = line.IndexOf(MarkerEnd, markerStartIndex, StringComparison.Ordinal);
var markerName = line.Substring(markerStartIndex + 2, markerEndIndex - markerStartIndex - 2);
var markerLocation = new DiagnosticLocation(i + 1, markerStartIndex + 1);
if (testInput.DefaultMarkerLocation == null)
{
testInput.DefaultMarkerLocation = markerLocation;
}
testInput.MarkerLocations.Add(markerName, markerLocation);
line = line.Substring(0, markerStartIndex) + line.Substring(markerEndIndex + MarkerEnd.Length);
}
lines[i] = line;
}
testInput.Source = string.Join(Environment.NewLine, lines);
return(testInput);
}
private async Task VerifyNoDiagnosticsAreReturned(TestSource source)
{
// Act
var result = await Executor.GetDiagnosticsAsync(source.Source);
// Assert
Assert.Empty(result);
}
public async Task ObservingThoughApiWorks()
{
await Prepared.ConfigureAwait(false);
var builder = new HubConnectionBuilder()
.WithUrl($"http://test{LiveHub.Route}",
cfg => cfg.HttpMessageHandlerFactory = _ => Server.CreateHandler())
;
var hubConnection = builder.Build();
await hubConnection.StartAsync();
var obs = hubConnection.Observe <ChangeData>(nameof(LiveHub.Observe));
const int takeCount = 10;
var sem = new SemaphoreSlim(2); // Coordinate progress between produced data and listener
var obsTask = obs
.TraceTest(Output)
.Take(takeCount)
.Select((v, idx) => new { v, idx })
// Start a new producer whenever we have received 5 items
.Do(x =>
{
if (x.idx % 5 == 0)
{
sem.Release();
}
})
.TraceTest(Output)
.Select(x => x.v)
.ToListAsync(CancellationToken);
var pushTask = TestSource.ProduceData(
// Wait for sem for each batch of data
sem.ObserveRelease().Take(2).Select(_ => DateTime.UtcNow)
.TraceTest(Output)
)
.TraceTest(Output)
.SelectMany(x => x)
.TraceTest(Output)
.ToListAsync(CancellationToken);
// All ready, start pusing
sem.Release();
var observedChanges = await obsTask.ConfigureAwait(false);
var observed = observedChanges.Select(c => c.Entity).ToList();
var pushed = await pushTask.ConfigureAwait(false);
var expect = pushed.Take(takeCount);
observed.Should().BeEquivalentTo(expect,
cfg => cfg.Excluding(x => x.Installation).Excluding(x => x.Signal));
// Reception should contained interleaved data
observed.Select(x => x.InstallationId)
.Should().NotBeAscendingInOrder()
.And.NotBeDescendingInOrder();
}
public void Add_Positive_Test()
{
var source = new TestSource();
Assert.Equal(3, source.Add(1, 2));
Assert.Equal(5, source.Add(3, 2));
Assert.NotEqual(8, source.Add(3, 4));
Assert.NotEqual(10, source.Add(5, 4));
}
public void GetPage_Should_Stop_Loading_Pages_When_LoadPage_Throws()
{
var target = new TestSource(2);
Assert.That(target.PagesLoaded, Is.Empty);
Assert.ThrowsAsync <AggregateException>(() => target.GetPage(3));
Assert.That(target.PagesLoaded, Is.EqualTo(new[] { 0, 1 }));
}
public void Add_Positive_Negative_Test()
{
var source = new TestSource();
Assert.Equal(1, source.Add(-1, 2));
Assert.Equal(1, source.Add(3, -2));
Assert.NotEqual(5, source.Add(3, -4));
Assert.NotEqual(-1, source.Add(5, -4));
}
public void Add_Negative_Test()
{
var source = new TestSource();
Assert.Equal(-3, source.Add(-1, -2));
Assert.Equal(-5, source.Add(-3, -2));
Assert.NotEqual(-8, source.Add(-3, -4));
Assert.NotEqual(-10, source.Add(-5, -4));
}
public void IsLoading_Should_Be_Set_To_False_When_LoadPage_Throws()
{
var target = new TestSource(2);
Assert.That(target.PagesLoaded, Is.Empty);
Assert.ThrowsAsync <AggregateException>(() => target.GetPage(3));
Assert.That(target.IsLoading, Is.False);
}
public async Task GetPage_Should_Load_Pages()
{
var target = new TestSource();
Assert.That(target.PagesLoaded, Is.Empty);
var count = await target.GetPage(3);
Assert.That(target.PagesLoaded, Is.EqualTo(new[] { 0, 1, 2, 3 }));
}
public void DefaultMappingAction_PropertyIsNull_InvalidCastExceptionIsThrown()
{
Assert.Throws(
typeof(InvalidCastException),
new TestDelegate(() =>
{
var mapFromTestSourceToDestination = new Map(typeof(TestSource), typeof(Destination));
var sourceObject = new TestSource();
mapFromTestSourceToDestination.DefaultMappingAction(sourceObject);
}));
}
public void GetFileByName_FileInFinalSubFolder_IsFoundByNameWithSubDirsImplicit()
{
// Arrange
string fileName = "Sub2FolderBinFile.rar";
// Act
ITestSourceItem testSourcesItem = TestSource.GetFileByName(fileName, true);
// Assert
testSourcesItem.Should().NotBeNull();
testSourcesItem.Name.Should().Be(fileName);
}
public void GetByName_FileInRoot_IsNotFoundByNameInLowerCase()
{
// Arrange
string fileName = "binfile01.rar";
// Act
ITestSourceItem testSourcesItem = TestSource.GetByName(fileName, false);
// Assert
testSourcesItem.Should().BeNull();
}
public async Task GetCount_Should_Load_First_Page()
{
var target = new TestSource();
Assert.That(target.PagesLoaded, Is.Empty);
var count = await target.GetCount();
Assert.That(count, Is.EqualTo(100));
Assert.That(target.PagesLoaded, Is.EqualTo(new[] { 0 }));
}
public void GetByName_UnexistingFileInRoot_IsNotFoundByNameWithoutSubdirs()
{
// Arrange
string fileName = "IDoNotExist.ext";
// Act
ITestSourceItem testSourcesItem = TestSource.GetByName(fileName, false);
// Assert
testSourcesItem.Should().BeNull();
}
public IDictionary <string, string> ImmutableDictionaryAdd(TestSource test)
{
var dictionary = ImmutableDictionary <string, string> .Empty;
foreach (var s in test.Data)
{
dictionary = dictionary.Add(s, s);
}
return(dictionary);
}
public void ShouldWork()
{
var source = new TestSource();
var target = new TestTarget();
this.utilitiesService.UpdatePropertiesReflection(source, target);
source.Date.Should().Be(target.Date);
source.Name.Should().Be(target.Name);
source.Id.Should().Be(target.Id);
}
public void GetFolderByName_FolderInFinalSubFolder_IsFoundByNameWithSubDirsExplicit()
{
// Arrange
string folderName = "sub02";
// Act
ITestSourceItem testSourcesItem = TestSource.GetFolderByName(folderName, true);
// Assert
testSourcesItem.Should().NotBeNull();
testSourcesItem.Name.Should().Be(folderName);
}
public void GetFolderByName_FolderInRoot_IsFoundByNameWithoutSubDirs()
{
// Arrange
string folderName = "FileContentTests";
// Act
ITestSourceItem testSourcesItem = TestSource.GetFolderByName(folderName, false);
// Assert
testSourcesItem.Should().NotBeNull();
testSourcesItem.Name.Should().Be(folderName);
}
public void CanRemoveEventHandler()
{
var source = new TestSource();
int beforeRun = source.Count;
source.Fire();
Assert.IsTrue(source.Count == 1);
source.Clean();
source.Fire();
Assert.IsTrue(source.Count == 1);
}
public void PropertySource_is_stored_and_retrieved()
{
var target = new Tracker();
var source = new TestSource();
var metadata = new HarshObjectMetadata(typeof(Tracker));
var accessor = metadata.ReadableWritableInstanceProperties.Single();
accessor.SetValue(target, "42", source);
Assert.Equal("42", target.Property);
Assert.Same(source, accessor.GetValueSource(target));
}
public void IsolateSecureSettingSource()
{
var testSource = new TestSource {Name = Value };
_fakeSetting = new TestSetting(testSource);
_fakeSetting.Key = _fakeSetting.SecureMarker + Value;
_fakeSetting.Value = _fakeSetting.SecureMarker + Value;
Isolate.WhenCalled(() => _fakeSetting.Key = null).CallOriginal();
_secretKeyManager = new SecretKeyManager();
Isolate.WhenCalled(() => _secretKeyManager.GetKey()).WillReturn(Secret);
_crypt = Isolate.Fake.Instance<CryptoGraphy>();
Isolate.WhenCalled(() => _crypt.SetKey(Secret)).IgnoreCall();
_secureSetting = new SecureSetting(_fakeSetting, _secretKeyManager, _crypt);
Isolate.WhenCalled(() => _crypt.Encrypt(Value)).WillReturn(Value);
var secureValue = _secureSetting.SecureMarker + Value;
Isolate.WhenCalled(() => _crypt.Decrypt(secureValue)).WillReturn(Value);
}
public MainWindow()
{
InitializeComponent();
// immediate flush
_logManager.FlushInterval = TimeSpan.FromMilliseconds(1);
// set test log source
_logManager.Sources.Add(_testSource = new TestSource());
// set .NET Trace system based source
_logManager.Sources.Add(new StockSharp.Logging.TraceSource());
// write logs into MainWindow
_logManager.Listeners.Add(new GuiLogListener(Monitor));
// and file logs.txt
_logManager.Listeners.Add(new FileLogListener
{
FileName = "logs",
});
}
