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.

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)