intro-to-tests.md

1. List four types of tests commonly used in software development.
2. Explain the difference between unit tests, integration tests, and end-to-end tests.
3. Explain the concept of TDD and discuss its advantages and disadvantages.
4. Why is testing considered crucial in software development.
5. What's the difference between manual testing and automated testing.
6. Why is integrating testing into CI/CD beneficial for software development?
7. What are some common types of non-functional tests? How do these tests contribute to the overall quality and reliability of a software system?

Ahmed Jalal | Nada Al-shakiry | Hana | Afeaa | Elaf

Software development relies on various testing strategies to ensure a well-functioning product. Here's a quick summary of four common types:
Unit Testing: Makes sure individual building blocks of code (functions, classes) work as intended, like tiny isolated tests.
Integration Testing: Checks how these building blocks work together, ensuring smooth communication and data flow between them.
Functional Testing: Mimics user interaction to verify the software delivers its promised features and behaves as expected.
Non-Functional Testing: Goes beyond core functionality, focusing on aspects like performance, security, and usability. This might involve testing how fast the software runs, how secure it is from attacks, or how easy it is to use.

---

Unit tests:
Test individual units or components of a system in isolation.
Focus on testing small, specific pieces of code, such as functions or methods.
Typically run quickly and are isolated from external dependencies.
Help ensure that each unit of code behaves as expected.
Integration tests:
Test interactions between different units or components of a system.
Aim to verify that integrated units work together correctly.
Involve testing the communication and data flow between modules or subsystems.
May require setting up a test environment that resembles the production environment.
End-to-end tests:
Test the entire system from start to finish, simulating real user scenarios.
Focus on validating the system's behavior and functionality as a whole.
Involve testing across multiple layers of the application, including user interfaces, APIs, and databases.
Mimic real user interactions and workflows, often using automation tools.

So, in summary, unit tests validate small, isolated parts of the codebase, integration tests ensure that these parts work together correctly, and end-to-end tests validate the entire system's functionality from a user's perspective.
Each type of test serves a different purpose and provides a different level of confidence in the system's correctness and reliability.

---

Test-Driven Development (TDD) is a software development methodology where tests are written before the actual code.

Test-Driven Development (TDD) has many benefits like making your code more reliable, easier to maintain, and able to handle more users. But it also takes longer and isn’t as flexible as other code-writing methods. So you must consider the pros and cons before deciding if TDD suits your project.

---

Testing in software development is essential for catching bugs early, improving code quality, boosting developer confidence, and reducing risks. It ensures a smooth user experience, maintains code, and facilitates CI/CD. In short, testing saves time, money, and frustration by building trust in your software

---

Manual testing involves humans testing and interacting with a software application or product to identify issues, while automated testing uses computer programs, applications, or scripts to write pre-defined tests and run them programmatically.

---

Integrating testing into Continuous Integration/Continuous Deployment (CI/CD) processes reduces the number of errors that may occur in the repetitive steps of CI/CD.
This saves the developer's time and also reduces the bug-fixing cost. Also, improving the code quality with automation improves your test ROI

---

Non-functional tests like performance, security, usability, scalability, and stress testing ensure the software can handle real-world demands. They improve overall quality and reliability by finding weaknesses in areas like speed, security, and user-friendliness. These tests make software robust, user-friendly, and ready for future growth.

Dilan Ahmed | Muhammad Sabah | Aween Ezzat | Shinak Mohamed | Omar Sardar

1. Unit Tests
   Integration Tests
   Functional Tests
   Regression Tests

2. The Unit tests are test individual components and units of code in separate way to ensure the functionality. While the intergration test are more about validate ineteractions between different Units to ensure they cohesively work together smoothly . Also the last one end to end test are the tests to asses the system's functionality entirely through simulating the scenarios in which the software meets requirements accordingly

3)The TDD which stands for Test Driven Development is about written tests before the code which is useful in terms of improvement in code qulaity, better feedback loop and design. The disadvantages will be more about initial learnings, overhead, and potential of constant problem solveing and over enigneering

4. testing is crucial because it finds and fixes problems before the software goes live. It ensures the software works correctly, meets user needs, and avoids costly errors later on.

5. The main difference between manual testing and automated testing is about the way they are being cnducted, as in manual testing developers manually do the execution of the test . on the other hand the automated testing relies on automation tools to execute the scripted test had being written before hand.

6)Integrating testing into CI/CD is beneficial because it helps catch bugs early, ensures code quality, and promotes faster development cycles by automating the testing process within the continuous integration and continuous deployment pipeline.

7. The common types of non functional tests are like performance testing which tests the way a system performs in different conditions and loads, and Security testing which identifies vulnerabilities potentials and making sure we have a secure system. Also we do have Usability and Reliability testing as well, which they both are about assessing and measure the way how it is user friendly and how the system is able to perform as it supposed consistently

Rafeef thamer, Ahmed isam, shkar gharib, Aya hassan, Meer atta, and Rawan

1. Unit Tests
   Integration Tests
   Functional Tests
   Regression Tests
2. Unit tests

Unit tests are very low level and close to the source of an application. They consist in testing individual methods and functions of the classes, components, or modules used by your software.
Integration tests

Integration tests verify that different modules or services used by your application work well together.
Functional tests

Functional tests focus on the business requirements of an application. They only verify the output of an action and do not check the intermediate states of the system when performing that action.
End-to-end tests

End-to-end testing replicates a user behavior with the software in a complete application environment. It verifies that various user flows work as expected and can be as simple as loading a web page or logging in or much more complex scenarios verifying email notifications, online payments, etc...
3.Test-Driven Development (TDD) is a software development process where tests are written before the actual code.
Advantages of TDD:

Improved code quality: TDD encourages writing modular, testable code, resulting in fewer bugs and easier maintenance.
Faster feedback loop: Instant feedback from failing tests helps catch issues early in the development process.
Design guidance: TDD encourages developers to focus on the interface and behavior of their code before implementation, leading to better-designed software.
Regression testing: With a comprehensive suite of tests, developers can confidently refactor code without fear of introducing new bugs.

Disadvantages of TDD:

Initial learning curve: Adopting TDD requires a shift in mindset and additional upfront effort to write tests.
Time-consuming: Writing tests before code can slow down the initial development process, especially for complex systems.
False sense of security: Passing tests don't guarantee bug-free code, as tests might not cover all edge cases or scenarios.
Maintenance overhead: Maintaining a large suite of tests alongside codebase changes can become cumbersome and time-consuming.

5.Manual testing involves human testers executing test cases without automation tools, allowing for exploratory testing but can be time-consuming and subjective. Automated testing, on the other hand, utilizes scripts or tools to execute tests automatically, providing repeatability, faster execution, and objective results, making it suitable for repetitive tasks like regression testing.
6.Integrating testing into CI/CD processes offers benefits such as early issue detection, faster feedback, improved code quality, streamlined release processes, enhanced collaboration, increased efficiency, and continuous improvement, ultimately leading to higher-quality software releases and improved customer satisfaction.
7.Non-functional testing is a type of software testing that focuses on the non-functional aspects of a software application, such as performance, reliability, scalability, and usability, rather than its specific behavior or features. It is called "non-functional" because it doesn't directly test the functions or features of the software, but rather its characteristics and attributes. This type of testing helps ensure that the software meets the required standards for factors like speed, responsiveness, and security

Aland rebwar || Mawj M.Basheer || vinos sarhad || ibrahim muhaned

1-List four types of tests commonly used in software development.?

a-Unit Tests: These test individual components or units of code in isolation, typically at the function or method level.
b-Integration Tests: These test how different units of code work together as a group. They ensure that integrated units function
correctly as a whole.
c-End-to-End Tests: These test the entire software application from start to finish, simulating real user scenarios. They validate the
system's behavior and interactions with external dependencies.
d-Regression Tests**: These ensure that previously developed and tested software still performs correctly after changes or updates.

---

2-Explain the difference between unit tests, integration tests, and end-to-end tests.?

a-Unit Tests: Focus on testing individual components in isolation. They're typically fast to execute and help identify bugs early in the
development process.
b-Integration Tests: Verify interactions between integrated components or modules. They ensure that the integrated units work together
correctly.
c-End-to-End Tests: Test the entire application flow, simulating real user scenarios. They validate the behavior of the system as a whole, including its interactions with external dependencies like databases or APIs.

---

3-Explain the concept of TDD and discuss its advantages and disadvantages.?

*Advantages:
- Improved Code Quality: TDD encourages writing modular and testable code.
-Fewer Bugs: Since tests are written upfront, the likelihood of introducing bugs decreases.
-Design Clarity: TDD promotes clearer code design and better understanding of requirements.
*Disadvantages:
-Time-consuming: Initially, it may seem slower because developers need to write tests upfront.
-Over-testing: There's a risk of writing too many tests, leading to maintenance overhead.

---

4-Why is testing considered crucial in software development.?

-Testing is crucial because it:
a-Identifies Bugs Early: Detecting and fixing bugs early reduces the cost of development.
b-Ensures Reliability: Testing ensures that the software behaves as expected and meets the user's requirements.
c-Maintains Quality: Testing helps maintain the quality and stability of the software product over time.

---

5-What's the difference between manual testing and automated testing.?

-Manual Testing: Involves human testers executing test cases manually without automation tools. It's subjective, time-consuming, and
error-prone.

-Automated Testing: Involves using automation tools to execute test cases. It's faster, repeatable, and less error-prone.

---

6-Why is integrating testing into CI/CD beneficial for software development?

-Integrating testing into Continuous Integration/Continuous Deployment (CI/CD) pipelines offers several benefits:
a-Early Detection of Issues: Automated tests run with each code change, catching issues early in the development cycle.
b-Faster Feedback Loop: Developers receive immediate feedback on the impact of their changes.
c-Improved Code Quality: Continuous testing helps maintain code quality and stability across releases.

---

7-What are some common types of non-functional tests? How do these tests contribute to the overall quality and reliability of a software system?

-Non-functional testing : is a software testing type that tests the non-functional aspects of an application, such as usability, performance, scalability, reliability, security, compatibility, and more. In contrast, functional testing focuses on testing its functional behavior.

-Non functional testing is of crucial importance in the software development and testing process. While functional testing ensures that the software meets its intended functionality, non-functional testing validates other critical aspects of the system.

Non functional requirements were not given proper importance in the initial test cycles, but now it has changed for good.

Non functional testing is crucial to identify all the performance and security-related issues. It focuses on the non-functional aspects of the application. For example, using performance testing is a type of non-functional testing that lets you check the performance of an application under heavy traffic or user load. Also, it helps ensure that your application is stable and can handle heavy loads.

---

1. Unit testing.
   Integration testing.
   System testing.
   Acceptance testing.

2. Unit testing is a software testing process for testing specific units, components, or software elements. integration testing, which is when different software components and modules are combined and tested as a group to make sure everything is ready for the next level. End-to-end testing is a software testing technique 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.

3. It is a software development approach which is about typing the test function before the real code. it helps to improve code quality and it helps with refactorization. it can take too much time.

4. It ensures that the app is works the way intended and avoids bugs. It confirms that software meets specified requirements and user expectations.

5. Manual testing involves humans testing and interacting with a software application or product to identify issues, while automated testing uses computer programs, applications, or scripts to write pre-defined tests and run them programmatically

6. Because you will have faster information about how your code is running making it easier and faster to spot the bugs and fix them, which make integrating of new feature much easier and reliable

7. Non-Functional Testing is defined as a type of Software testing to check non-functional aspects (performance, usability, reliability) of a software application. It is designed to test the readiness of a system as per nonfunctional parameters which are never addressed by functional testing

Halwest, Dawood, Hanan Isalm, SHvan, Zainab Mirza

zhin, Amal, Koshyar, Ali, Barham

1. here we have : unit test, functional testing, Integration tests, Regression Testing
2. unit tests is like a function that test a specific task and operation in the project, and integration It tests the interactions between various components to ensure they integrate correctly, and end to end tests checks if the user login is successfully performed
3. Test-Driven Development (TDD) is a software development approach where tests are written before the actual code implementation.
   Advantages: 1.Faster Feedback Loop 2. Improved Code Quality 3.Documentation
   disadvantages: 1.Upfront Investment 2. Learning Curve 3.Maintenance Overhead
   4.Testing is crucial in software development because it helps identify and prevent bugs, ensures that the software meets requirements, improves code quality, and boosts user confidence in the product's reliability and performance. Essentially, it helps catch issues early, reduces the risk of defects in production, and ultimately contributes to a better user experience.

5.Manual testing involves humans executing test cases by hand, while automated testing involves using software tools to execute test cases automatically. Manual testing is more flexible but time-consuming and prone to human error, while automated testing is faster, repeatable, and scalable but requires upfront investment in tools and scripts.

6.Early Issue Detection: Finds problems early.
Quick Feedback: Provides rapid notifications.
Better Code Quality: Maintains high standards.
Confident Releases: Increases trust in deployments.
Smooth Deployment: Reduces chances of deployment failures.
Continuous Improvement: Helps refine both code and processes.
Shift-Left Testing: Encourages testing early in development.

7.For example, using performance testing is a type of non-functional testing that lets you check the performance of an application under heavy traffic or user load. Also, it helps ensure that your application is stable and can handle heavy loads.
common types: 1. Compatibility Testing 2. Performance Testing 3. Security Testing

Mohammed Nazar, Zainab Al-Najjar, Didam Goran, Payam R.
1.
a. Unit Tests
b. Integration Tests
c. Regression Tests
d. Acceptance Tests

a. Unit Tests: These check if small parts of the code (like functions or classes) work correctly on their own.
b. Integration Tests: They ensure that different parts of the code work well together as a whole system.
c. End-to-End Tests: These test the entire application from start to finish, just like how a real user would use it.

Test-Driven Development (TDD) means writing tests before writing the actual code.

Advantages:
Better Code Quality: Helps in writing cleaner and more maintainable code.
Faster Feedback: Catches bugs early, saving time and effort in the long run.
Disadvantages:
Initial Time Investment: Requires extra time upfront to write tests first.
Complex for Existing Code: Harder to implement in projects with existing code.

4. Testing is crucial in software development because it helps find and fix mistakes early, ensuring that the software works well, performs efficiently, and satisfies users. It saves time and money, builds trust, and makes it easier to make improvements in the future.

5. Manual Testing:
   Done by humans.
   Testers click around and check if everything works as expected.
   Slower, more subjective, and prone to human error.

Automated Testing:
Done by machines.
Tests are written in code to automatically check the software.
Faster, more reliable, and good for repetitive tasks.

6. Integrating testing into CI/CD is beneficial because it catches bugs early, provides quick feedback to developers, ensures code quality before deployment, streamlines the deployment process, helps in continuous improvement, and increases development efficiency.

7. Common non-functional tests include:
   Performance: Checks how fast the software is and how well it handles heavy use.
   Security: Makes sure the software is safe from unauthorized access and data breaches.
   Usability: Tests how easy and intuitive the software is to use.
   Reliability: Ensures the software works consistently over time without crashing.
   Compatibility: Checks if the software works on different devices and systems.