private static void RunAnalysis(TSqlModel model, string OutFile)
{
CodeAnalysisService service = new CodeAnalysisServiceFactory().CreateAnalysisService(model.Version);
service.ResultsFile = OutFile;
CodeAnalysisResult result = service.Analyze(model);
}
public void TestDateTimeColumnWithScale7()
{
string[] scripts = new[]
{
"CREATE TABLE t1 (c1 DATETIME2(7) NOT NULL)"
};
using (TSqlModel model = new TSqlModel(SqlServerVersion.SqlAzure, new TSqlModelOptions()))
{
// Adding objects to the model.
foreach (string script in scripts)
{
model.AddObjects(script);
}
var ruleSettings = new CodeAnalysisRuleSettings()
{
new RuleConfiguration(DateTimeColumnsWith7ScaleRule.RuleId)
};
ruleSettings.DisableRulesNotInSettings = true;
CodeAnalysisService service = new CodeAnalysisServiceFactory().CreateAnalysisService(model.Version,
new CodeAnalysisServiceSettings()
{
RuleSettings = ruleSettings
});
CodeAnalysisResult analysisResult = service.Analyze(model);
Assert.AreEqual(1, analysisResult.Problems.Count, "Expect 1 problems to be found");
}
}
public void RunSCARules()
{
CodeAnalysisService service = new CodeAnalysisServiceFactory().CreateAnalysisService(_Model.Version);
CodeAnalysisResult result = service.Analyze(_Model);
SerializeResultOutput(result);
CollectionAssert.AreEquivalent(_FoundProblems, _ExpectedProblems);
}
public void RunSqlRuleTest()
{
CodeAnalysisService service = new CodeAnalysisServiceFactory().CreateAnalysisService(_Model.Version);
CodeAnalysisResult result = service.Analyze(_Model);
LoadRuleResults(result);
// Assert
CollectionAssert.AreEquivalent(_ExpectedProblems, _ActualProblems);
}
private void RunAnalysis(TSqlModel model, string OutFile)
{
CodeAnalysisService service = new CodeAnalysisServiceFactory().CreateAnalysisService(model.Version);
service.ResultsFile = OutFile;
CodeAnalysisResult result = service.Analyze(model);
Console.WriteLine("Code Analysis with output file {0} complete, analysis succeeded? {1}",
OutFile, result.AnalysisSucceeded);
}
/// <summary>
/// Runs analysis, writing the output to a file
/// </summary>
private static void RunAnalysis(TSqlModel model, string resultsFilePath)
{
// Creating a default service will run all discovered rules, treating issues as Warnings.
// To configure which rules are run you can pass a CodeAnalysisRuleSettings object to the service
// or as part of the CodeAnalysisServiceSettings passed into the factory method. Examples of this
// can be seen in the RuleTest.CreateCodeAnalysisService method.
CodeAnalysisService service = new CodeAnalysisServiceFactory().CreateAnalysisService(model.Version);
service.ResultsFile = resultsFilePath;
CodeAnalysisResult result = service.Analyze(model);
Console.WriteLine("Code Analysis with output file {0} complete, analysis succeeded? {1}",
resultsFilePath, result.AnalysisSucceeded);
PrintProblemsAndValidationErrors(model, result);
}
protected void InitTest(string ruleId)
{
var casFactory = new CodeAnalysisServiceFactory();
var ruleSettings = new CodeAnalysisRuleSettings()
{
new RuleConfiguration(ruleId)
};
ruleSettings.DisableRulesNotInSettings = true;
var caSettings = new CodeAnalysisServiceSettings()
{
RuleSettings = ruleSettings
};
caService = casFactory.CreateAnalysisService(SqlServerVersion.Sql120, caSettings);
}
/// <summary>
/// Sets up the service and disables all rules except the rule you wish to test.
///
/// If you want all rules to run then do not change the
/// <see cref="CodeAnalysisRuleSettings.DisableRulesNotInSettings"/> flag, as it is set to "false" by default which
/// ensures that all rules are run.
///
/// To run some (but not all) of the built-in rules then you could query the
/// <see cref="CodeAnalysisService.GetRules"/> method to get a list of all the rules, then set their
/// <see cref="RuleConfiguration.Enabled"/> and other flags as needed, or alternatively call the
/// <see cref="CodeAnalysisService.ApplyRuleSettings"/> method to apply whatever rule settings you wish
///
/// </summary>
private CodeAnalysisService CreateCodeAnalysisService(string ruleIdToRun)
{
CodeAnalysisServiceFactory factory = new CodeAnalysisServiceFactory();
var ruleSettings = new CodeAnalysisRuleSettings()
{
new RuleConfiguration(ruleIdToRun)
};
ruleSettings.DisableRulesNotInSettings = true;
CodeAnalysisService service = factory.CreateAnalysisService(this.ModelForAnalysis.Version, new CodeAnalysisServiceSettings()
{
RuleSettings = ruleSettings
});
this.DumpErrors(service.GetRuleLoadErrors());
Assert.IsTrue(service.GetRules().Any((rule) => rule.RuleId.Equals(ruleIdToRun, StringComparison.OrdinalIgnoreCase)),
"Expected rule '{0}' not found by the service", ruleIdToRun);
return(service);
}
protected CodeAnalysisService CreateCodeAnalysisService(TSqlModel model, string ruleIdToRun)
{
var factory = new CodeAnalysisServiceFactory();
var ruleSettings = new CodeAnalysisRuleSettings
{
new RuleConfiguration(ruleIdToRun)
};
ruleSettings.DisableRulesNotInSettings = true;
var service = factory.CreateAnalysisService(model, new CodeAnalysisServiceSettings()
{
RuleSettings = ruleSettings
});
Assert.IsTrue(service.GetRules()
.Any(rule => rule.RuleId
.Equals(ruleIdToRun, StringComparison.OrdinalIgnoreCase)),
$"Expected rule '{ruleIdToRun}' not found by the service");
return(service);
}
public void NoDatetime7Columns()
{
TSqlModel model = TSqlModel.LoadFromDacpac(@"..\..\..\Database1\bin\Debug\Database1.dacpac",
new ModelLoadOptions(DacSchemaModelStorageType.Memory, true));
var ruleSettings = new CodeAnalysisRuleSettings()
{
new RuleConfiguration(DateTimeColumnsWith7ScaleRule.RuleId)
};
ruleSettings.DisableRulesNotInSettings = true;
CodeAnalysisService service2 = new CodeAnalysisServiceFactory().CreateAnalysisService(model.Version, new CodeAnalysisServiceSettings()
{
RuleSettings = ruleSettings
});
service2.ResultsFile = "results.txt";
CodeAnalysisResult analysisResult = service2.Analyze(model);
Assert.AreEqual(0, analysisResult.Problems.Count, "Expect 0 problems to be found");
}
private static void RunAnalysis(TSqlModel model,string OutFile)
{
CodeAnalysisService service = new CodeAnalysisServiceFactory().CreateAnalysisService(model.Version);
service.ResultsFile = OutFile;
CodeAnalysisResult result = service.Analyze(model);
}
public void Create(ReportRequest request)
{
var fileName = Path.GetFileNameWithoutExtension(request.InputPath);
#region Loading dacpac
SendNotification($"Loading {request.FileName}.dacpac");
var sw = Stopwatch.StartNew();
//load the dacpac
TSqlModel model = TSqlModel.LoadFromDacpac(
request.InputPath
, new ModelLoadOptions()
{
LoadAsScriptBackedModel = true,
ModelStorageType = Microsoft.SqlServer.Dac.DacSchemaModelStorageType.Memory
});
CodeAnalysisServiceFactory factory = new CodeAnalysisServiceFactory();
CodeAnalysisService service = factory.CreateAnalysisService(model);
//surpress rules
service.SetProblemSuppressor(request.Suppress);
sw.Stop();
SendNotification($"Loading {request.FileName}.dacpac complete, elapsed: {sw.Elapsed.ToString(@"hh\:mm\:ss")}");
#endregion
#region Running rules
SendNotification("Running rules");
sw = Stopwatch.StartNew();
//process non-suppressed rules
var result = service.Analyze(model);
if (!result.AnalysisSucceeded)
{
foreach (var err in result.AnalysisErrors)
{
SendNotification(err.Exception.Message, NotificationType.Error);
}
return;
}
sw.Stop();
SendNotification($"Running rules complete, elapsed: {sw.Elapsed.ToString(@"hh\:mm\:ss")}");
#endregion
#region Writing report
//create report object
var report = new Report(
request.Solution,
GetIssueTypes(service.GetRules(), request.SuppressIssueTypes).ToList(),
request.FileName,
GetProblems(result.Problems).ToList());
SendNotification("Writing report");
sw = Stopwatch.StartNew();
//write out the xml
switch (request.ReportOutputType)
{
case ReportOutputType.XML:
var outFileName = GetOutputFileName(request, request.ReportOutputType);
SerializeReport(report, outFileName);
var outDir = GetOutputDirectory(request);
var xlstPath = Path.Combine(outDir, "RulesTransform.xslt");
if (!File.Exists(xlstPath))
{
File.WriteAllText(xlstPath, Resources.RulesTransform);
}
var xPathDoc = new XPathDocument(outFileName);
var xslTransform = new XslCompiledTransform();
using (var xmlWriter = new XmlTextWriter(Path.Combine(outDir, $"{request.FileName}.html"), null))
{
xslTransform.Load(xlstPath);
xslTransform.Transform(xPathDoc, null, xmlWriter);
}
break;
case ReportOutputType.CSV:
SerializeReportToCSV(report, GetOutputFileName(request, request.ReportOutputType));
break;
default:
SendNotification($"Invalid report type: {request.ReportOutputType}");
break;
}
sw.Stop();
SendNotification($"Writing report complete, elapsed: {sw.Elapsed.ToString(@"hh\:mm\:ss")}");
#endregion
SendNotification($"Done with {request.FileName}.dacpac");
}
public void RunSCARules()
{
CodeAnalysisService service = new CodeAnalysisServiceFactory().CreateAnalysisService(_Model.Version);
CodeAnalysisResult result = service.Analyze(_Model);
SerializeResultOutput(result);
CollectionAssert.AreEquivalent(_FoundProblems, _ExpectedProblems);
}
