/// <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); } }