Skip to main content
100%

Gist 70aa9843db736bfad529

✓ Published0🌍 Public
ZZeukkari
Last edited Jul 23, 2015
Created on Jul 23, 2015

This example demonstrates automated UI testing for a web application’s navigation and search features. The code uses the WebDriver API via the `wd` library with Mocha and async.js to simulate user interactions. It verifies that the top-level category “Terveys” appears in the service tree, that the typeahead suggestions show “Kallion kirjasto,” and that a full search returns that same result. The tests rely on XPath and CSS selectors to locate elements and assert their displayed text.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 159860

This example shows a browser-based test suite for a web application, rendering and validating the behavior of game interfaces for character management, chat, combat, inventory, and store features. The page runs JavaScript test specifications using JSpec, a testing framework, and includes jQuery and jQuery UI plugins for DOM manipulation and event handling. It also embeds HTML templates for dynamically displaying equipment, inventory items, and buffs. The code relies on custom application scripts, such as `application.js` and `character.js`, and uses `JSpec.include` to execute multiple test files sequentially, reporting results in the `#jspec` container. The data comes from the application’s live DOM elements and simulated XHR requests.

XXXX
66% match
Loading thumbnail…

beautify - selenium webdriverjs test

This example demonstrates how to automate a Selenium WebDriver test in JavaScript to verify the process of copying a default theme in the beautify.io web application. The test uses the `selenium-webdriver` and `selenium-webdriver/testing` APIs to drive a Chrome browser, logging in, navigating to the default themes page, selecting a theme, and triggering a copy action via either a phone mockup button or a submenu click. It interacts with modal dialogs using XPath selectors and asserts the resulting theme name via `getAttribute('value')`. No external data visualization is involved; the focus is on functional UI testing.

CColinEberhardt
66% match
Loading thumbnail…

Gist 8bdccc4175e97c6859ad86bca38c9a7d

This example automates interactions with William Hill’s betting site using Selenium WebDriver, specifically targeting two promotional games: “Free or Four” and “Scratch of the Day.” The script logs in via environment variables for credentials, then navigates to each game’s URL, clicks through modal popups or iframes, and triggers the game’s main action—such as clicking a card or a summary button. The code relies on explicit XPath selectors and waits, while using Chrome in headless mode. It demonstrates UI automation for repeated tasks, though it does not show any data visualization or rendering API.

CConorAspell
63% match
Loading thumbnail…

Gist e856f50454ea971a6d4af31d5c4a44ef

This example demonstrates automated login and page interaction for a sports betting website, showing how Selenium WebDriver navigates to the William Hill URL, fills in email and password fields from environment variables, and clicks the "Log In" button. The code uses Chrome options for headless, maximized, and sandbox-disabled browsing, with explicit waits via `time.sleep`. It relies on XPath selectors to locate the login form elements and button, printing confirmation after successful login. The visualization highlights the automated workflow of credential injection and form submission, though it does not show data extraction or post-login content.

CConorAspell
58% match
Loading thumbnail…

Gist 58c79c81e9a950a0cdafc7d2d0275742

This example shows a dynamic, browser-automated web-scraping workflow that captures rendered page content. It uses Selenium’s `webdriver` to launch a Chrome browser, wait for elements via `WebDriverWait` and `expected_conditions`, and then extracts page HTML with BeautifulSoup. The script programmatically sends keyboard inputs via `Keys`, and also employs the `requests` library for direct HTTP calls. It parses the returned data with `json`, timestamps actions with `datetime`, and structures results into a pandas DataFrame. The process includes randomized delays (`random` and `time`) to mimic human browsing behavior, though no explicit visualization or rendering library is used beyond the raw captured markup.

AArizonaTay
57% match
Loading thumbnail…

Gist 7232670

This example demonstrates how a single-page application skeleton is transformed from a static document into an interactive, AJAX-driven experience. The visualization shows a list of user-submitted code entries, with each entry dynamically loaded and rendered without a full page refresh. The implementation uses jQuery’s `$.ajax` method to fetch the `lucky_ajax.md` file and other resources, then updates the DOM with the retrieved content. The code also relies on JavaScript’s `Promise` API for handling asynchronous responses, and highlights the use of `XMLHttpRequest` for network communication. The data source is the downloaded application skeleton, whose structure is revealed through the fetched files. The example focuses on the interaction between client-side scripting and server responses.

EElaineYu
57% match
Loading thumbnail…

Testa

This example demonstrates a simple interactive event-handling pattern for HTML links. Two links, each bound to a separate instance of a JavaScript `Obj` constructor, respond to clicks by logging a greeting to the console. The code relies on native DOM APIs such as `document.getElementById` and the `onclick` property, while closures capture each instance’s current `word` property. The first link logs “Hola testa” after the property is reassigned, while the second logs “Hello testa,” illustrating how per-instance state persists. No external libraries or data sources are used; the behavior is purely client-side.

DDylanFM
56% match
Loading thumbnail…

Browser test run for ToDoMVC

This visualization displays the results of a browser test run for the ToDoMVC project, tracking 1,624 individual test cases across multiple JavaScript frameworks. Each test is rendered as a colored cell, with green indicating a pass, orange marking a known issue, and red denoting a failure, arranged sequentially to show the overall progression and clustering of outcomes. The data comes from a text log file, which is parsed and mapped to a grid layout. The visualization uses React for rendering the interactive interface, allowing users to hover over or click on cells to see detailed test descriptions, while the framework name appears as a categorical label along the axis.

CColinEberhardt
56% match