6497765030

Committed 12 Oct 2023 03:22PM UTC coverage: 51.463% (+0.5%) from 50.964%

Build # 6497765030

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #306 from loresoft/feature/services

Feature/services

Run Details

979 of 2448 branches covered (0.0%)

Branch coverage included in aggregate %.

213 of 213 new or added lines in 8 files covered. (100.0%)

2890 of 5070 relevant lines covered (57.0%)

156.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.53

/src/FluentCommand/DataConfigurationBuilder.cs

using System.Data.Common;

using FluentCommand.Extensions;
using FluentCommand.Query.Generators;

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;

namespace FluentCommand;

public class DataConfigurationBuilder
{
    private readonly IServiceCollection _services;
    private string _connectionName;
    private string _connectionString;
    private Type _providerFactoryType;
    private Type _dataCacheType;
    private Type _queryGeneratorType;
    private Type _queryLoggerType;

    public DataConfigurationBuilder(IServiceCollection services)
    {
        _services = services;
    }


    public DataConfigurationBuilder UseConnectionName(string connectionName)
    {
        _connectionName = connectionName;
        return this;
    }

    public DataConfigurationBuilder UseConnectionString(string connectionString)
    {
        _connectionString = connectionString;
        return this;
    }


    public DataConfigurationBuilder AddProviderFactory<TService>(TService providerFactory)
        where TService : DbProviderFactory
    {
        _providerFactoryType = typeof(TService);
        _services.TryAddSingleton(providerFactory);
        return this;
    }

    public DataConfigurationBuilder AddProviderFactory<TService>(Func<IServiceProvider, TService> implementationFactory)
        where TService : DbProviderFactory
    {
        _providerFactoryType = typeof(TService);
        _services.TryAddSingleton(implementationFactory);
        return this;
    }

    public DataConfigurationBuilder AddProviderFactory<TService>()
        where TService : DbProviderFactory
    {
        _providerFactoryType = typeof(TService);
        _services.TryAddSingleton<TService>();
        return this;
    }


    public DataConfigurationBuilder AddDataCache<TService>(TService dataCache)
        where TService : class, IDataCache
    {
        _dataCacheType = typeof(TService);
        _services.TryAddSingleton(dataCache);
        return this;
    }

    public DataConfigurationBuilder AddDataCache<TService>(Func<IServiceProvider, TService> implementationFactory)
        where TService : class, IDataCache
    {
        _dataCacheType = typeof(TService);
        _services.TryAddSingleton(implementationFactory);
        return this;
    }

    public DataConfigurationBuilder AddDataCache<TService>()
        where TService : class, IDataCache
    {
        _dataCacheType = typeof(TService);
        _services.TryAddSingleton<TService>();
        return this;
    }


    public DataConfigurationBuilder AddQueryGenerator<TService>(TService queryGenerator)
        where TService : class, IQueryGenerator
    {
        _queryGeneratorType = typeof(TService);
        _services.TryAddSingleton(queryGenerator);
        return this;
    }

    public DataConfigurationBuilder AddQueryGenerator<TService>()
        where TService : class, IQueryGenerator
    {
        _queryGeneratorType = typeof(TService);
        _services.TryAddSingleton<TService>();
        return this;
    }

    public DataConfigurationBuilder AddQueryGenerator<TService>(Func<IServiceProvider, TService> implementationFactory)
        where TService : class, IQueryGenerator
    {
        _queryGeneratorType = typeof(TService);
        _services.TryAddSingleton(implementationFactory);
        return this;
    }

    public DataConfigurationBuilder AddSqlServerGenerator()
    {
        AddQueryGenerator<SqlServerGenerator>();
        return this;
    }

    public DataConfigurationBuilder AddSqliteGenerator()
    {
        AddQueryGenerator<SqliteGenerator>();
        return this;
    }

    public DataConfigurationBuilder AddPostgreSqlGenerator()
    {
        AddQueryGenerator<PostgreSqlGenerator>();
        return this;
    }


    public DataConfigurationBuilder AddQueryLogger<TService>(TService queryLogger)
        where TService : class, IDataQueryLogger
    {
        _queryLoggerType = typeof(TService);
        _services.TryAddSingleton(queryLogger);
        return this;
    }

    public DataConfigurationBuilder AddQueryLogger<TService>()
        where TService : class, IDataQueryLogger
    {
        _queryLoggerType = typeof(TService);
        _services.TryAddSingleton<TService>();
        return this;
    }

    public DataConfigurationBuilder AddQueryLogger<TService>(Func<IServiceProvider, TService> implementationFactory)
        where TService : class, IDataQueryLogger
    {
        _queryLoggerType = typeof(TService);
        _services.TryAddSingleton(implementationFactory);
        return this;
    }


    public DataConfigurationBuilder AddService(Action<IServiceCollection> setupAction)
    {
        setupAction(_services);
        return this;
    }


    internal void AddConfiguration()
    {
        RegisterDefaults();

        // resolve using specific types to support multiple configurations
        var providerFactory = _providerFactoryType ?? typeof(DbProviderFactory);
        var dataCache = _dataCacheType ?? typeof(IDataCache);
        var queryGenerator = _queryGeneratorType ?? typeof(IQueryGenerator);
        var queryLogger = _queryLoggerType ?? typeof(IDataQueryLogger);

        if (_connectionName.HasValue())
        {
            _services.TryAddSingleton<IDataConfiguration>(sp =>
            {
                var configuration = sp.GetRequiredService<IConfiguration>();
                var connectionString = configuration.GetConnectionString(_connectionName);

                return new DataConfiguration(
                    sp.GetRequiredService(providerFactory) as DbProviderFactory,
                    connectionString,
                    sp.GetService(dataCache) as IDataCache,
                    sp.GetService(queryGenerator) as IQueryGenerator,
                    sp.GetService(queryLogger) as IDataQueryLogger
                );
            });
        }
        else
        {
            _services.TryAddSingleton<IDataConfiguration>(sp =>
                new DataConfiguration(
                    sp.GetRequiredService(providerFactory) as DbProviderFactory,
                    _connectionString,
                    sp.GetService(dataCache) as IDataCache,
                    sp.GetService(queryGenerator) as IQueryGenerator,
                    sp.GetService(queryLogger) as IDataQueryLogger
                )
            );
        }

        _services.TryAddTransient<IDataSessionFactory>(sp => sp.GetService<IDataConfiguration>());
        _services.TryAddTransient<IDataSession, DataSession>();
    }

    internal void AddConfiguration<TDiscriminator>()
    {
        RegisterDefaults();

        // resolve using specific types to support multiple configurations
        var providerFactory = _providerFactoryType ?? typeof(DbProviderFactory);
        var dataCache = _dataCacheType ?? typeof(IDataCache);
        var queryGenerator = _queryGeneratorType ?? typeof(IQueryGenerator);
        var queryLogger = _queryLoggerType ?? typeof(IDataQueryLogger);

        if (_connectionName.HasValue())
        {
            _services.TryAddSingleton<IDataConfiguration<TDiscriminator>>(sp =>
            {
                var configuration = sp.GetRequiredService<IConfiguration>();
                var connectionString = configuration.GetConnectionString(_connectionName);

                return new DataConfiguration<TDiscriminator>(
                    sp.GetRequiredService(providerFactory) as DbProviderFactory,
                    connectionString,
                    sp.GetService(dataCache) as IDataCache,
                    sp.GetService(queryGenerator) as IQueryGenerator,
                    sp.GetService(queryLogger) as IDataQueryLogger
                );
            });
        }
        else
        {
            _services.TryAddSingleton<IDataConfiguration<TDiscriminator>>(sp =>
                new DataConfiguration<TDiscriminator>(
                    sp.GetRequiredService(providerFactory) as DbProviderFactory,
                    _connectionString,
                    sp.GetService(dataCache) as IDataCache,
                    sp.GetService(queryGenerator) as IQueryGenerator,
                    sp.GetService(queryLogger) as IDataQueryLogger
                )
            );
        }

        _services.TryAddTransient<IDataSessionFactory<TDiscriminator>>(sp => sp.GetService<IDataConfiguration<TDiscriminator>>());
        _services.TryAddTransient<IDataSession<TDiscriminator>, DataSession<TDiscriminator>>();
    }

    private void RegisterDefaults()
    {
        // add defaults if not already added
        _services.TryAddSingleton<IDataQueryFormatter, DataQueryFormatter>();

        // convert specific types to interfaces
        if (_providerFactoryType != null)
            _services.TryAddSingleton(sp => sp.GetService(_providerFactoryType) as DbProviderFactory);

        if (_dataCacheType != null)
            _services.TryAddSingleton(sp => sp.GetService(_dataCacheType) as IDataCache);

        if (_queryGeneratorType != null)
            _services.TryAddSingleton(sp => sp.GetService(_queryGeneratorType) as IQueryGenerator);
        else
            _services.TryAddSingleton<IQueryGenerator, SqlServerGenerator>();

        if (_queryLoggerType != null)
            _services.TryAddSingleton(sp => sp.GetService(_queryLoggerType) as IDataQueryLogger);
        else
            _services.TryAddSingleton<IDataQueryLogger, DataQueryLogger>();

    }
}

1	using System.Data.Common;
2
3	using FluentCommand.Extensions;
4	using FluentCommand.Query.Generators;
5
6	using Microsoft.Extensions.Configuration;
7	using Microsoft.Extensions.DependencyInjection;
8	using Microsoft.Extensions.DependencyInjection.Extensions;
9
10	namespace FluentCommand;
11
12	public class DataConfigurationBuilder
13	{
14	private readonly IServiceCollection _services;
15	private string _connectionName;
16	private string _connectionString;
17	private Type _providerFactoryType;
18	private Type _dataCacheType;
19	private Type _queryGeneratorType;
20	private Type _queryLoggerType;
21
22	public DataConfigurationBuilder(IServiceCollection services)
23	{
24	_services = services;	4✔
25	}	4✔
26
27
28	public DataConfigurationBuilder UseConnectionName(string connectionName)
29	{
30	_connectionName = connectionName;	2✔
31	return this;	2✔
32	}
33
34	public DataConfigurationBuilder UseConnectionString(string connectionString)
35	{
36	_connectionString = connectionString;	2✔
37	return this;	2✔
38	}
39
40
41	public DataConfigurationBuilder AddProviderFactory<TService>(TService providerFactory)
42	where TService : DbProviderFactory
43	{
44	_providerFactoryType = typeof(TService);	4✔
45	_services.TryAddSingleton(providerFactory);	4✔
46	return this;	4✔
47	}
48
49	public DataConfigurationBuilder AddProviderFactory<TService>(Func<IServiceProvider, TService> implementationFactory)
50	where TService : DbProviderFactory
51	{
52	_providerFactoryType = typeof(TService);	×
53	_services.TryAddSingleton(implementationFactory);	×
54	return this;	×
55	}
56
57	public DataConfigurationBuilder AddProviderFactory<TService>()
58	where TService : DbProviderFactory
59	{
60	_providerFactoryType = typeof(TService);	×
61	_services.TryAddSingleton<TService>();	×
62	return this;	×
63	}
64
65
66	public DataConfigurationBuilder AddDataCache<TService>(TService dataCache)
67	where TService : class, IDataCache
68	{
69	_dataCacheType = typeof(TService);	×
70	_services.TryAddSingleton(dataCache);	×
71	return this;	×
72	}
73
74	public DataConfigurationBuilder AddDataCache<TService>(Func<IServiceProvider, TService> implementationFactory)
75	where TService : class, IDataCache
76	{
77	_dataCacheType = typeof(TService);	×
78	_services.TryAddSingleton(implementationFactory);	×
79	return this;	×
80	}
81
82	public DataConfigurationBuilder AddDataCache<TService>()
83	where TService : class, IDataCache
84	{
85	_dataCacheType = typeof(TService);	2✔
86	_services.TryAddSingleton<TService>();	2✔
87	return this;	2✔
88	}
89
90
91	public DataConfigurationBuilder AddQueryGenerator<TService>(TService queryGenerator)
92	where TService : class, IQueryGenerator
93	{
94	_queryGeneratorType = typeof(TService);	×
95	_services.TryAddSingleton(queryGenerator);	×
96	return this;	×
97	}
98
99	public DataConfigurationBuilder AddQueryGenerator<TService>()
100	where TService : class, IQueryGenerator
101	{
102	_queryGeneratorType = typeof(TService);	4✔
103	_services.TryAddSingleton<TService>();	4✔
104	return this;	4✔
105	}
106
107	public DataConfigurationBuilder AddQueryGenerator<TService>(Func<IServiceProvider, TService> implementationFactory)
108	where TService : class, IQueryGenerator
109	{
110	_queryGeneratorType = typeof(TService);	×
111	_services.TryAddSingleton(implementationFactory);	×
112	return this;	×
113	}
114
115	public DataConfigurationBuilder AddSqlServerGenerator()
116	{
117	AddQueryGenerator<SqlServerGenerator>();	2✔
118	return this;	2✔
119	}
120
121	public DataConfigurationBuilder AddSqliteGenerator()
122	{
123	AddQueryGenerator<SqliteGenerator>();	1✔
124	return this;	1✔
125	}
126
127	public DataConfigurationBuilder AddPostgreSqlGenerator()
128	{
129	AddQueryGenerator<PostgreSqlGenerator>();	1✔
130	return this;	1✔
131	}
132
133
134	public DataConfigurationBuilder AddQueryLogger<TService>(TService queryLogger)
135	where TService : class, IDataQueryLogger
136	{
137	_queryLoggerType = typeof(TService);	×
138	_services.TryAddSingleton(queryLogger);	×
139	return this;	×
140	}
141
142	public DataConfigurationBuilder AddQueryLogger<TService>()
143	where TService : class, IDataQueryLogger
144	{
145	_queryLoggerType = typeof(TService);	×
146	_services.TryAddSingleton<TService>();	×
147	return this;	×
148	}
149
150	public DataConfigurationBuilder AddQueryLogger<TService>(Func<IServiceProvider, TService> implementationFactory)
151	where TService : class, IDataQueryLogger
152	{
153	_queryLoggerType = typeof(TService);	×
154	_services.TryAddSingleton(implementationFactory);	×
155	return this;	×
156	}
157
158
159	public DataConfigurationBuilder AddService(Action<IServiceCollection> setupAction)
160	{
161	setupAction(_services);	2✔
162	return this;	2✔
163	}
164
165
166	internal void AddConfiguration()
167	{
168	RegisterDefaults();	3✔
169
170	// resolve using specific types to support multiple configurations
171	var providerFactory = _providerFactoryType ?? typeof(DbProviderFactory);	3!
172	var dataCache = _dataCacheType ?? typeof(IDataCache);	3✔
173	var queryGenerator = _queryGeneratorType ?? typeof(IQueryGenerator);	3!
174	var queryLogger = _queryLoggerType ?? typeof(IDataQueryLogger);	3✔
175
176	if (_connectionName.HasValue())	3✔
177	{
178	_services.TryAddSingleton<IDataConfiguration>(sp =>	2✔
179	{	2✔
180	var configuration = sp.GetRequiredService<IConfiguration>();	2✔
181	var connectionString = configuration.GetConnectionString(_connectionName);	2✔
182		2✔
183	return new DataConfiguration(	2✔
184	sp.GetRequiredService(providerFactory) as DbProviderFactory,	2✔
185	connectionString,	2✔
186	sp.GetService(dataCache) as IDataCache,	2✔
187	sp.GetService(queryGenerator) as IQueryGenerator,	2✔
188	sp.GetService(queryLogger) as IDataQueryLogger	2✔
189	);	2✔
190	});	2✔
191	}
192	else
193	{
194	_services.TryAddSingleton<IDataConfiguration>(sp =>	1✔
195	new DataConfiguration(	1✔
196	sp.GetRequiredService(providerFactory) as DbProviderFactory,	1✔
197	_connectionString,	1✔
198	sp.GetService(dataCache) as IDataCache,	1✔
199	sp.GetService(queryGenerator) as IQueryGenerator,	1✔
200	sp.GetService(queryLogger) as IDataQueryLogger	1✔
201	)	1✔
202	);	1✔
203	}
204
205	_services.TryAddTransient<IDataSessionFactory>(sp => sp.GetService<IDataConfiguration>());	3✔
206	_services.TryAddTransient<IDataSession, DataSession>();	3✔
207	}	3✔
208
209	internal void AddConfiguration<TDiscriminator>()
210	{
211	RegisterDefaults();	1✔
212
213	// resolve using specific types to support multiple configurations
214	var providerFactory = _providerFactoryType ?? typeof(DbProviderFactory);	1!
215	var dataCache = _dataCacheType ?? typeof(IDataCache);	1!
216	var queryGenerator = _queryGeneratorType ?? typeof(IQueryGenerator);	1!
217	var queryLogger = _queryLoggerType ?? typeof(IDataQueryLogger);	1✔
218
219	if (_connectionName.HasValue())	1!
220	{
221	_services.TryAddSingleton<IDataConfiguration<TDiscriminator>>(sp =>	×
222	{	×
223	var configuration = sp.GetRequiredService<IConfiguration>();	×
224	var connectionString = configuration.GetConnectionString(_connectionName);	×
225		×
226	return new DataConfiguration<TDiscriminator>(	×
227	sp.GetRequiredService(providerFactory) as DbProviderFactory,	×
228	connectionString,	×
229	sp.GetService(dataCache) as IDataCache,	×
230	sp.GetService(queryGenerator) as IQueryGenerator,	×
231	sp.GetService(queryLogger) as IDataQueryLogger	×
232	);	×
233	});	×
234	}
235	else
236	{
237	_services.TryAddSingleton<IDataConfiguration<TDiscriminator>>(sp =>	1✔
238	new DataConfiguration<TDiscriminator>(	1✔
239	sp.GetRequiredService(providerFactory) as DbProviderFactory,	1✔
240	_connectionString,	1✔
241	sp.GetService(dataCache) as IDataCache,	1✔
242	sp.GetService(queryGenerator) as IQueryGenerator,	1✔
243	sp.GetService(queryLogger) as IDataQueryLogger	1✔
244	)	1✔
245	);	1✔
246	}
247
248	_services.TryAddTransient<IDataSessionFactory<TDiscriminator>>(sp => sp.GetService<IDataConfiguration<TDiscriminator>>());	1✔
249	_services.TryAddTransient<IDataSession<TDiscriminator>, DataSession<TDiscriminator>>();	1✔
250	}	1✔
251
252	private void RegisterDefaults()
253	{
254	// add defaults if not already added
255	_services.TryAddSingleton<IDataQueryFormatter, DataQueryFormatter>();	4✔
256
257	// convert specific types to interfaces
258	if (_providerFactoryType != null)	4✔
259	_services.TryAddSingleton(sp => sp.GetService(_providerFactoryType) as DbProviderFactory);	4✔
260
261	if (_dataCacheType != null)	4✔
262	_services.TryAddSingleton(sp => sp.GetService(_dataCacheType) as IDataCache);	2✔
263
264	if (_queryGeneratorType != null)	4!
265	_services.TryAddSingleton(sp => sp.GetService(_queryGeneratorType) as IQueryGenerator);	4✔
266	else
267	_services.TryAddSingleton<IQueryGenerator, SqlServerGenerator>();	×
268
269	if (_queryLoggerType != null)	4!
270	_services.TryAddSingleton(sp => sp.GetService(_queryLoggerType) as IDataQueryLogger);	×
271	else
272	_services.TryAddSingleton<IDataQueryLogger, DataQueryLogger>();	4✔
273
274	}	4✔
275	}

loresoft / FluentCommand / 6497765030

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous