General Quiz Overview Kurs C

Each component of a system should have only one reason to change.

A comparison of the cost of something against its benefits.

Making a tool easier to use by disabling unnecessary features.

Test APIs with the highest likelihood of failure and most significant impact first.

Automatically measuring and reporting code coverage during testing.

A system that automates software testing.

The software or system being tested.

Testing components of a system independently before integration.

Retesting existing functionalities after changes to ensure they still work.

Creating variety in input data for automated testing.

Testing how software systems communicate over the web.

Professional responsible for test automation.

Software used to create and run automated tests.

Test automation that uses keywords to represent actions rather than programming language.

Ease of understanding, modifying, and maintaining code.

Separate data from test scripts to make tests more adaptable.

Setup for running tests, including tools and access credentials.

Recording and replaying user interactions to create automated tests.

Details about test cases, results, and any issues.

Part of the TAS that manages the actual running of individual test scripts.

Using models to define how tests should function.

Waiting for a particular event to occur at regular intervals (delay)

Script where each test step follows sequentially.

Adhering to SRP helps create a modular and maintainable TAS by ensuring that each component is focused on a single task.

The tool should meet all your technical requirements and offer a favorable cost-benefit ratio.

Disable unnecessary features to reduce complexity and confusion.

Prioritize testing APIs with the highest likelihood of failure and most significant impact first.

Use a tool that automatically tracks code coverage, exports the data to a spreadsheet, and updates a trend chart for analysis.

Promptly fix failed tests to ensure the test suite remains accurate and reliable.

Use a tool that can automate the creation of test data by calling a web service endpoint.

Assess the impact on the TAS and make any necessary changes to keywords, tests, tools, and scripts.

Use tools that can clearly indicate exceptions and actions based on system events.

Test individual components of the automation (creation, validation, recovery), followed by a focus on database access during regression testing.

To verify compatibility between two different systems, such as microservices.

Install the Test Automation System (TAS) into a central repository so all projects use the same version.

Use keyword-driven scripting. It allows for clear separation of actions with keywords and provides better maintainability.

Perform a pilot test in a isolated environment to assess compatibility and functionality.

Contact the vendor and search online forums for solutions or workarounds.

A common core library is not part of test environment configuration. It's a collection of reusable code.

The System Under Test (SUT) must be available during recording, which limits flexibility and development.

Restart the service, wait for it to come back online, and then continue with the test case.

Remove any redundant tests to reduce the overall time without compromising test coverage.

Use design patterns to structure the code, making it reusable and easier to understand.

Keyword-driven scripting is ideal for CLI, as it provides high independence from the tool and allows reusable keywords for efficiency.

Store data used by multiple tests externally, which makes tests more independent and easier to manage.

Configure the connection to the new app in the Business Logic layer, as it reflects the core functionality of the application.

Implement the flow model pattern to separate web elements (page models) from user actions (flow models), which makes the framework more manageable with GUI changes.

Low code coverage obtained while running regression tests means new features aren't being tested.

Static analyzers help maintain code cleanliness by automatically identifying potential problems and violations.

Increase the granularity of keywords to make tests more adaptable to changes and easier to manage.

Developing test scripts is an implementation task and not part of the design.

Tests are run frequently alongside deployments to ensure the system functions correctly. They act as a quality gate.

Track dynamic measurements of the system during tests, like performance metrics, to identify why a test failed.

Ensure developers are committed to helping deploy the TAS, as they are vital to the success of the integration.

A good test automation strategy considers costs, benefits, and risks across all parts of the system, both old and new.

Synchronize upgrades for development/test environments and the test tool to maintain compatibility.

Adhere to the replacement principle, meaning components should be easily swapped without impacting the whole system.

Organizing and structuring test cases is the primary goal of editing test suites. This keeps them manageable.

Test libraries in the test definition layer support keyword-driven approaches by offering reusable keywords or actions.

The test execution layer interprets test data and test cases into executable scripts.

Test definitions, specifications, and test data should be included in TAS configuration management.

Deciding the implementation technology for test procedures is a later step, after the requirements for the TAA have been determined.

Selection of test interfaces to the SUT is more relevant to the test design and integration layers, not the execution layer .

Use a tool that translates test procedures into automated test scripts. This combines abstraction and automation.

Capture/playback is a technique for recording and replaying interactions with the SUT, directly creating automation scripts.

Linear scripts require creating separate scripts for each test case. This makes maintenance difficult when changes occur.

The major difference is the use of a script library in structured scripting.

Integrate the TAS with the SUT during each development phase to ensure continuous adaptation.

Ensure the necessary infrastructure, such as hardware and software, is ready for the TAS.

The System Under Test (SUT) must be available during the capture phase, limiting flexibility and development.

When a service is unavailable, all dependant scripts fail, wasting time and requiring extensive debugging.

Restart the service, wait for it to come back online, and continue the test case.

Integrate the TAS with the SUT during each development phase to ensure it adapts to changes.

Remove redundant tests without compromising coverage, reducing overall test execution time.

Ensure the necessary infrastructure (hardware and software) is ready before deploying the Test Automation System.

Design TAS components for easy replacement without impacting the entire system. This promotes maintainability and flexibility.

Structured scripting uses a script library to organize and reuse test steps, making it more maintainable than linear scripting.

Runtime information like performance metrics, resource usage, and operational data collected from the System Under Test (SUT) during automated tests.

The process of investigating why a test failed to understand the root cause and identify areas for improvement.

Documenting bugs or issues found during testing, providing details for developers to fix.

A small-scale trial of a new system, like a test run before full implementation.

The steps involved in installing, configuring, and integrating a Test Automation System (TAS) into an existing environment.

Assurance from developers that they will collaborate and support the TAS implementation.

Educational sessions teaching users how to utilize the TAS effectively.

A plan outlining goals, resources, and timelines for the TAS pilot project.

When database changes occur, prioritize testing those database access parts of your code to ensure they work correctly.

Used to verify that two separate systems, like microservices, can communicate and work together properly.

A method of scripting that uses a library of reusable scripts or functions, improving maintainability and reducing redundancy.

A collection of pre-written and reusable scripts or functions that can be easily accessed and integrated into other scripts.

The introduction of a script library that provides reusable scripts or functions, enhancing maintainability and reducing redundancy.

Ensuring that the Test Automation System (TAS) remains in sync with any changes to the system under test (SUT), maintaining its effectiveness.

Ensuring that the TAS is integrated with the SUT throughout the different stages of development, allowing for continuous adaptation and alignment.

The system that automates software testing, comprising various tools, scripts, and frameworks.

A set of automated tests that cover the core functionality of a software application. It's rerun frequently to ensure that existing features still work correctly after code changes.

Measurements that indicate how much of the software's code is executed by automated tests. Higher coverage suggests more comprehensive testing.

Analyzing code coverage metrics over time to ensure that test coverage doesn't decrease and ideally increases as the software evolves.

Automatically generating reports and charts that show changes in code coverage over time, simplifying the process of monitoring test coverage trends.

Designing test automation to require minimal manual effort, reducing errors and wasted time.

A spreadsheet template designed in advance to automatically store and organize test coverage data, making it easy to analyze and share.

A visual representation of code coverage changes over time, presented in a bar chart format, making it easy to identify overall trends.

Sharing test coverage metrics and reports with relevant stakeholders, such as project managers and developers, to keep everyone informed and aligned.

A testing approach where reusable keywords or actions are used to create test scripts. This allows for easier maintenance and readability.

The layer in a test automation system (TAS) that defines the test cases and test data.

The process of converting test data and test cases into a format that can be understood by the system being tested.

Collections of reusable keywords or actions that can be used to create test scripts.

Keyword-driven testing makes test scripts more readable, reusable, and easier to maintain. It also helps to reduce the need for programming expertise.

The test execution layer initiates actions on the SUT, such as sending commands or input data, and collects the results of those actions.