Testing

test.md

Testing in JS disscusion

1. What is the purpose of unit testing in JavaScript development? How does it contribute to the overall quality of a software application?
2. Explain the difference between manual testing and automated testing. What are the advantages of using automated testing in JavaScript projects?
3. What is a test suite, and how does it relate to test cases in JavaScript testing? Provide an example of a test suite and its corresponding test cases.
4. Describe the concept of test-driven development (TDD) in JavaScript. How does TDD influence the development process and help in writing robust and reliable code?
5. What are the popular testing frameworks and libraries available for JavaScript? Compare and contrast two of them, highlighting their key features and use cases.

Nokulunga, Nhlanhla, Angela

1. Unit testing in JavaScript development involves testing individual units or components of a software application to ensure they function correctly. Its key purposes include:
   Maintaining Code Quality: By testing functions, methods, and classes in isolation, unit tests help identify and fix bugs early, ensuring the code works as expected.

Simplifying Refactoring: Unit tests help confirm that code changes or refactoring do not introduce new issues, as passing tests indicate the code still behaves correctly.

Documenting Code Behavior: Unit tests act as documentation, illustrating how functions or modules should operate, aiding other developers in understanding the code.

Supporting Agile Development: In Agile practices, where continuous integration and delivery are common, automated unit tests maintain code quality and stability, allowing for frequent changes and deployments.

Reducing Debugging Efforts: By catching bugs early and ensuring component functionality, unit tests save time on debugging complex integration issues.

Encouraging Modular Design: Writing unit tests
Ensures Functionality: Unit tests verify that each part of the application works as intended. This helps maintain the reliability of the software, ensuring that features perform their expected functions.

Facilitates Code Maintenance: With unit tests in place, maintaining and updating code becomes easier. Developers can confidently make changes, knowing that the tests will catch any unintended side effects.

Promotes Clean Code: Writing unit tests encourages developers to create modular, well-organized, and decoupled code. This not only makes the code easier to test but also enhances readability and maintainability.

Supports Refactoring: Unit tests provide a safety net during refactoring. Developers can restructure code to improve performance or readability without fearing that they will break existing functionality, as long as the tests continue to pass.

Manual Testing vs. Automated Testing
Manual Testing:
Process: Testers manually execute test cases without the use of any automation tools.
Scope: Involves manually interacting with the application, observing behavior, and recording results.
Time and Effort: Time-consuming and prone to human error, especially for repetitive tasks.
Flexibility: Can adapt quickly to changes or new test cases.
Suitability: Best for exploratory, usability, and ad-hoc testing where human judgment is critical.
Automated Testing:
Process: Testers write scripts and use tools to automatically execute test cases.
Scope: Can cover a wide range of tests including unit, integration, end-to-end, and regression testing.
Time and Effort: Initial setup is time-consuming, but execution is fast and can be repeated with consistent accuracy.
Consistency: Provides reliable and repeatable results, reducing the likelihood of human error.
Suitability: Ideal for regression testing, performance testing, and any repetitive tests that need to be executed frequently.

Advantages of Automated Testing in JavaScript Projects
Speed and Efficiency: Automated tests run much faster than manual tests, especially for large applications with many test cases.
Repeatability: Tests can be run repeatedly with the same results, ensuring consistency and reliability.
Early Bug Detection: Automated testing enables continuous integration and continuous deployment (CI/CD), allowing bugs to be detected and fixed early in the development cycle.
Cost-Effective in the Long Run: Although the initial setup of automated tests can be expensive and time-consuming, they save costs over time by reducing the need for manual testing and allowing for faster release cycles.
Scalability: Automated tests can handle a large number of test cases efficiently, making it easier to scale the testing process as the project grows.

3 .A test suite is a collection of test cases that are related to a specific functionality or feature of an application.
In JavaScript testing, a test suite is typically a file or a module that contains multiple test cases that are executed together to ensure that a particular aspect of the application is working as expected.
A test case, on the other hand, is a single test that verifies a specific behavior or functionality of the application.
For example, let's say we're building a calculator application and we want to test the "add" function. Our test suite might be called "calculator.spec.js" and it would contain multiple test cases such as "adds two positive numbers", "adds two negative numbers", "adds a positive and a negative number", etc. Each test case would contain the necessary code to execute the test and verify the expected result. By grouping these test cases into a test suite, we can easily run all the tests related to the "add" function together, making it easier to maintain and execute our tests.

4. Test-Driven Development (TDD) in JavaScript
   Concept of TDD: Test-Driven Development (TDD) is a software development process in which developers write tests before writing the actual code. The process typically follows a cycle known as "Red-Green-Refactor."
   Red: Write a test for a new feature or functionality. At this stage, the test will fail because the feature hasn't been implemented yet.
   Green: Write the minimum amount of code necessary to make the test pass. This means implementing just enough functionality to satisfy the test conditions.
   Refactor: Clean up the code, improving its structure and readability while ensuring that all tests still pass. This step helps in maintaining high code quality without changing its external behavior.

How TDD Influences the Development Process
Focus on Requirements: TDD forces developers to think about the requirements and design of the functionality before writing the actual code. This helps in understanding the problem and planning the solution more effectively.
Incremental Development: By breaking down features into small, manageable pieces and writing tests for each, TDD promotes incremental development. This approach makes it easier to track progress and identify issues early.
Immediate Feedback: Since tests are run frequently, developers receive immediate feedback on their code. This helps in identifying and fixing bugs as soon as they are introduced, reducing the cost and effort required to address them later.
Improved Code Quality: Writing tests first encourages developers to write code that is easy to test, often resulting in more modular, flexible, and maintainable code. The refactoring step ensures that the codebase remains clean and efficient.

5. Popular Testing Frameworks and Libraries for JavaScript
   Jest
   Mocha
   Jasmine
   Karma
   Chai
   Enzyme
   Cypress

Comparison of Jest and Mocha
Jest
Key Features:
Built-in Assertions: Jest comes with a built-in assertion library, which means you don't need to install additional libraries like Chai.
Zero Configuration: Jest works out of the box for most JavaScript projects without the need for complex setup or configuration.
Mocking and Spying: Jest has built-in support for mocking and spying on functions, making it easier to test components in isolation.
Snapshot Testing: Jest supports snapshot testing, allowing developers to capture the rendered output of components and compare them over time.
Parallel Test Execution: Jest runs tests in parallel, which speeds up the testing process, especially in larger codebases.

Mocha
Key Features:
Flexible and Modular: Mocha is highly configurable and can be combined with various assertion libraries (e.g., Chai), mocking libraries (e.g., Sinon), and other tools.
Asynchronous Testing: Mocha has robust support for asynchronous tests, making it a good choice for testing asynchronous code.
Custom Reporters: Mocha supports custom reporters, allowing developers to format test results in various ways.
Browser and Node.js: Mocha can run tests in both the browser and Node.js environments, providing flexibility for different types of projects.
BDD and TDD: Supports both Behavior-Driven Development (BDD) and Test-Driven Development (TDD) styles, making it versatile for different testing approaches.

Sharon Matjila
Konanani Nemauluma
Koketso Lepulana

1. Unit testing in JavaScript helps make sure individual parts of the code work correctly. It catches mistakes early making it easier to fix problems, and write better code. This leads to a more stable and reliable application with fewer bugs. Unit testing also helps developers work together better and makes sure changes don't break existing code. Unit testing is an important step in making sure the software is high-quality, works well, and is easy to maintain.

2. Manual Testing:
   Process: Involves human testers manually executing test cases without the use of automation tools.

Automated Testing:
Process: Involves using automation tools to write and execute test scripts that validate the functionality of the application.

Advantages of Using Automated Testing in JavaScript Projects.
1.Efficiency and Speed :Automated tests run much faster than manual tests, especially for repetitive tasks and large test suites.
2.Consistency and Reliability: Automated tests run much faster than manual tests, especially for repetitive tasks and large test suites. 3.Scalability:Automated tests can easily scale to cover more features and scenarios as the application grows.

3. Test Suite:
   A test suite is a collection of test cases that are intended to be executed together to test a specific feature or component of an application. It groups related tests to make them easier to manage and run together. In JavaScript testing, a test suite typically contains multiple test cases, each of which checks a different aspect or scenario of the functionality being tested.

example : function add(a, b) {
return a + b;
}

This is how you can test it :
const { expect } = require('chai'); const add = require('../add');
describe('add function', function() {
it('should return 4 when adding 2 and 2', function() { expect(add(2, 2)).to.equal(4);
});

Test Case:
A test case is a single unit of testing that checks a specific function or a piece of functionality. Each test case has a specific purpose and checks whether a particular aspect of the code works as expected.

4. Test-driven development (TDD) in JavaScript is a development approach that involves writing tests before writing code. The process works as follows: developers write a test that defines the expected behavior of a specific piece of code, which initially fails since the code hasn't been written yet. Then, they write the minimal code necessary to pass the test. After that, all tests, including existing ones, are run to ensure the new code integrates seamlessly. If all tests pass, developers can refactor the code for clarity, efficiency, or maintainability without changing its behavior. By using TDD, developers can break down tasks into clear steps, detect bugs early, ensure code meets requirements, promote modular and maintainable designs, and gain confidence in code reliability, making it a valuable approach in JavaScript development

5.Popular testing frameworks and libraries for JavaScript include:

Jest
Mocha
Jasmine
Karma
Ava
Cypress

Jest and Mocha are top JavaScript testing frameworks, each with its own strengths.

Jest
Key Features: Works out of the box, snapshot testing, built-in mocking, integrated code coverage, and parallel test running.
Best For: Quick setup, React apps, and projects prioritizing speed and ease.

Mocha
Key Features: Highly flexible, supports various assertion libraries, excellent for asynchronous testing, customizable reporting, and extensive plugin support.
Best For: Projects needing customization, both frontend and backend testing, and flexibility in tools and reporters.

Comparison
Ease of Use: Jest is simpler, especially for React, while Mocha needs more setup.
Performance: Jest runs tests faster with built-in features, while Mocha’s speed depends on configuration.
Flexibility: Mocha allows more customization; Jest is more streamlined.
Community: Jest has a strong React community; Mocha has a broad plugin ecosystem.
Jest is perfect for quick setups and React projects, while Mocha excels in customizable, flexible environments.

Wesley, Tumelo, Mpho.

1. The main goal of unit testing is to ensure that each unit of the software performs as intended and meets requirements. Unit tests help make sure that software is working as expected before it is released.

Ensures Quality and Reliability Testing is important as it helps identify defects and issues early in the development process, ensuring that the final product is of high quality and reliable. Testing also helps to prevent bugs and errors in the software.
Enhances User Experience Through comprehensive testing, companies can ensure that their products meet user requirements and expectations, leading to a positive user experience. Testing helps in delivering a user-friendly and efficient product.
Saves Time and Costs Testing helps in reducing the time and costs involved in fixing defects post-release. By identifying and resolving issues early on, companies can avoid expensive rework and deliver the product to market faster

2. Manual Testing involves human testers executing test cases without the use of any automation tools. Automated Testing involves using software tools and scripts to perform tests on the software.

advantages:

Cross-Browser Testing: Automated tests can be run across different browsers and devices, ensuring consistent behavior of JavaScript applications in varied environments.
Performance Testing: Automated tools can simulate multiple users and test the performance of JavaScript applications under load, identifying bottlenecks and performance issues
Improved Code Quality: Automated testing encourages developers to write better code by providing immediate feedback on code changes, reducing the likelihood of introducing defects.
API Testing: Automated testing tools can effectively test JavaScript applications that rely heavily on APIs, ensuring proper integration and functionality.

3. A test suite in JavaScript testing is a collection of test cases that are used to test a specific feature or functionality of a codebase. Test suites help organize and group related test cases together for easier management and execution.

Test cases, on the other hand, are individual tests that are written to verify specific behaviors or conditions in the code. They are the building blocks of a test suite and are designed to check different aspects of the code's functionality.

// Example of a test suite

describe('Math operations', () => {
  
  test('Adding numbers', () => {
    expect(2 + 2).toBe(4);
  });

  
  test('Multiplying numbers', () => {
    expect(3 * 4).toBe(12);
  });

  
  test('Dividing numbers', () => {
    expect(10 / 2).toBe(5);
  });
});``

4. Test-Driven Development (TDD) is a software development methodology in which developers write automated tests before writing the actual code. The process follows a repetitive cycle of writing a test, writing code to pass the test, and then refactoring the code.

TDD Influence on Development Process
Enhanced Focus on Requirements: Writing tests first requires developers to think through the requirements and design before coding, leading to a better understanding of the expected functionality.
Incremental Development: TDD encourages small, incremental changes, which makes the development process more manageable and less error-prone
Immediate Feedback: Tests provide immediate feedback, allowing developers to detect and fix issues early in the development process.
Documentation: The tests serve as documentation for the code, showing how the functionality is supposed to work and making it easier for others to understand the codebase.

Benefits of TDD in Writing Robust and Reliable Code
Fewer Bugs: By writing tests first, developers catch errors early, resulting in fewer bugs and issues in the final product.
Reduced Debugging Time: With tests catching issues early, the time spent debugging is significantly reduced.

5. Jest is a popular JavaScript testing framework developed by Facebook. It is known for its simplicity, speed, and powerful features such as snapshot testing, mocking, and code coverage.

key features:
Simplicity and Speed: Easy to set up and fast to execute.
Snapshot Testing: Captures the state of your UI components and compares them during future runs to catch unexpected changes.
Mocking: Built-in support for mocking functions, modules, and timers.

Mocha: Mocha is another widely used JavaScript testing framework that provides great flexibility and extensibility.

key features:
Flexibility and Extensibility: Highly configurable with a wide range of plugins and integrations.
Testing Styles: Supports various styles like BDD (Behavior-Driven Development) and TDD (Test-Driven Development).
Asynchronous Testing: Handles asynchronous tests easily with promises and callbacks.

@Hophneylen
@Geraldmutsw
@mpilomthiyane97

1. Unit testing in JavaScript development serves the purpose of verifying the functionality of individual units of your code. These units can be functions, methods, or even modules. By isolating these units and testing them in controlled environments, unit testing helps developers ensure that each piece works as expected.
2. Unit testing in JavaScript
   The main difference between manual testing and automated testing lies in who or what executes the tests,
   In manual testing

• a human tester interacts with the JavaScript application following a predefined set of instructions (test cases).
• They manually verify if the application behaves as expected, identify any issues, and report them.
  Automated testing
• uses software tools and scripts to execute test cases.
• These scripts are written in programming languages like JavaScript and leverage testing frameworks to simulate user interactions and verify application behavior.

3. A test suite is a collection of test cases that are designed to validate the behavior of a particular component, module, or functionality in a software application. It groups related tests together to ensure that they are executed in a specific order or context, allowing for comprehensive testing of the application.
   Relationship Between Test Suite and Test Cases

• Test Case: A single unit of testing that verifies a specific aspect of the functionality. It includes the test input, execution conditions, and expected results.
• Test Suite: A container that holds multiple test cases. It organizes and manages the execution of related test cases to ensure thorough testing of the targeted functionality.
  Example of a Test Suite and Its Corresponding Test Cases
  Let's consider a simple example of a JavaScript function that adds two numbers: function add(a, b) {
  return a + b;
  }
  Test Suite for the add Function: // add.test.js

// Import the function to be tested
const add = require('./add');

// Describe the test suite for the 'add' function

describe('add function', () => {
  
  // Test case 1: Adding two positive numbers
  test('should return the sum of two positive numbers', () => {
    expect(add(1, 2)).toBe(3);
  });

  // Test case 2: Adding a positive number and a negative number
  test('should return the sum of a positive number and a negative number', () => {
    expect(add(5, -3)).toBe(2);
  });

  // Test case 3: Adding two negative numbers
  test('should return the sum of two negative numbers', () => {
    expect(add(-2, -3)).toBe(-5);
  });

  // Test case 4: Adding zero to a number
  test('should return the same number when adding zero', () => {
    expect(add(7, 0)).toBe(7);
  });

  // Test case 5: Adding decimal numbers
  test('should return the sum of two decimal numbers', () => {
    expect(add(1.2, 3.4)).toBe(4.6);
  });

});

4. Test-Driven Development (TDD) is a development process where developers write tests for a feature or functionality before writing the actual code to implement it. The cycle typically follows three steps: Red, Green, Refactor.

• Red: Write a failing test for the new functionality.

• Green: Write the minimum amount of code necessary to make the test pass.

• Refactor: Improve the code while ensuring that all tests still pass.
  Influence of TDD on the Development Process
  Early Bug Detection: Identifies issues early in the development cycle, reducing the cost and effort of fixing them later.
  Clear Requirements: Clarifies and solidifies requirements before implementation, ensuring developers understand what needs to be built.
  Improved Code Quality: Encourages writing modular, reusable, and testable code.
  Continuous Feedback: Provides immediate feedback on code changes, ensuring that new code
  How TDD Helps in Writing Robust and Reliable Code

• Ensures Functionality: Guarantees that the code meets the specified requirements.

• Reduces Regression Bugs: Prevents new changes from breaking existing features.

• Promotes Best Practices: Encourages clean code principles and best practices.

• Enhances Maintainability: Makes the codebase easier to maintain and extend with confidence.

5. Popular libraries are Mocha and Jest.

• Mocha is a Flexible framework focusing on asynchronous testing. Requires additional libraries for assertions and other features. Often used for backend testing.
• Jest is a Feature-rich framework with built-in test runners, assertion library, and mocking capabilities. Great for UI testing and all-in-one solution.
• Popular libraries would be Chai a popular assertion library with a rich set of matchers for verifying test expectations.
• Sinon a library for creating test doubles (stubs, mocks, spies) to isolate units under test.
  Comparison Between Jest and Mocha
  Jest key features include built-in test runner and assertion library (expect), snapshot testing for UI components, mocking capabilities for isolating units. Use cases include all-in-one testing solution, especially for React projects with snapshot testing. Great for unit testing, integration testing, and UI testing. Mocha is highly flexible and customizable, focuses on asynchronous testing, requires additional libraries for assertions and runners (e.g., Chai + Karma), offers more control over test execution. Use cases it is preferred for complex backend testing scenarios with specific needs. A good choice for developers familiar with Node.js and JavaScript testing concepts, offers more granular control over testing compared to Jest

Vuyo Ngwane @Vuyo-Ngwane
Ntokozo Nkosi
Thitevhelwi Samuel Masuvhe @samuelthis

1.) Correctness Verification: Unit tests assist in confirming that separate code units (functions, modules, or other components) operate as intended when they are separated. Early Bug Detection: Early in the development cycle, unit tests can identify bugs. When a test fails, it means that something isn't functioning as planned, which enables engineers to address the problem before it gets more complicated and expensive to correct. Unit tests act as a safety net for refactoring. If they break, you know your changes went off course, preventing regressions and boosting refactoring confidence. Documentation and Understanding: Unit tests are living code comments, explaining how the code works for both you and new developers. Unit testing is a cornerstone of software development best practices. It contributes to a more robust, maintainable, and reliable codebase, leading to a higher quality software application that delivers a better user experience.

2.) Manual testing is a process in which test cases are executed manually without the help of any automated tool. It ensures that all the functions in the application are working, as defined in the requirement document.

Automation Testing is a technique that uses tools to write scripts and execute test cases. It is the best way to enhance the execution speed, effectiveness, and test coverage in software testing.

Advantages of Using Automated Testing in JavaScript Projects:
Increased Speed and Efficiency: Automated tests execute faster than manual tests, allowing for quicker feedback and reducing the time needed for repetitive tasks like regression testing.
Greater Test Coverage: Automation allows for more extensive test coverage. Scripts can be run across multiple environments and configurations, ensuring all aspects of the application are tested. Consistency and Reliability: Automated tests provide consistent results, reducing the risk of human error. They ensure that tests are executed in the same manner every time, leading to more reliable outcomes.
Reusability of Test Scripts: Once written, automated test scripts can be reused for different versions of the application, saving time and effort in the long run.

3.) Test suites are the logical grouping or collection of test cases to run a single job with different test scenarios.

Test Case is a sequence of actions necessary to verify a specific functionality or feature of the software. It specifies the prerequisites, post conditions, steps, and data required for feature verification.

A test scenario where we need to check the login functionality. One of the test cases could be:
Test Case: Check results when a valid Login ID and Password are entered.
You can create multiple test cases to ensure comprehensive coverage of the particular test scenario.
Test Suite: a test suite for a product purchase process:
Test Case 1: Login
Test Case 2: Adding Products
Test Case 3: Checkout
Test Case 4: Logout
4.) Test-Driven Development (TDD) in JavaScript is a software development approach where you write a failing test before writing the actual code to make it pass. This cycle of "red-green-refactor" (failed test, passing test, code improvement) helps developers:
Catch errors early: Bugs are identified as soon as the code is written, making them easier to fix.
Focus on functionality: Each test defines a specific requirement, keeping the code focused and concise.
Improve design: TDD promotes modular, loosely coupled code, making it easier to maintain and extend.
Increase confidence: A comprehensive test suite provides confidence in the code's correctness and stability.
Document code: Tests act as living documentation, showing how the code is intended to be used.

5.) Jest, Mocha, Supertest, Jasmine, Cypress.
Jest is currently one of the most popular testing frameworks since it works for both frontend and backend tests. It was initially developed for writing tests for React but now it can work not only with Node but also Babel, TypeScript, React, Angular and Vue! Using Jest, it is very quick and easy to setup unit tests. Cypress is an amazing testing framework that helps perform end-to-end testing on a frontend.

Lethukuthula Mkhonto
Simphiwe Ndlovu
Sinethemba Zulu

1. unit testing in Javascript development involves writing tests for units or components to ensure they work properly. example code :
   const request = require("supertest");
   const expect = require("chai").expect;

const app = require("../index");

const blogPosts = [
{
title: "Blog 1",
content: "Lorem ipsum dolor sit amet",
tags: ["coding", "design", "engineering"],
author: {
name: "Ali",
age: 23,
gender: "Male",
nationality: "Iraqi",
areasOfExpertise: ["engineering"],
},
},
{
title: "Design Blog 1",
content: "Lorem ipsum dolor sit amet",
tags: ["design"],
author: {
name: "Huda",
age: 25,
gender: "Female",
nationality: "Iraqi",
areasOfExpertise: ["engineering"],
},
},
let blogPostId;

describe("Creating blog posts", () => {
it("POST /api/blogposts should create a new blog post and return it in the response", (done) => {
request(app)
.post("/api/blogposts")
.set("Content-Type", "application/json")
.send(blogPosts[0])
.expect("Content-Type", /json/)
.expect(201, (err, res) => {
if (err) return done(err);
expect(res.body.title).to.equal(blogPosts[0].title);
expect(res.body.content).to.equal(blogPosts[0].content);
expect(res.body.tags).to.deep.equal(blogPosts[0].tags);
expect(res.body.author.name).to.equal(blogPosts[0].author.name);
expect(res.body.author.age).to.equal(blogPosts[0].author.age);
expect(res.body.author.gender).to.equal(blogPosts[0].author.gender);
expect(res.body.author.nationality).to.equal(
blogPosts[0].author.nationality
);
expect(res.body.author.areasOfExpertise).to.deep.equal(
blogPosts[0].author.areasOfExpertise
);
blogPostId = res.body._id;
done();
});
});
the code mentioned above is from a previous assignment, written by Recoded. so the units can be functions, methods, classes or modules.

Contribution to Overall Software Quality
Reliability: By ensuring individual components function correctly, the overall reliability of the application increases.

Maintainability: Well-tested code is easier to maintain and modify, as tests provide immediate feedback on the impact of changes.

Bug Reduction: Early bug detection reduces the number of defects in the final product.

Confidence in Code Changes: Developers can make changes with confidence, knowing that the tests will catch any unintended consequences.

Regression Prevention: Automated tests prevent old bugs from reappearing, as any changes that reintroduce bugs will cause tests to fail.

2. Difference Between Manual and Automated Testing:

Manual Testing: Humans execute test cases.
Automated Testing: Tools or scripts execute test cases.

. Advantages of Automated Testing in JavaScript Projects:
speed: Tests run faster.
Consistency: No human errors.
Reusability: Scripts can be reused.
Efficiency: Great for large projects and frequent changes.

3. In JavaScript testing, a test suite is a group of tests that check if a specific part of an application works as it should. Each test in the group called a test case, looks at different conditions or situations to see if the code behaves correctly. The test suite helps organize these tests and runs them in an orderly way. This makes it easier to make sure everything works properly.

example:

// function to be tested
function add(a, b) {
return a + b;
}

const add = require('./add');

// Test suite for the add function
describe('add function', () => {

// Test case: Adding two positive numbers
test('should add two positive numbers correctly', () => {
expect(add(1, 2)).toBe(3);
});

there can be a lot of test cases but to save time my team and I we have shown one to depict the idea of test cases and test suites.

4. Test-driven development (TDD) in JavaScript involves writing tests first and then writing code to pass those tests. The process includes three main steps: writing a test, writing code to make the test pass, and then refactoring the code. This approach keeps developers focused on requirements, catches bugs early, and makes it safe to improve the code later. As a result, TDD leads to robust and reliable code, with the tests acting as documentation and significantly reducing bugs in the long run.

5. 5. Jest, Mocha, Jasmine, Karma, Chai, Sinon

Jest

Key Features:
Built-in Assertions: Jest comes with built-in assertion libraries, so you don’t need to install any additional packages for assertions.
Test Runner: Jest provides a powerful test runner that can run tests in parallel, which speeds up the testing process.
Mocking: Jest includes built-in mocking capabilities for functions, modules, and timers.
Snapshot Testing: Jest supports snapshot testing, which is useful for testing the UI components by comparing the output to a saved snapshot.
Code Coverage: Jest has built-in support for generating code coverage reports.
Zero Configuration: Jest is designed to work out of the box without any configuration, making it easy to set up and use.

Use Cases:
Ideal for projects using React, as it integrates well with React’s testing utilities.
Suitable for projects where a zero-configuration setup is preferred.
Good for large projects that can benefit from parallel test execution and built-in code coverage.

Mocha

Key Features:
Flexibility: Mocha is a highly flexible framework that can be configured to suit various testing needs. It doesn’t include assertion libraries or mocking frameworks, allowing developers to choose their preferred tools (e.g., Chai for assertions, Sinon for mocks).
Asynchronous Testing: Mocha has strong support for asynchronous testing, making it a good choice for testing applications with asynchronous operations.
Extensible: Mocha’s flexible plugin system allows for extensive customization and integration with other tools and libraries.
BDD/TDD Interface: Mocha supports both Behavior-Driven Development (BDD) and Test-Driven Development (TDD) styles, offering a variety of interfaces (describe, it, before, after) for structuring tests.

Use Cases:
It is ideal for backend testing, especially for Node.js applications, due to its flexibility and extensive configuration options.
Suitable for projects where developers want to have full control over the testing setup and use specific assertion and mocking libraries.
Good for projects that require complex testing setups or need to integrate with other tools and plugins.

Thabiso Mokolana
Lindokuhle Skosana
Pumlani Kewana

Unit testing is a type of software testing used to test the smallest parts of a software application, that is, its units. In JavaScript, these units can often be functions, methods, or modules. Unit tests are used to verify whether the units work in accordance with the expected inputs and outputs. unit testing plays a vital role in enhancing the overall quality of a software application by ensuring reliability, preventing regressions, improving code design, supporting continuous integration /continuous deployment practices, and ultimately leading to a better user experience. The main goal of unit testing is to ensure that each unit of the software performs as intended and meets requirements.

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.

- Advantages:

• Efficiency: Automated tests can run quickly and frequently, improving the speed of the development cycle.
• Consistency: Automated tests provide consistent results, reducing the risk of human error.
• Reusability: Test scripts can be reused across different versions of the application.
• Scalability: Automated testing scales well for large projects and extensive test suites.

Test suites are the logical grouping or collection of test cases to run a single job with different test scenarios. A test suite also acts as a container for test cases. It also has multiple stages for specifying the status of the test execution process, like in-progress, active, and completed. It is also known as the validations suite, with detailed information and objectives for different test cases and system configurations required for testing.

It's a development approach where tests are written before the actual code is written, Writing tests first forces developers to think through the desired behavior before implementation it also encourages writing small, focused functions that are easier to test and maintain.

Jest vs. Mocha, Jest has zero-config setup for most JavaScript projects while Mocha Requires more initial setup.

@ImisebenziEmihle @katmafalela @Yenkosii

1. Purpose of unit testing:
   Unit testing is testing each function/method induvudually to ensure code quality. The purpose is to ensure that the block of code being tested runs as expected, according to the developer's logic. It can also interact with block of code via inputs an captured asserted output.

• Contribution to overall quality of software application:
  If there are any input, output, or logic-based errors within a code block, your unit tests help you catch them before the bugs reach production.
  Unit testing also helps finds bugs faster in code. Your developers don’t spend a large amount of time on debugging activities. They can quickly pinpoint the exact part of the code that has an error.

2. Manual testing involves humans testing and interacting with a software application or product to identify issues, whereas automated testing utilizes computer programs, applications, or scripts to write and execute predefined tests programmatically.

The benefits of using automated testing in JavaScript are:

• Efficiency: Tests run faster than manual testing.
• Reusability: Test scripts can be reused in multiple projects.
• Consistency: Reduces human error, ensuring reliable results.
• Coverage: Enables comprehensive testing, including edge cases.
• Immediate Feedback: Quickly identifies and resolves issues in the development process.

3. In JavaScript testing, a test suite is a collection of related test cases that verify the functionality of a specific module or component within the application. It acts as an organizer for your tests, grouping them logically based on the feature or functionality they target.

Here's how they relate:
Test Case: An individual test that focuses on a single aspect of the code's behavior. It defines the input, expected output, and asserts whether the actual output matches the expectation.
Test Suite: A collection of these test cases that together cover the functionality of a specific module or component. Think of it as a container for related test cases.

Example :

You have a function called greet(name) that takes a name as input and returns a greeting message.

describe('Greeter Function', () => { it('should greet with "Hello" for any name', () => { const name = 'Alice'; // Or any name const expectedGreeting = 'Hello, ' + name; // Construct expected output const actualGreeting = greet(name); expect(actualGreeting).toBe(expectedGreeting); }); // Add another test case here, for example, handling empty names it('should handle empty names', () => { const name = ''; const expectedGreeting = 'Hello, '; // Greet with just a comma for empty name const actualGreeting = greet(name); expect(actualGreeting).toBe(expectedGreeting); }); });

4. Test-Driven Development (TDD) in JavaScript flips the traditional coding workflow on its head. Instead of writing code first and then testing it, TDD emphasizes writing tests before you write the actual code.
   Here's a breakdown of the TDD cycle:
   Red: This is the starting point where you identify a new feature or functionality to be implemented. You begin by writing a failing test case. This test outlines the expected behavior of the code but will initially fail because the code to fulfill that behavior hasn't been written yet.

Green: Now comes the coding part. Your goal is to write the minimum amount of code necessary to make the failing test pass. This ensures the code is focused on achieving the desired functionality defined in the test.

Refactor: Once the test passes, it's time to clean up and improve your code. This stage involves refactoring your code to enhance its readability, maintainability, and overall quality without affecting the passing test. You can use techniques like removing redundancy, improving variable names, or restructuring logic for better clarity.

Benefits of TDD in JavaScript Development
TDD has a profound impact on how you write JavaScript code and the overall quality of your application:
Improved Design: By focusing on writing tests first, you're forced to think about the desired functionality before writing code. This leads to a clearer understanding of what the code needs to achieve and often results in better design choices.
Enhanced Confidence: With each passing test, your confidence in the code's correctness grows. You know that the code fulfills the specific behavior outlined in the test.
Early Bug Detection: Since tests are written upfront, bugs are caught during the development process, often before they become major issues. This makes debugging faster and easier.
Comprehensive Test Coverage: TDD encourages writing test cases for various scenarios, leading to more comprehensive test coverage compared to traditional approaches.
Robust and Reliable Code: The continual cycle of writing tests, implementing code, and refactoring leads to cleaner, more maintainable, and reliable code in the long run.

Example:
Imagine you're building a shopping cart functionality. Here's how TDD might influence the development:

Red: You write a test case that expects the addToCart function to add an item with a specific quantity to the cart and update the total price accordingly. Initially, this test will fail because the function hasn't been written yet.
Green: You write the addToCart function with basic logic to add the item and update the price, making the test pass.
Refactor: You can now improve the code by adding error handling for invalid quantities or checking for item availability before adding to the cart.

5. Some of the popular testing frameworks are:

MochaJS- has been one of the most popular JavaScript testing frameworks since 2011. It operates on Node.js and provides front-end and back-end asynchronous testing compatibility.

Benefits:
Provides compatibility for both front-end and back-end testing
NodeJS debugger is supported, which makes error tracing easier
Accurate reporting
Provides support for all browsers, including the headless Chrome library
Very convenient framework for the developers to write test cases

When to use:
Unit testing
Integration testing
End to end testing

Jasmine- Introduced in 2010, Jasmine is an open-source JavaScript testing framework that is capable of testing all types of JavaScript applications. This framework supports Behavioral Driven Development (BDD).

Benefits:
Provides small, clean, and straightforward syntax for easy testing
Does not require any Document Object Model (DOM)
Includes support for both front-end and back-end tests
Ease in coding as the syntax used is very similar to a natural language
Strong documentation and community support

When to use:
BDD Framework for Unit Testing

Team Members ( Phamela, Bonolo, Nonhlanhla).

Answers.

1. Unit testing in JavaScript development is like checking individual parts of a machine to ensure each one works correctly on its own. By writing tests for small, specific pieces of code (like functions or methods), we can catch errors early and make sure each part behaves as expected.

Purpose of Unit Testing:
Validation: Ensures each piece of code works correctly.
Isolation: Tests small parts independently, avoiding interference from other code.
Regression Prevention: Helps detect if new changes break existing functionality.
Documentation: Provides a clear description of what the code is supposed to do.
Contribution to Software Quality:
Reliability: Increases confidence that the code works as intended.
Maintainability: Makes it easier to change and refactor code without fear of breaking things.
Bug Detection: Finds and fixes bugs early in the development process.
Code Quality: Encourages writing cleaner, more modular code.

2. Automated testing
   uses software tools and scripts to conduct pre-written test cases which require little human intervention and can be repeated,

Manual testing
involves human testers carrying out test cases and following a set of standard procedures to ensure that the software acts as intended.

Advantages of using automated testing include but are not limited to: greatly improving the development process, improving the quality of the code, and the assurance of a more dependable and robust application.

3. A test suite is a compilation of test cases designed to evaluate certain features or parts of a software program. A test suite in JavaScript testing usually consists of several test cases that validate the behaviour of a certain module, function, or feature.

//JS function
function calculateCalories(AHR, duration, steps) {
return ((AHR * duration) / 100) + (steps / 20);
}

module.exports = calculateCalories;

//calculateCalories.test.js
// Import JS function
const calculateCalories = require('./calculateCalories');

// Define the test suite
describe('calculateCalories function', () => {

// Test case 1: Check if the function calculates calories correctly for given inputs
test('should calculate calories
correctly for AHR = 120, duration = 30, steps = 2000', () => {
const AHR = 120;
const duration = 30;
const steps = 2000;
const result = calculateCalories(AHR, duration, steps);
expect(result).toBe(42); // ((120 * 30) / 100) + (2000 / 20) = 36 + 100 = 42
});

4. Test-driven development is a coding practice where programmers write the expected result of the program before creating the program. The process of test-driven development involves writing the test code, running the test so it fails, write the code for the program that will pass the test and lastly write the code in a clean and efficient manner. The test code should be short, and it should be based on a single behavior of a function. Tests When writing a test you should put the input and test against an output. Tests should clearly describe the behavior they are verifying, making them easy to understand.
   Influence of TDD:
   TDD often leads to more modular and loosely coupled code, as developers focus on writing code that is easy to test.
   It encourages small, manageable chunks of functionality that are easier to understand and maintain. Tests serve as documentation for the code. They provide examples of how the code is expected to behave, making it easier for new developers to understand the codebase. Although writing tests initially adds time, it can speed up the overall development process by catching bugs early and reducing time spent on debugging.

5. Jest:
   Can be used for both front-end and back-end testing. It provides a complete testing solution with built-in support for mocking, assertions, and code coverage, so we don't need to install additional libraries for basic testing needs. Jest also allows you to easily test the output of React components and other serializable data Jest has a powerful watch mode that only runs tests related to changed files, making it very efficient for development. Jest runs tests in parallel by default, which can lead to faster test execution times, especially for large codebases. For very simple or small projects, Jest might feel a bit overkill due to its comprehensive feature set (direct message)