public async Task ShouldCaptureFullElementWhenLargerThanViewportInParallel()
{
await Page.SetViewportAsync(new Viewport
{
Width = 500,
Height = 500
});
await Page.SetContentAsync(@"
<div style=""height: 14px"">oooo</div>
<style>
div.to-screenshot {
border: 1px solid blue;
width: 600px;
height: 600px;
margin-left: 50px;
}
::-webkit-scrollbar{
display: none;
}
</style>
<div class=""to-screenshot""></div>
<div class=""to-screenshot""></div>
<div class=""to-screenshot""></div>
");
var elementHandles = await Page.QuerySelectorAllAsync("div.to-screenshot");
var screenshotTasks = elementHandles.Select(e => e.ScreenshotAsync());
await Task.WhenAll(screenshotTasks);
Assert.True(ScreenshotHelper.PixelMatch("screenshot-element-padding-border.png", screenshotTasks.ElementAt(2).Result));
}
public async Task ShouldCaptureFullElementWhenLargerThanViewport()
{
await Page.SetViewportAsync(new Viewport
{
Width = 500,
Height = 500
});
await Page.SetContentAsync(@"
something above
<style>
div.to-screenshot {
border: 1px solid blue;
width: 600px;
height: 600px;
margin-left: 50px;
}
::-webkit-scrollbar{
display: none;
}
</style>
<div class='to-screenshot'></div>"
);
var elementHandle = await Page.QuerySelectorAsync("div.to-screenshot");
byte[] screenshot = await elementHandle.ScreenshotAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-element-larger-than-Viewport.png", screenshot));
Assert.Equal(new[] { 500, 500 }, await Page.EvaluateAsync <int[]>("[window.innerWidth, window.innerHeight]"));
}
public async Task ShouldWorkWithFile()
{
var outputFile = Path.Combine(BaseDirectory, "output.png");
var fileInfo = new FileInfo(outputFile);
await using (var page = await Context.NewPageAsync())
{
await page.SetViewportAsync(new ViewPortOptions
{
Width = 500,
Height = 500
});
await page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
if (fileInfo.Exists)
{
fileInfo.Delete();
}
await page.ScreenshotAsync(outputFile);
fileInfo = new FileInfo(outputFile);
Assert.True(new FileInfo(outputFile).Length > 0);
Assert.True(ScreenshotHelper.PixelMatch("screenshot-sanity.png", outputFile));
if (fileInfo.Exists)
{
fileInfo.Delete();
}
}
}
public async Task ShouldCaptureFullElementWhenLargerThanViewport()
{
await Page.SetViewportAsync(new ViewPortOptions
{
Width = 500,
Height = 500
});
await Page.SetContentAsync(@"
something above
<style>
div.to-screenshot {
border: 1px solid blue;
width: 600px;
height: 600px;
margin-left: 50px;
}
::-webkit-scrollbar{
display: none;
}
</style>
<div class='to-screenshot'></div>"
);
var elementHandle = await Page.QuerySelectorAsync("div.to-screenshot");
var screenshot = await elementHandle.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-element-larger-than-viewport.png", screenshot));
Assert.Equal(JToken.FromObject(new { w = 500, h = 500 }),
await Page.EvaluateExpressionAsync("({ w: window.innerWidth, h: window.innerHeight })"));
}
public async Task ShouldScrollElementIntoView()
{
await Page.SetViewportAsync(new Viewport
{
Width = 500,
Height = 500
});
await Page.SetContentAsync(@"
<div style=""height: 14px"">oooo</div>
<style>div.above {
border: 2px solid blue;
background: red;
height: 1500px;
}
div.to-screenshot {
border: 2px solid blue;
background: green;
width: 50px;
height: 50px;
}
</style>
<div class=""above""></div>
<div class=""to-screenshot""></div>");
var elementHandle = await Page.QuerySelectorAsync("div.to-screenshot");
byte[] screenshot = await elementHandle.ScreenshotAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-element-scrolled-into-view.png", screenshot));
}
public async Task ShouldWorkForOffscreenClip()
{
using (var page = await Browser.NewPageAsync())
{
await page.SetViewportAsync(new ViewPortOptions
{
Width = 500,
Height = 500
});
await page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
var screenshot = await page.ScreenshotStreamAsync(new ScreenshotOptions
{
Clip = new Clip
{
X = 50,
Y = 600,
Width = 100,
Height = 100
}
});
Assert.True(ScreenshotHelper.PixelMatch("screenshot-offscreen-clip.png", screenshot));
}
}
public async Task ShouldTakeIntoAccountPaddingAndBorder()
{
await Page.SetViewportAsync(new ViewPortOptions
{
Width = 500,
Height = 500
});
await Page.SetContentAsync(@"
something above
<style> div {
border: 2px solid blue;
background: green;
width: 50px;
height: 50px;
}
</style>
<div></div>
");
var elementHandle = await Page.QuerySelectorAsync("div");
var screenshot = await elementHandle.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-element-padding-border.png", screenshot));
}
public async Task ShouldTakeIntoAccountPaddingAndBorder()
{
await Page.SetViewportAsync(new Viewport
{
Width = 500,
Height = 500
});
await Page.SetContentAsync(@"
<div style=""height: 14px"">oooo</div>
<style>div {
border: 2px solid blue;
background: green;
width: 50px;
height: 50px;
}
</style>
<div id=""d""></div>");
var elementHandle = await Page.QuerySelectorAsync("div#d");
byte[] screenshot = await elementHandle.ScreenshotAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-element-padding-border.png", screenshot));
}
public async Task ShouldAllowMockingBinaryResponses()
{
await Page.SetRequestInterceptionAsync(true);
Page.Request += async(sender, e) =>
{
var imageData = File.ReadAllBytes("./assets/pptr.png");
await e.Request.RespondAsync(new ResponseData
{
ContentType = "image/png",
BodyData = imageData
});
};
await Page.EvaluateFunctionAsync(@"PREFIX =>
{
const img = document.createElement('img');
img.src = PREFIX + '/does-not-exist.png';
document.body.appendChild(img);
return new Promise(fulfill => img.onload = fulfill);
}", TestConstants.ServerUrl);
var img = await Page.QuerySelectorAsync("img");
Assert.True(ScreenshotHelper.PixelMatch("mock-binary-response.png", await img.ScreenshotDataAsync()));
}
public async Task ShouldClipScale()
{
await using (var page = await Context.NewPageAsync())
{
await page.SetViewportAsync(new ViewPortOptions
{
Width = 500,
Height = 500
});
await page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
var screenshot = await page.ScreenshotDataAsync(new ScreenshotOptions
{
Clip = new Clip
{
X = 50,
Y = 100,
Width = 150,
Height = 100,
Scale = 2
}
});
Assert.True(ScreenshotHelper.PixelMatch("screenshot-clip-rect-scale.png", screenshot));
}
}
public async Task ShouldRunInParallel()
{
await using (var page = await Context.NewPageAsync())
{
await page.SetViewportAsync(new ViewPortOptions
{
Width = 500,
Height = 500
});
await page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
var tasks = new List <Task <byte[]> >();
for (var i = 0; i < 3; ++i)
{
tasks.Add(page.ScreenshotDataAsync(new ScreenshotOptions
{
Clip = new Clip
{
X = 50 * i,
Y = 0,
Width = 50,
Height = 50
}
}));
}
await Task.WhenAll(tasks);
Assert.True(ScreenshotHelper.PixelMatch("grid-cell-1.png", tasks[0].Result));
}
}
public async Task ShouldScrollElementIntoView()
{
await Page.SetViewportAsync(new ViewPortOptions
{
Width = 500,
Height = 500
});
await Page.SetContentAsync(@"
something above
<style> div.above {
border: 2px solid blue;
background: red;
height: 1500px;
}
div.to-screenshot {
border: 2px solid blue;
background: green;
width: 50px;
height: 50px;
}
</style>
<div class='above'></div>
<div class='to-screenshot'></div>
");
var elementHandle = await Page.QuerySelectorAsync("div.to-screenshot");
var screenshot = await elementHandle.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-element-scrolled-into-view.png", screenshot));
}
public async Task ShouldWorkForAnElementWithAnOffset()
{
await Page.SetContentAsync("<div style=\"position:absolute; top: 10.3px; left: 20.4px;width:50.3px;height:20.2px;border:1px solid black;\"></div>");
var elementHandle = await Page.QuerySelectorAsync("div");
var screenshot = await elementHandle.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-element-fractional-offset.png", screenshot));
}
public async Task ShouldWorkForAnElementWithFractionalDimensions()
{
await Page.SetContentAsync("<div style=\"width:48.51px;height:19.8px;border:1px solid black;\"></div>");
var elementHandle = await Page.QuerySelectorAsync("div");
var screenshot = await elementHandle.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-element-fractional.png", screenshot));
}
public async Task ShouldTakeScreenshot()
{
await _page.SetViewportSizeAsync(500, 500);
await _page.GoToAsync(TestConstants.ServerUrl + "/dynamic-oopif.html");
Assert.Equal(2, _page.Frames.Count());
Assert.Equal(1, await CountOOPIFsASync(_browser));
Assert.True(ScreenshotHelper.PixelMatch("screenshot-oopif.png", await _page.ScreenshotAsync()));
}
public async Task ShouldRunInParallelInMultiplePages()
{
var n = 2;
var pageTasks = new List <Task <Page> >();
for (var i = 0; i < n; i++)
{
async Task <Page> func()
{
var page = await Context.NewPageAsync();
await page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
return(page);
}
pageTasks.Add(func());
}
await Task.WhenAll(pageTasks);
var screenshotTasks = new List <Task <byte[]> >();
for (var i = 0; i < n; i++)
{
screenshotTasks.Add(pageTasks[i].Result.ScreenshotDataAsync(new ScreenshotOptions
{
Clip = new Clip
{
X = 50 * i,
Y = 0,
Width = 50,
Height = 50
}
}));
}
await Task.WhenAll(screenshotTasks);
for (var i = 0; i < n; i++)
{
Assert.True(ScreenshotHelper.PixelMatch($"grid-cell-{i}.png", screenshotTasks[i].Result));
}
var closeTasks = new List <Task>();
for (var i = 0; i < n; i++)
{
closeTasks.Add(pageTasks[i].Result.CloseAsync());
}
await Task.WhenAll(closeTasks);
}
public async Task ShouldFire()
{
await Page.SetViewportAsync(new ViewPortOptions
{
Width = 500,
Height = 500
});
await Page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
await Page.EvaluateExpressionAsync("window.scrollBy(50, 100)");
var elementHandle = await Page.QuerySelectorAsync(".box:nth-of-type(3)");
var screenshot = await elementHandle.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-element-bounding-box.png", screenshot));
}
public async Task ShouldWorkForWebgl()
{
await Page.SetViewportAsync(new Viewport
{
Width = 640,
Height = 480
});
await Page.GoToAsync(TestConstants.ServerUrl + "/screenshots/webgl.html");
byte[] screenshot = await Page.ScreenshotAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-webgl.png", screenshot));
}
public async Task ShouldReturnBase64()
{
await Page.SetViewportAsync(new Viewport
{
Width = 500,
Height = 500
});
await Page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
string screenshot = await Page.ScreenshotBase64Async();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-sanity.png", Convert.FromBase64String(screenshot)));
}
public async Task ShouldRenderWhiteBackgroundOnJpegFile()
{
await Page.SetViewportAsync(new Viewport { Width = 100, Height = 100 });
await Page.GoToAsync(TestConstants.EmptyPage);
byte[] screenshot = await Page.ScreenshotAsync(new ScreenshotOptions
{
OmitBackground = true,
Type = ScreenshotFormat.Jpeg
});
Assert.True(ScreenshotHelper.PixelMatch("white.jpg", screenshot));
}
public async Task ShouldTakeScreenshot()
{
string[] result = await Page.EvaluateAsync <string[]>(
@"async url => {
await page.setViewport({width: 500, height: 500});
await page.goto(url);
const screenshot = await page.screenshot();
return [screenshot.toString('base64'), screenshot.constructor.name] };
}",
TestConstants.ServerUrl + "/grid.html");
Assert.True(ScreenshotHelper.PixelMatch("screenshot-sanity.png", Convert.FromBase64String(result[0])));
Assert.Equal("BufferImpl", result[1]);
}
public async Task ShouldWorkForTranslateZ()
{
await Page.SetViewportAsync(new Viewport
{
Width = 500,
Height = 500
});
await Page.GoToAsync(TestConstants.ServerUrl + "/screenshots/translateZ.html");
byte[] screenshot = await Page.ScreenshotAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-translateZ.png", screenshot));
}
public async Task ShouldWorkWithOddClipSizeOnRetinaDisplays()
{
byte[] screenshot = await Page.ScreenshotAsync(new ScreenshotOptions
{
Clip = new Rect
{
X = 0,
Y = 0,
Width = 11,
Height = 11
}
});
Assert.True(ScreenshotHelper.PixelMatch("screenshot-clip-odd-size.png", screenshot));
}
public async Task ShouldWorkWithAMobileViewport()
{
await Page.SetViewportAsync(new Viewport
{
Width = 320,
Height = 480,
IsMobile = true
});
await Page.GoToAsync(TestConstants.ServerUrl + "/overflow.html");
byte[] screenshot = await Page.ScreenshotAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-mobile.png", screenshot));
}
public async Task ShouldWork()
{
await Page.SetViewportAsync(new ViewPortOptions { Width = 500, Height = 500 });
await Page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
await Page.EmulateVisionDeficiencyAsync(VisionDeficiency.None);
var screenshot = await Page.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-sanity.png", screenshot));
await Page.EmulateVisionDeficiencyAsync(VisionDeficiency.Achromatopsia);
screenshot = await Page.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("vision-deficiency-achromatopsia.png", screenshot));
await Page.EmulateVisionDeficiencyAsync(VisionDeficiency.BlurredVision);
screenshot = await Page.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("vision-deficiency-blurredVision.png", screenshot));
await Page.EmulateVisionDeficiencyAsync(VisionDeficiency.Deuteranopia);
screenshot = await Page.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("vision-deficiency-deuteranopia.png", screenshot));
await Page.EmulateVisionDeficiencyAsync(VisionDeficiency.Protanopia);
screenshot = await Page.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("vision-deficiency-protanopia.png", screenshot));
await Page.EmulateVisionDeficiencyAsync(VisionDeficiency.Tritanopia);
screenshot = await Page.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("vision-deficiency-tritanopia.png", screenshot));
await Page.EmulateVisionDeficiencyAsync(VisionDeficiency.None);
screenshot = await Page.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-sanity.png", screenshot));
}
public async Task ShouldWork()
{
await using (var page = await Context.NewPageAsync())
{
await page.SetViewportAsync(new ViewPortOptions
{
Width = 500,
Height = 500
});
await page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
var screenshot = await page.ScreenshotDataAsync();
Assert.True(ScreenshotHelper.PixelMatch("screenshot-sanity.png", screenshot));
}
}
public async Task ShouldRenderWhiteBackgroundOnJpegFile()
{
await using (var page = await Context.NewPageAsync())
{
await page.SetViewportAsync(new ViewPortOptions { Width = 100, Height = 100 });
await page.GoToAsync(TestConstants.EmptyPage);
var screenshot = await page.ScreenshotDataAsync(new ScreenshotOptions
{
OmitBackground = true,
Type = ScreenshotType.Jpeg
});
Assert.True(ScreenshotHelper.PixelMatch("white.jpg", screenshot));
}
}
public async Task ShouldTakeFullPageScreenshots()
{
await Page.SetViewportAsync(new Viewport
{
Width = 500,
Height = 500
});
await Page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
byte[] screenshot = await Page.ScreenshotAsync(new ScreenshotOptions
{
FullPage = true
});
Assert.True(ScreenshotHelper.PixelMatch("screenshot-grid-fullpage.png", screenshot));
}
public async Task ShouldAllowTransparency()
{
await Page.SetViewportAsync(new Viewport
{
Width = 50,
Height = 150
});
await Page.GoToAsync(TestConstants.EmptyPage);
byte[] screenshot = await Page.ScreenshotAsync(new ScreenshotOptions
{
OmitBackground = true
});
Assert.True(ScreenshotHelper.PixelMatch("transparent.png", screenshot));
}
public async Task ShouldWorkWithOddClipSizeOnRetinaDisplays()
{
await using (var page = await Context.NewPageAsync())
{
var screenshot = await page.ScreenshotDataAsync(new ScreenshotOptions
{
Clip = new Clip
{
X = 0,
Y = 0,
Width = 11,
Height = 11
}
});
Assert.True(ScreenshotHelper.PixelMatch("screenshot-clip-odd-size.png", screenshot));
}
}
