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"); }