Testing Disucssion

testing.md

Test types discussion

Please type your answers in the comment section below

• What are the differences between manual and automated tests?
• What are the differences between functional and non-functional tests?
• Explain the main idea of the following test types:
  • Unit tests
  • Integration tests
  • End-to-end tests
  • Smoke tests

Team Member: Abdullah Alawad, Hadeel Obaid, Noor Alra'i, Wajd Kayyali

Q1. Manual Testing:
• Execution: Human testers manually interact with the application's interface.
• Speed: Slower, relies on human observation.
• Repeatability: Results may vary due to human factors.
• Exploratory Testing: Allows for creative exploration to find defects.
• Setup and Maintenance: Minimal upfront setup, but ongoing efforts can be labor-intensive.
• Human Judgment: Relies on human intuition and judgment.
• Cost: Lower initial investment but may become costlier in the long run.
• Adaptability to UI Changes: Adapts well to frequent UI changes.
• Usability Testing: Well-suited for evaluating user experience and GUI testing.

Automated Testing:
• Execution: Automated tools execute pre-scripted tests.
• Speed: Faster and more efficient for repetitive tasks.
• Repeatability: Provides consistent and repeatable results.
• Exploratory Testing: Primarily focuses on scripted tests, less suitable for exploration.
• Setup and Maintenance: Requires upfront investment but is time-efficient for regression testing.
• Human Judgment: Lacks subjective judgment capabilities.
• Cost: Higher initial setup costs but more cost-effective for repetitive tasks.
• Adaptability to UI Changes: May require script modifications with significant UI changes.
• Usability Testing: Limited in assessing user interface aspects beyond predefined scripts.

Q2. Functional requirements [USER view] —> explain how the system must work, while
non functional requirements [HACKER view] —> explain how the system should perform.

Examples:
functional: APIs testing, Smoke Testing, Unit Testing, and Database Testing.
Non functional: performance testing and stress testing

Q3.
-Unit Testing: Unit testing is the process where you test the smallest functional unit of code. Software testing helps ensure code
quality,
and it's an integral part of software development. It's a software development best practice to write software as small, functional units
then write a unit test for each code unit.

 -Integration Testing: a type of software testing in which the different units, modules or components of a software application are tested 
  as a combined entity.
 
The primary goal of integration testing is to ensure that these integrated components work together as intended and that the interfaces 
between them function correctly.

-End-to-end tests: is a software testing technique or methodology that verifies the functionality and performance of an entire software 
application from start to finish by simulating real-world user scenarios and replicating live data. it verifies the working order of a 
 software product in a start-to-finish process. and it verifies that all components of a system can run under real-world scenarios.

the idea is to run the application with all of its dependencies: database, external services, metrics, logging, etc. This can still be in a test 
environment, separate from the production environment. But ideally, this test environment represents the production environment as 
closely as possible.

-Smoke tests: a software testing method that is used to determine if a new software build is ready for the next testing phase.
 This testing method determines if the most crucial functions of a program work but does not delve into finer details. It is used to 
 quickly identify and fix any major issues with the software before more detailed testing is performed. The goal of smoke testing is to 
 determine whether the build is stable enough to proceed with further testing.

Teammates: Hayder Abu Al-Hummos, Farah Arar, Jana Abuhaltam

A1: Manual testing is when you perform tests one by one individually, in order to catch bugs and/or errors. Whereas automated tests are usually done by using tools and frameworks, like Jest, to automate the process of testing.

A2: Functional tests focus on verifying that the system performs its intended functions correctly, while non-functional tests evaluate the system's performance, reliability, security, usability, and other qualities.

A3:

1. Unit testing is when you take individual components like a function, procedure, method, object, or such, and you test it in isolation to see how it performs. The main goal of unit testing is to ensure that each unit of the software performs as intended and meets requirements.

2. Integration tests are performed to check if different components or modules of a system work together properly. The main goal is to ensure that the integrated system functions correctly and that the components communicate and interact as expected. These tests help identify and fix any issues that arise during the integration process.

3. End-to-end tests are tests that evaluates the entire application flow, from start to finish, by simulating real-world data. The purpose of E2E testing is to validate the application’s overall behavior, including its functionality, reliability, performance, and security.

4. Smoke tests are tests made to check that the basic functionalities of the application are working in a new build, and that it is bug-free and working as expected, so that it is ready for deployment.

Team Members: lin, Baraa Sidair, Najwan Shawared, Farah Alsoqi, Sara Jouma

Q.1) Manual Testing:

• Executed manually without automation tools.
• Slower, prone to human error.
• Effective for exploratory testing.
• Quick initial setup but higher maintenance.

Automated Testing:

• Executed using automation tools and scripts.
• Faster, repeatable, and efficient.
• Less effective for exploratory testing.
• Higher upfront setup costs, but cost-effective in the long term.
  One of famous app used for automated testing is Selenium
  A combination of both methods is often used based on project requirements.

Q.2) Functional testing checks the application’s processes against a set of requirements or specifications. It focuses on the features and requirements of customers, and It helps enhance the behavior of the application. It's usually easy to execute manually. Examples: Unit testing, integration testing, and system testing.

Non-functional testing assesses web application properties that aren’t critical to functionality but contribute to the end-user experience, like performance and reliability under load, security and usability .Examples: Performance testing, security testing, usability testing.

Q.3) - Unit tests focus on isolated units of code, ensuring they work correctly independently.
- Integration tests focus on the collaboration of multiple units, verifying that they integrate seamlessly and produce the expected results when combined.
- End-to-end testing verifies that all components of a system can run under real-world scenarios. The goal of this form of testing is to simulate a user experience from start to finish.
- Smoke tests quickly assess the stability and basic functionality of a software build.

Room #3: Lunar Salameh, Mohamad Sheikh Alshabab, Mohammad Elamaireh, Ahmed Ahmed

---

Q1: What are the differences between manual and automated tests?

1. Manual Testing:

• Execution: Test cases are executed by a human tester.
• Speed: Slow, since it relies on human interaction.
• Reusability: Test cases will be executed manually each time, so it is less reusable.
• Human Factors: Subject to Human errors, leading to inconsistent results.

2. Automated Testing:

• Execution: Test cases are executed by automation tools or scripts.
• Speed: Faster, since it relies on automated scripts.
• Reusability: Test scripts can be reused on different environments.
• Human Factors: More consistent and less prone to human error.

---

Q2: What are the differences between functional and non-functional tests?

1. Functional Tests:

It is a type of software testing in which the system is tested against the functional requirements and specifications. Functional testing ensures that the requirements or specifications are properly satisfied by the application.
It is basically defined as a type of testing which verifies that each function of the software application works in conformance with the requirement and specification, Each functionality of the software application is tested by providing appropriate test input, expecting the output and comparing the actual output with the expected output.

• It verifies the operations and actions of an application.
• It is based on the requirements of the customer.
• It helps to enhance the behavior of the application.
• Functional testing is easy to execute manually.
• It tests what the product does.
• Examples: Unit Testing, Smoke Testing and Integration Testing.

2. Non-Functional Tests:

It is a type of software testing that is performed to verify the non-functional requirements of the application. It verifies whether the behavior of the system is as per the requirement or not.
It tests all the aspects which are not tested in functional testing, It is designed to test the readiness of a system as per nonfunctional parameters which are never addressed by functional testing.

• It verifies the behavior of an application.
• It is based on expectations of customer.
• It helps to improve the performance of the application.
• It is hard to execute non-functional testing manually.
• It describes how the product does.
• Examples: Performance Testing, LoadTesting and StressTesting.

---

Q3: Explain the main idea of the following test types:

- Unit Tests :

• Unit tests are designed to test individual units or components of a software application in isolation.� - These tests are typically written by developers and are executed frequently during the development process to catch bugs and errors early on.

• The goal of unit testing is to ensure that each unit of the software is working correctly and meeting its functional requirements.

• Main Idea:

• Unit tests are like checking individual LEGO pieces to ensure each one works correctly.

• Developers write these tests to verify that each small part (or unit) of their code behaves as expected.

• It's like making sure each component of a car engine functions properly.

- Integration Tests :

• Integration tests are used to verify that different units or components of a software application work together correctly.

• These tests are designed to test the interactions between different parts of the system to ensure that they are functioning as expected.

• Integration tests are typically more complex than unit tests and may require the use of specialized tools and frameworks.

• Main Idea :

• Integration tests are similar to checking if LEGO pieces fit together correctly.

• After testing individual pieces, integration tests ensure that these pieces combine and interact smoothly.

• It's like making sure all the parts of a car work well together when assembled.

- End-to-End :

• Tests End-to-end tests are used to simulate real-world scenarios and use cases for a software application.

• These tests are designed to test the entire system, from start to finish, to ensure that it is functioning correctly and providing the expected results.

• End-to-end tests are typically more complex and time-consuming than unit or integration tests and may require the use of specialized tools and frameworks.

• Main Idea:

• End-to-end tests are like taking a complete car for a test drive.

• These tests simulate the entire user journey, checking if the application behaves as expected from start to finish.

• It's like ensuring that driving the car (using the complete software) meets user expectations.

- Smoke Tests :

• Smoke tests are used to verify that the basic functionality of a software application is working correctly.

• • These tests are typically run after a new build or deployment to ensure that the system is stable and ready for further testing.

• Smoke tests are designed to be quick and easy to execute and typically focus on the most critical features and functions of the system.

• Main Idea:

• Smoke tests are like turning on a new electronic device for the first time to see if it works.

• These tests aim to quickly check the basic functionalities of the software to ensure there are no major issues.

• It's like making sure the car starts, and basic features like lights and brakes work before going on an extensive test drive.

Team name : Feda , hammam, Momena,ramah
Q1- a test refers to a piece of code that can be run to verify the behavior of a program.
manual testing, you perform the tests step by step without the help of tools and involves humans testing and interacting, whereas in automated testing, tests are executed automatically using automation tools & frameworks. like Jest.

---

Q2- Functional testing checks the application's processes against a set of requirements or specifications and is done based on the business requirement. Non-functional testing assesses application properties that aren't critical to functionality but contribute to the end-user experience, like performance and reliability under load and customer expectation and Performance requirement.

---

Q3- Unit Test : test a small unit of code, such as a function or a component. Unit tests are very low level.
Integration test : While unit tests always take results from a single unit, such as a function call, integration tests may aggregate results from various parts and sources and also Multiple parts of a system can be tested An example of this would be a test that starts a frontend and a backend.

E2E test : End-to-end testing (E2E testing) is a testing method that evaluates the entire application flow, from start to finish. It ensures that all components work as expected and the software application functions correctly in real-world scenarios. these are much harder to maintain, as you need to set up a backend, a database, and a frontend in a test environment and have them all work together. E2E testing is usually performed after integration testing, which tests individual modules,

Smoke testing is the practice of testing fundamental and core elements of a software program in the early phases of development to identify minor issues that might delay the product’s release.

At its core, smoke testing is used to establish whether the released software build is reliable or not. Smoke testing allows the quality assurance (QA) team to continue with additional software testing. It comprises a minimal collection of tests executed on every build to verify the software’s operation.

Mohmmad smadi , Sanad Alshobaki , Hakimah Ismail , Nour kayyali.
Room 2

Q1: Manual testing is done in person, by clicking through the application or interacting with the software and APIs with the appropriate tooling.

Automated tests, on the other hand, are performed by a machine that executes a test script that has been written in advance. These tests can vary a lot in complexity, from checking a single function to making sure that performing a sequence of complex actions in the UI leads to the same results

Q2:
1-Purpose:
Functional tests ensure that software behaves according to specified requirements.
Non-functional tests evaluate attributes like performance, security, and usability.

2-Scope:
Functional tests focus on specific features and functionalities.
Non-functional tests address broader system qualities beyond individual functionalities.

3-Measurability:
Functional tests determine if software functions correctly (pass/fail).
Non-functional tests measure attributes against benchmarks or thresholds.

basically :
functional tests validate functionality, while non-functional tests assess system attributes and qualities. Both are integral to ensuring software quality and reliability.

Q3:

Unit Testing: to isolate written code to test and determine if it works as intended.

Integration tests verify that different modules or services used by your application work well together. These types of tests are more expensive to run as they require multiple parts of the application to be up and running.

End-to-end testing: replicates a user behavior in a complete application environment.

Smoke tests: smoke tests means verifying the important features are working and there are no showstoppers in the build that is under testing