public CInterface BuildSqlScriptInterface(KDataStoreTestProject sqlTestKProject)
{
var @interface = new CInterface()
{
InterfaceName = "ISqlScript",
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}.DataAccess"
},
};
AddNamespaceRefs(@interface);
@interface.Method.Add(new CMethod()
{
SignatureOnly = true, ReturnType = "ICommand", MethodName = "ToCommand"
});
@interface.Method.Add(new CMethod()
{
SignatureOnly = true, ReturnType = "IQuery<IEnumerable<T>>", MethodName = "ToQuery<T>"
});
return(@interface);
}
public CClass ReadSqlScriptClass(KDataStoreTestProject sqlTestKProject, KDataLayerProject dataLayerKProject)
{
var @class = new CClass("ReadSqlScript")
{
IsStatic = true,
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}.DataAccess"
}
};
AddNamespaceRefs(sqlTestKProject, @class);
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Internal,
IsStatic = true,
ReturnType = "string",
MethodName = "FromEmbeddedResource",
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "string", ParameterName = "scriptName"
}
},
CodeSnippet = $@"var sourceName = $""{dataLayerKProject.ProjectFullName}.EmbeddedSql.{{scriptName}}.esql"";
var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(a => a.FullName.Contains("".Data.SqlServer""));
var dataAssembly = assemblies.First();
return dataAssembly.ReadToEndEmbeddedResource(sourceName);"
});
return(@class);
}
public CClass BuildSqlScriptClass(KDataStoreTestProject sqlTestKProject)
{
var @class = new CClass("SqlScript")
{
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}.DataAccess"
},
Implements = new List <CInterface>()
{
new CInterface()
{
InterfaceName = "ISqlScript"
}
}
};
AddNamespaceRefs(@class);
@class.Constructor.Add(new CConstructor()
{
AccessModifier = CAccessModifier.Public,
ConstructorName = "SqlScript",
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "string", ParameterName = "name"
}, new CParameter()
{
Type = "object", ParameterName = "parameters", DefaultValue = "null"
}
},
CodeSnippet = @"Name = name;
Parameters = parameters; "
});
@class.Property.Add(new CProperty()
{
Type = "string", PropertyName = "Name"
});
@class.Property.Add(new CProperty()
{
Type = "object", PropertyName = "Parameters"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public, ReturnType = "ICommand", MethodName = "ToCommand", UseExpressionDefinition = true, CodeSnippet = "new EmbeddedSqlCommand(Name, Parameters);"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public, ReturnType = "IQuery<IEnumerable<T>>", MethodName = "ToQuery<T>", UseExpressionDefinition = true, CodeSnippet = "new EmbeddedSqlQuery<T>(Name, Parameters);"
});
return(@class);
}
public KDataStoreTestProject BuildDatabaseTestProject(KickstartWizardModel kickstartWizardModel, KProtoFile kProtoFile)
{
var databaseProject = new KDataStoreTestProject {
CompanyName = kickstartWizardModel.CompanyName, ProjectName = kickstartWizardModel.ProjectName,
Kickstart = kickstartWizardModel.CreateDatabaseTestProject
};
databaseProject.DataStoreType = kickstartWizardModel.DatabaseType;
return(databaseProject);
}
public CClass BuildAssemblyExtensionsClass(KDataStoreTestProject sqlTestKProject)
{
var @class = new CClass("AssemblyExtensions")
{
AccessModifier = CAccessModifier.Internal,
IsStatic = true,
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}.Extensions"
}
};
AddNamespaceRefs(@class);
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Internal,
IsStatic = true,
IsExtensionMethod = true,
ReturnType = "string",
MethodName = "ReadToEndEmbeddedResource",
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "Assembly", ParameterName = "assembly"
},
new CParameter()
{
Type = "string", ParameterName = "resourceName"
}
},
CodeSnippet = $@"if (assembly == null)
{{
throw new ArgumentNullException(nameof(assembly));
}}
var stream = assembly.GetManifestResourceStream(resourceName);
if (stream == null)
{{
throw new InvalidOperationException($""Embedded resource {{resourceName}} was not found in assembly <{{assembly.FullName}}>"");
}}
using (stream)
using (var reader = new StreamReader(stream))
{{
return reader.ReadToEnd();
}}"
});
return(@class);
}
private void AddNamespaceRefs(KDataStoreTestProject sqlTestKProject, CClass @class)
{
var namespaces = new List <string>
{
"System",
"System.Linq",
$"{sqlTestKProject.ProjectFullName}.Extensions"
};
foreach (var ns in namespaces)
{
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = ns
}
});
}
}
public CProject BuildProject(KSolution kSolution, KDataStoreProject dataStoreKProject, KDataStoreTestProject sqlTestKProject,
KDataLayerProject dataLayerKProject,
CProject dataStoreProject, CInterface dbProviderInterface, CClass dbProviderClass)
{
_dataStoreKProject = dataStoreKProject;
_sqlTestKProject = sqlTestKProject;
_dataLayerKProject = dataLayerKProject;
_dataStoreProject = dataStoreProject;
_dbProviderInterface = dbProviderInterface;
_dbProviderClass = dbProviderClass;
var dbTestProject = new CProject
{
ProjectName = sqlTestKProject.ProjectFullName,
ProjectShortName = sqlTestKProject.ProjectName,
ProjectFolder = sqlTestKProject.ProjectFolder,
ProjectType = CProjectType.CsProj
};
dbTestProject.ProjectReference.Add(dataStoreProject);
dbTestProject.TemplateProjectPath = @"templates\NetCore31ConsoleApp.csproj";
AddTestInitializationClass(dbTestProject);
AddStartupContainerClass(dbTestProject);
AddTestDataServiceClass(dbTestProject);
AddTestDataServiceBuilderInterface(dbTestProject);
AddTestDataServiceBuilderClass(dbTestProject);
AddReadSqlScriptClass(dbTestProject);
AddSqlScriptInterface(dbTestProject);
AddSqlScriptClass(dbTestProject);
AddEmbeddedSqlCommandClass(dbTestProject);
AddEmbeddedSqlQueryClass(dbTestProject);
AddAssemblyExtensionClass(dbTestProject);
AddAppSettingsJson(dbTestProject);
AddDataServiceTestClass(dbTestProject);
AddNuGetRefs(dbTestProject);
return(dbTestProject);
}
public CClass BuildTestInitializationClass(CProject dbTestProject, KDataStoreTestProject sqlTestKProject, CInterface dbProviderInterface)
{
var @class = new CClass("TestInitialization")
{
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}"
}
};
AddNamespaceRefs(@class, dbProviderInterface);
@class.ClassAttribute.Add(new CClassAttribute()
{
AttributeName = "TestClass"
});
@class.Field.Add(new CField()
{
AccessModifier = CAccessModifier.Public,
FieldType = "IServiceProvider",
IsStatic = true,
FieldName = "ServiceProvider"
});
@class.Field.Add(new CField()
{
AccessModifier = CAccessModifier.Private,
IsConst = true,
FieldType = "string",
FieldName = "EnvPrefix",
DefaultValue = @"""SAMPLE_SVC_TESTS_"""
});
@class.Property.Add(new CProperty()
{
AccessModifier = CAccessModifier.Private,
IsStatic = true,
Type = "string",
PropertyName = "EnvironmentName",
DefaultValue = @"Environment.GetEnvironmentVariable(""ASPNETCORE_ENVIRONMENT"")"
});
@class.Property.Add(new CProperty()
{
AccessModifier = CAccessModifier.Private, IsStatic = true, Type = "string", PropertyName = "ApplicationName", DefaultValue = "Environment.GetEnvironmentVariable(EnvPrefix + \"ApplicationName\") ?? \"daypart-integration-test\""
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
IsStatic = true,
ReturnType = "void",
MethodName = "AssemblySetup",
Attribute = new List <CMethodAttribute>()
{
new CMethodAttribute()
{
AttributeName = "AssemblyInitialize"
}
},
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "TestContext", ParameterName = "testContext"
}
},
CodeSnippet = "ServiceProvider = InitializeServiceProvider();"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
IsStatic = true,
ReturnType = "void",
MethodName = "AssemblyCleanup",
Attribute = new List <CMethodAttribute>()
{
new CMethodAttribute()
{
AttributeName = "AssemblyCleanup"
}
},
CodeSnippet = "ServiceProvider.Dispose();"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "void",
MethodName = "TestServiceProvider",
Attribute = new List <CMethodAttribute>()
{
new CMethodAttribute()
{
AttributeName = "TestMethod"
}
},
CodeSnippet = @"var container = ((StructureMapServiceProvider)ServiceProvider).Container;
/*
* Some of these could be intentional
*/
var dbConnectionMock = new Mock<DbConnection>();
var dbTransactionMock = new Mock<DbTransaction>();
container.Configure(c =>
{
c.For<IDbConnection>().Use(dbConnectionMock.Object);
c.For<IDbTransaction>().Use(dbTransactionMock.Object);
});
container.AssertConfigurationIsValid();"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Private,
IsStatic = true,
ReturnType = "IServiceProvider",
MethodName = "InitializeServiceProvider",
CodeSnippet = $@"var configuration = InitializeConfiguration();
var serviceCollection = InitializeServiceCollection(configuration);
serviceCollection.AddTransient<{dbProviderInterface.InterfaceName}>(
p =>
{{
return new EventCaptureDbProvider(configuration.GetConnectionString(""EventCapture""));
}});
return serviceCollection.ConfigureContainer();//configuration);"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Private,
IsStatic = true,
ReturnType = "IServiceCollection",
MethodName = "InitializeServiceCollection",
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "IConfigurationRoot", ParameterName = "config"
}
},
CodeSnippet = @"var serviceCollection = new ServiceCollection();
/*ServiceCollectionExtensions.ConfigureServiceCollection(serviceCollection, config)
.Configure<AppSettings>(config)
.Configure<DaypartConfig>(config.GetSection(""zzzzz""));*/
return serviceCollection; "
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Private,
IsStatic = true,
ReturnType = "IConfigurationRoot",
MethodName = "InitializeConfiguration",
CodeSnippet = @"return new ConfigurationBuilder()
.AddJsonFile(""appsettings.json"", false)
.AddJsonFile($""appsettings.{EnvironmentName}.json"", true)
.AddEnvironmentVariables(EnvPrefix)
.AddConfigCenter(ApplicationName, EnvPrefix)
.Build(); "
});
return(@class);
}
public CClass BuildTestDataServiceBuilderClass(KDataStoreTestProject sqlTestKProject)
{
var @class = new CClass("TestDataServiceBuilder<T>")
{
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}.DataAccess"
},
Implements = new List <CInterface>()
{
new CInterface()
{
InterfaceName = "ITestDataServiceBuilder<T>"
}
},
Where = new List <CWhere> {
new CWhere()
{
WhereName = "T : IDbProvider"
}
}
};
AddNamespaceRefs(@class);
@class.Field.Add(new CField {
AccessModifier = CAccessModifier.Private, IsReadonly = true, FieldType = "TestDataService<T>", FieldName = "_dataService"
});
@class.Constructor.Add(new CConstructor()
{
AccessModifier = CAccessModifier.Public,
ConstructorName = "TestDataServiceBuilder",
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "TestDataService<T>", ParameterName = "dataService"
}
},
CodeSnippet = @"_dataService = dataService;"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "ITestDataServiceBuilder<T>",
MethodName = "NewSetup",
CodeSnippet = @"_dataService.Reset();
return this;"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "ITestDataServiceBuilder<T>",
MethodName = "WithSeedScript",
Parameter = new List <CParameter>()
{
new CParameter {
Type = "string", ParameterName = "scriptName"
},
new CParameter {
Type = "object", ParameterName = "parameters", DefaultValue = "null"
}
},
CodeSnippet = @" _dataService.AddSeedScript(new SqlScript(scriptName, parameters));
return this;"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "ITestDataServiceBuilder<T>",
MethodName = "WithSeedQuery",
Parameter = new List <CParameter>()
{
new CParameter {
Type = "string", ParameterName = "scriptName"
},
new CParameter {
Type = "object", ParameterName = "parameters", DefaultValue = "null"
}
},
CodeSnippet = @" _dataService.AddSeedQuery(new SqlScript(scriptName, parameters));
return this;"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "ITestDataServiceBuilder<T>",
MethodName = "WithCleanScript",
Parameter = new List <CParameter>()
{
new CParameter {
Type = "string", ParameterName = "scriptName"
},
new CParameter {
Type = "object", ParameterName = "parameters", DefaultValue = "null"
}
},
CodeSnippet = @" _dataService.AddCleanupScript(new SqlScript(scriptName, parameters));
return this;"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "TestDataService<T>",
MethodName = "Create",
CodeSnippet = @"return _dataService;"
});
return(@class);
}
public CClass BuildStartupContainerClass(KDataStoreTestProject sqlTestKProject, CInterface dbProviderInterface, CClass dbProviderClass)
{
var @class = new CClass("ServiceCollectionExtensions")
{
Namespace = new CNamespace
{
NamespaceName =
$"{sqlTestKProject.CompanyName}.{sqlTestKProject.ProjectName}{sqlTestKProject.NamespaceSuffix}.{sqlTestKProject.ProjectSuffix}.Startup"
},
AccessModifier = CAccessModifier.Public,
IsStatic = true
};
AddNamespaceRefs(@class, dbProviderInterface);
@class.Field.Add(new CField
{
AccessModifier = CAccessModifier.Private,
IsStatic = true,
FieldType = "IContainer",
FieldName = "_container"
});
@class.Method.Add(new CMethod
{
IsStatic = true,
IsExtensionMethod = true,
ReturnType = "IServiceProvider",
MethodName = "ConfigureContainer",
Parameter = new List <CParameter>
{
new CParameter {
Type = "IServiceCollection", ParameterName = "services"
}
},
CodeSnippet =
$@"
r.Scan(scanner =>
{{
scanner.AssembliesAndExecutablesFromApplicationBaseDirectory(a => a.FullName.StartsWith(""Company""));
scanner.WithDefaultConventions();
scanner.ConnectImplementationsToTypesClosing(typeof(IRequestHandler<,>));
scanner.ConnectImplementationsToTypesClosing(typeof(INotificationHandler<>));
}});
r.For<IMediator>().Use<Mediator>().Transient();
r.For<ServiceFactory>().Use(ctx => ctx.GetInstance);
r.For<IMediatorExecutor>().Use(ctx => new MediatorExecutor(ctx.GetInstance<IServiceScopeFactory>()));
r.AddAppServices(configuration);
r.AddSingleton(configuration)
.AddLogging()
.AddOptions()
.Configure<CloudformationOutputs>(configuration.GetSection(""CloudformationOutputs""))
.Configure<AuthenticationSettings>(configuration.GetSection(""Authentication""));
var tracingOptions = new TracingOptions(configuration);
if (tracingOptions.Enabled)
{{
r.AddDatadogOpenTracing(new TracingSettings
{{
TracingAddress = tracingOptions.TracingAddress,
ServiceName = tracingOptions.ServiceName
}});
r.AddTransient<IDbDiagnosticsFactory, ServiceDbDiagnosticsFactory>();
}}
"
});
@class.Method.Add(
new CMethod
{
AccessModifier = CAccessModifier.Public,
IsStatic = true,
IsExtensionMethod = true,
ReturnType = "void",
MethodName = "Dispose",
Parameter = new List <CParameter>
{
new CParameter {
Type = "IServiceProvider", ParameterName = "services"
}
},
CodeSnippet = "_container.Dispose();"
});
return(@class);
}
public CClass BuildEmbeddedSqlCommandBuilderClass(KDataStoreTestProject sqlTestKProject)
{
var @class = new CClass("EmbeddedSqlCommand")
{
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}.DataAccess"
},
Implements = new List <CInterface>()
{
new CInterface()
{
InterfaceName = "ICommand"
}
}
};
AddNamespaceRefs(@class);
@class.Constructor.Add(new CConstructor()
{
AccessModifier = CAccessModifier.Public,
ConstructorName = "EmbeddedSqlCommand",
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "string", ParameterName = "scriptName"
},
new CParameter()
{
Type = "object", ParameterName = "param", DefaultValue = "null"
},
new CParameter()
{
Type = "int?", ParameterName = "commandTimeout", DefaultValue = "null"
},
new CParameter()
{
Type = "CommandType?", ParameterName = "commandType", DefaultValue = "null"
},
},
CodeSnippet = @"_query = ReadSqlScript.FromEmbeddedResource(scriptName);
_parameters = param;
_commandTimeout = commandTimeout;
_commandType = commandType;"
});
@class.Field.Add(new CField()
{
IsReadonly = true, FieldType = "string", FieldName = "_query"
});
@class.Field.Add(new CField()
{
IsReadonly = true, FieldType = "object", FieldName = "_parameters"
});
@class.Field.Add(new CField()
{
IsReadonly = true, FieldType = "int?", FieldName = "_commandTimeout"
});
@class.Field.Add(new CField()
{
IsReadonly = true, FieldType = "CommandType?", FieldName = "_commandType"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = "Task<int>",
MethodName = "Execute",
Parameter = new List <CParameter> {
new CParameter()
{
Type = "IDatastoreConnectionProxy", ParameterName = "datastoreConnectionProxy"
}
},
CodeSnippet = @"return await datastoreConnectionProxy.Execute(_query, _parameters, _commandTimeout, _commandType)
.ConfigureAwait(false); "
});
return(@class);
}
public CClass BuildTestDataServiceClass(KDataStoreTestProject sqlTestKProject)
{
var @class = new CClass("TestDataService<T>")
{
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}.DataAccess"
},
InheritsFrom = new CClass("BaseDataService<T>")
{
},
Where = new List <CWhere>()
{
new CWhere()
{
WhereName = "T : IDbProvider"
}
}
};
AddNamespaceRefs(@class);
@class.Constructor.Add(new CConstructor()
{
AccessModifier = CAccessModifier.Public,
ConstructorName = "TestDataService",
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "IDatastoreContext<T>", ParameterName = "datastoreContext", PassToBaseClass = true
}
},
CodeSnippet = "//EmptyConstructor"
});
@class.Field.Add(new CField()
{
AccessModifier = CAccessModifier.Private,
IsReadonly = true,
FieldType = "List<ISqlScript>",
FieldName = "_seedScripts",
DefaultValue = "new List<ISqlScript>()"
});
@class.Field.Add(new CField()
{
AccessModifier = CAccessModifier.Private,
IsReadonly = true,
FieldType = "List<ISqlScript>",
FieldName = "_seedQueries",
DefaultValue = "new List<ISqlScript>()"
});
@class.Field.Add(new CField()
{
AccessModifier = CAccessModifier.Private,
IsReadonly = true,
FieldType = "List<ISqlScript>",
FieldName = "_cleanScripts",
DefaultValue = "new List<ISqlScript>()"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "void",
MethodName = "Reset",
CodeSnippet = @"_seedScripts.Clear();
_seedQueries.Clear();
_cleanScripts.Clear();"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "void",
MethodName = "AddSeedScript",
CodeSnippet = @" _seedScripts.Add(script);",
Parameter = new List <CParameter> {
new CParameter()
{
Type = "ISqlScript", ParameterName = "script"
}
}
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "void",
MethodName = "AddSeedQuery",
CodeSnippet = @" _seedQueries.Add(script);",
Parameter = new List <CParameter> {
new CParameter()
{
Type = "ISqlScript", ParameterName = "script"
}
}
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "void",
MethodName = "AddCleanupScript",
CodeSnippet = @" _cleanScripts.Add(script);",
Parameter = new List <CParameter> {
new CParameter()
{
Type = "ISqlScript", ParameterName = "script"
}
}
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = "Task<T1>",
MethodName = "Query<T1>",
CodeSnippet = @"return await DatastoreContext.Query(query)
.ConfigureAwait(false);",
Parameter = new List <CParameter> {
new CParameter()
{
Type = "IQuery<T1>", ParameterName = "query"
}
}
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = "Task<int>",
MethodName = "Execute",
CodeSnippet = @"return await DatastoreContext.Execute(command)
.ConfigureAwait(false);",
Parameter = new List <CParameter> {
new CParameter()
{
Type = "ICommand", ParameterName = "command"
}
}
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = "Task",
MethodName = "SeedAsync",
CodeSnippet = @"await ExecuteAsync(_seedScripts);"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = "Task<IEnumerable<T1>>",
MethodName = "SeedQueryAsync<T1>",
CodeSnippet = @"return await QueryAsync<T1>(_seedQueries);"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = "Task",
MethodName = "CleanUpAsync",
CodeSnippet = @"await ExecuteAsync(_cleanScripts);"
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = "Task<IEnumerable<T1>>",
MethodName = "QueryScriptAsync<T1>",
CodeSnippet = @"var query = new EmbeddedSqlQuery<T1>(scriptName, parameters);
return await DatastoreContext.Query(query);",
Parameter = new List <CParameter>
{
new CParameter()
{
Type = "string", ParameterName = "scriptName"
},
new CParameter()
{
Type = "object", ParameterName = "parameters", DefaultValue = "null"
}
}
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = "Task",
MethodName = "ExecuteAsync",
CodeSnippet = @"var command = new EmbeddedSqlCommand(scriptName, parameters);
await DatastoreContext.Execute(command);",
Parameter = new List <CParameter>
{
new CParameter()
{
Type = "string", ParameterName = "scriptName"
},
new CParameter()
{
Type = "object", ParameterName = "parameters", DefaultValue = "null"
}
}
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Private,
IsAsync = true,
ReturnType = "Task",
MethodName = "ExecuteAsync",
CodeSnippet = @"foreach (var script in scripts)
{
await DatastoreContext.Execute(script.ToCommand());
}",
Parameter = new List <CParameter>
{
new CParameter()
{
Type = "IEnumerable<ISqlScript>", ParameterName = "scripts"
}
}
});
@class.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Private,
IsAsync = true,
ReturnType = "Task<IEnumerable<T>>",
MethodName = "QueryAsync<T>",
CodeSnippet = @"var results = (await Task.WhenAll(scripts.Select(async s => await DatastoreContext.Query(s.ToQuery<T>()))))
.Aggregate(Enumerable.Empty<T>(), (result, next) => result.Concat(next))
.ToArray();
return results;",
Parameter = new List <CParameter>
{
new CParameter()
{
Type = "IEnumerable<ISqlScript>", ParameterName = "scripts"
}
}
});
return(@class);
}
public CInterface BuildTestDataServiceBuilderInterface(KDataStoreTestProject sqlTestKProject)
{
var @interface = new CInterface()
{
InterfaceName = "ITestDataServiceBuilder<T>",
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}.DataAccess"
},
Where = new List <CWhere> {
new CWhere()
{
WhereName = "T : IDbProvider"
}
}
};
AddNamespaceRefs(@interface);
@interface.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "ITestDataServiceBuilder<T>",
MethodName = "NewSetup",
SignatureOnly = true
});
@interface.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "ITestDataServiceBuilder<T>",
MethodName = "WithSeedScript",
Parameter = new List <CParameter>()
{
new CParameter {
Type = "string", ParameterName = "scriptName"
},
new CParameter {
Type = "object", ParameterName = "parameters", DefaultValue = "null"
}
},
SignatureOnly = true
});
@interface.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "ITestDataServiceBuilder<T>",
MethodName = "WithSeedQuery",
Parameter = new List <CParameter>()
{
new CParameter {
Type = "string", ParameterName = "scriptName"
},
new CParameter {
Type = "object", ParameterName = "parameters", DefaultValue = "null"
}
},
SignatureOnly = true
});
@interface.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "ITestDataServiceBuilder<T>",
MethodName = "WithCleanScript",
Parameter = new List <CParameter>()
{
new CParameter {
Type = "string", ParameterName = "scriptName"
},
new CParameter {
Type = "object", ParameterName = "parameters", DefaultValue = "null"
}
},
SignatureOnly = true
});
@interface.Method.Add(new CMethod()
{
AccessModifier = CAccessModifier.Public,
ReturnType = "TestDataService<T>",
MethodName = "Create",
SignatureOnly = true
});
return(@interface);
}
public CClass BuildDataServiceTestClass(KDataStoreProject sqlKProject, KDataLayerProject dataLayerKProject, KDataStoreTestProject sqlTestKProject, CInterface dbProviderInterface)
{
var @class = new CClass("EventCaptureDataServiceTest")
{
Namespace = new CNamespace()
{
NamespaceName =
$"{sqlTestKProject.ProjectFullName}"
},
ClassAttribute = new List <CClassAttribute>()
{
new CClassAttribute()
{
AttributeName = "TestClass"
}
}
};
AddNamespaceRefs(@class, dbProviderInterface);
@class.Field.Add(new CField()
{
AccessModifier = CAccessModifier.Private,
IsStatic = true,
FieldType = $"TestDataService<{dbProviderInterface.InterfaceName}>",
FieldName = "_testDataService"
});
@class.Method.Add(new CMethod()
{
Attribute = new List <CMethodAttribute>()
{
new CMethodAttribute()
{
AttributeName = "ClassInitialize"
}
},
AccessModifier = CAccessModifier.Public,
IsStatic = true,
ReturnType = "void",
MethodName = "ClassInitialize",
Parameter = new List <CParameter>()
{
new CParameter()
{
Type = "TestContext", ParameterName = "context"
}
},
CodeSnippet = $@"var testDataServiceBuilder =
TestInitialization.ServiceProvider.GetService<ITestDataServiceBuilder<{dbProviderInterface.InterfaceName}>>();
_testDataService = testDataServiceBuilder.Create();
_testDataService.SeedAsync()
.GetAwaiter()
.GetResult();"
});
var service = new DataLayerServiceProjectServiceBase();
foreach (var kStoredProcedure in sqlKProject.StoredProcedure)
{
if (!string.IsNullOrEmpty(kStoredProcedure.ParameterSetName))
{
var @entityClass = service.BuildParameterEntityClass(kStoredProcedure.GeneratedStoredProcedure, kStoredProcedure.ParameterSetName);
int x = 1;
}
if (!string.IsNullOrWhiteSpace(kStoredProcedure.ResultSetName))
{
var @entityClass = service.BuildResultEntityClass(kStoredProcedure.GeneratedStoredProcedure, kStoredProcedure.ResultSetName, dataLayerKProject);
@class.Method.Add(new CMethod()
{
Attribute = new List <CMethodAttribute>()
{
new CMethodAttribute()
{
AttributeName = "TestMethod"
}
},
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = "Task",
MethodName = $"Test{kStoredProcedure.StoredProcedureName}",
CodeSnippet = $@"var result = await _testDataService.Query(new EmbeddedSqlQuery<{@entityClass.ClassName}>(""{kStoredProcedure.StoredProcedureName}""));"
});
}
}
return(@class);
}
