Introduction:

Role:

Goals:

• Train the team in fundamental Postman operations, including creating requests, managing collections, and using environment variables effectively.
• Build confidence in using Postman as a central tool for API testing

• Implement automation scripts within Postman collections using JavaScript for response validation, data-driven testing, and workflow automation.
• Follow structured approaches for writing reusable and maintainable tests

• Design and execute test cases using projects like the "Artisan Coffee House API", a sample API Despa uses to teach realistic automation scenarios.
• Create scenarios to test API endpoints for functionality, reliability, and error handling

• Share collections and environments within the team for consistent testing and review.
• Use Postman’s collaboration features to streamline feedback and iteration during the development and testing lifecycle

• Learn to execute Postman tests through GitHub Action in CI/CD pipelines to enable continuous validation.
• Automate regression test suites and integrate test reports with tools like GitHub Action

• Encourage team members to complete Valentin Despa’s API Test Automation courses to build comprehensive skills.
• Use Postman’s certification as a milestone for team development and benchmarking

• Test for functional correctness, edge cases, performance, and security to achieve comprehensive coverage.
• Leverage data-driven testing techniques taught by Despa to simulate multiple real-world use cases

• Create internal documentation and tutorials, similar to Despa's educational style, to ensure the team’s continuous learning.
• Organize workshops or knowledge-sharing sessions to instill best practices

Attachment :

• Youtube Tutorials: Postman API Test Automation for Beginners
• Course Notes: Postman Course Notes
• Postman Collection Workspaces: Fahmi's API Test Automation

Introduction:

Role:

Goals:

• Build an API Endpoint: Create a robust API that accepts user input for metric and imperial measurements and returns accurate conversions.
• Implement Conversion Logic: Develop precise conversion algorithms for units such as length, weight, and volume.
• Validate User Input: Ensure the API handles invalid or missing inputs gracefully with appropriate error messages.

• Write Unit Tests: Use Mocha and Chai to test individual functions for conversion accuracy and input validation.
• Perform Functional Testing: Utilize Chai-HTTP to test complete API workflows, including successful conversions and error handling.
• Ensure Code Reliability: Identify edge cases and write comprehensive tests to ensure consistent performance and accuracy.
• Maintain Test Coverage: Strive for high test coverage to catch potential bugs and ensure all code paths are tested.

Attachment :

• Project workspace: Metric-Imperial Converter on freeCodeCamp
• GitHub Repository: Metric-Imperial Converter Repository

Introduction:

Role:

Goals:

• Build a RESTful API: Create endpoints to handle CRUD operations for managing issues, including creating, updating, viewing, and deleting issues.
• Design a Database Schema: Structure a database to store and manage issue data effectively, including fields like title, description, status, and assigned project.
• Implement Input Validation: Ensure all user inputs are validated, handling missing or invalid data gracefully.

• Write Functional Tests: Use Chai-HTTP to write comprehensive tests for all API endpoints, ensuring they work as expected.
• Test Edge Cases: Validate how the API handles various edge cases, such as invalid inputs, empty requests, or attempting to update non-existent issues.
• Ensure API Reliability: Verify that all endpoints handle errors gracefully and respond with the correct status codes and messages.
• Maintain Test Coverage: Aim for high test coverage to ensure all critical functionalities are tested and bugs are minimized.

Attachment :

• Project workspace: Issue Tracker on freeCodeCamp
• GitHub Repository: Issue Tracker Repository

Introduction:

Role:

Goals:

• Build a RESTful API: Create endpoints to handle CRUD operations for managing books, including adding, viewing, updating, and deleting book entries.
• Design a Database Schema: Structure a database to store book information, such as titles, authors, and associated comments.
• Handle Comments for Books: Implement functionality to allow users to add and retrieve comments for specific books.
• Implement Input Validation: Ensure user inputs are validated, handling errors and missing data appropriately.

• Write Functional Tests: Use Chai-HTTP to write and run functional tests for all API endpoints, verifying correct responses and behaviors.
• Test Edge Cases: Validate how the API handles invalid inputs, empty requests, and attempts to manipulate non-existent records.
• Ensure API Reliability: Confirm all endpoints respond with appropriate status codes and error messages in various scenarios.
• Maintain Comprehensive Test Coverage: Cover all critical functionalities to minimize bugs and ensure the API performs as expected.

Attachment :

• Project workspace: Personal Library on freeCodeCamp
• GitHub Repository: Personal Library Repository

Introduction:

Role:

Goals:

• Build Core Functionality: Implement algorithms to validate Sudoku puzzles, check puzzle completion, and generate solutions.
• Create API Endpoints: Develop endpoints to handle puzzle submissions, validate inputs, and return solutions.
• Handle Edge Cases: Ensure the solver works for various scenarios, including incomplete puzzles, invalid inputs, and unsolvable configurations.

• Write Unit Tests: Use Chai to test individual functions, such as validation logic and solution generation, ensuring they work correctly.
• Perform Functional Testing: Use Chai-HTTP to test the API endpoints, verifying the responses for valid and invalid requests.
• Test Edge Cases: Validate how the API handles incomplete, incorrect, or unsolvable puzzles, ensuring appropriate error handling and messages.
• Maintain High Test Coverage: Write comprehensive tests to cover all critical functionalities, minimizing bugs and ensuring reliability.

Attachment :

• Project workspace: Sudoku Solver on freeCodeCamp
• GitHub Repository: Sudoku Solver Repository

Introduction:

Role:

Goals:

• Develop Translation Logic: Implement algorithms to accurately translate text between American and British English, considering spelling, idioms, and phrasing.
• Create API Endpoints: Build endpoints to accept text input, specify the translation direction, and return the translated text.
• Handle Input Validation: Ensure the API properly handles invalid, empty, or missing text inputs with appropriate error responses.

• Write Unit Tests: Use Chai to test the translation logic, ensuring the correct conversion of words, phrases, and idioms.
• Perform Functional Testing: Use Chai-HTTP to test API endpoints, verifying the service responds correctly to valid and invalid requests.
• Test Edge Cases: Validate the behavior of the translator with special cases, such as texts with mixed languages, unusual formatting, or ambiguous phrases.
• Maintain Comprehensive Test Coverage: Ensure all critical translation rules and API functionalities are covered to guarantee accuracy and reliability.

Attachment :

• Project workspace: American British Translator on freeCodeCamp
• GitHub Repository: American British Translator Repository

Introduction:

Role:

Goals:

• Develop CRUD Functionality: Implement Create, Read, Update, and Delete operations for managing data in a MongoDB database using Node.js and Express.js.
• Build a RESTful API: Design a RESTful API with organized routes and controllers, following best practices for a clean and maintainable structure.
• Connect to MongoDB: Set up a MongoDB database, configure connections, and handle data storage and retrieval effectively.
• Test API Endpoints: Use Postman, Insomnia, and Thunder Client to test each endpoint, ensuring that all routes work as expected and return appropriate responses.
• Error Handling and Validation: Add error handling and input validation to improve app reliability and prevent invalid data entries.
• Strengthen Backend Skills: Gain hands-on experience with backend development, database interactions, and API testing tools.

Attachment :

• GitHub Repository: Simple CRUD Apps Repository

Introduction:

Role:

Goals:

• Build an API Endpoint: Create an API that accepts date input and responds with timestamp data in both Unix and UTC formats.
• Parse and Validate Dates: Implement logic to handle various date formats, parse them correctly, and validate user input.
• Handle Edge Cases: Ensure the microservice can handle invalid dates, returning appropriate error messages when necessary.
• Convert Timestamps: Provide accurate conversions between Unix timestamps and UTC date formats based on user input.
• Deploy the Microservice: Host the microservice on a platform like Heroku, making it accessible online for users to test and interact with.
• Strengthen API and Backend Skills: Gain hands-on experience building a backend service, parsing data, and handling HTTP requests

Attachment :

• Project workspace: Timestamp Microservice on freeCodeCamp
• GitHub Repository: Timestamp Microservice Repository

Introduction:

Role:

Goals:

• Build an API Endpoint: Create an API that responds to HTTP requests by parsing and returning key header information.
• Extract User Information: Retrieve details from the request headers, including the user's IP address, language, and operating system.
• Handle HTTP Requests: Gain experience in handling and responding to HTTP requests within a microservice environment.
• Format Data for API Response: Organize the extracted header information into a structured, JSON-formatted response.
• Deploy the Microservice: Host the microservice on a platform like Heroku to make it accessible to users for testing and feedback.
• Enhance Backend Development Skills: Strengthen skills in backend development, working with HTTP headers, and building API endpoints.

Attachment :

• Project workspace: Request Header Parser Microservice on freeCodeCamp
• GitHub Repository: Request Header Parser Microservice Repository

Introduction:

Role:

Goals:

• Build an API Endpoint: Create an API that receives a long URL as input and returns a shortened version for easier sharing.
• Generate Short URLs: Implement logic to convert long URLs into unique, shortened versions using identifiers.
• Store URLs in a Database: Save both original and shortened URLs in a database for future lookups.
• Redirect to Original URL: Set up the API to redirect users from the shortened URL back to the original URL when accessed.
• Handle Input Validation: Ensure valid URL input from users, returning helpful error messages for invalid or unsupported URLs.
• Deploy the Microservice: Host the microservice on a platform like Heroku, making it accessible for users to test and use.
• Strengthen Backend Skills: Enhance understanding of URL encoding, database interaction, and HTTP redirects in a backend application.

Attachment :

• Project workspace: URL Shortener Microservice on freeCodeCamp
• GitHub Repository: URL Shortener Microservice Repository

Introduction:

Role:

Goals:

• Build an API to Track Exercises: Create an API that allows users to log exercises with details like description, duration, and date.
• Set Up User Profiles: Enable users to create profiles that store their exercise logs and associated data.
• Implement CRUD Operations: Develop endpoints to create, read, update, and delete exercise logs for each user.
• Filter and Display Exercise Logs: Allow users to retrieve their exercise logs, with optional filtering by date range and limiting results.
• Store Data in a Database: Use a database to store user profiles and exercise data securely for easy retrieval.
• Deploy the Application: Host the application on a platform like Heroku, making it accessible for users to log and track their workouts.
• Enhance API and Backend Skills: Practice building RESTful APIs, managing user input, and creating data-driven applications in a backend environment.

Attachment :

• Project workspace: Exercise Tracker on freeCodeCamp
• GitHub Repository: Exercise Tracker Repository

Introduction:

Role:

Goals:

• Build an API Endpoint for File Uploads: Create an endpoint that allows users to upload files for metadata analysis.
• Extract File Metadata: Implement functionality to retrieve key file information, such as file name, size, and type.
• Return Metadata as JSON: Format and return the extracted metadata in a structured JSON response to the user.
• Handle File Validation: Ensure the service can handle various file types and sizes, providing appropriate error messages for unsupported files.
• Deploy the Microservice: Host the microservice on a platform like Heroku, making it accessible for users to test file uploads and metadata retrieval.
• Strengthen Backend Development Skills: Gain practical experience in handling file uploads, extracting metadata, and building data-driven microservices.

Attachment :

• Project workspace: File Metadata Microservice on freeCodeCamp
• GitHub Repository: File Metadata Microservice Repository

Introduction:

Role:

Goals:

• Implement Game Logic: Create the core functionality of a number guessing game where the player guesses a randomly generated number within a range.
• Track User Input: Capture and validate user guesses, providing feedback on whether the guess is too high, too low, or correct.
• Manage Game Flow: Set up game loops to continue until the player guesses correctly, and track the number of attempts made.
• Provide User Feedback: Display helpful messages to the player, such as indicating the number of guesses left or congratulating them for guessing correctly.
• Enhance User Interface: Build a simple, user-friendly interface to interact with the game, displaying information and handling input.
• Practice Core Programming Skills: Strengthen JavaScript programming skills, including logic, loops, conditionals, and handling user input.

Attachment :

• Project workspace: Build a Number Guessing Game on freeCodeCamp
• GitHub Repository: Number Guessing Game Repository

Introduction:

Role:

Goals:

• Design a Database Schema: Create tables to store information about chemical elements, such as their names, symbols, atomic numbers, and properties.
• Establish Relationships: Set up relationships between tables, for example, linking elements to their respective groups or periods on the periodic table.
• Perform CRUD Operations: Implement SQL queries to create, read, update, and delete element data in the database.
• Write Queries for Element Information: Develop SQL queries to retrieve details about elements, such as their atomic mass, type, or placement on the periodic table.
• Normalize the Database: Ensure the database is normalized to avoid data redundancy and maintain data integrity.
• Enhance SQL and Database Skills: Improve skills in structuring, querying, and managing relational databases with scientific data.

Attachment :

• Project workspace: Build a Periodic Table Database on freeCodeCamp
• GitHub Repository: Periodic Table Repository

Introduction:

Role:

Goals:

• Design a Database Schema: Create tables to store data about clients, appointments, and salon staff.
• Establish Relationships: Link tables to associate clients with their appointments and staff with scheduled services.
• Implement CRUD Operations: Use SQL to create, read, update, and delete appointment records.
• Write Queries for Scheduling: Write SQL queries to manage and view upcoming appointments, staff availability, and client schedules.
• Create a User-Friendly Interface: Build a simple interface for salon staff to manage bookings and clients to check availability.
• Enhance SQL and Backend Skills: Practice backend development by working with databases and handling real-world scheduling data.

Attachment :

• Project workspace: Build a Salon Appointment Scheduler on freeCodeCamp
• GitHub Repository: Salon Appointment Scheduler Repository

Introduction:

Role:

Goals:

• Design a Database Schema: Create tables to store data about World Cup teams, players, matches, and results.
• Establish Relationships: Link tables together, such as associating players with teams and matches with their outcomes.
• Perform CRUD Operations: Implement SQL queries to create, read, update, and delete World Cup data.
• Write Complex Queries: Develop SQL queries to retrieve specific information, such as top goal scorers, match results, or team performance.
• Normalize the Database: Organize data efficiently by normalizing the database to reduce redundancy and ensure data consistency.
• Enhance SQL and Database Skills: Strengthen our ability to design and query relational databases, focusing on real-world sports data.

Attachment :

• Project workspace: Build a World Cup Database on freeCodeCamp
• GitHub Repository: World Cup Database Repository

Introduction:

Role:

Goals:

• Design a Database Schema: Create tables to store information about celestial bodies, including planets, moons, stars, and galaxies.
• Establish Relationships: Set up relationships between tables, such as linking moons to their respective planets.
• Perform CRUD Operations: Implement and practice basic SQL operations (Create, Read, Update, Delete) to manage celestial body data.
• Write Complex Queries: Write SQL queries to retrieve specific information, such as finding planets with the most moons or galaxies within a certain distance.
• Normalize the Database: Organize data efficiently by ensuring the database is normalized to reduce redundancy and improve data integrity.
• Enhance SQL Skills: Strengthen our ability to design and query relational databases through practical, hands-on experience.

Attachment :

• Project workspace: Build a Celestial Bodies Database on freeCodeCamp
• GitHub Repository: Celestial Bodies Repository

Introduction:

Role:

Goals:

Test Point for STS Token Translator:

• Send STS Class 1 Token to smart meter
• Retrieve and decrypt bit-string data form meter after token accepted

Introduction:

Role:

Goals:

• Automation Testing
• Structured and Informative Report

Test Point for Automated Script Test:

• Read multiple object value
• Write multiple object value
• Invoke method
• Validate objects value modification

Introduction:

Role:

Goals:

Test Point for Access Right Test:

• Retrieved and parse all DLMS objects from Current Association class
• Performing test based on object Access Right (Read/Write) on Current Association

Introduction:

Role:

Goals:

Test Point for Meter Program Download Mode:

• Enter/Exit Download Mode
• Reading Active/Passive Meter Program
• Insert/Delete Passive Meter Program
• Activating Passive Meter Program
• Reserving Activation of Passive Meter Program