public IProcessor Create(ProcessorOptions options, ILogger logger)
{
var generatorOptions = new GeneratorOptions();
var generator = new SQLiteGenerator(generatorOptions);
return(new SQLiteProcessor(generator, logger, options, new SQLiteBatchParser()));
}
public void when_generating_database_from_test_document_generator_then_succeeds()
{
var configuration = new AnmatConfiguration {
DocumentsPath = "GeneratedDb",
TargetDatabaseName = this.GetDatabaseName("TestDb"),
ReplaceExistingTargetDatabase = true
};
var updateVersion = new UpdateVersion {
Number = version, Date = DateTime.UtcNow
};
var job = new DataGenerationJob
{
Version = updateVersion.Number,
Status = DataGenerationJobStatus.InProgress
};
var jobService = new Mock <IDataGenerationJobService> ();
jobService
.Setup(s => s.GetLatestJob())
.Returns(job);
var versionService = new Mock <IVersionService> ();
versionService
.Setup(r => r.IncrementVersion())
.Returns(updateVersion);
var sqlGenerator = new SQLiteGenerator(jobService.Object, versionService.Object, configuration);
var documentName = "FooDocument";
var document = this.GetDocument();
var documentGenerator = new Mock <IDocumentGenerator> ();
documentGenerator
.Setup(g => g.Name)
.Returns(documentName);
documentGenerator
.Setup(g => g.Metadata)
.Returns(TestMetadataGenerator.GetTestMetadata(documentName));
documentGenerator
.Setup(g => g.Generate())
.Returns(document);
var databaseFileName = sqlGenerator.GenerateDatabase(documentGenerator.Object);
Assert.True(File.Exists(databaseFileName));
Assert.False(string.IsNullOrEmpty(sqlGenerator.Script));
var connectionString = string.Format("Data Source={0};Version=3;", databaseFileName);
var connection = new SQLiteConnection(connectionString);
connection.Open();
var command = new SQLiteCommand(@"SELECT COUNT(*) FROM " + documentName, connection);
var read = (long)command.ExecuteScalar();
Assert.Equal(document.Rows.Count(), int.Parse(read.ToString()));
connection.Close();
}
public NzbDroneSQLiteProcessor(SQLiteDbFactory factory,
SQLiteGenerator generator,
ILogger <NzbDroneSQLiteProcessor> logger,
IOptionsSnapshot <ProcessorOptions> options,
IConnectionStringAccessor connectionStringAccessor,
IServiceProvider serviceProvider)
: base(factory, generator, logger, options, connectionStringAccessor, serviceProvider)
{
}
public SQLiteProcessor(
// ReSharper disable once SuggestBaseTypeForParameter
SQLiteGenerator generator,
ILogger logger,
ProcessorOptions options,
SQLiteBatchParser batchParser)
: base(() => new SQLiteFactory(), generator, logger, options)
{
this.batchParser = batchParser;
}
public override IMigrationProcessor Create(string connectionString, IAnnouncer announcer, IMigrationProcessorOptions options)
{
var factory = new MigrationDbFactory();
var connection = factory.CreateConnection(connectionString);
var generator = new SQLiteGenerator {
compatabilityMode = CompatabilityMode.STRICT
};
return(new NzbDroneSqliteProcessor(connection, generator, announcer, options, factory));
}
public SQLiteProcessor(
[NotNull] SQLiteDbFactory factory,
[NotNull] SQLiteGenerator generator,
[NotNull] ILogger <SQLiteProcessor> logger,
[NotNull] IOptionsSnapshot <ProcessorOptions> options,
[NotNull] IConnectionStringAccessor connectionStringAccessor,
[NotNull] IServiceProvider serviceProvider)
: base(() => factory.Factory, generator, logger, options.Value, connectionStringAccessor)
{
_serviceProvider = serviceProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="SQLiteProcessor"/> class.
/// </summary>
/// <param name="factory">The SQLite DB factory.</param>
/// <param name="generator">The migration generator.</param>
/// <param name="logger">The logger.</param>
/// <param name="options">The options.</param>
/// <param name="connectionStringAccessor">The connection string accessor.</param>
/// <param name="batchParserFactory">The batch parser factory.</param>
public SQLiteProcessor(
[NotNull] SQLiteDbFactory factory,
[NotNull] SQLiteGenerator generator,
[NotNull] ILogger <SQLiteProcessor> logger,
[NotNull] IOptionsSnapshot <ProcessorOptions> options,
[NotNull] IConnectionStringAccessor connectionStringAccessor,
[NotNull] SQLiteBatchParserFactory batchParserFactory)
: base(() => factory.Factory, generator, logger, options.Value, connectionStringAccessor)
{
_batchParserFactory = batchParserFactory;
}
public SQLiteProcessor(
[NotNull] SQLiteDbFactory factory,
[NotNull] SQLiteGenerator generator,
[NotNull] ILogger <SQLiteProcessor> logger,
[NotNull] IOptionsSnapshot <ProcessorOptions> options,
[NotNull] IConnectionStringAccessor connectionStringAccessor,
[NotNull] IServiceProvider serviceProvider)
: base(() => factory.Factory, generator, logger, options.Value, connectionStringAccessor)
{
_batchParserFactory = serviceProvider.GetService <SQLiteBatchParserFactory>()
?? new SQLiteBatchParserFactory(serviceProvider);
}
public void CallToMissingFileShouldFail()
{
_fileWrapper.Setup(m => m.Exists(It.IsAny <string>())).Returns(false);
_generator = new SQLiteGenerator(_fileWrapper.Object);
var args = new[]
{
"missing.csv"
};
var expected = string.Format("{0} was not found", args[0]);
var ex = Assert.Throws <FileNotFoundException>(() => _generator.ValidateCommandLine(args));
Assert.AreEqual(ex.Message, expected);
}
public SqliteTestingProcessor(IDbConnection connection,
SQLiteDbFactory factory,
SQLiteGenerator generator,
ILogger <SQLiteProcessor> logger,
IOptionsSnapshot <ProcessorOptions> options,
IConnectionStringAccessor connectionStringAccessor,
IServiceProvider serviceProvider) : base(
factory,
generator,
logger,
options,
connectionStringAccessor,
serviceProvider)
{
Connection = connection;
}
public static IAnmatContext Initialize()
{
if (context != null)
{
return(context);
}
var configuration = new AnmatConfiguration {
AnmatDataServiceUrl = ConfigurationManager.AppSettings["AnmatDataServiceUrl"],
DocumentsPath = ConfigurationManager.AppSettings["DocumentsPath"],
TargetDatabaseName = ConfigurationManager.AppSettings["TargetDatabaseName"],
TargetMedicinesTableName = ConfigurationManager.AppSettings["TargetMedicinesTableName"],
TargetActiveComponentsTableName = ConfigurationManager.AppSettings["TargetActiveComponentsTableName"],
TargetGroupsTableName = ConfigurationManager.AppSettings["TargetGroupsTableName"],
TargetPregnancyComponentsTableName = ConfigurationManager.AppSettings["TargetPregnancyComponentsTableName"],
ReplaceExistingTargetDatabase = bool.Parse(ConfigurationManager.AppSettings["ReplaceExistingTargetDatabase"]),
FullInitialize = bool.Parse(ConfigurationManager.AppSettings["FullInitialize"]),
DefaultCulture = ConfigurationManager.AppSettings["DefaultCulture"],
DefaultTextEncoding = ConfigurationManager.AppSettings["DefaultTextEncoding"]
};
var dataContext = new AnmatDataContext(configuration);
var metadataRepository = new SqlRepository <DocumentMetadata>(dataContext, configuration, new DocumentMetadataInitializer(configuration));
var versionRepository = new SqlRepository <UpdateVersion>(dataContext, configuration, new UpdateVersionInitializer());
var jobRepository = new SqlRepository <DataGenerationJob>(dataContext, configuration);
var versionService = new VersionService(versionRepository);
var metadataService = new DocumentMetadataService(metadataRepository);
var jobService = new DataGenerationJobService(jobRepository);
var documentReader = new CsvDocumentReader(configuration);
var documentGenerators = new List <IDocumentGenerator> ();
documentGenerators.Add(new DocumentGenerator(configuration.TargetGroupsTableName,
documentReader, jobService, metadataService, configuration));
documentGenerators.Add(new DocumentGenerator(configuration.TargetPregnancyComponentsTableName,
documentReader, jobService, metadataService, configuration));
documentGenerators.Add(new DocumentGenerator(configuration.TargetMedicinesTableName,
documentReader, jobService, metadataService, configuration));
documentGenerators.Add(new DocumentGenerator(configuration.TargetActiveComponentsTableName,
documentReader, jobService, metadataService, configuration));
var sqlGenerator = new SQLiteGenerator(jobService, versionService, configuration);
context = new AnmatContext(versionService, jobService, documentReader, documentGenerators, sqlGenerator, configuration);
return(context);
}
public void when_database_already_exists_and_configuration_does_not_allow_override_then_fails()
{
var configuration = new AnmatConfiguration {
DocumentsPath = "GeneratedDb",
TargetDatabaseName = this.GetDatabaseName("TestDb"),
ReplaceExistingTargetDatabase = false
};
var updateVersion = new UpdateVersion {
Number = 2, Date = DateTime.UtcNow
};
var job = new DataGenerationJob
{
Version = updateVersion.Number,
Status = DataGenerationJobStatus.InProgress
};
var jobService = new Mock <IDataGenerationJobService> ();
jobService
.Setup(s => s.GetLatestJob())
.Returns(job);
var versionService = new Mock <IVersionService> ();
versionService
.Setup(r => r.IncrementVersion())
.Returns(updateVersion);
var sqlGenerator = new SQLiteGenerator(jobService.Object, versionService.Object, configuration);
var documentGenerator = new Mock <IDocumentGenerator> ();
var databaseFileName = this.GetDatabaseFileName(configuration, sqlGenerator);
using (File.Create(databaseFileName)) {};
Assert.Throws <SQLGenerationException>(
() => sqlGenerator.GenerateDatabase(documentGenerator.Object));
}
public void Setup()
{
Generator = new SQLiteGenerator();
}
public void Setup()
{
_fileWrapper = new Mock <IFileWrapper>();
_fileWrapper.Setup(m => m.Exists(It.IsAny <string>())).Returns(true);
_generator = new SQLiteGenerator(_fileWrapper.Object);
}
private static void Main(string[] args)
{
#region Validation
// Check config
if (!SQLiteMappingConfig.ValidateConfig())
{
SQLiteMappingConfig.OutputConfigErrorsToConsole();
Console.WriteLine("Press any key to end program...");
Console.ReadKey();
return;
}
/*
* // Check arguments
* if (args.Length == 0)
* {
* Console.WriteLine("No arguments specified.");
* return;
* }
* else if (args.Length == 1)
* {
* Console.WriteLine("Missing output path parameter");
* return;
* }*/
#endregion Validation
#region Variable Assignment
//1st argument is expected to be the path of the assembly to investigate
//AssemblyFilePath = args[0];
AssemblyFilePath = @".\SQLiteTestAssembly.dll";
//check the assembly exists
if (!File.Exists(AssemblyFilePath))
{
Console.WriteLine($"File {AssemblyFilePath} does not exist.");
return;
}
/*
* //2nd argument is the output location of the generation script
* string outputPath = args[1];
*
* //check the directory exists
* if (!Directory.Exists(outputPath))
* {
* Console.WriteLine($"Folder {outputPath} does not exist.");
* return;
* }
*/
#endregion Variable Assignment
#region TestCode
SQLiteGenerator sqLiteGenerator = new SQLiteGenerator(AssemblyFilePath);
Console.Write(sqLiteGenerator.GenerateNewDatabase());
#endregion TestCode
Console.WriteLine("Press any key to end program...");
Console.ReadKey();
}
