public void TestSwitchBrowserWindow()
{
Driver.Navigate().GoToUrl(IndexPage.Url);
var linkChecker = new LinkChecker(Driver);
linkChecker.HammerLinks();
}
public void WithHttpAtStart_LinkParses()
{
var links = LinkChecker.GetLinks("", "<a href=\"http://google.com\" />");
Assert.Equal(1, links.Count());
Assert.Equal("http://google.com", links.First());
}
public void WithHttpAtStartOfLink_LinkParses()
{
var links = LinkChecker.GetLinks("<a href=\"http://google.com\" />");
Assert.Equal(links.Count(), 1);
Assert.Equal(links.First(), "http://google.com");
}
public void WithoutHttpAtStartOfLink_NoLinks()
{
var links = LinkChecker.GetLinks("", "<a href=\"google.com\" />");
Assert.Empty(links);
//Assert.Equal("google.com", links.First());
}
public void WithoutHttpAtStartOfLink_NoLinks()
{
var links = LinkChecker.GetLinks("<a href=\"google.com\" />");
Assert.Equal(links.Count(), 0);
//Assert.Equal(links.First(), "google.com");
}
private async Task CheckLink(BindableLinkDescription arg, CancellationToken cancelToken)
{
try
{
var res = await LinkChecker.CheckLink(arg.OriginalLink, cancelToken).ConfigureAwait(false);
// access the binding on the UI thread
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
arg.HttpStatus = (int)res.HttpStatusCode;
arg.LinkAfterRedirect = res.NewLink;
arg.Result = res.Summary;
if (res.Summary == LinkCheckSummary.SimpleChange)
{
arg.SelectForUpdate = true;
}
else if (res.Summary == LinkCheckSummary.Error ||
res.Summary == LinkCheckSummary.NotFound)
{
arg.SelectForInvalidMark = true;
}
});
}
catch (Exception ex)
{
Logger.Log(LogLevel.Error, nameof(CheckLink), "Error checking link: " + arg?.OriginalLink, ex);
}
}
public void LinkChecker_Visit_InValidMemberAccessThrows()
{
Assert.Throws <Exception>(() =>
{
AbstractSyntaxTree ast = TestAstBuilder.BuildAst(TestCode3_3, TestCode3_2);
LinkChecker linkChecker = new LinkChecker(ast);
linkChecker.Visit(ast.Root.GameObjects["SampleScreen1"]);
});
}
public void LinkChecker_Visit_ThrowOnInvalidExitLink()
{
AbstractSyntaxTree ast = TestAstBuilder.BuildAst(TestCode1_1, TestCode1_2);
LinkChecker linkChecker = new LinkChecker(ast);
void TestDelegate() => linkChecker.Visit(ast.Root.GameObjects["SampleScreen1"]);
Assert.Throws <Exception>(TestDelegate);
}
public void ValidLinksTest_RequireInternetConnection()
{
var linkStatus = new LinkChecker().GetLinkStatus(validLinksHtml);
var expected = new[] {
new LinkStatus("https://www.bing.com", isValid: true),
new LinkStatus("http://www.microsoft.com", isValid: true),
};
Assert.Equal(expected.OrderBy(a => a.Url), linkStatus.OrderBy(a => a.Url));
}
private void Checker_LinkToProcess(object?sender, LinkModificationEventArgs e)
{
switch (e.Modification)
{
case LinkModification.MarkInvalid:
this.SourceValue = LinkChecker.MarkInvalid(this.SourceValue, e.LinkHref);
break;
case LinkModification.UpdateSchema:
this.SourceValue = LinkChecker.UpdateHref(this.SourceValue, e.LinkHref, e.NewHref);
break;
}
}
static void Main(string[] args)
{
var site = "https://github.com/g0t4/pluralsight-dotnet-core-xplat-apps";
var client = new HttpClient();
var body = client.GetStringAsync(site);
Console.WriteLine(body.Result);
Console.WriteLine();
Console.WriteLine("Links");
var links = LinkChecker.GetLinks(body.Result);
links.ToList().ForEach(Console.WriteLine);
}
public void CheckLinksWithResultsAsync_TwoLinksInPageForUri_OneOkTheOtherBad(string elementId)
{
// arrange
var mainPageUri = new Uri("https://dummy.com/");
string okLink = "https://ok.com/";
string notFoundLink = "https://notfound.com/";
var mockHttpMessageHandler = new Mock <HttpMessageHandler>();
mockHttpMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.Is <HttpRequestMessage>(hrh => hrh.RequestUri.OriginalString == mainPageUri.ToString()), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = GetHtmlWithTwoLinksInside(elementId, okLink, notFoundLink)
});
mockHttpMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.Is <HttpRequestMessage>(hrh => hrh.RequestUri.OriginalString == okLink), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("some text.."),
RequestMessage = new HttpRequestMessage(HttpMethod.Get, okLink)
});
mockHttpMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.Is <HttpRequestMessage>(hrh => hrh.RequestUri.OriginalString == notFoundLink), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.NotFound,
RequestMessage = new HttpRequestMessage(HttpMethod.Get, notFoundLink)
});
var httpClient = new HttpClient(mockHttpMessageHandler.Object);
var linkChecker = new LinkChecker(httpClient, new LinkGetter(httpClient, elementId));
// act
Dictionary <string, HttpResponseMessage> results = linkChecker.CheckLinks(mainPageUri);
// assert
CollectionAssert.IsNotEmpty(results);
Assert.That(results.Count, Is.EqualTo(2));
Assert.That(results[okLink].StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(results[notFoundLink].StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
}
public void InvalidLinksTest_RequireInternetConnection()
{
var linkStatus = new LinkChecker().GetLinkStatus(InvalidLinksHtml);
var expected = new[] {
new LinkStatus("https://www.Idontexistasdfsdfsdf.com", isValid: false),
new LinkStatus("http://www.Idontexistasdfsdfsdf123.com", isValid: false),
new LinkStatus("ThisIsInvalidUrl", isValid: false),
new LinkStatus("This Is Invalid Url", isValid: false),
new LinkStatus("abcde://ThisIsInvalidUrl.com", isValid: false)
};
Assert.Equal(expected.OrderBy(a => a.Url), linkStatus.OrderBy(a => a.Url));
}
private async Task CheckLinksAsync()
{
var links = LinkChecker.FindLinks(this.SourceValue);
if (!links.Any())
{
await this.SetStatusAsync("No links found to check.").ConfigureAwait(false);
return;
}
this.Frame.Navigate(typeof(LinkCheckerWindow));
await Task.CompletedTask;
}
public Post ConvertPostFromJson(JToken jsonPost)
{
Post newPost = new Post
{
ID = jsonPost["id"].ToString(),
Title = jsonPost["title"].ToString(),
Content = jsonPost["selftext"].ToString(),
Permalink = jsonPost["permalink"].ToString(),
Link = jsonPost["url"].ToString(),
AuthorName = jsonPost["author"].ToString(),
Likes = Convert.ToInt32(jsonPost["ups"]),
Thumbnail = jsonPost["thumbnail"].ToString(),
Subreddit = jsonPost["subreddit"].ToString(),
NSFW = Convert.ToBoolean(jsonPost["over_18"])
};
newPost.LinkType = LinkChecker.GetLinkType(newPost.Link);
if (newPost.LinkType == "Youtube")
{
newPost.Link = LinkChecker.ConvertYoutubeLink(newPost.Link);
}
if (newPost.LinkType == "Streamable")
{
newPost.Link = LinkChecker.ConvertStreamableLink(newPost.Link);
newPost.LinkType = "Youtube";
}
if (newPost.LinkType == "Twitch")
{
newPost.Link = LinkChecker.ConvertTwitchLink(newPost.Link);
}
// Convert gfycat and gifv to use reddit video
if (newPost.LinkType == "Gfycat" || newPost.LinkType == "Gifv")
{
newPost.Link = jsonPost["preview"]["reddit_video_preview"]["fallback_url"].ToString();
newPost.LinkType = "Video";
}
// For converting reddit videos
if (Convert.ToBoolean(jsonPost["is_video"]) == true)
{
newPost.Link = jsonPost["secure_media"]["reddit_video"]["fallback_url"].ToString();
newPost.LinkType = "Video";
}
return(newPost);
}
public LinkCheckerWindow()
{
this.InitializeComponent();
this.DataContext = this;
var appView = Windows.UI.ViewManagement.ApplicationView.GetForCurrentView();
appView.Title = "Link Checker";
var links = LinkChecker.FindLinks(CleanerSettings.Instance.HtmlSource);
this.Links.Clear();
foreach (var lnk in links)
{
this.Links.Add(new BindableLinkDescription(lnk));
}
}
private static async Task CheckLink(BindableLinkDescription arg, CancellationToken cancelToken)
{
var res = await LinkChecker.CheckLink(arg.OriginalLink, cancelToken).ConfigureAwait(false);
arg.HttpStatus = (int)res.HttpStatusCode;
arg.LinkAfterRedirect = res.NewLink;
arg.Result = res.Summary;
if (res.Summary == LinkCheckSummary.SimpleChange)
{
arg.SelectForUpdate = true;
}
else if (res.Summary == LinkCheckSummary.Error ||
res.Summary == LinkCheckSummary.NotFound)
{
arg.SelectForInvalidMark = true;
}
}
public void CheckAllInputLinksWhenNoFilterIsSpecified()
{
// arrange
var input = new LinkCheckerInput(_links);
(var httpClient, _) = CreateMockHttpClient((msg, token) => new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK
});
var linkChecker = new LinkChecker(httpClient);
// act
var result = linkChecker.Check(input);
PrintOut(result);
// assert
result.LinkStates.Keys.Should().BeEquivalentTo(_links);
}
public void SkipNonHttpLinks()
{
// arrange
var malformedUrl = new Link("xtp://something.com/");
var input = new LinkCheckerInput(new [] { malformedUrl });
(var httpClient, var httpHandlerMock) = CreateMockHttpClient((msg, token) => throw new NotImplementedException());
var linkChecker = new LinkChecker(httpClient);
// act
var result = linkChecker.Check(input);
PrintOut(result);
// assert
result.LinkStates.Should().BeEquivalentTo(new Dictionary <Link, LinkStatus> {
[malformedUrl] = LinkStatus.SKIPPED
});
httpHandlerMock.Protected().Verify("SendAsync", Times.Never(), ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>());
}
private void UpdateSource(object sender, RoutedEventArgs e)
{
int count = 0;
var html = CleanerSettings.Instance.HtmlSource;
// process any checked link, but "invalid" beats "update".
foreach (var lnk in this.Links.Where(l => l.SelectForUpdate || l.SelectForInvalidMark))
{
if (lnk.SelectForInvalidMark)
{
MarkError(lnk);
}
else if (lnk.SelectForUpdate && !string.IsNullOrEmpty(lnk.LinkAfterRedirect))
{
UpdateUrl(lnk);
}
lnk.SelectForInvalidMark = false;
lnk.SelectForUpdate = false;
}
this.MessageLabel.Text = $"{count} link(s) updated.";
CleanerSettings.Instance.HtmlSource = html;
void MarkError(BindableLinkDescription link)
{
html = LinkChecker.MarkInvalid(html, link.OriginalLink);
link.Result = LinkCheckSummary.Updated;
count++;
}
void UpdateUrl(BindableLinkDescription link)
{
html = LinkChecker.UpdateHref(html, link.OriginalLink, link.LinkAfterRedirect);
link.Result = LinkCheckSummary.Updated;
count++;
}
}
private async Task CheckLinks()
{
this.checker?.Links.Clear();
var links = LinkChecker.FindLinks(this.SourceValue);
if (!links.Any())
{
MessageBox.Show("No links found.");
return;
}
OpenLinkCheckerWindow();
this.checker !.Links.Clear();
foreach (var lnk in links)
{
checker.Links.Add(new BindableLinkDescription(lnk));
}
checker.Focus();
await checker.CheckAllLinks().ConfigureAwait(false);
}
public void ReportInvalidLinks(HttpResponseMessage responseMessage)
{
// arrange
var link = new Link("http://www.google.com/");
var input = new LinkCheckerInput(new [] { link });
(var httpClient, var httpHandlerMock) = CreateMockHttpClient((msg, token) => responseMessage);
var linkChecker = new LinkChecker(httpClient);
// act
var result = linkChecker.Check(input);
PrintOut(result);
// assert
result.LinkStates.Should().BeEquivalentTo(new Dictionary <Link, LinkStatus> {
[link] = LinkStatus.INVALID
});
httpHandlerMock.Protected().Verify(
"SendAsync",
Times.Exactly(1),
ItExpr.Is <HttpRequestMessage>(rm => rm.Method == HttpMethod.Get && rm.RequestUri == new Uri(link.Url)),
ItExpr.IsAny <CancellationToken>());
}
public void LinkWithBeginnerTest()
{
var links = LinkChecker.GetLinks("<a href=\"https:\\\\google.com\"><\\a>");
Assert.AreEqual(links.ToList().Count(), 1);
}
public async Task ExtractedALink()
{
var links = await LinkChecker.GetLinks("https://google.com");
Assert.True(links.Count() > 0);
}
public void WithoutHttpAtStartOfLink_NoLinks()
{
var links = LinkChecker.GetLinks("<a href=\"google.com\">");
Assert.Equal(0, links.Count());
}
public void WithoutHttpAtStartOfLink_NoLinks()
{
var links = new LinkChecker(null).Getlinks("", "<a href=\"google.com\" />");
Assert.Equal(links.Count(), 0);
}
public void WithoutHTTPAtTheStartOfTheLink_NoLinks()
{
var links = LinkChecker.GetLinks("<a href=\"google.com\" />");
Assert.Equal(links.Count(), 0);
}
public void NoLinksTest()
{
var linkStatus = new LinkChecker().GetLinkStatus(string.Empty);
Assert.Equal(Enumerable.Empty <LinkStatus>(), linkStatus);
}
