public void TypeProperty_OnSet_SetsTheValue()
{
var resultRule = new ResultRule();
resultRule.Type = "type";
Assert.AreEqual("type", resultRule.Type);
}
public override AnalyzeResult Analyse(HtmlNode document, string focuskeyword, string url)
{
var result = new AnalyzeResult
{
Alias = "anchorTagAnalyzer"
};
var anchorTags = HtmlHelper.GetElements(document, "a");
var anchorTagCount = anchorTags.Count();
var anchorWithTitleTagCount = anchorTags.Count(x => HtmlHelper.GetAttribute(x, "title") != null && !string.IsNullOrWhiteSpace(HtmlHelper.GetAttribute(x, "title").Value));
if (anchorTagCount > anchorWithTitleTagCount)
{
var resultRule = new ResultRule
{
Alias = "anchorTagAnalyzer_missing_title_tags",
Type = ResultType.Hint
};
var numberOfTagsMissingTitle = anchorTagCount - anchorWithTitleTagCount;
resultRule.Tokens.Add(numberOfTagsMissingTitle.ToString());
result.ResultRules.Add(resultRule);
}
else
{
result.AddResultRule("anchorTagAnalyzer_all_title_tags_present", ResultType.Hint);
}
return(result);
}
public override void Analyse(IPageData pageData)
{
if (pageData == null)
{
throw new ArgumentNullException(nameof(pageData));
}
// Check for h1, h2, h3 and h4
var headerTagCount = 0;
for (var i = 1; i <= 4; i++)
{
var headerTag = pageData.Document.GetElements("h" + i);
headerTagCount += headerTag.Count(x => x.InnerText.ToLower().Contains(pageData.Focuskeyword));
}
if (headerTagCount > 0)
{
var resultRule = new ResultRule
{
Alias = "keyword_used_in_heading",
Type = ResultType.Success
};
resultRule.Tokens.Add(headerTagCount.ToString());
AddResultRule(resultRule);
}
else
{
AddResultRule("keyword_not_used_in_heading", ResultType.Hint);
}
}
public void TypeProperty_OnSet_SetsTheValueToNull()
{
var resultRule = new ResultRule();
resultRule.Type = null;
Assert.IsNull(resultRule.Type);
}
private void CheckFile(HtmlNode file, Uri url)
{
var address = GetAttribute(file);
if (address != null)
{
var fullPath = _urlHelper.GetFullPath(address.Value, url);
var cacheKey = $"{CacheKeyPrefix}{fullPath}";
if (!_cacheHelper.Exists(cacheKey))
{
var isMinified = false;
var content = _urlHelper.GetContent(fullPath);
if (content != null)
{
isMinified = _minificationHelper.IsMinified(content);
}
_cacheHelper.SetValue(cacheKey, isMinified.ToString());
}
if (_cacheHelper.GetValue(cacheKey).ToString() != true.ToString())
{
var resultRule = new ResultRule
{
Alias = "file_not_minified",
Type = ResultType.Hint
};
resultRule.Tokens.Add(fullPath);
AddResultRule(resultRule);
}
}
}
public void AliasProperty_OnSet_SetsTheValue()
{
var resultRule = new ResultRule();
resultRule.Alias = "alias";
Assert.AreEqual("alias", resultRule.Alias);
}
public void AliasProperty_OnSet_SetsTheValueToNull()
{
var resultRule = new ResultRule();
resultRule.Alias = null;
Assert.IsNull(resultRule.Alias);
}
public override AnalyzeResult Analyse(IPageData pageData)
{
var result = new AnalyzeResult();
// Check for h1, h2, h3 and h4
var headerTagCount = 0;
for (var i = 1; i <= 4; i++)
{
var headerTag = pageData.Document.GetElements("h" + i);
headerTagCount += headerTag.Count(x => x.InnerText.ToLower().Contains(pageData.Focuskeyword));
}
if (headerTagCount > 0)
{
var resultRule = new ResultRule
{
Alias = "keyword_used_in_heading",
Type = ResultType.Success
};
resultRule.Tokens.Add(headerTagCount.ToString());
result.ResultRules.Add(resultRule);
}
else
{
result.AddResultRule("keyword_not_used_in_heading", ResultType.Hint);
}
return(result);
}
public override AnalyzeResult Analyse(HtmlNode document, params object[] additionalValues)
{
var result = new AnalyzeResult
{
Alias = "cssminificationanalyzer"
};
var url = (Uri)additionalValues[0];
var localCssFiles = HtmlHelper.GetElementsWithAttribute(document, "link", "href").
Where(x =>
x.Attributes.Any(y => y.Name == "rel" && y.Value == "stylesheet") &&
x.Attributes.Any(y => y.Name == "href" && ((y.Value.StartsWith("/") && !y.Value.StartsWith("//")) ||
y.Value.StartsWith(url.Host)
))
);
var webClient = new WebClient();
foreach (var localCssFile in localCssFiles)
{
var address = HtmlHelper.GetAttribute(localCssFile, "href");
if (address != null)
{
var fullPath = address.Value;
if (fullPath.StartsWith("/"))
{
fullPath = string.Format("{0}://{1}{2}", url.Scheme, url.Host, fullPath);
}
try
{
var content = webClient.DownloadString(fullPath);
var totalCharacters = content.Length;
var lines = content.Count(x => x == '\n');
var ratio = totalCharacters / lines;
if (ratio < 200)
{
var resultRule = new ResultRule();
resultRule.Alias = "cssminificationanalyzer_file_not_minified";
resultRule.Type = ResultType.Hint;
resultRule.Tokens.Add(address.Value);
result.ResultRules.Add(resultRule);
}
}
catch (Exception)
{ }
}
}
if (!result.ResultRules.Any())
{
result.AddResultRule("cssminificationanalyzer_all_minified", ResultType.Success);
}
return(result);
}
public override AnalyzeResult Analyse(IPageData pageData)
{
var result = new AnalyzeResult();
var bodyTag = _htmlTagHelper.GetBodyTag(pageData.Document, result);
if (bodyTag != null)
{
var bodyText = bodyTag.InnerText.Trim();
var text = Regex.Replace(bodyText.ToLower(), @"\s+", " ");
var matches = Regex.Matches(text, pageData.Focuskeyword);
if (matches.Count == 0)
{
result.AddResultRule("content_doesnt_contain_keyword", ResultType.Warning);
}
else
{
var resultRule = new ResultRule
{
Alias = "content_contains_keyword",
Type = ResultType.Success
};
resultRule.Tokens.Add(matches.Count.ToString());
result.ResultRules.Add(resultRule);
}
}
return(result);
}
private void CheckFile(HtmlNode localCssFile, Uri url, AnalyzeResult result)
{
var address = localCssFile.GetAttribute("href");
if (address != null)
{
var fullPath = address.Value;
var content = GetContent(fullPath, url);
if (content != null)
{
var isMinified = _minificationHelper.IsMinified(content);
if (isMinified)
{
var resultRule = new ResultRule
{
Alias = "file_not_minified",
Type = ResultType.Hint
};
resultRule.Tokens.Add(fullPath);
result.ResultRules.Add(resultRule);
}
}
}
}
public void TokensProperty_OnSet_SetsTheValue()
{
var resultRule = new ResultRule();
resultRule.Tokens = new List <string> {
"token"
};
Assert.IsNotNull(resultRule.Tokens);
Assert.AreEqual(1, resultRule.Tokens.Count());
}
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);
}
private void CheckImagesForAttribute(IEnumerable <HtmlNode> imageTags, int imageTagCount, string attributeName)
{
var imagesWithAttributeCount =
imageTags.Count(x => x.GetAttribute(attributeName) != null && !string.IsNullOrWhiteSpace(x.GetAttribute(attributeName).Value));
if (imageTagCount > imagesWithAttributeCount)
{
var resultRule = new ResultRule
{
Alias = "missing_" + attributeName + "_attribute",
Type = ResultType.Hint
};
var numberOfTagsMissingAttribute = imageTagCount - imagesWithAttributeCount;
resultRule.Tokens.Add(numberOfTagsMissingAttribute.ToString());
AddResultRule(resultRule);
}
}
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);
}
private void AnalyzeMetaDescriptionAttribute(HtmlAttribute metaDescriptionAttribute)
{
var descriptionValue = metaDescriptionAttribute.Value;
var resultRule = new ResultRule();
if (string.IsNullOrWhiteSpace(descriptionValue))
{
resultRule.Alias = "no_description_value";
resultRule.Type = ResultType.Error;
}
else
{
descriptionValue = descriptionValue.Trim();
if (descriptionValue.Length > MaximumLength)
{
resultRule.Alias = "description_too_long";
resultRule.Type = ResultType.Warning;
}
if (descriptionValue.Length < MinimumLength)
{
resultRule.Alias = "description_too_short";
resultRule.Type = ResultType.Warning;
}
else if (descriptionValue.Length < AcceptableLength)
{
resultRule.Alias = "description_shorter_then_acceptable";
resultRule.Type = ResultType.Hint;
}
if (descriptionValue.Length <= MaximumLength && descriptionValue.Length >= AcceptableLength)
{
resultRule.Alias = "description_perfect";
resultRule.Type = ResultType.Success;
}
}
resultRule.Tokens.Add(MaximumLength.ToString()); // 0
resultRule.Tokens.Add(MinimumLength.ToString()); // 1
resultRule.Tokens.Add(AcceptableLength.ToString()); // 2
AddResultRule(resultRule);
}
public override void Analyse(IPageData pageData)
{
if (pageData == null)
{
throw new ArgumentNullException(nameof(pageData));
}
try
{
var bodyTag = _htmlTagHelper.GetBodyTag(pageData.Document);
if (bodyTag != null)
{
var bodyText = bodyTag.InnerText.Trim();
// replace multiple spaces with 1
var text = Regex.Replace(bodyText.ToLower(), @"\s+", " ");
var matches = Regex.Matches(text, pageData.Focuskeyword);
if (matches.Count == 0)
{
AddResultRule("content_doesnt_contain_keyword", ResultType.Warning);
}
else
{
var resultRule = new ResultRule
{
Alias = "content_contains_keyword",
Type = ResultType.Success
};
resultRule.Tokens.Add(matches.Count.ToString());
AddResultRule(resultRule);
}
}
}
catch (NoElementFoundException e)
{
AddResultRule("no_" + e.ElementName + "_tag", ResultType.Error);
}
catch (MultipleElementsFoundException e)
{
AddResultRule("multiple_" + e.ElementName + "_tags", ResultType.Error);
}
}
private void CheckTag(HtmlNode htmlNode, string tagname)
{
var foundElements = htmlNode.GetElements(tagname);
if (foundElements.Any())
{
var resultRute = new ResultRule()
{
Alias = "tag_found",
Type = ResultType.Warning,
Tokens = new List <string>()
{
tagname
}
};
AddResultRule(resultRute);
}
}
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 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 void Analyse(IPageData pageData)
{
if (pageData == null)
{
throw new ArgumentNullException(nameof(pageData));
}
var cssFiles = pageData.Document.GetElementsWithAttribute("link", "href").Where(x => x.Attributes.Any(y => y.Name == "rel" && y.Value == "stylesheet"));
var scriptFiles = pageData.Document.GetElementsWithAttribute("script", "src");
var images = pageData.Document.GetElementsWithAttribute("img", "src");
var objects = pageData.Document.GetElementsWithAttribute("object", "data");
var total = cssFiles.Count() + scriptFiles.Count() + images.Count() + objects.Count();
var resultRule = new ResultRule();
if (total > MaximumAdditionalCalls)
{
resultRule.Alias = "more_than_maximum_calls";
resultRule.Type = ResultType.Warning;
}
else if (total > AcceptableAdditionalCalls)
{
resultRule.Alias = "more_than_acceptable_calls";
resultRule.Type = ResultType.Hint;
}
else
{
resultRule.Alias = "less_than_acceptable_calls";
resultRule.Type = ResultType.Success;
}
resultRule.Tokens.Add(total.ToString()); // 0
resultRule.Tokens.Add(cssFiles.Count().ToString()); // 1
resultRule.Tokens.Add(scriptFiles.Count().ToString()); // 2
resultRule.Tokens.Add(images.Count().ToString()); // 3
resultRule.Tokens.Add(objects.Count().ToString()); // 4
resultRule.Tokens.Add(MaximumAdditionalCalls.ToString()); // 5
resultRule.Tokens.Add(AcceptableAdditionalCalls.ToString()); // 6
AddResultRule(resultRule);
}
public override AnalyzeResult Analyse(IPageData pageData)
{
var result = new AnalyzeResult();
var cssFiles = pageData.Document.GetElementsWithAttribute("link", "href").
Where(x => x.Attributes.Any(y => y.Name == "rel" && y.Value == "stylesheet"));
var scriptFiles = pageData.Document.GetElementsWithAttribute("script", "src");
var images = pageData.Document.GetElementsWithAttribute("img", "src");
var objects = pageData.Document.GetElementsWithAttribute("object ", "data");
var total = cssFiles.Count() + scriptFiles.Count() + images.Count() + objects.Count();
var resultRule = new ResultRule();
if (total > 30)
{
resultRule.Alias = "more_than_30_calls";
resultRule.Type = ResultType.Warning;
}
else if (total > 15)
{
resultRule.Alias = "more_than_15_calls";
resultRule.Type = ResultType.Hint;
}
else
{
resultRule.Alias = "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 override AnalyzeResult Analyse(IPageData pageData)
{
var htmlSizeAnalysis = new AnalyzeResult();
var byteCount = _byteSizeHelper.GetByteSize(pageData.Document.InnerHtml);
var htmlSizeResultRule = new ResultRule();
if (byteCount < MaximumSizeInKb)
{
htmlSizeResultRule.Alias = "html_size_small";
htmlSizeResultRule.Type = ResultType.Success;
}
else
{
htmlSizeResultRule.Alias = "htmlsizeanalyzer_html_size_too_large";
htmlSizeResultRule.Type = ResultType.Warning;
}
htmlSizeResultRule.Tokens.Add(_byteSizeHelper.GetSizeSuffix(byteCount));
htmlSizeAnalysis.ResultRules.Add(htmlSizeResultRule);
return(htmlSizeAnalysis);
}
private void AnalyzeTitleTag(HtmlNode titleTag)
{
var titleValue = titleTag.InnerText;
var resultRule = new ResultRule();
if (string.IsNullOrWhiteSpace(titleValue))
{
resultRule.Alias = "no_title_value";
resultRule.Type = ResultType.Error;
}
else
{
titleValue = titleValue.Trim();
if (titleValue.Length > MaximumLength)
{
resultRule.Alias = "title_too_long";
resultRule.Type = ResultType.Warning;
}
if (titleValue.Length < MinimumLength)
{
resultRule.Alias = "title_too_short";
resultRule.Type = ResultType.Hint;
}
if (titleValue.Length <= MaximumLength && titleValue.Length >= MinimumLength)
{
resultRule.Alias = "title_success";
resultRule.Type = ResultType.Success;
}
}
resultRule.Tokens.Add(MaximumLength.ToString()); // 0
resultRule.Tokens.Add(MinimumLength.ToString()); // 1
AddResultRule(resultRule);
}
public override void Analyse(IPageData pageData)
{
if (pageData == null)
{
throw new ArgumentNullException(nameof(pageData));
}
var anchorTags = pageData.Document.GetElements("a");
var anchorTagCount = anchorTags.Count();
var url = new Uri(pageData.Url);
foreach (var anchorTag in anchorTags)
{
CheckAnchor(anchorTag, url);
}
if (!_brokenLinks.Any())
{
AddResultRule("all_links_working", ResultType.Success);
}
else
{
foreach (var brokenLink in _brokenLinks)
{
var resultRule = new ResultRule()
{
Alias = "broken_link",
Type = ResultType.Warning,
Tokens = new List <string>()
{
brokenLink, brokenLink
}
};
AddResultRule(resultRule);
}
}
}
public override AnalyzeResult Analyse(HtmlNode document, params object[] additionalValues)
{
var result = new AnalyzeResult
{
Alias = "keywordheadinganalyzer"
};
var h1Tags = HtmlHelper.GetElements(document, "h1");
var h2Tags = HtmlHelper.GetElements(document, "h2");
var h3Tags = HtmlHelper.GetElements(document, "h3");
var h4Tags = HtmlHelper.GetElements(document, "h4");
var keyword = additionalValues[0].ToString();
var usedInHeadingCount = h1Tags.Count(x => x.InnerText.ToLower().Contains(keyword)) +
h2Tags.Count(x => x.InnerText.ToLower().Contains(keyword)) +
h3Tags.Count(x => x.InnerText.ToLower().Contains(keyword)) +
h4Tags.Count(x => x.InnerText.ToLower().Contains(keyword));
if (usedInHeadingCount > 0)
{
var resultRule = new ResultRule
{
Alias = "keywordheadinganalyzer_keyword_used_in_heading",
Type = ResultType.Success
};
resultRule.Tokens.Add(usedInHeadingCount.ToString());
result.ResultRules.Add(resultRule);
}
else
{
result.AddResultRule("keywordheadinganalyzer_keyword_not_used_in_heading", ResultType.Hint);
}
return(result);
}
public override AnalyzeResult Analyse(HtmlNode document, params object[] additionalValues)
{
var htmlSizeAnalysis = new AnalyzeResult
{
Alias = "htmlsizeanalyzer"
};
var byteCount = Encoding.Unicode.GetByteCount(document.InnerHtml);
var htmlSizeResultRule = new ResultRule();
if (byteCount < (33 * 1024))
{
htmlSizeResultRule.Alias = "htmlsizeanalyzer_html_size_small";
htmlSizeResultRule.Type = ResultType.Success;
}
else
{
htmlSizeResultRule.Alias = "htmlsizeanalyzer_html_size_too_large";
htmlSizeResultRule.Type = ResultType.Warning;
}
htmlSizeResultRule.Tokens.Add(SizeSuffix(byteCount));
htmlSizeAnalysis.ResultRules.Add(htmlSizeResultRule);
return(htmlSizeAnalysis);
}
public override void Analyse(IPageData pageData)
{
if (pageData == null)
{
throw new ArgumentNullException(nameof(pageData));
}
var byteCount = _byteSizeHelper.GetByteSize(pageData.Document.InnerHtml);
var htmlSizeResultRule = new ResultRule();
if (byteCount < MaximumSizeInBytes)
{
htmlSizeResultRule.Alias = "html_size_small";
htmlSizeResultRule.Type = ResultType.Success;
}
else
{
htmlSizeResultRule.Alias = "html_size_too_large";
htmlSizeResultRule.Type = ResultType.Warning;
}
htmlSizeResultRule.Tokens.Add(_byteSizeHelper.GetSizeSuffix(byteCount));
htmlSizeResultRule.Tokens.Add(_byteSizeHelper.GetSizeSuffix(MaximumSizeInBytes));
AddResultRule(htmlSizeResultRule);
}
public void Constructor_OnExecute_InitializesCollections()
{
var resultRule = new ResultRule();
Assert.IsNotNull(resultRule.Tokens);
}
public void AddResultRule(ResultRule resultRule)
{
AnalyzeResult.ResultRules.Add(resultRule);
}
public ResultRule(ResultRule rule)
: base(rule)
{
Repair = rule.Repair;
}
