public string CreateClassFileContent(int maxServiceCount)
{
CodeNames codeNames = new CodeNames(maxServiceCount, false, false);
LogicGenerator logicGenerator = new LogicGenerator();
StringBuilder sb = new StringBuilder();
sb.AppendLine($@"using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Pekspro.PolicyScope.LogicTest.Workers;
using System;
using System.Threading;
using System.Threading.Tasks;
namespace Pekspro.PolicyScope.LogicTest
{{
public class Worker : BackgroundService
{{
public Worker(IServiceScopeFactory serviceScopeFactory, IHostApplicationLifetime hostApplicationLifetime)
{{
ServiceProviderFactory = serviceScopeFactory;
HostApplicationLifetime = hostApplicationLifetime;
}}
public IServiceScopeFactory ServiceProviderFactory {{ get; }}
public IHostApplicationLifetime HostApplicationLifetime {{ get; }}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{{
await Task.Delay(100);
Console.WriteLine();
using (var scope = ServiceProviderFactory.CreateScope())
{{
{logicGenerator.GetInterfaceName(codeNames)} logic = scope.ServiceProvider.GetService<{logicGenerator.GetInterfaceName(codeNames)}>();");
for (int asyncMode = 0; asyncMode < (GenerateSync ? 2 : 1); asyncMode++)
{
for (int resultMode = 0; resultMode < 2; resultMode++)
{
for (int serviceCount = 0; serviceCount <= maxServiceCount; serviceCount++)
{
sb.AppendLine(CreateTestStep(new CodeNames(serviceCount, resultMode != 0, asyncMode == 0)));
}
}
}
sb.AppendLine(
@" }
Console.WriteLine();
HostApplicationLifetime.StopApplication();
}
}
}");
return(sb.ToString());
}
public override string GetClassName(CodeNames codeNames)
{
string name = codeNames.ClassNamePrefix +
"PolicyScopeServiceSelectorMockBuilder";
return(name);
}
public string CreateFunctionDeclaration(CodeNames codeNames)
{
StringBuilder sb = new StringBuilder();
if (codeNames.IsAsync)
{
if (codeNames.HasReturnType)
{
sb.Append("Task<int>");
}
else
{
sb.Append("Task");
}
}
else
{
if (codeNames.HasReturnType)
{
sb.Append("int");
}
else
{
sb.Append("void");
}
}
sb.Append($" {CreateFunctionName(codeNames)}()");
return(sb.ToString());
}
public string CreateInterfaceCode(CodeNames codeNameBase, int maxServiceCount)
{
StringBuilder sb = new StringBuilder();
sb.Append(
$@" public interface {GetInterfaceNameAndTemplateParamaters(codeNameBase)}
{{
");
PolicyScopeResultSelectorGenerator servicePolicyScopeBuilderGenerator = new PolicyScopeResultSelectorGenerator();
for (int serviceCount = 0; serviceCount <= maxServiceCount; serviceCount++)
{
if (serviceCount != 0)
{
sb.AppendLine();
}
CodeNames codeNames = new CodeNames(serviceCount, false, codeNameBase.IsAsync);
sb.AppendLine(
$@" {servicePolicyScopeBuilderGenerator.GetInterfaceNameAndTemplateParamaters(codeNames)} {codeNames.FunctionWithServicesName}{codeNames.TemplateParameters}();");
}
sb.AppendLine(
$@" }}");
return(sb.ToString());
}
public override string GetClassName(CodeNames codeNames)
{
string name = codeNames.ClassNamePrefix +
"PolicyScopeResultSelector";
return(name);
}
public string CreateInterfaceCode(CodeNames codeNames)
{
StringBuilder sb = new StringBuilder();
sb.Append(
$@" public interface {GetInterfaceNameAndTemplateParamaters(codeNames)}
{{
");
if (codeNames.IsAsync)
{
sb.AppendLine(
$@" Task{(codeNames.HasReturnType ? $"<{CodeNames.TResultName}>" : "")} RunAsync({codeNames.GetFunctionDeclaration()} func);");
}
else
{
sb.AppendLine(
$@" {(codeNames.HasReturnType ? $"{CodeNames.TResultName}" : "void")} Run({codeNames.GetFunctionDeclaration()} func);");
}
sb.AppendLine(
$@" }}");
return(sb.ToString());
}
public string CreateInterfaceFileContent(int maxServiceCount)
{
CodeNames codeNames = new CodeNames(maxServiceCount, false, false);
StringBuilder sb = new StringBuilder();
sb.AppendLine(@$ "using System.Threading.Tasks;
public string CreateClassCode(CodeNames codeNames)
{
StringBuilder sb = new StringBuilder();
sb.Append(
$@" internal class {GetClassNameAndTemplateParamaters(codeNames)} : {codeNames.BaseClassName}, {GetInterfaceNameAndTemplateParamaters(codeNames)}
{{
internal {GetClassName(codeNames)}({codeNames.BaseClassName} settings)
: base(settings)
{{
}}
");
CodeNames codeNameWithResult = new CodeNames(codeNames.ServiceCount, true, codeNames.IsAsync);
PolicyScopeRunnerGenerator policyRunnerGenerator = new PolicyScopeRunnerGenerator();
sb.AppendLine(
$@" public {policyRunnerGenerator.GetInterfaceNameAndTemplateParamaters(codeNames)} {WithNoResultName}()
{{
return new {policyRunnerGenerator.GetClassNameAndTemplateParamaters(codeNames)}(this);
}}
public {policyRunnerGenerator.GetInterfaceNameAndTemplateParamaters(codeNameWithResult)} {WithResultName}<{CodeNames.TResultName}>()
{{
return new {policyRunnerGenerator.GetClassNameAndTemplateParamaters(codeNameWithResult)}(this);
}}");
sb.AppendLine(
$@" }}");
return(sb.ToString());
}
public string CreateClassCode(CodeNames codeNames)
{
StringBuilder sb = new StringBuilder();
sb.Append(
$@" public class {GetClassNameAndTemplateParamaters(codeNames)}
{{
public {GetClassName(codeNames)}(PolicyScopeMockBuilder policyScopeMockBuilder)
{{
PolicyScopeMockBuilder = policyScopeMockBuilder;
}}
protected PolicyScopeMockBuilder PolicyScopeMockBuilder {{ get; }}
public PolicyScopeMockBuilder WithNoResult()
{{
return PolicyScopeMockBuilder;
}}
public PolicyScopeMockBuilder WithResultType<TResult>()
{{
PolicyScopeMockBuilder.NextConfiguration.ReturnType = typeof(TResult);
return PolicyScopeMockBuilder;
}}
}}
");
return(sb.ToString());
}
public string CreateFunctionName(CodeNames codeNames)
{
string name = "Run";
if (codeNames.HasReturnType)
{
name += "WithResult";
}
else
{
name += "WithNoResult";
}
if (codeNames.HasServices)
{
name += $"{codeNames.ServicesTypes.Count()}Service";
}
else
{
name += "NoService";
}
if (codeNames.IsAsync)
{
name += "Async";
}
return(name);
}
public override string GetClassName(CodeNames codeNames)
{
PolicyScopeServiceSelectorGenerator policyScopeServiceSelectorGenerator =
new PolicyScopeServiceSelectorGenerator();
return(policyScopeServiceSelectorGenerator.GetClassName(codeNames) + "Mock");
}
public override string GetClassName(CodeNames codeNames)
{
LogicGenerator dummyLogicGenerator = new LogicGenerator();
string name = "UnitTest" + dummyLogicGenerator.GetClassName(codeNames);
return(name);
}
public override string GetClassName(CodeNames codeNames)
{
string name = codeNames.ClassNamePrefix +
codeNames.ClassNameServicePrefix +
codeNames.ClassNameResultPrefix +
"PolicyScopeRunner";
return(name);
}
public string CreateClassCode(CodeNames codeNames)
{
PolicyScopeResultSelectorGenerator policyScopeResultSelectorGenerator =
new PolicyScopeResultSelectorGenerator();
StringBuilder sb = new StringBuilder();
sb.Append(
$@" internal class {GetClassNameAndTemplateParamaters(codeNames)} : {policyScopeResultSelectorGenerator.GetInterfaceNameAndTemplateParamaters(codeNames)}
{{
internal {GetClassName(codeNames)}(IEnumerable<PolicyScopeMockConfiguration> configurations)
{{
Configurations = configurations;
}}
internal IEnumerable<PolicyScopeMockConfiguration> Configurations {{ get; }}
");
CodeNames codeNameWithResult = new CodeNames(codeNames.ServiceCount, true, codeNames.IsAsync);
PolicyScopeRunnerGenerator policyRunnerGenerator = new PolicyScopeRunnerGenerator();
PolicyScopeRunnerMockGenerator policyScopeRunnerMockGenerator = new PolicyScopeRunnerMockGenerator();
sb.AppendLine(
$@" public {policyRunnerGenerator.GetInterfaceNameAndTemplateParamaters(codeNames)} {PolicyScopeResultSelectorGenerator.WithNoResultName}()
{{
var config = Configurations.FirstOrDefault(conf => conf.ReturnType == null);
if(config == null)
{{
throw new PolicyScopeMockException($""No matching policy scope mock configuration was found. Found no configuration with no result type."", Configurations);
}}
return new {policyScopeRunnerMockGenerator.GetClassNameAndTemplateParamaters(codeNames)}(config);
}}
public {policyRunnerGenerator.GetInterfaceNameAndTemplateParamaters(codeNameWithResult)} {PolicyScopeResultSelectorGenerator.WithResultName}<{CodeNames.TResultName}>()
{{
var config = Configurations.FirstOrDefault(conf => conf.ReturnType == typeof({CodeNames.TResultName}));
if (config == null)
{{
throw new PolicyScopeMockException($""No matching policy scope mock configuration was found. Found no configuration with result type {{typeof(TResult)}}."", Configurations);
}}
return new {policyScopeRunnerMockGenerator.GetClassNameAndTemplateParamaters(codeNameWithResult)}(config);
}}");
sb.AppendLine(
$@" }}");
return(sb.ToString());
}
public string CreateTestStep(CodeNames codeNames)
{
StringBuilder sb = new StringBuilder();
LogicGenerator dummyLogicGenerator = new LogicGenerator();
sb.AppendLine(
$@" Console.WriteLine($""Running {{nameof(logic.{dummyLogicGenerator.CreateFunctionName(codeNames)})}}..."");
{(codeNames.IsAsync ? "await " : "")}logic.{dummyLogicGenerator.CreateFunctionName(codeNames)}();");
return(sb.ToString());
}
public string CreateFunctionDeclaration(CodeNames codeNames)
{
var dummyLogicGenerator = new LogicGenerator();
string s = string.Empty;
if (codeNames.IsAsync)
{
s += "async Task ";
}
else
{
s += "void ";
}
return(s + "Test" + dummyLogicGenerator.CreateFunctionName(codeNames));
}
public string CreateClassCode(CodeNames codeNameBase, int maxServiceCount)
{
StringBuilder sb = new StringBuilder();
string interfacePolicyName = codeNameBase.IsAsync ? "IAsyncPolicy" : "ISyncPolicy";
string variablePolicyName = codeNameBase.IsAsync ? "asyncPolicy" : "syncPolicy";
sb.Append(
$@" internal class {GetClassNameAndTemplateParamaters(codeNameBase)} : {codeNameBase.BaseClassName}, {GetInterfaceNameAndTemplateParamaters(codeNameBase)}
{{
internal {GetClassName(codeNameBase)}(IServiceProvider serviceProvider, {interfacePolicyName} {variablePolicyName})
: base(serviceProvider, {variablePolicyName})
{{
}}
");
PolicyScopeResultSelectorGenerator servicePolicyScopeBuilderGenerator = new PolicyScopeResultSelectorGenerator();
for (int serviceCount = 0; serviceCount <= maxServiceCount; serviceCount++)
{
if (serviceCount != 0)
{
sb.AppendLine();
}
CodeNames codeNames = new CodeNames(serviceCount, false, codeNameBase.IsAsync);
sb.AppendLine(
$@" public {servicePolicyScopeBuilderGenerator.GetInterfaceNameAndTemplateParamaters(codeNames)} {codeNames.FunctionWithServicesName}{codeNames.TemplateParameters}()
{{
return new {servicePolicyScopeBuilderGenerator.GetClassNameAndTemplateParamaters(codeNames)}(this);
}}");
}
sb.AppendLine(
$@" }}");
return(sb.ToString());
}
public string CreateClassFileContent(int maxServiceCount)
{
var codeNames = new CodeNames(maxServiceCount, false, false);
StringBuilder sb = new StringBuilder();
sb.AppendLine($@"using Pekspro.PolicyScope.LogicTest.Services;
using System.Threading.Tasks;
namespace Pekspro.PolicyScope.LogicTest.Workers
{{
public class {GetClassName(codeNames)} : {GetInterfaceName(codeNames)}
{{
public IPolicyScopeBuilder PolicyScopeBuilder {{ get; }}
public {GetClassName(codeNames)}(IPolicyScopeBuilder policyScopeBuilder)
{{
PolicyScopeBuilder = policyScopeBuilder;
}}
public int LatestResult {{ get; set; }}
");
for (int asyncMode = 0; asyncMode < (GenerateSync ? 2 : 1); asyncMode++)
{
for (int resultMode = 0; resultMode < 2; resultMode++)
{
for (int serviceCount = 0; serviceCount <= maxServiceCount; serviceCount++)
{
sb.AppendLine(CreateFunctionCode(new CodeNames(serviceCount, resultMode != 0, asyncMode == 0)));
}
}
}
sb.AppendLine(@" }
}");
return(sb.ToString());
}
public string CreateInterfaceCode(CodeNames codeNames)
{
StringBuilder sb = new StringBuilder();
sb.Append(
$@" public interface {GetInterfaceNameAndTemplateParamaters(codeNames)}
{{
");
CodeNames codeNameWithResult = new CodeNames(codeNames.ServiceCount, true, codeNames.IsAsync);
PolicyScopeRunnerGenerator policyRunnerGenerator = new PolicyScopeRunnerGenerator();
sb.AppendLine(
$@" {policyRunnerGenerator.GetInterfaceNameAndTemplateParamaters(codeNames)} WithNoResult();
");
sb.AppendLine(
$@" {policyRunnerGenerator.GetInterfaceNameAndTemplateParamaters(codeNameWithResult)} WithResult<{CodeNames.TResultName}>();");
sb.AppendLine(
$@" }}");
return(sb.ToString());
}
public string CreateClassCode(CodeNames codeNames)
{
PolicyScopeRunnerGenerator policyScopeRunnerGenerator =
new PolicyScopeRunnerGenerator();
StringBuilder sb = new StringBuilder();
sb.Append(
$@" internal class {GetClassNameAndTemplateParamaters(codeNames)} : {policyScopeRunnerGenerator.GetInterfaceNameAndTemplateParamaters(codeNames)}
{{
internal {GetClassName(codeNames)}(PolicyScopeMockConfiguration policyScopeMockConfiguration)
{{
PolicyScopeMockConfiguration = policyScopeMockConfiguration;
}}
internal PolicyScopeMockConfiguration PolicyScopeMockConfiguration {{ get; }}
");
string retValueGrab = string.Empty;
if (codeNames.HasReturnType)
{
retValueGrab = CodeNames.TResultName + " retValue = ";
}
if (codeNames.IsAsync)
{
sb.AppendLine(
$@" public async Task{(codeNames.HasReturnType ? $"<{CodeNames.TResultName}>" : "")} {PolicyScopeRunnerGenerator.GetRunName(true)}({codeNames.GetFunctionDeclaration()} func)
{{");
}
else
{
sb.AppendLine(
$@" public {(codeNames.HasReturnType ? $"{CodeNames.TResultName}" : "void")} {PolicyScopeRunnerGenerator.GetRunName(false)}({codeNames.GetFunctionDeclaration()} func)
{{");
}
if (codeNames.HasServices)
{
for (int i = 0; i < codeNames.ServiceCount; i++)
{
sb.AppendLine(
$@" var {codeNames.ServicesNames[i]} = ({codeNames.ServicesTypes[i]}) PolicyScopeMockConfiguration.ServiceInstances[{i}];");
}
sb.AppendLine();
}
if (codeNames.IsAsync)
{
sb.AppendLine(
$@" {retValueGrab}await func.Invoke({string.Join(", ", codeNames.ServicesNames)}).ConfigureAwait(false);");
}
else
{
sb.AppendLine(
$@" {retValueGrab} func.Invoke({string.Join(", ", codeNames.ServicesNames)});");
}
sb.AppendLine(
$@"
PolicyScopeMockConfiguration.ExecutionCount++;");
if (codeNames.HasReturnType)
{
sb.AppendLine(
$@"
return retValue;");
}
sb.AppendLine(
$@" }}
}}");
return(sb.ToString());
}
public override string GetClassName(CodeNames codeNames)
{
string name = "Logic";
return(name);
}
public string CreateFunctionCode(CodeNames codeNames)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine($@" public {CreateFunctionDeclaration(codeNames)}");
sb.Append(
$@" {{
LatestResult = -1;
");
if (codeNames.IsAsync || codeNames.HasReturnType)
{
sb.Append("return ");
}
sb.AppendLine("PolicyScopeBuilder");
if (codeNames.IsAsync)
{
sb.AppendLine(" .WithAsyncPolicy(PolicyNames.AsyncPolicyName)");
}
else
{
sb.AppendLine(" .WithSyncPolicy(PolicyNames.SyncPolicyName)");
}
if (!codeNames.HasServices)
{
sb.AppendLine($" .{codeNames.FunctionWithServicesName}()");
}
else
{
sb.Append($" .{codeNames.FunctionWithServicesName}<");
var serviceNames = Enumerable
.Range(1, codeNames.ServiceCount)
.Select(r => "IDummyService" + r);
sb.Append(string.Join(", ", serviceNames));
sb.AppendLine(">()");
}
if (!codeNames.HasReturnType)
{
sb.AppendLine(" .WithNoResult()");
}
else
{
sb.AppendLine(" .WithResult<int>()");
}
sb.Append($" .{(codeNames.IsAsync ? "RunAsync" : "Run")}(");
if (codeNames.IsAsync && codeNames.HasServices)
{
sb.Append("async ");
}
if (!codeNames.HasServices)
{
sb.Append("()");
}
else
{
var serviceNames = Enumerable
.Range(1, codeNames.ServiceCount)
.Select(r => "service" + r);
sb.Append("(");
sb.Append(string.Join(", ", serviceNames));
sb.Append(")");
}
sb.AppendLine(" =>");
sb.AppendLine(
@" {
LatestResult = 0;");
if (codeNames.HasServices)
{
var serviceNames = Enumerable
.Range(1, codeNames.ServiceCount)
.Select(r => "service" + r);
foreach (var serviceName in serviceNames)
{
if (codeNames.IsAsync)
{
sb.AppendLine(
@$ " LatestResult += await {serviceName}.CalculateAsync();");
}
else
{
sb.AppendLine(
@$ " LatestResult += {serviceName}.Calculate();");
}
}
}
if (codeNames.IsAsync)
{
if (codeNames.HasReturnType)
{
sb.AppendLine();
if (!codeNames.HasServices)
{
sb.AppendLine(
@" return Task.FromResult(LatestResult);");
}
else
{
sb.AppendLine(
@" return LatestResult;");
}
}
else if (!codeNames.HasServices)
{
sb.AppendLine();
sb.AppendLine(
@" return Task.CompletedTask;");
}
}
else
{
if (codeNames.HasReturnType)
{
sb.AppendLine();
sb.AppendLine(
@" return LatestResult;");
}
}
sb.AppendLine(
@" });
}");
return(sb.ToString());
}
public override string GetClassName(CodeNames codeNames)
{
return("UnitTestResourceNotFound");
}
public string CreateClassCode(CodeNames codeNames)
{
StringBuilder sb = new StringBuilder();
sb.Append(
$@" internal class {GetClassNameAndTemplateParamaters(codeNames)} : {codeNames.BaseClassName}, {GetInterfaceNameAndTemplateParamaters(codeNames)}
{{
internal {GetClassName(codeNames)}({codeNames.BaseClassName} settings)
: base(settings)
{{
}}
");
string retValueDefinition = string.Empty;
string retValueGrab = string.Empty;
if (codeNames.HasReturnType)
{
retValueDefinition =
@"
TResult retValue = default!;
";
retValueGrab = "retValue = ";
}
if (codeNames.IsAsync)
{
sb.AppendLine(
$@" public async Task{(codeNames.HasReturnType ? $"<{CodeNames.TResultName}>" : "")} {GetRunName(true)}({codeNames.GetFunctionDeclaration()} func)
{{{retValueDefinition}
await Policy.ExecuteAsync(async () =>
{{");
}
else
{
sb.AppendLine(
$@" public {(codeNames.HasReturnType ? $"{CodeNames.TResultName}" : "void")} {GetRunName(false)}({codeNames.GetFunctionDeclaration()} func)
{{{retValueDefinition}
Policy.Execute(() =>
{{");
}
if (codeNames.HasServices)
{
sb.AppendLine(
$@" using (var scope = ServiceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope())
{{");
for (int i = 0; i < codeNames.ServiceCount; i++)
{
sb.AppendLine(
$@" var {codeNames.ServicesNames[i]} = scope.ServiceProvider.GetService<{codeNames.ServicesTypes[i]}>()!;");
}
sb.AppendLine();
sb.Append(" ");
}
if (codeNames.IsAsync)
{
sb.AppendLine(
$@" {retValueGrab}await func.Invoke({string.Join(", ", codeNames.ServicesNames)}).ConfigureAwait(false);");
}
else
{
sb.AppendLine(
$@" {retValueGrab} func.Invoke({string.Join(", ", codeNames.ServicesNames)});");
}
if (codeNames.HasServices)
{
sb.AppendLine(
$@" }}");
}
sb.AppendLine(
$@" }});");
if (codeNames.HasReturnType)
{
sb.AppendLine(
$@"
return retValue;");
}
sb.AppendLine(
$@" }}
}}");
return(sb.ToString());
}
public string CreateFunctionCode(CodeNames codeNames)
{
LogicGenerator logicGenerator = new LogicGenerator();
StringBuilder sb = new StringBuilder();
sb.AppendLine($@" [Fact]");
sb.AppendLine($@" public {CreateFunctionDeclaration(codeNames)}()");
sb.AppendLine(
$@" {{
// Arrange");
var serviceRange = Enumerable
.Range(1, codeNames.ServiceCount);
if (codeNames.IsAsync)
{
var mockDeclarations = serviceRange
.Select(r =>
$@" Mock<IDummyService{r}> dummyServiceMock{r} = new Mock<IDummyService{r}>();
dummyServiceMock{r}
.Setup(d => d.CalculateAsync())
.Returns(Task.FromResult(1 << {r - 1}));"
);
sb.Append(string.Join(Environment.NewLine + Environment.NewLine, mockDeclarations));
}
else
{
var mockDeclarations = serviceRange
.Select(r =>
$@" Mock<IDummyService{r}> dummyServiceMock{r} = new Mock<IDummyService{r}>();
dummyServiceMock{r}
.Setup(d => d.Calculate())
.Returns(1 << {r - 1});"
);
sb.Append(string.Join(Environment.NewLine + Environment.NewLine, mockDeclarations));
}
if (codeNames.HasServices)
{
sb.AppendLine();
sb.AppendLine();
}
if (codeNames.IsAsync)
{
sb.AppendLine(@" var policyScopeMock = PolicyScopeMock
.AsyncPolicy(PolicyNames.AsyncPolicyName)");
}
else
{
sb.AppendLine(@" var policyScopeMock = PolicyScopeMock
.SyncPolicy(PolicyNames.SyncPolicyName)");
}
if (codeNames.HasServices)
{
sb.Append($" .{codeNames.FunctionWithServicesName}(");
var mockNames = serviceRange
.Select(r =>
$@"dummyServiceMock{r}.Object"
);
sb.Append(string.Join(", ", mockNames));
sb.AppendLine(")");
}
else
{
sb.AppendLine($" .{codeNames.FunctionWithServicesName}()");
}
if (!codeNames.HasReturnType)
{
sb.AppendLine(" .WithResultType<int>()");
}
else
{
sb.AppendLine(" .WithNoResult()");
}
sb.AppendLine(" .Build();");
sb.AppendLine();
sb.AppendLine($" {logicGenerator.GetClassName(codeNames)} logic = new {logicGenerator.GetClassName(codeNames)}(policyScopeMock.Object);");
sb.AppendLine();
sb.AppendLine(" // Act and assert");
LogicGenerator dummyLogicGenerator = new LogicGenerator();
if (codeNames.IsAsync)
{
sb.AppendLine(
@" await Assert.ThrowsAsync<PolicyScopeMockException>(async () =>
{");
if (codeNames.HasReturnType)
{
sb.AppendLine($" int result = await logic.{dummyLogicGenerator.CreateFunctionName(codeNames)}();");
}
else
{
sb.AppendLine($" await logic.{dummyLogicGenerator.CreateFunctionName(codeNames)}();");
}
sb.AppendLine(
@" });");
}
else
{
sb.AppendLine(
@" Assert.Throws<PolicyScopeMockException>(() =>
{");
if (codeNames.HasReturnType)
{
sb.AppendLine($" int result = logic.{dummyLogicGenerator.CreateFunctionName(codeNames)}();");
}
else
{
sb.AppendLine($" logic.{dummyLogicGenerator.CreateFunctionName(codeNames)}();");
}
sb.AppendLine(
@" });");
}
sb.AppendLine(
@" }");
return(sb.ToString());
}
private static string Format(Code code)
{
return(CodeNames.GetName(code).PadRight(15));
}
public override string GetClassName(CodeNames codeNames)
{
return("Worker");
}
public string CreateClassCode(CodeNames codeNameBase, int maxServiceCount)
{
PolicyScopeResultSelectorMockGenerator policyScopeResultSelectorMockGenerator =
new PolicyScopeResultSelectorMockGenerator();
PolicyScopeServiceSelectorGenerator policyScopeServiceSelectorGenerator =
new PolicyScopeServiceSelectorGenerator();
PolicyScopeResultSelectorGenerator servicePolicyScopeBuilderGenerator =
new PolicyScopeResultSelectorGenerator();
StringBuilder sb = new StringBuilder();
sb.Append(
$@" internal class {GetClassNameAndTemplateParamaters(codeNameBase)} : {policyScopeServiceSelectorGenerator.GetInterfaceNameAndTemplateParamaters(codeNameBase)}
{{
internal {GetClassName(codeNameBase)}(IEnumerable<PolicyScopeMockConfiguration> configurations)
{{
Configurations = configurations;
}}
internal IEnumerable<PolicyScopeMockConfiguration> Configurations {{ get; }}
");
for (int serviceCount = 0; serviceCount <= maxServiceCount; serviceCount++)
{
if (serviceCount != 0)
{
sb.AppendLine();
}
CodeNames codeNames = new CodeNames(serviceCount, false, codeNameBase.IsAsync);
sb.Append(
$@" public {servicePolicyScopeBuilderGenerator.GetInterfaceNameAndTemplateParamaters(codeNames)} {codeNames.FunctionWithServicesName}{codeNames.TemplateParameters}()
{{
var configurations = Configurations
.Where(conf => conf.ServiceTypes.Count() == {codeNames.ServiceCount})");
for (int i = 0; i < codeNames.ServiceCount; i++)
{
sb.Append(
$@"
.Where(conf => typeof({codeNames.ServicesTypes[i]}).IsAssignableFrom(conf.ServiceTypes[{i}]))"
);
}
sb.AppendLine(
$@";
if(!configurations.Any())
{{
string errorMessage = ""Found no configuration with {codeNames.ServiceCount} {(codeNames.ServiceCount == 1 ? "service" : "services")}"";");
for (int i = 0; i < codeNames.ServiceCount; i++)
{
sb.AppendLine(
$@" errorMessage += Environment.NewLine + "" and service {i} is "" + typeof({codeNames.ServicesTypes[i]});"
);
}
sb.AppendLine(
$@" errorMessage += ""."";
throw new PolicyScopeMockException(errorMessage, Configurations);
}}
return new {policyScopeResultSelectorMockGenerator.GetClassNameAndTemplateParamaters(codeNames)}(configurations);
}}");
}
sb.AppendLine(
$@" }}");
return(sb.ToString());
}
public string CreateClassCode(CodeNames codeNames, int maxServiceCount)
{
StringBuilder sb = new StringBuilder();
sb.Append(
$@" public class {GetClassNameAndTemplateParamaters(codeNames)}
{{
public {GetClassName(codeNames)}(PolicyScopeMockBuilder policyScopeMockBuilder)
{{
PolicyScopeMockBuilder = policyScopeMockBuilder;
}}
protected PolicyScopeMockBuilder PolicyScopeMockBuilder {{ get; }}
");
PolicyScopeResultSelectorMockBuilderGenerator policyScopeResultSelectorMockGenerator =
new PolicyScopeResultSelectorMockBuilderGenerator();
for (int serviceCount = 0; serviceCount <= maxServiceCount; serviceCount++)
{
CodeNames codeNamesWithService = new CodeNames(serviceCount, false, codeNames.IsAsync);
string constructorServiceParameters = string.Empty;
string configurationCode = string.Empty;
if (codeNamesWithService.HasServices)
{
if (codeNamesWithService.ServiceCount == 1)
{
constructorServiceParameters = $"{codeNamesWithService.ServicesTypes.First()} service";
configurationCode =
$@"
PolicyScopeMockBuilder.NextConfiguration.ServiceTypes.Add(typeof({codeNamesWithService.ServicesTypes.First()}));
PolicyScopeMockBuilder.NextConfiguration.ServiceInstances.Add(service!);
";
}
else
{
configurationCode =
$@"
";
for (int i = 1; i <= codeNamesWithService.ServiceCount; i++)
{
if (i != 1)
{
constructorServiceParameters += ", ";
}
constructorServiceParameters += $"{codeNamesWithService.ServicesTypes[i - 1]} service{i}";
configurationCode +=
$@" PolicyScopeMockBuilder.NextConfiguration.ServiceTypes.Add(typeof({codeNamesWithService.ServicesTypes[i - 1]}));
PolicyScopeMockBuilder.NextConfiguration.ServiceInstances.Add(service{i}!);
";
}
}
}
sb.Append(
$@"
public {policyScopeResultSelectorMockGenerator.GetClassNameAndTemplateParamaters(codeNamesWithService)} {codeNamesWithService.FunctionWithServicesName}{codeNamesWithService.TemplateParameters}({constructorServiceParameters})
{{{configurationCode}
return new {policyScopeResultSelectorMockGenerator.GetClassNameAndTemplateParamaters(codeNamesWithService)}(PolicyScopeMockBuilder);
}}");
}
sb.Append(
$@"
}}
");
return(sb.ToString());
}
