public async Task StartupAnalyzer_WorksWithNonImplicitMain() { // Arrange var source = TestSource.Read(@"using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; namespace MyApp; 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(); } }"); // 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 Analyses Repeat(TaggedLemmas value, int count) { global::System.IntPtr cPtr = morphodita_csharpPINVOKE.Analyses_Repeat(TaggedLemmas.getCPtr(value), count); Analyses ret = (cPtr == global::System.IntPtr.Zero) ? null : new Analyses(cPtr, true); if (morphodita_csharpPINVOKE.SWIGPendingException.Pending) { throw morphodita_csharpPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public void FlexLength_NativeCall_DoesNotThrowException() { // Arrange var analyses = new Analyses("слово"); // Act var lemma = analyses[0]; // Assert Assert.DoesNotThrow(() => { var _ = lemma.FlexLength; }); }
public void Count_NativeCall_ShouldReturnGreaterThanZero() { // Arrange var analyses = new Analyses("слово"); // Act var count = analyses.Count; // Assert Assert.That(count, Is.GreaterThan(0)); }
public void RuleId_NativeCall_DoesNotThrowException() { // Arranga var analyses = new Analyses("слово"); // Act var lemma = analyses[0]; // Assert Assert.DoesNotThrow(() => { var _ = lemma.RuleId; }); }
public Analyses GetRange(int index, int count) { global::System.IntPtr cPtr = morphodita_csharpPINVOKE.Analyses_GetRange(swigCPtr, index, count); Analyses ret = (cPtr == global::System.IntPtr.Zero) ? null : new Analyses(cPtr, true); if (morphodita_csharpPINVOKE.SWIGPendingException.Pending) { throw morphodita_csharpPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public void Form_NativeCall_ShouldNotBeEmpty() { // Arrange var analyses = new Analyses("слово"); // Act var lemma = analyses[0]; var form = lemma.Form; // Assert Assert.That(form, Is.Not.Null.Or.Empty); }
public void Quality_NativeCall_ShouldReturnQualityWithDictionaryFlag() { // Arrange var analyses = new Analyses("слово"); // Act var lemma = analyses[0]; var quality = lemma.Quality; // Assert Assert.That(quality.HasFlag(Quality.Dictionary)); }
public void StemGram_NativeCall_ShouldReturnNonEmptyString() { // Arrange var analyses = new Analyses("слово"); // Act var lemma = analyses[0]; var stemGram = lemma.StemGram; // Assert Assert.That(stemGram, Is.Not.Null.Or.Empty); }
public void Text_NativeCall_ShouldNotBeEmpty() { // Arrange var analyses = new Analyses("слово"); // Act var lemma = analyses[0]; var text = lemma.Text; // Assert Assert.That(text, Is.Not.Null.Or.Empty); }
public void Count_NativeCall_DoesNotThrowException() { // Arrange var analyses = new Analyses("слово"); // Act var lemma = analyses[0]; var forms = lemma.Forms; // Assert Assert.DoesNotThrow(() => { var _ = forms.Count; }); }
public async Task StartupAnalyzer_MvcOptionsAnalysis_MultipleMiddleware() { // Arrange var source = @" using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; namespace Microsoft.AspNetCore.Analyzers.TestFiles.StartupAnalyzerTest { public class MvcOptions_UseMvcWithOtherMiddleware { public void ConfigureServices(IServiceCollection services) { services.AddMvc(); } public void Configure(IApplicationBuilder app) { app.UseStaticFiles(); app.UseMiddleware<AuthorizationMiddleware>(); {|#0:app.UseMvc()|}; app.UseRouting(); app.UseEndpoints(endpoints => { }); } } }"; var diagnosticResult = new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting) .WithLocation(0) .WithArguments("UseMvc", "ConfigureServices"); // Act await VerifyAnalyzerAsync(source, diagnosticResult); // Assert var optionsAnalysis = Analyses.OfType <OptionsAnalysis>().First(); Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); var middlewareAnalysis = Analyses.OfType <MiddlewareAnalysis>().First(); 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)); }
public IndexViewModel(Jobcoach gebruiker) { Naam = gebruiker.Naam; Voornaam = gebruiker.Voornaam; Emailadres = gebruiker.Emailadres; Organisatie = gebruiker.Organisatie; Analyses = gebruiker.Analyses .Select(a => new AnalyseViewModel(a)) .ToList(); listItems = new List <SelectListItem>(); TotaalAnalyses = Analyses.Count(); }
private void BuildAnalyses(object status) { try { IProgressCallback callback = status as IProgressCallback; callback.SetRange(0, CheckedIndices.Count - 1); callback.Begin(); int expectedCount = uCtrlNumberPerCase.Value.Activated ? uCtrlNumberPerCase.Value.Value : -1; PackableBrick packable = cbBoxes.SelectedType as PackableBrick; // build list of analyses for (int i = 0; i < CheckedIndices.Count; ++i) { try { if (callback.IsAborting) { break; } callback.StepTo(i); callback.SetText(string.Format(Resources.ID_EVALUATINGCASE, i + 1, CheckedIndices.Count)); if ((chklbCases.Items[CheckedIndices[i]] as ItemBaseCB).Item is BoxProperties caseProperties) { // build constraint set ConstraintSetBoxCase constraintSet = new ConstraintSetBoxCase(caseProperties); constraintSet.SetAllowedOrientations(uCtrlCaseOrient.AllowedOrientations); if (uCtrlNumberPerCase.Value.Activated) { constraintSet.SetMaxNumber(uCtrlNumberPerCase.Value.Value); } // build solver + get analyses SolverBoxCase solver = new SolverBoxCase(packable, caseProperties); var listAnalyses = solver.BuildAnalyses(constraintSet, false); foreach (var analysis in listAnalyses) { if ((-1 == expectedCount) || (expectedCount == analysis.Solution.ItemCount)) { Analyses.Add(analysis); } } } } catch (Exception) {} } callback.SetText(Resources.ID_SORTINGSOLUTIONS); // sort analysis Analyses.Sort(new AnalysisComparer()); callback.End(); } catch (Exception) {} }
public async Task StartupAnalyzer_UseAuthorizationInvokedMultipleTimesInEndpointRoutingBlock_ReportsNoDiagnostics() { // Arrange var source = Read(nameof(TestFiles.StartupAnalyzerTest.UseAuthMultipleTimes)); // Act var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); // Assert var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>()); Assert.NotEmpty(middlewareAnalysis.Middleware); Assert.Empty(diagnostics); }
public async Task StartupAnalyzer_UseAuthorizationConfiguredCorrectly_ReportsNoDiagnostics() { // Arrange var source = GetSource(nameof(TestFiles.StartupAnalyzerTest.UseAuthConfiguredCorrectly)); // Act var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); // Assert var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>()); Assert.NotEmpty(middlewareAnalysis.Middleware); Assert.Empty(diagnostics); }
public async Task StartupAnalyzer_WorksWithNonImplicitMain() { // Arrange var source = @" using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; namespace MyApp; 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>(); {|#0:app.UseMvc()|}; app.UseRouting(); app.UseEndpoints(endpoints => { }); app.Run(); } }"; var diagnosticResult = new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting) .WithLocation(0) .WithArguments("UseMvc", "Main"); // Act await VerifyAnalyzerAsync(source, diagnosticResult); // Assert var optionsAnalysis = Analyses.OfType <OptionsAnalysis>().First(); Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); var middlewareAnalysis = Analyses.OfType <MiddlewareAnalysis>().First(); 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)); }
public async Task StartupAnalyzer_MultipleUseAuthorization_ReportsNoDiagnostics() { // Arrange var source = Read(nameof(TestFiles.StartupAnalyzerTest.UseAuthFallbackPolicy)); // Act var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); // Assert var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>()); Assert.NotEmpty(middlewareAnalysis.Middleware); Assert.Empty(diagnostics); }
private async Task VerifyMvcOptionsAnalysis(string source, string mvcMiddlewareName, params DiagnosticResult[] diagnosticResults) { // Arrange await VerifyAnalyzerAsync(source, diagnosticResults); // Assert var optionsAnalysis = Analyses.OfType <OptionsAnalysis>().First(); Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); var middlewareAnalysis = Analyses.OfType <MiddlewareAnalysis>().First(); var middleware = Assert.Single(middlewareAnalysis.Middleware); Assert.Equal(mvcMiddlewareName, middleware.UseMethod.Name); }
public async Task StartupAnalyzer_UseAuthorizationConfiguredAsAChain_ReportsNoDiagnostics() { // Regression test for https://github.com/dotnet/aspnetcore/issues/15203 // Arrange var source = GetSource(nameof(TestFiles.StartupAnalyzerTest.UseAuthConfiguredCorrectlyChained)); // Act var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); // Assert var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>()); Assert.NotEmpty(middlewareAnalysis.Middleware); Assert.Empty(diagnostics); }
public async Task StartupAnalyzer_UseAuthorizationConfiguredBeforeUseRoutingChained_ReportsDiagnostics() { // This one asserts a false negative for https://github.com/dotnet/aspnetcore/issues/15203. // We don't correctly identify chained calls, this test verifies the behavior. // Arrange var source = GetSource(nameof(TestFiles.StartupAnalyzerTest.UseAuthBeforeUseRoutingChained)); // Act var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); // Assert var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>()); Assert.NotEmpty(middlewareAnalysis.Middleware); Assert.Empty(diagnostics); }
public async Task StartupAnalyzer_MvcOptionsAnalysis_MultipleUseMvc() { // Arrange var source = @" using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; using Microsoft.AspNetCore.Authorization; var builder = WebApplication.CreateBuilder(args); builder.Services.AddMvc(); var app = builder.Build(); {|#0:app.UseMvcWithDefaultRoute()|}; app.UseStaticFiles(); app.UseMiddleware<AuthorizationMiddleware>(); {|#1:app.UseMvc()|}; app.UseRouting(); app.UseEndpoints(endpoints => { }); {|#2:app.UseMvc()|}; app.Run();"; var diagnosticResults = new[] { new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting) .WithLocation(0) .WithArguments("UseMvcWithDefaultRoute", TopLevelMainName), new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting) .WithLocation(1) .WithArguments("UseMvc", TopLevelMainName), new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting) .WithLocation(2) .WithArguments("UseMvc", TopLevelMainName), }; // Act await VerifyAnalyzerAsync(source, diagnosticResults); // Assert var optionsAnalysis = Analyses.OfType <OptionsAnalysis>().First(); Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); }
public async Task StartupAnalyzer_ServicesAnalysis_CallBuildServiceProvider() { // Arrange var source = Read("ConfigureServices_BuildServiceProvider"); // Act var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); // Assert var servicesAnalysis = Assert.Single(Analyses.OfType <ServicesAnalysis>()); Assert.NotEmpty(servicesAnalysis.Services); Assert.Collection(diagnostics, diagnostic => { Assert.Same(StartupAnalyzer.Diagnostics.BuildServiceProviderShouldNotCalledInConfigureServicesMethod, diagnostic.Descriptor); AnalyzerAssert.DiagnosticLocation(source.MarkerLocations["MM1"], diagnostic.Location); }); }
public async Task StartupAnalyzer_UseAuthorizationConfiguredAfterUseEndpoints_ReportsDiagnostics() { // Arrange var source = Read(nameof(TestFiles.StartupAnalyzerTest.UseAuthAfterUseEndpoints)); // Act var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); // Assert var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>()); Assert.NotEmpty(middlewareAnalysis.Middleware); Assert.Collection(diagnostics, diagnostic => { Assert.Same(StartupAnalyzer.Diagnostics.IncorrectlyConfiguredAuthorizationMiddleware, diagnostic.Descriptor); AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); }); }
public async Task StartupAnalyzer_MvcOptionsAnalysis_AddMvcOptions_FindsEndpointRoutingDisabled() { // Arrange var source = Read("MvcOptions_UseMvcWithDefaultRouteAndAddMvcOptionsEndpointRoutingDisabled"); // Act var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); // Assert var optionsAnalysis = Assert.Single(Analyses.OfType <OptionsAnalysis>()); Assert.True(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>()); var middleware = Assert.Single(middlewareAnalysis.Middleware); Assert.Equal("UseMvcWithDefaultRoute", middleware.UseMethod.Name); Assert.Empty(diagnostics); }
public async Task StartupAnalyzer_MvcOptionsAnalysis_UseMvc_FindsEndpointRoutingDisabled() { // Arrange var source = ReadSource("MvcOptions_UseMvcWithDefaultRouteAndEndpointRoutingDisabled"); // Act var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); // Assert var mvcOptionsAnalysis = Assert.Single(Analyses.OfType <MvcOptionsAnalysis>()); Assert.False(mvcOptionsAnalysis.EndpointRoutingEnabled); var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>()); var middleware = Assert.Single(middlewareAnalysis.Middleware); Assert.Equal("UseMvcWithDefaultRoute", middleware.UseMethod.Name); Assert.Empty(diagnostics); }
public async Task StartupAnalyzer_AuthNoRouting() { // Arrange var source = @" using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; using Microsoft.AspNetCore.Authorization; var builder = WebApplication.CreateBuilder(args); builder.Services.AddAuthorization(); var app = builder.Build(); app.UseAuthorization(); app.Run();"; // Act await VerifyAnalyzerAsync(source, DiagnosticResult.EmptyDiagnosticResults); // Assert var middlewareAnalysis = Analyses.OfType <MiddlewareAnalysis>().First(); Assert.Single(middlewareAnalysis.Middleware); }
public async Task StartupAnalyzer_AuthNoRouting() { // Arrange var source = TestSource.Read(@"using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; using Microsoft.AspNetCore.Authorization; var builder = WebApplication.CreateBuilder(args); builder.Services.AddAuthorization(); var app = builder.Build(); app.UseAuthorization(); app.Run();"); // Act var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); // Assert var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>()); Assert.Single(middlewareAnalysis.Middleware); Assert.Empty(diagnostics); }
public async Task StartupAnalyzer_ServicesAnalysis_CallBuildServiceProvider() { // Arrange var source = @" using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; var builder = WebApplication.CreateBuilder(args); {|#0:builder.Services.BuildServiceProvider()|}; var app = builder.Build(); app.Run();"; var diagnosticResult = new DiagnosticResult(StartupAnalyzer.Diagnostics.BuildServiceProviderShouldNotCalledInConfigureServicesMethod) .WithLocation(0); // Act await VerifyAnalyzerAsync(source, diagnosticResult); // Assert var servicesAnalysis = Analyses.OfType <ServicesAnalysis>().First(); Assert.NotEmpty(servicesAnalysis.Services); }
public async Task StartupAnalyzer_UseAuthorizationConfiguredCorrectly_ReportsNoDiagnostics() { // Arrange var source = @" using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; using Microsoft.AspNetCore.Authorization; var builder = WebApplication.CreateBuilder(args); builder.Services.AddAuthorization(); var app = builder.Build(); app.UseRouting(); app.UseAuthorization(); app.UseEndpoints(r => {}); app.Run();"; // Act await VerifyAnalyzerAsync(source, DiagnosticResult.EmptyDiagnosticResults); // Assert var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>()); Assert.NotEmpty(middlewareAnalysis.Middleware); }