Mobile DevTest Dictionary

Mobile DevTest Dictionary:
Terminology from A to Z

Introduction
As a market-leader with experience spanning many industries and
levels of mobile testing maturity, Perfecto has unique insights into
tools and trends. We’ve used this inside information as the source for
our “Mobile DevTest Dictionary:Terminology from A to Z,” a go-to
guide for developers, testers and practitioners to stay informed on
the resources they need to excel at their jobs.
The DevTest Dictionary is divided into six categories with terms
covering automation and CI tools, testing styles, agile best practices,
and more. Happy reading!
For more information, read the full Mobile DevTest Dictionary

Appium—An open-source test automation framework for use with native
and hybrid mobile apps. It tests iOS and Android apps using the WebDriver
JSON wire protocol. All implementations of WebDriver that communicate
with the browser, or RemoteWebDriver server, use a common wire protocol.
This wire protocol defines a RESTful web service using JSON over HTTP.
Perfecto supports Appium test execution and extends Appium capabilities
capabilities inside Perfecto’s Continuous Quality Lab.
Calabash—This software automation tool supported by Xamarin is based on
the BDD concept and Cucumber tool. Calabash was extended by LessPainful
(acquired by Xamarin) to mobile app testing based on the Ruby language.
Calabash tests can be developed and executed on local devices or remotely
using the Xamarin test cloud.
Perfecto supports Calabash test execution.

CI Tools—TeamCity, Bamboo, Gradle, Jenkins, TFS, BuildBot
Jenkins is supported by Perfecto. The plugin is in the public Maven repository and in the Jenkins
in the Jenkins official wiki page. Microsoft CI is also supported.
Development Languages—C#, Java, Objective-C, Swift, Ruby, Python
– most of these are supported by Selenium.
As part of Perfecto’s Remote WebDriver implementation, Perfecto offers full support for the
for the Selenium languages within Eclipse and Visual Studio IDEs.

Espresso—The Espresso testing framework, available in the Android Testing
Support Library, provides APIs for writing UI tests to simulate user
interactions within a single app. Espresso tests can run on devices running
Android 2.2 (API level 8) and higher. A key benefit of using Espresso is that
it provides automatic synchronization of test actions with the UI of the app
you’re testing.
Perfecto supports the development and execution of Espresso Android UI tests on real devices in its
real devices in its CQ Lab.
Maven—Apache Maven is a software project management and
comprehension tool. Based on the concept of a project object model
(POM), Maven can manage a project’s build, reporting and
documentation from a central piece of information.

Remote WebDriver—Remote WebDriver is a tool that helps execute
Selenium and Appium tests. It’s composed of two pieces: a client and a
server. The client is your WebDriver test and the server is simply a
servlet, which can be hosted in any modern JEE app server. The server
will always run on the machine with the browser you want to test.
Perfecto supports Remote WebDriver to develop Selenium/Appium test code in any
in any supported language.
Selenium—Selenium is a suite of tools that automates the testing of
web browsers and mobile apps across various platforms. It has an add-
on for the Firefox browser for web automation recording, and also
mobile specific solutions such as MobileCloud WebDriver and
The Selenium technology allows you to identify objects from
applications using XPATH, CSS, Class Name and visual.

WebDriver—Selenium WebDriver is the successor to Selenium RC (remote
control). WebDriver accepts commands (sent in Selenese, or via a Client API)
and sends them to a browser. This is implemented through a browser-specific
driver (Android, Chrome, iOS), which sends commands to a browser and
retrieves results. In mobile, there are specific WebDrivers for Android and iOS.
For desktop, there are drivers for the relevant browsers (Chrome, Internet
Explorer, FireFox, etc).
MobileCloud WebDriver is in phase out mode; we recommend customers use
customers use the Remote WebDriver solution
Selenium Grid—Selenium Grid supports distributed test execution by allowing
customers to run multiple tests at the same time on different machines against
against different browsers and devices.

App Instrumentation—The method of bundling a source code library within
an application, or changing its code to get native object support.
This test automation supporting technique allows dev and testers access to the app’s native object
native object properties. It’s most commonly used in iOS platform test automation. Perfecto provides
Perfecto provides an app instrumentation solution to get fully native and DOM object identification
object identification for hybrid apps.
Hybrid Application—Hybrid apps run inside a native container, and use the
device’s browser engine (but not the browser) to render the HTML and
process the JavaScript locally.

Web Application—A web app is an app written in HTML/JavaScript that
runs within the platform browser (Chrome, Safari, Android Native Browser)
and requires constant network connectivity to access the server and retrieve
data. On the other hand, native apps run locally on the device platform and
can be launched independently from the browser.
Responsive Web App—Responsive app design works on the principle that a
single fluid website can look good on any device. Responsive websites use
media queries, flexible grids, and responsive images to create a consistent
user experience that adapts and changes across digital platforms such as
mobile, web and IoT.
Perfecto enables customers to test responsive web design through its Selenium Remote WebDriver
Remote WebDriver solution. Customers can build a Selenium Grid and execute Selenium tests in
Selenium tests in parallel on desktop browsers and mobile devices.

Adaptive Web App—Like responsive web design, adaptive design
attempts to optimize the website experience across platforms. But
instead of one flexible design, adaptive design detects the device, and
then provides the appropriate feature and layout based on a
predefined set of viewport sizes and other characteristics.

DOM Objects—The list of objects for a mobile web/hybrid application on
which the test automation developer will perform actions (press the buttons,
etc.).
The DOM is represented as a tree of objects where each object is related to the others, making the path from
making the path from one to the other reasonable. Getting DOM objects analysis from the native browser
native browser (Safari) is not always easy. Perfecto is among only a few vendors providing such support for
such support for both web and hybrid apps.
Native Objects—These are mobile OS-specific objects that are identified by
the unique properties that the app developer assigned to them. For example,
XPATH retrieves and provides the native objects properties from a
mobile/hybrid app.
Perfecto supports OS level native objects for both iOS and Android. Such objects can be identified through
identified through XPATH, CSS or other methods.

System Level Control—The ability to interact with the mobile operating system outside
of the application under test (change device settings, press the Home button, etc).
This is essential for various use cases, better test coverage and continuous integration.
Visual Objects—Usually known as OCR (Optical Character Recognition) engines. OCR
essentially uses a smart software engine that converts scanned images of handwritten,
handwritten, typewritten or printed text into machine-encoded text.
Perfecto supports visual object analysis as part of its test automation solution.
XPATH—XML Path Language is a query language for selecting nodes (i.e., locating
data or objects) from an XML document.
As part of its Selenium support, Perfecto supports XPATH object identification in native, web and hybrid
web and hybrid apps.

Advanced Functional Testing—The practice of adding simulated real
world conditions and out-of-application context events to functional
test flows to ensure that the application functions in real world
conditions.
Perfecto’s Wind Tunnel enables advanced functional testing on real devices.
Availability—Measurement of the availability of key steps of the
application.

ATDD—Acceptance Test-Driven Development is a technique used to bring customers
into the test design process before coding begins. It’s a collaborative practice where
users, testers and developers define automated acceptance criteria. ATDD helps ensure
ensure that all project members understand precisely what needs to be implemented.
Failed tests provide quick feedback that requirements are not being met. Each feature
must deliver real and measurable business value. If a feature doesn’t trace back to at
least one business goal, then it may not be necessary.
Integration Testing—The phase in software testing in which individual software
modules are combined and tested as a group. It occurs after unit testing and before
validation testing. Integration testing uses modules that have been unit tested, groups
them in larger aggregates, applies tests defined in an integration test plan to those
aggregates, and outputs the integrated system as ready for system testing.

Longevity Testing—The practice of testing the application behavior along
specified user flows over an extended period of time to ensure application
functionality over an extended period of usage. Typical aspects of such
testing is memory leaks and battery drain.
As part of Perfecto’s performance testing and Wind Tunnel capabilities, customers can get
customers can get insights into app CPU, memory and other resource consumption.
consumption.
Network Virtualization—This technology enables pre-production teams to
model and simulate network conditions as accurately as possible. Network
virtualization provides predictability of the user experience in real world
conditions to optimize the application behavior in such conditions.
Perfecto offers NV capabilities as part of the manual, automation and performance products
performance products in its private hosted cloud deployments.

Performance Optimization—The practice of analyzing the
application design and behavior (availability and responsiveness of
KPIs), as well as underlying data (vitals, network analysis) to ensure
availability of key steps in the application.
Performance Testing—The practice of measuring and optimizing
the behavior of an application’s availability and responsiveness to
ensure acceptable user experience under real-world conditions.
Performance testing can come in two flavors: single user
performance test and load/stress test.
Perfecto offers a full mobile performance testing solution that can be leveraged either
leveraged either through integration with Jmeter or HP LoadRunner.

RUM Monitoring—Real User Monitoring – A method of monitoring production apps
by embedding a piece of software (SDK) within the application that collects real-time
analytics data about the app from the device running back to the monitoring server.
Using this method allows more use of analytics-based information. However, it’s very hard to pinpoint
hard to pinpoint and identify the root cause of the issues because the reports are sent from a user’s
from a user’s private device where production teams do not have access.
Service Virtualization—A method to emulate the behavior of specific components in
heterogeneous component-based applications such as API-driven applications, cloud-
based applications and service-oriented architectures. It is used to provide software
development and QA/testing teams access to dependent system components that are
needed to exercise an application under test (AUT), but are unavailable or difficult-to-
access for development and testing purposes.
Perfecto provides mobile SV through its partnership with CA and the CA Lisa for Mobile solution.
solution.

Single User Performance Testing—The practice of adding simulated real world
conditions to functional test flows to measure the application’s responsiveness
responsiveness and availability under real world conditions.
Single User Profiling—A set of tests performed as part of the early
development stages, typically in-sprint, maybe nightly. Unlike load and stress
testing, typically done out of the sprint, the single user profiling increases
software reliability and usability by testing the software against various
simulated real world conditions such as network conditions and app
interruptions. The reporting includes measuring device vitals and memory
leaks as well as responsiveness on different platforms. With this practice,
development teams can reveal performance issues in advance and be more
prepared for the performance testing phase.

Synthetic Monitoring—A monitoring method that’s performed in a “clean
room environment” (lab) to detect, analyze and fix production issues as soon
as they are identified. No app changes are required to execute synthetic
monitoring scripts.
Perfecto supports this method of monitoring through integrations with HP BSM and AlertSite

Smoke Testing—Preliminary testing to reveal simple failures severe enough to
reject a software release. A subset of test cases that cover the most important
functionality of a component or system is selected and run to ascertain if crucial
functions of a program work correctly.
Perfecto customers can develop smoke subset tests for any of their mobile app styles in the
styles in the Perfecto CQ Lab in the cloud.
Sanity Testing—Basic test to quickly evaluate whether a claim or the result of a
calculation can possibly be true. Sanity Testing is a simple check to see if the
produced material is rational (that the material’s creator was thinking rationally).
The point of a sanity test is to rule out certain classes of obviously false results, not
not to catch every possible error. The advantage of a sanity test, over a complete or
or rigorous test, is speed.
Perfecto customers can develop and execute sanity tests for any of their mobile app styles in the
app styles in the Perfecto CQ Lab in the cloud.

Security Testing—Security testing is a process intended to reveal flaws in the
security mechanisms of an information system that protects data and
maintains functionality as intended. Due to the logical limitations of security
security testing, passing security testing is not an indication that flaws don’t
exist or that the system adequately satisfies the security requirements.
Typical security requirements may include specific elements of
confidentiality, integrity, authentication, availability, authorization and
repudiation. Actual security requirements depend on the security
requirements implemented by the system.

Regression Testing—A type of software testing that seeks to uncover new
software bugs, or regressions, in existing functional and non-functional
areas after changes such as enhancements, patches or configuration changes
changes have been made.
The purpose of regression testing is to ensure that changes such as those
mentioned above have not introduced new faults. One of the main reasons
for regression testing is to determine whether a change in one part of the
software affects other parts of the software.
Common methods of regression testing include re-running previously
completed tests and checking whether program behavior has changed and
whether previously fixed faults have reemerged.
Perfecto provides various test automation solutions to run regression tests on real devices and
devices and browsers.

Unit Tests—Unit testing is a software testing method by which individual
units of source code and usage and operating procedures are tested to
determine if they are fit for use.
Perfecto customers can integrate with various IDEs such as Eclipse and Visual Studio to
Studio to develop Junit, TestNG and other unit tests within the Perfecto CQ Lab in the
Lab in the cloud.
User Condition Testing—The mimicking of a user environment using
personas along with their environment and behavior traits such as network
conditions, devices and locations, and apps running in the background.
These conditions are all embedded into a test automation scenario to
increase app quality.
Perfecto offers user condition testing in its CQ Lab through the automation capabilities of
capabilities of its Wind Tunnel ™ service.

Vitals—Metrics indicating the state of the client/hardware/OS, as well as the
environment. Examples include CPU, memory, data throughout and HTTP
errors. Vitals are used to help shed light on the cause of a delayed response
in the application.
Perfecto provides device related vitals such as logs and CPU as well as app-level vitals.
vitals.
Production Insights—Tests performed after an app release on a continuous
basis to provide key insights about response time, app availability,
regressions and other issues.
Can be performed through Perfecto’s synthetic monitoring or test automation solutions.
solutions.

BDD—Behavior-Driven Development (BDD) is a software development
process that allows DevTest teams to collaborate earlier in the SDLC around
functional and user experience testing of an app. The advantage of BDD is it
makes development easier because it describes the business logic and
outcomes of specific use cases. Cucumber and Calabash are desktop/mobile
tools supporting this technique.
Perfecto provides basic support for Calabash, a BDD related tool used by developers and testers
developers and testers through the Ruby development language.

Continuous Integration (CI)—The software engineering practice of merging all
code copies to a shared mainline several times a day. When embarking on a
change, a developer takes a copy of the current code base on which to work. As
other developers submit changed code to the source code repository, this copy
gradually ceases to reflect the repository code.
Not only can the existing code base change, but new code can be added as well as
new libraries and other resources that create potential conflicts. The longer a
branch of code remains checked out, the greater the risk of integration conflicts
and failures when the developer branch is reintegrated into the main line.
Continuous integration involves integrating early and often to avoid the pitfalls of
“integration hell.” The practice aims to reduce rework and thus reduce cost and
time.
Perfecto customers can implement their continuous integration process in the cloud using Jenkins
cloud using Jenkins CI, Microsoft Visual Studio Team Services or TeamCity.

Continuous Delivery (CD)—Is a software engineering approach in which teams
produce software in short cycles, ensuring that the software can be reliably
released at any time. The CD process helps reduce the cost, time and risk of
delivering changes and facilitates more incremental updates to applications in
production.
Continuous Quality—Continuous Quality is a methodology for embedding quality
activities into every step of the SDLC process, from design to build to production
based on supporting processes, tools and lab infrastructure that’s tailored for the
intensity of the process. Successful continuous quality accelerates time to market,
drives faster and more frequent releases and helps reduce escaped defects to
production by managing risk in an automated way as early as possible.
Perfecto enables Continuous Quality through its CQ Lab in the cloud.

Continuous Quality Lab—The Continuous Quality Lab (CQ Lab) is the required
infrastructure and tools needed to conduct tests, measurements and analysis. It
allows teams to be fully integrated into the Agile / DevOps process and replicate
user conditions early in the lifecycle. The CQ Lab supports 24/7 continuous
operation with a production grade SLA, and consistency across the different
phases of the DevTest lifecycle, minimizing the time it takes to resolve issues while
while speeding up time to market.
The CQ Lab is Perfecto’s core offering.
Development Languages—C#, Java, Objective-C, Swift, Ruby, Python. Most of
these are supported by Selenium.
As part of the Perfecto Remote WebDriver implementation, Perfecto offers full support for all the
support for all the Selenium languages.

IDE—Integrated Development Environment, an environment used by software
developers to develop, debug, build and deploy their application. The common
IDEs in the mobile space are Xcode for iOS apps (MAC environment), Android
Studio (Google Tool suite), Eclipse (main IDE for Android), TFS and InteliJ.
Perfecto supports the Eclipse IDE and Microsoft Visual Studio for test code development as well as
development as well as the Perfecto web-based proprietary IDE.
Kanban—Kanban is a method for managing knowledge work with an emphasis
on just-in-time delivery while not overloading team members. With this
the process—from definition of a task to its delivery to the customer—is displayed
for participants to see and for team members to pull work from a queue. Kanban
in the context of software development can mean a visual process management
system that tells developers what to produce, when to produce it and how much to
to produce.

SCM—Source configuration manager is the task of tracking and
controlling changes in the software, part of the larger cross-discipline field
of configuration management. SCM practices include revision control and
the establishment of baselines. If something goes wrong, SCM can
determine what was changed and who changed it. If a configuration is
working well, SCM can determine how to replicate it across many hosts.
Shift Left—A trend where developer and testing teams collaborate as one
to deliver better software faster through CI/Agile and early testing that
utilizes efficient test automation, performance and unit testing.

Software Build—The result of a compilation of software code. In mobile, it can be
an Android app (.APK) or iOS app (.IPA) that can be executed on the target
platform. In other words, a software build is a binary artifact that can be deployed
and executed on the target platform (device, browser).
TDD—Test-Driven Development (TDD) is a software development process that
relies on the repetition of a very short development cycle. First, the developer
writes an initially failing automated test case that defines a desired improvement
or new function; then the developer produces the minimum amount of code to
pass that test; and finally re-factors the new code to acceptable standards.

Waterfall—The waterfall model is a sequential design software development
processes in which progress is seen as flowing steadily downwards (like a
waterfall) through the phases of conception, initiation, analysis, design,
construction, testing, production/implementation and maintenance.

DevOps—A culture or practice that emphasizes the collaboration and
communication of both software developers and other IT professionals to
automate the process of software delivery and infrastructure changes. The
purpose is to establish a culture and environment where building, testing and
releasing software can happen rapidly, frequently and more reliably.

GitHub—GitHub is a web-based Git repository hosting service. It offers all of
the distributed revision control and source code management (SCM)
functionality of Git as well as its own features. Unlike Git, which is strictly a
command-line tool, GitHub provides a web-based graphical interface and
desktop as well as mobile integration. It also provides access control and
several collaboration features such as bug tracking, feature requests, task
management and wikis for every project.
Developers use GitHub to get code samples and learn about community best practices
practices (including Selenium, Appium or other technology-based shared code).
code).
Key Performance Indicators (KPI)—Measurable metrics indicating the
responsiveness and availability of key steps in the user flow, typically
measured in a performance test.

MTTK—Mean Time to Know – This is a measurement of the time it takes a
monitoring/ops/DevOps team to be notified about defects, performance
degradation or outages.
Perfecto offers production monitoring 24x7 to reduce the MTTK. Because monitoring teams get
monitoring teams get immediate real-time alerts as issues are identified, faster MTTK helps
MTTK helps decrease the MTTR (Mean time to resolution).
MTTR—Mean Time to Resolution -- The time it takes from the moment an
outage/production defect is identified until it gets resolved and fixed in
production.
Perfecto offers production monitoring with debugging information, allowing teams to easily
to easily pinpoint the root cause of the issue and resolve it.

Persona—A detailed definition of an app user. Personas are defined by unique
traits such as location, devices, networks, background apps, and more.
Perfecto’s Wind Tunnel enables persona based testing as part of its test automation solution.
solution.
Stack Trace—Programmers commonly use stack tracing during interactive and
postmortem debugging. Users may see a stack trace displayed as part of an error
message, which the user can then report to a programmer.
A stack trace allows tracking the sequence of nested functions called—up to the
point where the stack trace is generated. In a postmortem scenario, this extends to
to the function where the failure occurred (but was not necessarily the cause).
Sibling function calls do not appear in a stack trace.

Stack Overflow—A website that serves as a platform for programmers
to become members and actively participate. Members ask, edit and
rate questions and answers about programming topics in a fashion
similar to a Wiki or Digg. Stack Overflow users can earn reputation
points and “badges.”
For more information, read the full Mobile DevTest Dictionary

Mobile DevTest Dictionary

More Related Content

What's hot

Similar to Mobile DevTest Dictionary

More from Perfecto by Perforce

Recently uploaded

Mobile DevTest Dictionary