/// <summary>
/// Save the all the data: "Email listings, printed pages, open tabs and all the sticky notes"
/// </summary>
/// <param name="playerData"></param>
/// <param name="bm"></param>
/// <param name="listings"></param>
/// <param name="missionManager"></param>
public static void SavePlayer(PlayerData playerData, BrowserManager bm, List <EmailListing> listings,
MissionManager missionManager)
{
BinaryFormatter formatter = new BinaryFormatter();
string path = Application.persistentDataPath + "player.save";
FileStream stream = new FileStream(path, FileMode.Create);
List <PrintStatusSave> printList = new List <PrintStatusSave>();
foreach (var currentState in bm.GetPrintStatus())
{
printList.Add(new PrintStatusSave(currentState.Key, currentState.Value));
}
PlayerSaveData playerSaveData = new PlayerSaveData();
playerSaveData.SetStickyNotes(GameObject.FindObjectOfType <HelpStickyManager>().objectListByID);
playerSaveData.SetPrintedCaseIDs(GameObject.FindObjectOfType <FilingCabinet>().caseFolders);
playerSaveData.SetLocation(playerData);
playerSaveData.SetTabs(bm.tabList);
playerSaveData.SetEmails(listings);
playerSaveData.SetCreatedCases(missionManager.GetCreated());
playerSaveData.SetPlayerLevel(missionManager.playerLevel);
playerSaveData.SetPrintStatus(printList);
formatter.Serialize(stream, playerSaveData);
stream.Close();
}
public void TestSendRequestUsingBrowserWebRequestHandlingHttpException()
{
ObjectResolver.RegisterType <IProcessManager, ProcessManager>();
var browserInstances = new Dictionary <BrowserType, int> {
{ BrowserType.Chrome, 1 }
};
using (var browserManager = new BrowserManager(browserInstances))
{
ObjectResolver.RegisterInstance <IBrowserManager>(browserManager);
var context = new Context();
WebRequestContext webRequestContext =
context.SendRequest(new ContextSendRequestParameter
{
Url = nonExistingTargetUrl,
BrowserType = BrowserType.Chrome
});
// check that we got the proper response back
webRequestContext.ResponseHolder.ShouldNotBeNull();
webRequestContext.ResponseHolder.ResponseContent.ShouldNotBeEmpty();
webRequestContext.ResponseHolder.RequestUserAgent.ShouldEqual(BrowserType.Chrome.ToString());
webRequestContext.ResponseHolder.StatusCode.ShouldEqual(HttpStatusCode.OK);
webRequestContext.ResponseHolder.BrowserPageTitle.IndexOfOi("404").ShouldBeGreaterThan(-1);
}
}
/// <summary>
/// Browser waits for XML document implementation.
/// </summary>
/// <param name="browserType">
/// Browser type.
/// </param>
private void BrowserWaitsForXmlDocumentImplementation(BrowserType browserType)
{
ObjectResolver.RegisterType <IProcessManager, ProcessManager>();
var browserInstances = new Dictionary <BrowserType, int> {
{ browserType, 1 }
};
const int MaxWait = 10;
using (var manager = new BrowserManager(browserInstances))
{
var browser = manager.AcquireBrowser(browserType);
var stopWatch = new Stopwatch();
stopWatch.Start();
// make the request, wait for up to 10 seconds.
browser.NavigateTo($"{Constants.VulnerabilitiesAddress}XmlResponse.aspx");
browser.WaitForPageLoad(MaxWait);
stopWatch.Stop();
// FF and Chrome will return the XML content, IE returns the XML with styles applied.
browser.PageSource.ShouldContain("content");
stopWatch.ElapsedMilliseconds.ShouldBeLessThan((MaxWait + 1) * 1000);
}
}
public void TestOpenRedirectClientSideHttp()
{
// Setup
ObjectResolver.RegisterType <IProcessManager, ProcessManager>();
var browserInstances = new Dictionary <BrowserType, int> {
{ BrowserType.Chrome, 1 }
};
using (var browserManager = new BrowserManager(browserInstances))
{
ObjectResolver.RegisterInstance <IBrowserManager>(browserManager);
var target =
Target.Create(
$"{Constants.VulnerabilitiesAddress}PluginsTestPages/XOpenRedirectToBadPlacesHTTP.aspx?q=junk");
// Execute
var vulns = ExecutePluginTestRequest(target);
// Validate
vulns.Count.ShouldEqual(2);
vulns.ElementAt(0).Title.ShouldEqual("Open Redirect");
vulns.ElementAt(0).Evidence.ShouldEqual("www.example.com");
vulns.ElementAt(1).Title.ShouldEqual("Open Redirect");
vulns.ElementAt(1).Evidence.ShouldEqual("www.example.com");
}
}
public void SpecifyingBrowserCompatibilityModeForIe()
{
// Arrange
const string webSiteName = "TestEasyWebSite";
// create Virtual Application and deploy files
WebServer server = WebServer.Create();
WebApplicationInfo appInfo = server.CreateWebApplication(webSiteName);
server.DeployWebApplication(appInfo.Name, new List <DeploymentItem>
{
new DeploymentItem {
Type = DeploymentItemType.Directory, Path = webSiteName
}
});
server.SetCustomHeaders(
Path.Combine(appInfo.PhysicalPath, "web.config"),
new Dictionary <string, string> {
{ "X-UA-Compatible", " IE=8" }
});
// create browser object using config settings
using (var browserManager = new BrowserManager())
{
var browser = browserManager.CreateBrowser(BrowserType.Ie, false);
// Act
browser.Navigate().GoToUrl(appInfo.VirtualPath + "/default.html");
// Assert
Assert.AreEqual("[This is my label]", browser.FindElement(By.Id("myLabel")).Text);
}
}
static void Main(string[] args)
{
Console.WriteLine(Directory.GetCurrentDirectory());
var driver = BrowserManager.CreateBrowser();
}
public async Task CanSendAndReceiveBytes()
{
if (BrowserManager.IsAvailable(BrowserKind.Chromium))
{
await using var browser = await BrowserManager.GetBrowserInstance(BrowserKind.Chromium, BrowserContextInfo);
var page = await browser.NewPageAsync();
await page.GoToAsync(_devHostServerFixture.RootUri + "/subdir/api/data");
/* var socket = BrowserContextInfo.Pages[page].WebSockets.SingleOrDefault() ??
* (await page.WaitForEventAsync(PageEvent.WebSocket)).WebSocket;
*
* // Receive render batch
* await socket.WaitForEventAsync(WebSocketEvent.FrameReceived);
* await socket.WaitForEventAsync(WebSocketEvent.FrameSent);
*
* // JS interop call to intercept navigation
* await socket.WaitForEventAsync(WebSocketEvent.FrameReceived);
* await socket.WaitForEventAsync(WebSocketEvent.FrameSent);
*
* await page.WaitForSelectorAsync("ul");*/
await page.CloseAsync();
}
//IssueRequest("/subdir/api/data");
//Assert.Equal("OK", _responseStatus.Text);
//Assert.Equal("OK", _responseStatusText.Text);
//Assert.Equal("", _testOutcome.Text);
}
/// <summary>
/// Browser handles missing page implementation.
/// </summary>
/// <param name="browserType">
/// Browser type.
/// </param>
private void BrowserHandlesMissingPageImplementation(BrowserType browserType)
{
ObjectResolver.RegisterType <IProcessManager, ProcessManager>();
var browserInstances = new Dictionary <BrowserType, int> {
{ browserType, 1 }
};
const int MaxWait = 10;
using (var manager = new BrowserManager(browserInstances))
{
var browser = manager.AcquireBrowser(browserType);
var stopWatch = new Stopwatch();
stopWatch.Start();
// make the request, wait for up to 10 seconds.
browser.NavigateTo(
"http://ieonline.microsoft.com/pinnedconfig?action=1&CurrentPage=1&itemId=1&nextQuestionId=1&nextQuestionUserId=1");
browser.WaitForPageLoad(MaxWait);
stopWatch.Stop();
// expect a browser specific 404 message
browser.PageSource.ShouldContain("Page not found");
stopWatch.ElapsedMilliseconds.ShouldBeLessThan((MaxWait * 1000) + 1500);
}
}
/// <summary>
/// Browser DOM access test implementation.
/// </summary>
/// <param name="browserType">The type of the browser being tested.</param>
private void BrowserFindElementImplementation(BrowserType browserType)
{
ObjectResolver.RegisterType <IProcessManager, ProcessManager>();
var browserInstances = new Dictionary <BrowserType, int> {
{ browserType, 1 }
};
using (var manager = new BrowserManager(browserInstances))
{
var browser = manager.AcquireBrowser(browserType);
browser.NavigateTo($"{Constants.VulnerabilitiesAddress}SimplePageWithForm.html");
browser.WaitForPageLoad(10);
var element = browser.FindWebElement(By.Id("textInputId"));
element.ShouldNotBeNull();
element.TagName.Equals("input").ShouldBeTrue();
element.SendKeys("Hello");
System.Threading.Thread.Sleep(1000);
element.SendKeys(" world");
element.GetAttribute("value").Equals("Hello world").ShouldBeTrue();
element = browser.FindWebElement(By.Name("textInputName"));
element.GetAttribute("value").Equals("Hello world").ShouldBeTrue();
}
}
public async Task BlazorWasmHostedTemplate_Works(BrowserKind browserKind)
{
var project = await ProjectFactory.GetOrCreateProject("blazorhosted" + browserKind, Output);
var serverProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server");
await BuildAndRunTest(project.ProjectName, serverProject, browserKind);
using var aspNetProcess = serverProject.StartPublishedProjectAsync();
Assert.False(
aspNetProcess.Process.HasExited,
ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", serverProject, aspNetProcess.Process));
await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html");
await AssertCompressionFormat(aspNetProcess, "br");
if (BrowserManager.IsAvailable(browserKind))
{
await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo);
var page = await browser.NewPageAsync();
await aspNetProcess.VisitInBrowserAsync(page);
await TestBasicNavigation(project.ProjectName, page);
}
else
{
EnsureBrowserAvailable(browserKind);
}
}
public async Task BlazorWasmStandaloneTemplate_IndividualAuth_Works(BrowserKind browserKind)
{
var project = await CreateBuildPublishAsync("blazorstandaloneindividual" + browserKind, args : new[] {
"-au",
"Individual",
"--authority",
"https://login.microsoftonline.com/common/v2.0/.well-known/openid-configuration",
"--client-id",
"sample-client-id"
});
// We don't want to test the auth flow as we don't have the required settings to talk to a third-party IdP
// but we want to make sure that we are able to run the app without errors.
// That will at least test that we are able to initialize and retrieve the configuration from the IdP
// for that, we use the common microsoft tenant.
await BuildAndRunTest(project.ProjectName, project, browserKind, usesAuth : false);
var(serveProcess, listeningUri) = RunPublishedStandaloneBlazorProject(project);
using (serveProcess)
{
Output.WriteLine($"Opening browser at {listeningUri}...");
await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo);
var page = await NavigateToPage(browser, listeningUri);
await TestBasicNavigation(project.ProjectName, page);
await page.CloseAsync();
}
}
public async Task BlazorWasmStandaloneTemplate_Works(BrowserKind browserKind)
{
var project = await CreateBuildPublishAsync("blazorstandalone" + browserKind);
// The service worker assets manifest isn't generated for non-PWA projects
var publishDir = Path.Combine(project.TemplatePublishDir, "wwwroot");
Assert.False(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "Non-PWA templates should not produce service-worker-assets.js");
await BuildAndRunTest(project.ProjectName, project, browserKind);
var(serveProcess, listeningUri) = RunPublishedStandaloneBlazorProject(project);
using (serveProcess)
{
Output.WriteLine($"Opening browser at {listeningUri}...");
if (BrowserManager.IsAvailable(browserKind))
{
await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo);
var page = await NavigateToPage(browser, listeningUri);
await TestBasicNavigation(project.ProjectName, page);
}
else
{
EnsureBrowserAvailable(browserKind);
}
}
}
protected async Task BuildAndRunTest(string appName, Project project, BrowserKind browserKind, bool usesAuth = false)
{
using var aspNetProcess = project.StartBuiltProjectAsync();
Assert.False(
aspNetProcess.Process.HasExited,
ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", project, aspNetProcess.Process));
await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html");
if (BrowserManager.IsAvailable(browserKind))
{
await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo);
var page = await browser.NewPageAsync();
await aspNetProcess.VisitInBrowserAsync(page);
await TestBasicNavigation(appName, page, usesAuth);
await page.CloseAsync();
}
else
{
EnsureBrowserAvailable(browserKind);
}
}
protected override async Task InitializeCoreAsync(TestContext context)
{
await base.InitializeCoreAsync(context);
// Default to Chrome
var browserKind = BrowserKind.Chromium;
// Check if a different browser is requested
var browserKindArgument = context.MethodArguments.FirstOrDefault();
if (browserKindArgument != null &&
browserKindArgument.GetType() == typeof(BrowserKind))
{
browserKind = (BrowserKind)browserKindArgument;
}
if (ShouldSkip(browserKind))
{
var avail = String.Join(",", BrowserManager.GetAvailableBrowsers());
var error = $"Skipping browser: {browserKind}: Available: {avail}";
Output.WriteLine(error);
return;
}
TestBrowser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo);
TestPage = await TestBrowser.NewPageAsync();
var response = await TestPage.GoToAsync(MountUri);
Assert.True(response.Ok, $"Got: {response.StatusText} from: {MountUri}");
Output.WriteLine($"Loaded MountUri: {MountUri}");
await MountTestComponentAsync(TestPage);
}
public async Task BlazorWasmStandalonePwaTemplate_Works(BrowserKind browserKind)
{
var project = await CreateBuildPublishAsync("blazorstandalonepwa", args: new[] { "--pwa" });
await BuildAndRunTest(project.ProjectName, project, browserKind);
ValidatePublishedServiceWorker(project);
if (BrowserManager.IsAvailable(browserKind))
{
var (serveProcess, listeningUri) = RunPublishedStandaloneBlazorProject(project);
await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo);
Output.WriteLine($"Opening browser at {listeningUri}...");
var page = await NavigateToPage(browser, listeningUri);
using (serveProcess)
{
await TestBasicNavigation(project.ProjectName, page);
}
// The PWA template supports offline use. By now, the browser should have cached everything it needs,
// so we can continue working even without the server.
await page.GoToAsync("about:blank");
await browser.SetOfflineAsync(true);
await page.GoToAsync(listeningUri);
await TestBasicNavigation(project.ProjectName, page, skipFetchData: true);
await page.CloseAsync();
}
else
{
EnsureBrowserAvailable(browserKind);
}
}
protected void LoadCategoryColors()
{
try
{
var json = BrowserManager.GetViewData(_views, "Binary Classification");
_binaryClassificationViewModel = BinaryClassificationViewModel.FromJSON(json);
if (_binaryClassificationViewModel != null)
{
if (_binaryClassificationViewModel.positiveColor == null)
{
_binaryClassificationViewModel.positiveColor = new SolidBrush(Color.FromArgb(150, 0, 255, 0));
}
if (_binaryClassificationViewModel.negativeColor == null)
{
_binaryClassificationViewModel.negativeColor = new SolidBrush(Color.FromArgb(150, 255, 0, 0));
}
if (_binaryClassificationViewModel.excludedColor == null)
{
_binaryClassificationViewModel.excludedColor = new SolidBrush(Color.FromArgb(150, 255, 255, 0));
}
///////////////////////////////////////////////////////////////////////////////
if (_binaryClassificationViewModel.columns == null)
{
_binaryClassificationViewModel.columns = new List <BinaryClassificationColumnInfo>();
}
}
}
catch
{
}
}
public List <Browser> GetBrowsersFromCache()
{
BrowserManager browserManager = new BrowserManager();
var result = browserManager.List();
return(result);
}
public void TestSendRequestUsingBrowserWebRequest()
{
ObjectResolver.RegisterType <IProcessManager, ProcessManager>();
var browserInstances = new Dictionary <BrowserType, int> {
{ BrowserType.Chrome, 1 }
};
using (var browserManager = new BrowserManager(browserInstances))
{
ObjectResolver.RegisterInstance <IBrowserManager>(browserManager);
var context = new Context();
WebRequestContext webRequestContext =
context.SendRequest(new ContextSendRequestParameter
{
Url = targetUrl,
BrowserType = BrowserType.Chrome
});
// check that we got the proper response back
webRequestContext.ResponseHolder.ShouldNotBeNull();
webRequestContext.ResponseHolder.ResponseContent.ShouldNotBeNullOrEmpty();
webRequestContext.ResponseHolder.RequestUserAgent.ShouldContain(BrowserType.Chrome.ToString());
}
}
public void DeployNavigateAndFindDomElementTest()
{
// Arrange
const string webSiteName = "TestEasyWebSite";
var server = WebServer.Create();
var appInfo = server.CreateWebApplication(webSiteName);
server.DeployWebApplication(appInfo.Name, new List <DeploymentItem>
{
new DeploymentItem {
Type = DeploymentItemType.Directory, Path = webSiteName
}
});
using (var browserManager = new BrowserManager())
{
var browser = browserManager.CreateBrowser();
// Act
browser.Navigate().GoToUrl(appInfo.VirtualPath + "/default.html");
// Assert
Assert.AreEqual("[This is my label]", browser.FindElement(By.Id("myLabel")).Text);
}
}
protected override async Task InitializeCoreAsync(TestContext context)
{
BrowserManager = await BrowserManager.CreateAsync(_config, LoggerFactory);
BrowserContextInfo = new ContextInformation(LoggerFactory);
_output = new BrowserTestOutputLogger(Logger);
}
private async Task BlazorWasmHostedTemplate_IndividualAuth_Works(BrowserKind browserKind, bool useLocalDb)
{
var project = await ProjectFactory.GetOrCreateProject("blazorhostedindividual" + browserKind + (useLocalDb ? "uld" : ""), Output);
var serverProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server");
await BuildAndRunTest(project.ProjectName, serverProject, browserKind, usesAuth : true);
UpdatePublishedSettings(serverProject);
if (BrowserManager.IsAvailable(browserKind))
{
using var aspNetProcess = serverProject.StartPublishedProjectAsync();
Assert.False(
aspNetProcess.Process.HasExited,
ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", serverProject, aspNetProcess.Process));
await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html");
await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo);
var page = await browser.NewPageAsync();
await aspNetProcess.VisitInBrowserAsync(page);
await TestBasicNavigation(project.ProjectName, page, usesAuth : true);
await page.CloseAsync();
}
else
{
EnsureBrowserAvailable(browserKind);
}
}
public bool IsDisplayRequiredFieldsMessage()
{
IWebDriver driver = BrowserManager.GetInstance().WrappedDriver;
IList <IWebElement> elements = driver.FindElements(requiredFieldsMessage);
return(elements.Count > 0);
}
public static void PostConditions()
{
if (!ExecutedAfterFeature)
{
BrowserManager.FinalizeBrowser();
ExecutedAfterFeature = true;
}
}
protected void SaveSettings()
{
_viewData.ExportNotesOptions = GetOptions();
var json = JsonConvert.SerializeObject(_viewData);
BrowserManager.SetViewData(_views, "Default", json);
}
/// <summary>
/// Save the all the data: "Email listings, printed pages, open tabs and all the sticky notes"
/// </summary>
public void SavePlayer()
{
BrowserManager bm = FindObjectOfType <BrowserManager>();
SaveSystem.SavePlayer(this, bm, FindObjectOfType <EmailInbox>().GetEmails(),
FindObjectOfType <MissionManager>());
Debug.Log("You saved!");
}
static GlobalTestingContext()
{
ConnectionManager = new ConnectionManager();
Metadata = new MetadataCache();
ButtonTexts = new ButtonTexts();
BrowserManager = new BrowserManager(ButtonTexts);
ErrorCodes = new ErrorCodes();
}
protected void LoadSettings()
{
_isSettingsLoading = true;
try
{
_viewData = DefaultViewData.Load(BrowserManager.GetViewData(_views, "Default"));
var settings = _viewData.ExportNotesOptions;
if (settings.Mode == ExportMode.Excel)
{
rdbExcelExport.Checked = true;
}
else
{
rdbXmlExport.Checked = true;
}
txtNumberOfLines.Value = settings.ExcelNumberOfLines;
txtOutputFolder.Text = settings.OutputFolder;
if (settings.ExportCriteria == ExportCriteria.Positive)
{
rdbExportPositive.Checked = true;
}
else if (settings.ExportCriteria == ExportCriteria.PositiveNegative)
{
rdbExportPositiveOrNegative.Checked = true;
}
else
{
rdbExportAll.Checked = true;
}
chkbExportDocumentsWithCategory.Checked = settings.ExportWithCategory;
if (settings.Categories.Any())
{
SetCategoriesChecked(categoryID => settings.Categories.Contains(categoryID));
}
else
{
SetCategoriesChecked(true);
}
chkbHighlightMatches.Checked = settings.ColorMatches;
chkbIncludePrefixSuffix.Checked = settings.ColorMatches;
if (String.IsNullOrEmpty(txtOutputFolder.Text))
{
txtOutputFolder.Text = Path.Combine(Directory.GetCurrentDirectory(), "Data");
}
}
finally
{
_isSettingsLoading = false;
}
}
public void SendKeys(string text)
{
if (text == null)
{
throw new ArgumentNullException("Invalid Text: Text cannot be null.");
}
WaitForElementExists(by);
BrowserManager.GetInstance().SendKeys(by, text);
}
protected void EnsureBrowserAvailable(BrowserKind browserKind)
{
Assert.False(
TryValidateBrowserRequired(
browserKind,
isRequired: !BrowserManager.IsExplicitlyDisabled(browserKind),
out var errorMessage),
errorMessage);
}
public async Task InitializeAsync()
{
var sink = new TestSink();
sink.MessageLogged += LogBrowserManagerMessage;
var factory = new TestLoggerFactory(sink, enabled: true);
BrowserManager = await BrowserManager.CreateAsync(_config, factory);
}
public BackupBrowser()
{
InitializeComponent();
_pluginManager = new PluginManager();
_pluginManager.Added += new EventHandler<PluginArgs>(_pluginManager_Added);
_pluginManager.Removed += new EventHandler<PluginArgs>(_pluginManager_Removed);
_browserManger = new BrowserManager(_pluginManager);
_menuManager = new MenuManager();
_menuManager.Added += new EventHandler<MenuEvent>(_menuManager_Added);
_menuManager.Removed += new EventHandler<MenuEvent>(_menuManager_Removed);
_model = new BrowserModel(this);
//init and load all plugins that is not blacklisted
foreach (IPlugin p in _pluginManager)
{
Register(p);
}
}
