public override AnalyzeResult Analyse(HtmlNode document, string focuskeyword, string url)
{
var result = new AnalyzeResult
{
Alias = "metarobotsanalyzer"
};
var metaTags = HtmlHelper.GetElements(document, "meta");
if (!metaTags.Any())
{
result.AddResultRule("metarobotsanalyzer_no_meta_tags", ResultType.Error);
}
else
{
var robots = from metaTag in metaTags
let attribute = HtmlHelper.GetAttribute(metaTag, "name")
where attribute != null
where attribute.Value == "robots"
select HtmlHelper.GetAttribute(metaTag, "content");
var googlebot = from metaTag in metaTags
let attribute = HtmlHelper.GetAttribute(metaTag, "name")
where attribute != null
where attribute.Value == "googlebot"
select HtmlHelper.GetAttribute(metaTag, "content");
if (!robots.Any() && !googlebot.Any())
{
result.AddResultRule("metarobotsanalyzer_no_robots_tag", ResultType.Success);
}
else
{
var firstRobotTag = robots.FirstOrDefault();
if (firstRobotTag != null)
{
AnalyzeTag(firstRobotTag.Value, result, "robots");
}
var firstGooglebotTag = googlebot.FirstOrDefault();
if (firstGooglebotTag != null)
{
AnalyzeTag(firstGooglebotTag.Value, result, "googlebot");
}
}
}
return(result);
}
public int GetResultScore(AnalyzeResult result)
{
var score = 100;
if (result.ErrorCount > 0)
{
score = 0;
}
score -= result.WarningCount * 50;
score -= result.HintCount * 25;
if (score < 0)
{
score = 0;
}
return(score);
}
public void BasicAnalyze_Pass()
{
AnalyzeOptions options = new()
{
SourcePath = new string[1] {
Path.Combine(Helper.GetPath(Helper.AppPath.testSource), @"unzipped\simple\main.cpp")
},
FilePathExclusions = Array.Empty <string>(),
TagsOnly = true
};
AnalyzeCommand command = new(options);
AnalyzeResult result = command.GetResult();
Assert.AreEqual(AnalyzeResult.ExitCode.Success, result.ResultCode);
}
private AnalyzeResult Analyze(IProgress <Tuple <string, int> > callback)
{
callback.Report(Tuple.Create("Starting", 0));
var pathResult = FindPaths(callback);
callback.Report(Tuple.Create("Checking nesting", 50));
CheckNesting(pathResult.Item1);
callback.Report(Tuple.Create("Finding files", 50));
var files = FindFiles(pathResult.Item1, callback);
callback.Report(Tuple.Create("Calculating", 90));
var result = new AnalyzeResult(files, pathResult.Item2.Select(a => "Found paths for " + a.Name).ToList());
callback.Report(Tuple.Create("Done", 100));
return(result);
}
public void ExpectedTagCountDupsAllowed_Pass()
{
AnalyzeOptions options = new AnalyzeOptions()
{
SourcePath = Path.Combine(Helper.GetPath(Helper.AppPath.testSource), @"unzipped\simple\mainduptags.cpp"),
FilePathExclusions = "none", //allow source under unittest path
AllowDupTags = true,
SingleThread = true
};
AnalyzeResult.ExitCode exitCode = AnalyzeResult.ExitCode.CriticalError;
try
{
AnalyzeCommand command = new AnalyzeCommand(options);
AnalyzeResult result = command.GetResult();
exitCode = result.ResultCode;
if (exitCode == AnalyzeResult.ExitCode.Success)
{
exitCode = result.Metadata.TotalMatchesCount == 10 && result.Metadata.UniqueMatchesCount == 6 ? AnalyzeResult.ExitCode.Success : AnalyzeResult.ExitCode.NoMatches;
}
}
catch (Exception)
{
exitCode = AnalyzeResult.ExitCode.CriticalError;
}
Assert.IsTrue(exitCode == AnalyzeResult.ExitCode.Success);
AnalyzeResult.ExitCode exitCodeMultiThread = AnalyzeResult.ExitCode.CriticalError;
options.SingleThread = false;
try
{
AnalyzeCommand command = new AnalyzeCommand(options);
AnalyzeResult result = command.GetResult();
exitCodeMultiThread = result.ResultCode;
if (exitCodeMultiThread == AnalyzeResult.ExitCode.Success)
{
exitCodeMultiThread = result.Metadata.TotalMatchesCount == 10 && result.Metadata.UniqueMatchesCount == 6 ? AnalyzeResult.ExitCode.Success : AnalyzeResult.ExitCode.NoMatches;
}
}
catch (Exception)
{
exitCodeMultiThread = AnalyzeResult.ExitCode.CriticalError;
}
Assert.IsTrue(exitCodeMultiThread == AnalyzeResult.ExitCode.Success);
}
public override void WriteResults(Result result, CLICommandOptions commandOptions, bool autoClose = true)
{
AnalyzeResult analyzeResult = (AnalyzeResult)result;
JsonSerializer jsonSerializer = new();
jsonSerializer.Formatting = Formatting.Indented;
if (TextWriter != null)
{
jsonSerializer.Serialize(TextWriter, analyzeResult);
}
if (autoClose)
{
FlushAndClose();
}
}
public async Task ExpectedTagCountAsync_Pass()
{
AnalyzeOptions options = new()
{
SourcePath = new string[1] {
Path.Combine(Helper.GetPath(Helper.AppPath.testSource), @"unzipped\simple\mainduptags.cpp")
},
FilePathExclusions = Array.Empty <string>(), //allow source under unittest path
SingleThread = true
};
AnalyzeCommand command = new(options);
AnalyzeResult result = await command.GetResultAsync(new CancellationToken());
Assert.AreEqual(AnalyzeResult.ExitCode.Success, result.ResultCode);
Assert.AreEqual(11, result.Metadata.TotalMatchesCount);
Assert.AreEqual(7, result.Metadata.UniqueMatchesCount);
}
public override AnalyzeResult Analyse(IPageData pageData)
{
var encoding = _encodingHelper.GetEncodingFromUrl(pageData.Url);
var result = new AnalyzeResult();
if (encoding == "gzip")
{
result.AddResultRule("gzip_enabled", ResultType.Success);
}
else
{
result.AddResultRule("gzip_disabled", ResultType.Hint);
}
return(result);
}
public override AnalyzeResult Analyse(IPageData pageData)
{
var result = new AnalyzeResult();
var imageTags = pageData.Document.GetElements("img");
var imageTagCount = imageTags.Count();
CheckImagesForAttribute(imageTags, imageTagCount, result, "alt");
CheckImagesForAttribute(imageTags, imageTagCount, result, "title");
if (!result.ResultRules.Any())
{
result.AddResultRule("alt_and_title_tags_present", ResultType.Success);
}
return(result);
}
private void AnalyzeQuery()
{
SparqlQuery = memoEditQuery.Text;
QueryAnalizer queryAnalizer = new QueryAnalizer(SparqlQuery);
AnalyzeResult analyzeResults = queryAnalizer.AnalyzeQuery();
if (!analyzeResults.IsCorrectQuery)
{
_buttonAnalyze.Image = SparqlAnalyzer.Properties.Resources.cancel_16x16;
_gridErrors.DataSource = analyzeResults.ErrorMessages;
}
else
{
_buttonAnalyze.Image = SparqlAnalyzer.Properties.Resources.apply_16x16;
_gridErrors.DataSource = new object[] { };
}
}
public void Add(AnalyzeResult analyzeResult)
{
//logger.Info(JsonConvert.SerializeObject(new
//{
// DataType = "0-analyzeResult",
// Value = analyzeResult,
//}));
analyzeResults.Enqueue(analyzeResult);
if (analyzeResult != null)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Analyze(analyzeResult);
stopwatch.Stop();
logger.Debug(stopwatch.Elapsed.TotalMilliseconds);
}
}
public override AnalyzeResult Analyse(HtmlNode document, string focuskeyword, string url)
{
var result = new AnalyzeResult
{
Alias = "keywordcontentanalyzer"
};
var bodyTags = HtmlHelper.GetElements(document, "body");
if (!bodyTags.Any())
{
result.AddResultRule("keywordcontentanalyzer_no_body_tag", ResultType.Warning);
}
else if (bodyTags.Count() > 1)
{
result.AddResultRule("keywordcontentanalyzer_multiple_body_tags", ResultType.Warning);
}
else
{
var bodyTag = bodyTags.FirstOrDefault();
if (bodyTag != null)
{
var text = Regex.Replace(bodyTag.InnerText.Trim().ToLower(), @"\s+", " ");
var matches = Regex.Matches(text, focuskeyword);
if (matches.Count == 0)
{
result.AddResultRule("keywordcontentanalyzer_content_doesnt_contain_keyword", ResultType.Warning);
}
else
{
var resultRule = new ResultRule
{
Alias = "keywordcontentanalyzer_content_contains_keyword",
Type = ResultType.Success
};
resultRule.Tokens.Add(matches.Count.ToString());
result.ResultRules.Add(resultRule);
}
}
}
return(result);
}
public override AnalyzeResult Analyse(HtmlNode document, string focuskeyword, string url)
{
var result = new AnalyzeResult
{
Alias = "imagetaganalyzer"
};
var imageTags = HtmlHelper.GetElements(document, "img");
var imageTagCount = imageTags.Count();
var imagesWithAltTagCount = imageTags.Count(x => HtmlHelper.GetAttribute(x, "alt") != null && !string.IsNullOrWhiteSpace(HtmlHelper.GetAttribute(x, "alt").Value));
if (imageTagCount > imagesWithAltTagCount)
{
var resultRule = new ResultRule
{
Alias = "imagetaganalyzer_missing_alt_tags",
Type = ResultType.Hint
};
var numberOfTagsMissingAlt = imageTagCount - imagesWithAltTagCount;
resultRule.Tokens.Add(numberOfTagsMissingAlt.ToString());
result.ResultRules.Add(resultRule);
}
var imagesWithTitleTagCount = imageTags.Count(x => HtmlHelper.GetAttribute(x, "title") != null && !string.IsNullOrWhiteSpace(HtmlHelper.GetAttribute(x, "title").Value));
if (imageTagCount > imagesWithTitleTagCount)
{
var resultRule = new ResultRule
{
Alias = "imagetaganalyzer_missing_title_tags",
Type = ResultType.Hint
};
var numberOfTagsMissingTitle = imageTagCount - imagesWithTitleTagCount;
resultRule.Tokens.Add(numberOfTagsMissingTitle.ToString());
result.ResultRules.Add(resultRule);
}
if (imageTagCount == imagesWithAltTagCount && imageTagCount == imagesWithTitleTagCount)
{
result.AddResultRule("imagetaganalyzer_alt_and_title_tags_present", ResultType.Success);
}
return(result);
}
// </snippet_deletemodel>
// <snippet_displayanalyze>
// Display analyze status
private static void DisplayAnalyzeResult(AnalyzeResult result)
{
foreach (var page in result.Pages)
{
Console.WriteLine("\tPage#: " + page.Number);
Console.WriteLine("\tCluster Id: " + page.ClusterId);
foreach (var kv in page.KeyValuePairs)
{
if (kv.Key.Count > 0)
{
Console.Write(kv.Key[0].Text);
}
if (kv.Value.Count > 0)
{
Console.Write(" - " + kv.Value[0].Text);
}
Console.WriteLine();
}
Console.WriteLine();
foreach (var t in page.Tables)
{
Console.WriteLine("Table id: " + t.Id);
foreach (var c in t.Columns)
{
foreach (var h in c.Header)
{
Console.Write(h.Text + "\t");
}
foreach (var e in c.Entries)
{
foreach (var ee in e)
{
Console.Write(ee.Text + "\t");
}
}
Console.WriteLine();
}
Console.WriteLine();
}
}
}
public void MaxNumMatchesDisabled_Pass()
{
AnalyzeOptions options = new()
{
SourcePath = new string[1] {
Path.Combine(Helper.GetPath(Helper.AppPath.testSource), @"unzipped\simple\main.cpp")
},
FilePathExclusions = Array.Empty <string>(), //allow source under unittest path,
};
AnalyzeResult.ExitCode exitCode = AnalyzeResult.ExitCode.CriticalError;
AnalyzeCommand command = new(options);
AnalyzeResult result = command.GetResult();
Assert.AreEqual(3, result.Metadata.Matches.Count(x => x.Tags?.Contains("Platform.OS.Microsoft.WindowsStandard") ?? false));
exitCode = result.ResultCode;
Assert.IsTrue(exitCode == AnalyzeResult.ExitCode.Success);
}
private HtmlNode GetSingleTag(HtmlNode document, AnalyzeResult result, string tagName)
{
var tags = document.GetElements(tagName);
if (!tags.Any())
{
result.AddResultRule("no_" + tagName + "_tag", ResultType.Error);
}
else if (tags.Count() > 1)
{
result.AddResultRule("multiple_" + tagName + "_tags", ResultType.Error);
}
else
{
return(tags.FirstOrDefault());
}
return(null);
}
private void _worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Cancelled)
{
_result = AnalyzeResult.Cancel;
}
else
{
if (e.Error != null)
{
_result = AnalyzeResult.Error;
}
else
{
_result = AnalyzeResult.Success;
}
}
}
public void CountRestultRulesByType_OnExecute_ReturnsNumberOfResultsWithType()
{
var analyzeResult = new AnalyzeResult();
analyzeResult.AddResultRule("code", "type1");
analyzeResult.AddResultRule("code", "type1");
analyzeResult.AddResultRule("code", "type2");
analyzeResult.AddResultRule("code", "type2");
analyzeResult.AddResultRule("code", "type2");
var type1Counter = analyzeResult.CountRestultRulesByType("type1");
var type2Counter = analyzeResult.CountRestultRulesByType("type2");
var type3Counter = analyzeResult.CountRestultRulesByType("type3");
Assert.AreEqual(2, type1Counter);
Assert.AreEqual(3, type2Counter);
Assert.AreEqual(0, type3Counter);
}
public void ExpectedResultCounts()
{
AnalyzeOptions options = new()
{
SourcePath = new string[1] {
testFilePath
},
CustomRulesPath = testRulesPath,
IgnoreDefaultRules = true
};
AnalyzeCommand command = new(options, factory);
AnalyzeResult result = command.GetResult();
Assert.AreEqual(AnalyzeResult.ExitCode.Success, result.ResultCode);
Assert.AreEqual(5, result.Metadata.TotalMatchesCount);
Assert.AreEqual(2, result.Metadata.UniqueMatchesCount);
}
public void ConfidenceFilters(Confidence[] confidenceFilter, int ActualExpectedNumberOfMatches)
{
AnalyzeOptions options = new()
{
SourcePath = new string[1] {
testFilePath
},
CustomRulesPath = testRulesPath,
ConfidenceFilters = confidenceFilter,
IgnoreDefaultRules = true
};
AnalyzeCommand command = new(options, factory);
AnalyzeResult result = command.GetResult();
Assert.AreEqual(AnalyzeResult.ExitCode.Success, result.ResultCode);
Assert.AreEqual(ActualExpectedNumberOfMatches, result.Metadata.Matches.Count);
}
public void TestExclusionFilter()
{
AnalyzeOptions options = new()
{
SourcePath = new string[1] {
testFilePath
},
FilePathExclusions = new[] { "**/TestFile.js" },
CustomRulesPath = testRulesPath,
IgnoreDefaultRules = true
};
AnalyzeCommand command = new(options, factory);
AnalyzeResult result = command.GetResult();
Assert.AreEqual(AnalyzeResult.ExitCode.NoMatches, result.ResultCode);
Assert.AreEqual(0, result.Metadata.TotalMatchesCount);
}
public async Task MaxNumMatchesAsync(int MaxNumberOfMatchesParameter, int ActualExpectedNumberOfMatches)
{
AnalyzeOptions options = new()
{
SourcePath = new string[1] {
testFilePath
},
MaxNumMatchesPerTag = MaxNumberOfMatchesParameter,
CustomRulesPath = testRulesPath,
IgnoreDefaultRules = true
};
AnalyzeCommand command = new(options, factory);
AnalyzeResult result = await command.GetResultAsync(new CancellationToken());
Assert.AreEqual(AnalyzeResult.ExitCode.Success, result.ResultCode);
Assert.AreEqual(ActualExpectedNumberOfMatches, result.Metadata.Matches.Count(x => x.Tags?.Contains("Test.Tags.Windows") ?? false));
}
public void TagsInBuildFiles()
{
string innerTestFilePath = $"{Path.GetTempFileName()}.json"; // JSON is considered a build file, it does not have code/comment sections.
File.WriteAllText(innerTestFilePath, fourWindowsOneLinux);
AnalyzeOptions options = new()
{
SourcePath = new string[1] {
innerTestFilePath
},
CustomRulesPath = testRulesPath,
IgnoreDefaultRules = true,
AllowAllTagsInBuildFiles = true
};
AnalyzeCommand command = new(options, factory);
AnalyzeResult result = command.GetResult();
Assert.AreEqual(AnalyzeResult.ExitCode.Success, result.ResultCode);
Assert.AreEqual(5, result.Metadata.Matches.Count);
Assert.AreEqual(2, result.Metadata.UniqueMatchesCount);
AnalyzeOptions dontAllowAllTagsOptions = new()
{
SourcePath = new string[1] {
innerTestFilePath
},
CustomRulesPath = testRulesPath,
IgnoreDefaultRules = true,
AllowAllTagsInBuildFiles = false
};
AnalyzeCommand dontAllowAllTagsCommand = new(dontAllowAllTagsOptions);
AnalyzeResult dontAllowAllTagsResult = dontAllowAllTagsCommand.GetResult();
File.Delete(innerTestFilePath);
Assert.AreEqual(AnalyzeResult.ExitCode.NoMatches, dontAllowAllTagsResult.ResultCode);
Assert.AreEqual(0, dontAllowAllTagsResult.Metadata.Matches.Count);
Assert.AreEqual(0, dontAllowAllTagsResult.Metadata.Matches.Count);
}
[DataRow(1, 3)]
public void Overrides()
{
var overridesTestRulePath = Path.Combine(TestHelpers.GetPath(TestHelpers.AppPath.testOutput), "OverrideTestRule.json");
var overridesWithoutOverrideTestRulePath = Path.Combine(TestHelpers.GetPath(TestHelpers.AppPath.testOutput), "OverrideTestRuleWithoutOverride.json");
var fourWindowsOne2000Path = Path.Combine(TestHelpers.GetPath(TestHelpers.AppPath.testOutput), "FourWindowsOne2000.cs");
File.WriteAllText(fourWindowsOne2000Path, threeWindowsOneWindows2000);
File.WriteAllText(overridesTestRulePath, findWindowsWithOverride);
File.WriteAllText(overridesWithoutOverrideTestRulePath, findWindowsWithOverrideRuleWithoutOverride);
AnalyzeOptions options = new()
{
SourcePath = new string[1] {
fourWindowsOne2000Path
},
CustomRulesPath = overridesTestRulePath,
IgnoreDefaultRules = true
};
AnalyzeCommand command = new(options, factory);
AnalyzeResult result = command.GetResult();
Assert.AreEqual(AnalyzeResult.ExitCode.Success, result.ResultCode);
Assert.AreEqual(4, result.Metadata.TotalMatchesCount);
Assert.AreEqual(2, result.Metadata.UniqueMatchesCount);
options = new()
{
SourcePath = new string[1] {
fourWindowsOne2000Path
},
CustomRulesPath = overridesWithoutOverrideTestRulePath,
IgnoreDefaultRules = true
};
command = new(options, factory);
result = command.GetResult();
Assert.AreEqual(AnalyzeResult.ExitCode.Success, result.ResultCode);
// This has one additional result for the same file because the match is not being overridden.
Assert.AreEqual(5, result.Metadata.TotalMatchesCount);
Assert.AreEqual(2, result.Metadata.UniqueMatchesCount);
}
[DataTestMethod]
public override AnalyzeResult Analyse(HtmlNode document, string focuskeyword, string url)
{
var result = new AnalyzeResult
{
Alias = "additionalcallanalyzer"
};
var cssFiles = HtmlHelper.GetElementsWithAttribute(document, "link", "href").
Where(x => x.Attributes.Any(y => y.Name == "rel" && y.Value == "stylesheet"));
var scriptFiles = HtmlHelper.GetElementsWithAttribute(document, "script", "src");
var images = HtmlHelper.GetElementsWithAttribute(document, "img", "src");
var objects = HtmlHelper.GetElementsWithAttribute(document, "object ", "data");
var total = cssFiles.Count() + scriptFiles.Count() + images.Count() + objects.Count();
var resultRule = new ResultRule();
if (total > 30)
{
resultRule.Alias = "additionalcallanalyzer_more_than_30_calls";
resultRule.Type = ResultType.Warning;
}
else if (total > 15)
{
resultRule.Alias = "additionalcallanalyzer_more_than_15_calls";
resultRule.Type = ResultType.Hint;
}
else
{
resultRule.Alias = "additionalcallanalyzer_less_than_15_calls";
resultRule.Type = ResultType.Success;
}
resultRule.Tokens.Add(total.ToString());
resultRule.Tokens.Add(cssFiles.Count().ToString());
resultRule.Tokens.Add(scriptFiles.Count().ToString());
resultRule.Tokens.Add(images.Count().ToString());
resultRule.Tokens.Add(objects.Count().ToString());
result.ResultRules.Add(resultRule);
return(result);
}
public void ExpectedTagCountMultiThread()
{
AnalyzeOptions options = new()
{
SourcePath = new string[1] {
Path.Combine(Helper.GetPath(Helper.AppPath.testSource), @"unzipped\simple\mainduptags.cpp")
},
FilePathExclusions = Array.Empty <string>(), //allow source under unittest path
SingleThread = false,
TagsOnly = true
};
AnalyzeCommand command = new(options);
AnalyzeResult result = command.GetResult();
Assert.AreEqual(AnalyzeResult.ExitCode.Success, result.ResultCode);
Assert.AreEqual(0, result.Metadata.TotalMatchesCount);
Assert.AreEqual(0, result.Metadata.UniqueMatchesCount);
Assert.AreEqual(7, result.Metadata.UniqueTags.Count);
}
public override AnalyzeResult Analyse(IPageData pageData)
{
var result = new AnalyzeResult();
var url = new Uri(pageData.Url);
var localCssFiles = GetLocalCssFiles(pageData, url);
foreach (var localCssFile in localCssFiles)
{
CheckFile(localCssFile, url, result);
}
if (!result.ResultRules.Any())
{
result.AddResultRule("all_minified", ResultType.Success);
}
return(result);
}
public override AnalyzeResult Analyse(HtmlNode document, params object[] additionalValues)
{
var serverResponseTime = (long)additionalValues[0];
var serverResponseAnalysis = new AnalyzeResult
{
Alias = "serverresponseanalyzer"
};
var serverResponseAnalysisResultRule = new ResultRule
{
Alias = "serverresponseanalyzer_responsetime",
Type = serverResponseTime > 3000 ? ResultType.Warning : ResultType.Success
};
serverResponseAnalysisResultRule.Tokens.Add(serverResponseTime.ToString());
serverResponseAnalysis.ResultRules.Add(serverResponseAnalysisResultRule);
return(serverResponseAnalysis);
}
public override AnalyzeResult Analyse(HtmlNode document, params object[] additionalValues)
{
var result = new AnalyzeResult
{
Alias = "keywordtitleanalyzer"
};
var titleTags = HtmlHelper.GetElements(document, "title");
var keyword = additionalValues[0].ToString();
if (!titleTags.Any())
{
result.AddResultRule("keywordtitleanalyzer_no_title_tag", ResultType.Error);
}
else if (titleTags.Count() > 1)
{
result.AddResultRule("keywordtitleanalyzer_multiple_title_tags", ResultType.Error);
}
else
{
var titleText = titleTags.First().InnerText;
var position = titleText.IndexOf(keyword, StringComparison.InvariantCultureIgnoreCase);
if (position >= 0)
{
if (position < 10)
{
result.AddResultRule("keywordtitleanalyzer_title_contains_keyword", ResultType.Success);
}
else
{
result.AddResultRule("keywordtitleanalyzer_title_not_in_front", ResultType.Hint);
}
}
else
{
result.AddResultRule("keywordtitleanalyzer_title_doesnt_contain_keyword", ResultType.Warning);
}
}
return(result);
}
public override AnalyzeResult Analyse(IPageData pageData)
{
var result = new AnalyzeResult();
var metaTags = _htmlTagHelper.GetMetaTags(pageData.Document, result);
if (metaTags.Any())
{
var attributeValues = from metaTag in metaTags
let attribute = metaTag.GetAttribute("name")
where attribute != null
where attribute.Value == "description"
select metaTag.GetAttribute("content");
if (!attributeValues.Any())
{
result.AddResultRule("no_meta_description_tag", ResultType.Warning);
}
else if (attributeValues.Count() > 1)
{
result.AddResultRule("multiple_meta_description_tags", ResultType.Warning);
}
else
{
var firstMetaDescriptionTag = attributeValues.FirstOrDefault();
if (firstMetaDescriptionTag != null)
{
var descriptionValue = firstMetaDescriptionTag.Value;
if (descriptionValue.IndexOf(pageData.Focuskeyword, StringComparison.InvariantCultureIgnoreCase) >= 0)
{
result.AddResultRule("meta_description_contains_keyword", ResultType.Success);
}
else
{
result.AddResultRule("meta_description_doesnt_contain_keyword", ResultType.Hint);
}
}
}
}
return(result);
}
