Test-driven development (TDD) is a software development process where test cases are written before code to validate requirements. The TDD process involves short cycles of adding a test, making it fail, making it pass, and refactoring code. Using TDD generates an automated test suite that gives developers confidence to refactor and change code quickly. Unit tests validate individual code units in isolation while feature tests validate code as a user would interact with it. Code coverage metrics help ensure tests cover enough of the codebase.
Getting Started with Test-Driven Development at Longhorn PHP 2023Scott Keck-Warren
Test-driven development (TDD) is a software development process where test cases are written before code to validate requirements. The TDD process involves short cycles of adding a test, making the test fail, writing code to pass the test, and refactoring code. Automated tests provide confidence to refactor and change code without breaking functionality. Unit tests isolate and test individual code units while feature tests simulate how a user interacts with the application. Code coverage metrics help ensure tests cover enough of the codebase, with higher coverage percentages generally indicating better test quality.
Getting Started with Test-Driven Development at PHPtek 2023Scott Keck-Warren
Scott Keck-Warren gives a presentation on getting started with test-driven development (TDD). He discusses what TDD is, the five phases of the TDD process, and why it is beneficial. He also covers how to use a testing framework like PHPUnit, what code coverage is, and some common pitfalls to avoid like neglecting to run tests or creating tests that are too large or trivial. The presentation aims to provide developers with the essential information needed to understand and implement TDD.
Automated Developer Testing: Achievements and ChallengesTao Xie
Automated Developer Testing: Achievements and Challenges discusses automation in developer testing, including challenges such as generating better test inputs and oracles faster. Parameterized unit testing is proposed as a way to specify tests at a higher level of abstraction and allow test generation tools to automatically generate test inputs. Dynamic symbolic execution, as implemented in tools like Pex, is presented as an approach to automatically generating test inputs to achieve high code coverage by modeling tests as constraints and solving them.
The document outlines an upcoming programming workshop that will cover various JetBrains IDEs like PyCharm, IntelliJ IDEA, and PhpStorm. It then discusses Test Driven Development (TDD), including what TDD is, the development cycle used in TDD, and benefits like encouraging simple designs and confidence. Different types of software tests are also listed like unit tests, integration tests, acceptance tests, and others. Specific testing techniques like unit testing, integration testing using bottom-up and top-down approaches, and acceptance testing are then explained at a high level. Finally, some important notes on testing like trusting tests and prioritizing maintainability are provided.
How do you tame a big ball of mud? One test at a time.Matt Eland
A broad and high level overview of .NET unit test libraries that will help you write better tests. Discussions around Scientist .NET, Bogus, AutoFixture, Snapper, and others.
The document discusses various topics related to software testing including:
1. It introduces different levels of testing in the software development lifecycle like component testing, integration testing, system testing and acceptance testing.
2. It discusses the importance of early test design and planning and its benefits like reducing costs and improving quality.
3. It provides examples of how not planning tests properly can increase costs due to bugs found late in the process, and outlines the typical costs involved in fixing bugs at different stages.
During the specification phase of testing, required tests and starting points are specified to prepare for quickly executing tests when developers deliver the test object. The execution phase then obtains insight into quality through agreed upon tests. Different types of testing include acceptance, unit, functional, exploratory, and performance/load testing which validate both business needs and implementation and help both the product and team.
The document discusses several automated testing tools:
- PHPUnit is a unit testing framework for PHP that allows writing and running automated tests. It helps ensure code quality and finds regressions.
- Selenium is a suite of tools for automating web application testing across browsers and platforms. It includes the Selenium IDE, RC, and Grid.
- Phing is a build system based on Apache Ant for PHP projects. It uses XML build files and PHP tasks to provide an extensible and flexible build framework.
Getting Started with Test-Driven Development at Longhorn PHP 2023Scott Keck-Warren
Test-driven development (TDD) is a software development process where test cases are written before code to validate requirements. The TDD process involves short cycles of adding a test, making the test fail, writing code to pass the test, and refactoring code. Automated tests provide confidence to refactor and change code without breaking functionality. Unit tests isolate and test individual code units while feature tests simulate how a user interacts with the application. Code coverage metrics help ensure tests cover enough of the codebase, with higher coverage percentages generally indicating better test quality.
Getting Started with Test-Driven Development at PHPtek 2023Scott Keck-Warren
Scott Keck-Warren gives a presentation on getting started with test-driven development (TDD). He discusses what TDD is, the five phases of the TDD process, and why it is beneficial. He also covers how to use a testing framework like PHPUnit, what code coverage is, and some common pitfalls to avoid like neglecting to run tests or creating tests that are too large or trivial. The presentation aims to provide developers with the essential information needed to understand and implement TDD.
Automated Developer Testing: Achievements and ChallengesTao Xie
Automated Developer Testing: Achievements and Challenges discusses automation in developer testing, including challenges such as generating better test inputs and oracles faster. Parameterized unit testing is proposed as a way to specify tests at a higher level of abstraction and allow test generation tools to automatically generate test inputs. Dynamic symbolic execution, as implemented in tools like Pex, is presented as an approach to automatically generating test inputs to achieve high code coverage by modeling tests as constraints and solving them.
The document outlines an upcoming programming workshop that will cover various JetBrains IDEs like PyCharm, IntelliJ IDEA, and PhpStorm. It then discusses Test Driven Development (TDD), including what TDD is, the development cycle used in TDD, and benefits like encouraging simple designs and confidence. Different types of software tests are also listed like unit tests, integration tests, acceptance tests, and others. Specific testing techniques like unit testing, integration testing using bottom-up and top-down approaches, and acceptance testing are then explained at a high level. Finally, some important notes on testing like trusting tests and prioritizing maintainability are provided.
How do you tame a big ball of mud? One test at a time.Matt Eland
A broad and high level overview of .NET unit test libraries that will help you write better tests. Discussions around Scientist .NET, Bogus, AutoFixture, Snapper, and others.
The document discusses various topics related to software testing including:
1. It introduces different levels of testing in the software development lifecycle like component testing, integration testing, system testing and acceptance testing.
2. It discusses the importance of early test design and planning and its benefits like reducing costs and improving quality.
3. It provides examples of how not planning tests properly can increase costs due to bugs found late in the process, and outlines the typical costs involved in fixing bugs at different stages.
During the specification phase of testing, required tests and starting points are specified to prepare for quickly executing tests when developers deliver the test object. The execution phase then obtains insight into quality through agreed upon tests. Different types of testing include acceptance, unit, functional, exploratory, and performance/load testing which validate both business needs and implementation and help both the product and team.
The document discusses several automated testing tools:
- PHPUnit is a unit testing framework for PHP that allows writing and running automated tests. It helps ensure code quality and finds regressions.
- Selenium is a suite of tools for automating web application testing across browsers and platforms. It includes the Selenium IDE, RC, and Grid.
- Phing is a build system based on Apache Ant for PHP projects. It uses XML build files and PHP tasks to provide an extensible and flexible build framework.
This was a workshop given on the UTN University, for the Software Engineering students. The idea is to give a brief explanation about TDD, and how to use it.
The QA professional is certainly needed within a company. However, in many cases, unfortunately, there are companies that don’t adhere to this professional culture. Increasing the code quality becomes a major challenge for development teams in these cases. This presentation aims to give tips learned from mistakes of this attempt to try to improve the code quality and test execution time for a quick feedback.
May: Automated Developer Testing: Achievements and ChallengesTriTAUG
Developer testing, a common step in software development, involves generating sufficient test inputs and checking the behavior of the program under test during the execution of the test inputs. Complicated logics inside a method make generating appropriate arguments difficult. In testing object-oriented programs, generating method sequences to put the receiver object or argument objects into appropriate states further complicates test-input generation. After the generated test inputs are executed, program crashes or uncaught exceptions can be used to indicate program problems, especially robustness problems. However, some program problems such as producing wrong program outputs do not crash the program.
In this talk, the speaker will present an overview of achievements and challenges in improving automation in developer testing, especially on test-input generation (i.e., generating sufficient test inputs) and test oracles (i.e., checking the behavior of the program under test).
About the speaker:
Tao Xie is an Associate Professor in the Department of Computer Science of the College of Engineering at North Carolina State University. He received his Ph.D. in Computer Science from the University of Washington in 2005. Before that, he received an M.S. in Computer Science from the University of Washington in 2002, an M.S. in Computer Science from Peking University in 2000, and a B.S. in Computer Science from Fudan University in 1997. He worked as a visiting researcher at Microsoft Research Redmond and Microsoft Research Asia.
His research interests are in software engineering, focusing on automated software testing and mining software engineering data. He has published more than 100 research papers in refereed journals and conference proceedings in the area of software engineering. Besides doing research, he has contributed to understanding the software engineering research community.
He has served as the ACM SIGSOFT History Liaison in the SIGSOFT Executive Committee as well as serving in the ACM History Committee. He received a National Science Foundation Faculty Early Career Development (CAREER) Award in 2009. He received 2008, 2009, and 2010 IBM Faculty Awards and a 2008 IBM Jazz Innovation Award. He received 2010 North Carolina State University Sigma Xi Faculty Research Award. He received the ASE 2009 Best Paper Award and an ACM SIGSOFT Distinguished Paper Award. He was Program Co-Chair of 2009 IEEE International Conference on Software Maintenance (ICSM) and is Program Co-Chair of 2011 and 2012 International Working Conference on Mining Software Repositories (MSR).
This document discusses various types of software testing performed at different stages of the software development lifecycle. It describes component testing, integration testing, system testing, and acceptance testing. Component testing involves testing individual program units in isolation. Integration testing combines components and tests their interactions, starting small and building up. System testing evaluates the integrated system against functional and non-functional requirements. Acceptance testing confirms the system meets stakeholder needs.
This document discusses unit testing and provides an overview of its benefits and best practices. It defines unit testing as testing small pieces of code in isolation. It recommends writing unit tests for all code to check functionality and prevent bugs, and integrating testing into the development process by writing tests before code and ensuring tests pass before check-ins. The document also discusses test-driven development, refactoring code based on test results, and tools like NUnit that can automate the testing process.
This document discusses test-driven development (TDD) and acceptance test-driven development (ATDD). It defines TDD as a process of first writing a test, then code to pass the test, and refactoring code while relying on tests. ATDD helps ensure correct external features by defining tests for customer requirements. The document outlines benefits like reduced bugs and increased confidence. It also discusses tools that support TDD/ATDD like unit testing frameworks, FitNesse for acceptance tests, continuous integration, and code coverage tools.
DevOps CI Automation Continuous IntegrationIRJET Journal
This document discusses implementing a DevOps continuous integration (CI) automation pipeline for test automation. It involves developing a Java-based test automation framework using Selenium and TestNG. Test cases and framework code are stored in a GitHub repository. Jenkins is configured to automatically build and run tests whenever code is committed to GitHub. This allows for continuous regression testing and helps deliver defect-free software by catching issues early in the development cycle.
Test driven development and unit testing with examples in C++Hong Le Van
Test-driven development (TDD) relies on short development cycles of writing a failing test case, producing code to pass that test, and refactoring the code. Unit testing tests individual units of code by isolating each part and showing they work correctly. Boost.Test is a popular C++ unit testing framework that allows organizing tests into suites and fixtures, and provides assertions and output of results. A minimal Boost.Test example defines a test case using BOOST_AUTO_TEST_CASE that contains an assertion like BOOST_CHECK_EQUAL to test that 2+2 equals 4.
The document discusses various types and stages of software testing in the software development lifecycle, including:
1. Component testing, the lowest level of testing done in isolation on individual software modules.
2. Integration testing in small increments to test communication between components and non-functional aspects.
3. System testing to test functional and non-functional requirements at the full system level, often done by an independent test group.
4. The document provides details on planning, techniques, and considerations for each type of testing in the software development and integration process.
Strategy-driven Test Generation with Open Source FrameworksDimitry Polivaev
Test suites for complex software systems contain thousands of test cases. Keeping track on the test coverage and changing the test suite as the system requirements evolve can consume significant efforts. The tutorial introduces and demonstrates an effort saving technique for developing, controlling and modifying test suites in agile, efficient, scalable and flexible way. The technique allows complete and explicit control over test amount, test depth and test coverage. It also makes possible to avoid code duplication in the non-generated test artifacts.
This technique allows generation of complete test suites given a specification describing test categories, test flow variations, test input data variations and requirement coverage criteria. All these kinds of data are commonly referred to as test properties. Their dependencies and variations are defined in test strategies.
The test strategies are expressed in a test strategy DSL which allows to express complex dependencies in a concise and easily understandable way. Behind the scene there is a rule engine generating test property value combinations from the test strategy definitions. The test suites containing independently executable test cases can be generated in any programming or scripting language or in a textual form. The generator uses a generic and an algorithm for mapping of test properties to the test scripts based on property naming conventions. For automatic test case execution a separate test driver component containing definition of single test steps referenced by the strategy should be written specifically in the chosen test script language.
All tools used for strategy-driven test generation are freely available under open source licenses.
How to Fit Performance Testing into a DevOps EnvironmentNeotys
This document discusses how to fit performance testing into DevOps environments. It recommends adopting best practices like shifting performance testing left to earlier stages, conducting continuous performance validation as part of continuous delivery, automating what can be automated while accelerating other tests, and ensuring collaboration between performance engineers and DevOps teams. The presentation provides an example of how a performance testing tool can integrate into a DevOps toolchain at different stages like build, deploy, test and release. It emphasizes the importance of performance testing for software quality in fast-paced DevOps environments.
Test Driven Development (TDD) with FlexUnit 4 - 360|Flex San Jose presoElad Elrom
This document discusses Test Driven Development (TDD) and how to implement it using FlexUnit 4 for a Twitter companion application. It provides an overview of TDD, outlines the process which includes defining objectives, writing user stories, and creating tests before code. It demonstrates how to set up the application, create a test suite and first test case class. Finally, it provides an example of implementing the first user story to retrieve tweets with a specific hashtag by writing a test to ensure the Twitter API is called correctly and events are dispatched properly.
Test Driven Development (TDD) Preso 360|Flex 2010guest5639fa9
This document discusses Test Driven Development (TDD) using FlexUnit 4. It provides an overview of TDD and its benefits. It then walks through an example of building a Twitter client application using TDD. It demonstrates how to create test suites and test cases, write tests to fail initially, then write code to pass the tests. It covers concepts like user stories, assertions, refactoring tests. The document recommends TDD for APIs, frameworks and services, but not GUI testing. It provides resources to learn more about TDD with FlexUnit 4 and Adobe technologies.
This document discusses Test Driven Development (TDD). It defines TDD, outlines the TDD process which involves writing tests first and then code to pass the tests, and emphasizes refactoring. Benefits of TDD include improved code quality, reduced bugs, and serving as documentation. Key TDD terms and libraries like JUnit and Mockito are explained. Continuous Integration (CI) is also discussed as it automates testing and builds when code is committed.
The document is an internship report that describes work done on quality assurance of virtual labs. It discusses manual testing including developing a test plan, test cases, and reports. It also covers automated testing using Python scripts to check links and spelling on pages. The report provides details on testing objectives, requirements, tools used, and the structure of test cases, reports, and defect management. It aims to help deliver high quality, open-source virtual labs.
JUnit: A unit testing framework that is extensively used to test the code written in Java.
Unit testing is a type of software testing.
Software testing: The process of examining whether the software and its components meet the specified requirements
Other types of software testing are as shown.
Webinar: Designing a schema for a Data WarehouseFederico Razzoli
Are you new to data warehouses (DWH)? Do you need to check whether your data warehouse follows the best practices for a good design? In both cases, this webinar is for you.
A data warehouse is a central relational database that contains all measurements about a business or an organisation. This data comes from a variety of heterogeneous data sources, which includes databases of any type that back the applications used by the company, data files exported by some applications, or APIs provided by internal or external services.
But designing a data warehouse correctly is a hard task, which requires gathering information about the business processes that need to be analysed in the first place. These processes must be translated into so-called star schemas, which means, denormalised databases where each table represents a dimension or facts.
We will discuss these topics:
- How to gather information about a business;
- Understanding dictionaries and how to identify business entities;
- Dimensions and facts;
- Setting a table granularity;
- Types of facts;
- Types of dimensions;
- Snowflakes and how to avoid them;
- Expanding existing dimensions and facts.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
Mais conteúdo relacionado
Semelhante a Getting Started with Test-Driven Development at Longhorn PHP 2023
This was a workshop given on the UTN University, for the Software Engineering students. The idea is to give a brief explanation about TDD, and how to use it.
The QA professional is certainly needed within a company. However, in many cases, unfortunately, there are companies that don’t adhere to this professional culture. Increasing the code quality becomes a major challenge for development teams in these cases. This presentation aims to give tips learned from mistakes of this attempt to try to improve the code quality and test execution time for a quick feedback.
May: Automated Developer Testing: Achievements and ChallengesTriTAUG
Developer testing, a common step in software development, involves generating sufficient test inputs and checking the behavior of the program under test during the execution of the test inputs. Complicated logics inside a method make generating appropriate arguments difficult. In testing object-oriented programs, generating method sequences to put the receiver object or argument objects into appropriate states further complicates test-input generation. After the generated test inputs are executed, program crashes or uncaught exceptions can be used to indicate program problems, especially robustness problems. However, some program problems such as producing wrong program outputs do not crash the program.
In this talk, the speaker will present an overview of achievements and challenges in improving automation in developer testing, especially on test-input generation (i.e., generating sufficient test inputs) and test oracles (i.e., checking the behavior of the program under test).
About the speaker:
Tao Xie is an Associate Professor in the Department of Computer Science of the College of Engineering at North Carolina State University. He received his Ph.D. in Computer Science from the University of Washington in 2005. Before that, he received an M.S. in Computer Science from the University of Washington in 2002, an M.S. in Computer Science from Peking University in 2000, and a B.S. in Computer Science from Fudan University in 1997. He worked as a visiting researcher at Microsoft Research Redmond and Microsoft Research Asia.
His research interests are in software engineering, focusing on automated software testing and mining software engineering data. He has published more than 100 research papers in refereed journals and conference proceedings in the area of software engineering. Besides doing research, he has contributed to understanding the software engineering research community.
He has served as the ACM SIGSOFT History Liaison in the SIGSOFT Executive Committee as well as serving in the ACM History Committee. He received a National Science Foundation Faculty Early Career Development (CAREER) Award in 2009. He received 2008, 2009, and 2010 IBM Faculty Awards and a 2008 IBM Jazz Innovation Award. He received 2010 North Carolina State University Sigma Xi Faculty Research Award. He received the ASE 2009 Best Paper Award and an ACM SIGSOFT Distinguished Paper Award. He was Program Co-Chair of 2009 IEEE International Conference on Software Maintenance (ICSM) and is Program Co-Chair of 2011 and 2012 International Working Conference on Mining Software Repositories (MSR).
This document discusses various types of software testing performed at different stages of the software development lifecycle. It describes component testing, integration testing, system testing, and acceptance testing. Component testing involves testing individual program units in isolation. Integration testing combines components and tests their interactions, starting small and building up. System testing evaluates the integrated system against functional and non-functional requirements. Acceptance testing confirms the system meets stakeholder needs.
This document discusses unit testing and provides an overview of its benefits and best practices. It defines unit testing as testing small pieces of code in isolation. It recommends writing unit tests for all code to check functionality and prevent bugs, and integrating testing into the development process by writing tests before code and ensuring tests pass before check-ins. The document also discusses test-driven development, refactoring code based on test results, and tools like NUnit that can automate the testing process.
This document discusses test-driven development (TDD) and acceptance test-driven development (ATDD). It defines TDD as a process of first writing a test, then code to pass the test, and refactoring code while relying on tests. ATDD helps ensure correct external features by defining tests for customer requirements. The document outlines benefits like reduced bugs and increased confidence. It also discusses tools that support TDD/ATDD like unit testing frameworks, FitNesse for acceptance tests, continuous integration, and code coverage tools.
DevOps CI Automation Continuous IntegrationIRJET Journal
This document discusses implementing a DevOps continuous integration (CI) automation pipeline for test automation. It involves developing a Java-based test automation framework using Selenium and TestNG. Test cases and framework code are stored in a GitHub repository. Jenkins is configured to automatically build and run tests whenever code is committed to GitHub. This allows for continuous regression testing and helps deliver defect-free software by catching issues early in the development cycle.
Test driven development and unit testing with examples in C++Hong Le Van
Test-driven development (TDD) relies on short development cycles of writing a failing test case, producing code to pass that test, and refactoring the code. Unit testing tests individual units of code by isolating each part and showing they work correctly. Boost.Test is a popular C++ unit testing framework that allows organizing tests into suites and fixtures, and provides assertions and output of results. A minimal Boost.Test example defines a test case using BOOST_AUTO_TEST_CASE that contains an assertion like BOOST_CHECK_EQUAL to test that 2+2 equals 4.
The document discusses various types and stages of software testing in the software development lifecycle, including:
1. Component testing, the lowest level of testing done in isolation on individual software modules.
2. Integration testing in small increments to test communication between components and non-functional aspects.
3. System testing to test functional and non-functional requirements at the full system level, often done by an independent test group.
4. The document provides details on planning, techniques, and considerations for each type of testing in the software development and integration process.
Strategy-driven Test Generation with Open Source FrameworksDimitry Polivaev
Test suites for complex software systems contain thousands of test cases. Keeping track on the test coverage and changing the test suite as the system requirements evolve can consume significant efforts. The tutorial introduces and demonstrates an effort saving technique for developing, controlling and modifying test suites in agile, efficient, scalable and flexible way. The technique allows complete and explicit control over test amount, test depth and test coverage. It also makes possible to avoid code duplication in the non-generated test artifacts.
This technique allows generation of complete test suites given a specification describing test categories, test flow variations, test input data variations and requirement coverage criteria. All these kinds of data are commonly referred to as test properties. Their dependencies and variations are defined in test strategies.
The test strategies are expressed in a test strategy DSL which allows to express complex dependencies in a concise and easily understandable way. Behind the scene there is a rule engine generating test property value combinations from the test strategy definitions. The test suites containing independently executable test cases can be generated in any programming or scripting language or in a textual form. The generator uses a generic and an algorithm for mapping of test properties to the test scripts based on property naming conventions. For automatic test case execution a separate test driver component containing definition of single test steps referenced by the strategy should be written specifically in the chosen test script language.
All tools used for strategy-driven test generation are freely available under open source licenses.
How to Fit Performance Testing into a DevOps EnvironmentNeotys
This document discusses how to fit performance testing into DevOps environments. It recommends adopting best practices like shifting performance testing left to earlier stages, conducting continuous performance validation as part of continuous delivery, automating what can be automated while accelerating other tests, and ensuring collaboration between performance engineers and DevOps teams. The presentation provides an example of how a performance testing tool can integrate into a DevOps toolchain at different stages like build, deploy, test and release. It emphasizes the importance of performance testing for software quality in fast-paced DevOps environments.
Test Driven Development (TDD) with FlexUnit 4 - 360|Flex San Jose presoElad Elrom
This document discusses Test Driven Development (TDD) and how to implement it using FlexUnit 4 for a Twitter companion application. It provides an overview of TDD, outlines the process which includes defining objectives, writing user stories, and creating tests before code. It demonstrates how to set up the application, create a test suite and first test case class. Finally, it provides an example of implementing the first user story to retrieve tweets with a specific hashtag by writing a test to ensure the Twitter API is called correctly and events are dispatched properly.
Test Driven Development (TDD) Preso 360|Flex 2010guest5639fa9
This document discusses Test Driven Development (TDD) using FlexUnit 4. It provides an overview of TDD and its benefits. It then walks through an example of building a Twitter client application using TDD. It demonstrates how to create test suites and test cases, write tests to fail initially, then write code to pass the tests. It covers concepts like user stories, assertions, refactoring tests. The document recommends TDD for APIs, frameworks and services, but not GUI testing. It provides resources to learn more about TDD with FlexUnit 4 and Adobe technologies.
This document discusses Test Driven Development (TDD). It defines TDD, outlines the TDD process which involves writing tests first and then code to pass the tests, and emphasizes refactoring. Benefits of TDD include improved code quality, reduced bugs, and serving as documentation. Key TDD terms and libraries like JUnit and Mockito are explained. Continuous Integration (CI) is also discussed as it automates testing and builds when code is committed.
The document is an internship report that describes work done on quality assurance of virtual labs. It discusses manual testing including developing a test plan, test cases, and reports. It also covers automated testing using Python scripts to check links and spelling on pages. The report provides details on testing objectives, requirements, tools used, and the structure of test cases, reports, and defect management. It aims to help deliver high quality, open-source virtual labs.
JUnit: A unit testing framework that is extensively used to test the code written in Java.
Unit testing is a type of software testing.
Software testing: The process of examining whether the software and its components meet the specified requirements
Other types of software testing are as shown.
Semelhante a Getting Started with Test-Driven Development at Longhorn PHP 2023 (20)
Webinar: Designing a schema for a Data WarehouseFederico Razzoli
Are you new to data warehouses (DWH)? Do you need to check whether your data warehouse follows the best practices for a good design? In both cases, this webinar is for you.
A data warehouse is a central relational database that contains all measurements about a business or an organisation. This data comes from a variety of heterogeneous data sources, which includes databases of any type that back the applications used by the company, data files exported by some applications, or APIs provided by internal or external services.
But designing a data warehouse correctly is a hard task, which requires gathering information about the business processes that need to be analysed in the first place. These processes must be translated into so-called star schemas, which means, denormalised databases where each table represents a dimension or facts.
We will discuss these topics:
- How to gather information about a business;
- Understanding dictionaries and how to identify business entities;
- Dimensions and facts;
- Setting a table granularity;
- Types of facts;
- Types of dimensions;
- Snowflakes and how to avoid them;
- Expanding existing dimensions and facts.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
OpenID AuthZEN Interop Read Out - AuthorizationDavid Brossard
During Identiverse 2024 and EIC 2024, members of the OpenID AuthZEN WG got together and demoed their authorization endpoints conforming to the AuthZEN API
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
Ivanti’s Patch Tuesday breakdown goes beyond patching your applications and brings you the intelligence and guidance needed to prioritize where to focus your attention first. Catch early analysis on our Ivanti blog, then join industry expert Chris Goettl for the Patch Tuesday Webinar Event. There we’ll do a deep dive into each of the bulletins and give guidance on the risks associated with the newly-identified vulnerabilities.
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
Ocean lotus Threat actors project by John Sitima 2024 (1).pptxSitimaJohn
Ocean Lotus cyber threat actors represent a sophisticated, persistent, and politically motivated group that poses a significant risk to organizations and individuals in the Southeast Asian region. Their continuous evolution and adaptability underscore the need for robust cybersecurity measures and international cooperation to identify and mitigate the threats posed by such advanced persistent threat groups.
Fueling AI with Great Data with Airbyte WebinarZilliz
This talk will focus on how to collect data from a variety of sources, leveraging this data for RAG and other GenAI use cases, and finally charting your course to productionalization.
Generating privacy-protected synthetic data using Secludy and MilvusZilliz
During this demo, the founders of Secludy will demonstrate how their system utilizes Milvus to store and manipulate embeddings for generating privacy-protected synthetic data. Their approach not only maintains the confidentiality of the original data but also enhances the utility and scalability of LLMs under privacy constraints. Attendees, including machine learning engineers, data scientists, and data managers, will witness first-hand how Secludy's integration with Milvus empowers organizations to harness the power of LLMs securely and efficiently.
Main news related to the CCS TSI 2023 (2023/1695)Jakub Marek
An English 🇬🇧 translation of a presentation to the speech I gave about the main changes brought by CCS TSI 2023 at the biggest Czech conference on Communications and signalling systems on Railways, which was held in Clarion Hotel Olomouc from 7th to 9th November 2023 (konferenceszt.cz). Attended by around 500 participants and 200 on-line followers.
The original Czech 🇨🇿 version of the presentation can be found here: https://www.slideshare.net/slideshow/hlavni-novinky-souvisejici-s-ccs-tsi-2023-2023-1695/269688092 .
The videorecording (in Czech) from the presentation is available here: https://youtu.be/WzjJWm4IyPk?si=SImb06tuXGb30BEH .
How to Get CNIC Information System with Paksim Ga.pptxdanishmna97
Pakdata Cf is a groundbreaking system designed to streamline and facilitate access to CNIC information. This innovative platform leverages advanced technology to provide users with efficient and secure access to their CNIC details.
Monitoring and Managing Anomaly Detection on OpenShift.pdfTosin Akinosho
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
Have you ever been confused by the myriad of choices offered by AWS for hosting a website or an API?
Lambda, Elastic Beanstalk, Lightsail, Amplify, S3 (and more!) can each host websites + APIs. But which one should we choose?
Which one is cheapest? Which one is fastest? Which one will scale to meet our needs?
Join me in this session as we dive into each AWS hosting service to determine which one is best for your scenario and explain why!
Skybuffer SAM4U tool for SAP license adoptionTatiana Kojar
Manage and optimize your license adoption and consumption with SAM4U, an SAP free customer software asset management tool.
SAM4U, an SAP complimentary software asset management tool for customers, delivers a detailed and well-structured overview of license inventory and usage with a user-friendly interface. We offer a hosted, cost-effective, and performance-optimized SAM4U setup in the Skybuffer Cloud environment. You retain ownership of the system and data, while we manage the ABAP 7.58 infrastructure, ensuring fixed Total Cost of Ownership (TCO) and exceptional services through the SAP Fiori interface.
Building Production Ready Search Pipelines with Spark and MilvusZilliz
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
Driving Business Innovation: Latest Generative AI Advancements & Success StorySafe Software
Are you ready to revolutionize how you handle data? Join us for a webinar where we’ll bring you up to speed with the latest advancements in Generative AI technology and discover how leveraging FME with tools from giants like Google Gemini, Amazon, and Microsoft OpenAI can supercharge your workflow efficiency.
During the hour, we’ll take you through:
Guest Speaker Segment with Hannah Barrington: Dive into the world of dynamic real estate marketing with Hannah, the Marketing Manager at Workspace Group. Hear firsthand how their team generates engaging descriptions for thousands of office units by integrating diverse data sources—from PDF floorplans to web pages—using FME transformers, like OpenAIVisionConnector and AnthropicVisionConnector. This use case will show you how GenAI can streamline content creation for marketing across the board.
Ollama Use Case: Learn how Scenario Specialist Dmitri Bagh has utilized Ollama within FME to input data, create custom models, and enhance security protocols. This segment will include demos to illustrate the full capabilities of FME in AI-driven processes.
Custom AI Models: Discover how to leverage FME to build personalized AI models using your data. Whether it’s populating a model with local data for added security or integrating public AI tools, find out how FME facilitates a versatile and secure approach to AI.
We’ll wrap up with a live Q&A session where you can engage with our experts on your specific use cases, and learn more about optimizing your data workflows with AI.
This webinar is ideal for professionals seeking to harness the power of AI within their data management systems while ensuring high levels of customization and security. Whether you're a novice or an expert, gain actionable insights and strategies to elevate your data processes. Join us to see how FME and AI can revolutionize how you work with data!
20. Agenda
1. What Is Test-Driven Development?
2. Why You Should Be Using Test-Driven
Development?
3. How To Do Test-Driven Development?
4. Unit and Feature Testing
5. What is Code Coverage?
22. TDD:
A test-first software development
process that uses short
development cycles to write very
specific test cases and then modify
our code so the tests pass.
23. What is Test-Driven Development?
• Short cycles of 5 phases
• Less Minute
• Dozens/hundreds of cycles each day
Add A
New Test
Run All
Tests to
See
Failures
Make a
change
Run Tests
to See
Success
Refactor
228. What You Need to Know
• TDD: test-first software development process
• Gives us confidence to make changes
• Five short phases
• Each of the phases happens very quickly
• Don’t neglect to refactor
229. What You Need to Know
Add A
New Test
Run All
Tests to
See
Failures
Make a
change
Run Tests
to See
Success
Refactor
230. What You Need to Know
• Use a testing framework like PHPUnit/Pest
• Write clear and concise tests
• Unit tests: tests code in isolation
• Feature tests: tests code as user interacts with it
• Code coverage determines if our code has enough tests
My grocery store changed layout and couldn’t find coffee for three weeks
As developers, we know that change breaks production
No mater how small the change
I’ve fixed a spelling error in a string and created a bug
That leads to…<click>
Whose heard this one before
<slide>
That’s way my mantra because I don’t want to have to boot my work computer up on Sunday
Maintained a module to set professional development goals
Process had seven steps <click>
Alternated between supervisor and direct <click>
Two “modes” <click>
Testing took a minimum of 10 minutes<click>
Manual so Error prone. Sometimes I would make a mistake in step 2 and not realize to step 6 and have to start over
God forbid I was on vacation and someone else made the change
Because there we so many moving parts:
<slide>
Someone would say can we add a new feature
I would say yes very reluctantly and then tell them 2 days minimum
Confidence that I could make changes
Not break anything
Hard to do with all the manual testing
Looked for a solution
How do we create automated tests
Lots of options
Cloud image in the back
TDD gave me that confidence
For those of you who haven’t met me my name is …
Professional PHP Developer for 15 years
// team lead/CTO role for 10 of those 15
Currently Director of Technology at WeCare Connect
Survey solutions to improve employee and resident retention at skilled nursing facilities
Use PHP for our backend
Also …
Create Educational Videos on PHPArchitect YouTube
Discuss topics helpful for PHP developers
If you want more content like this session follow me on social media and subscriber to our channel
Found at youtube.com/phparch
Could spend hours discussing automated testing with you all. It’s one of my favorite PHP adjacent topics but we only have 50 minutes.
My goals are to always have you leave one of my sessions with something you can use the next day you’re going to work and how you can implement this with your team
Create suite of automated tests
More automated tests means more confidence to make changes
TDD consists of five phases that we will repeat as we modify our code. Each of the phases happens very quickly and we might go through all five phases in less than a minute.
Back to our goals module from before
Problem was on this side because it was manual
<click>
Wrote 200+ automated tests for Goals Module
Still had that complexity but I didn’t care
Was 10 minutes now less 2 minutes
Wasn’t even 2 active minutes I could step away from my computer
Could confidently make a changes
Didn’t forget steps
Cycle time dropped from days to hours
Cycle time dropped from days
To
Hours
Abstract then concrete
TDD consists of 5 SHORT phases
< ten new lines of code being modified. If we find ourselves doing more than that we're working on too large a change and we need to break it into smaller pieces.
The first thing we're going to do is write a failing test. We'll use this failing test to help determine when we've achieved our expected functionality.
It's important that the test is succinct and that it's looking at how a **single** change will affect our code.
Goal: how does a single change affect our code
2. Run all tests and see the new one fail
In this step, we're going to run the test to make sure our test fails before we move on to the next phase. It's very easy to write a test that doesn't fail so we **always** run our test to verify it's failing before moving to the next phase.
If it’s not failing we don’t know if our change actually did anything
As a small aside, the wording for this phase says "run all the tests" but as our test suite (a collection of tests) grows this will take an unproductively large amount of time. Current code base takes 25 minutes to run whole suite.
We'll want to short circuit this and only run the test file or just our new test. Many IDEs can run a single file or even a single test and it's worth spending time figuring out how to get this working as it will make us more productive.
Some are built in like PHP Storm but some require extensions like VS Code.
3. Make a little change
Now our goal is to change the smallest amount of code possible to get that test to pass.
We don't want to change any more than is necessary because that extra bit of change wasn't made using TDD and is potentially not tested. We don't need perfect code in this phase we just need code that makes the test pass. It's very easy to get caught up in making sure everything is perfect but that's not the goal here. Perfect comes later.
4. Run all tests and see them all succeed
Now that we've made our change we can run our test and see that it passes new test and any other tests.
If it doesn't then we just jump back to phase #3 and keep making small changes until it does.
5. Refactor to remove duplication
Now that we have our tests passing we're going to take a break and inspect both our test code and our code under test to see where we can make changes so it's easier for future developers to read, understand, and maintain.
This is called Refactoring and it’s: restructure code so as to improve operation without altering functionality.
We're using TDD so changes are painless because we can quickly run our unit tests again to make sure we didn't make a mistake.
Now that we've completed a single TDD cycle we can start back at the beginning with a new test.
If you google TDD There’s also a three phase version
Called Red, green, refactor
Red and green come from colored messages we get from our testing tool
Basically group phases 1 and 2 and 3 and 4.
I like 5 phases because it gives explicit steps
This has been all very abstract so lets make it more concrete
Fast
Good starting point for new classes
Been working on an open source project for the YouTube Channel
Value objects
Did a whole video on how awesome value objects are
Nee
Custom classes for each domain type in our application
Provide three things
Problem they solve is this
Have a function to recreate user
Need first, last, email
Later call the function
Made an Oops
<click>
Should be <comment order>
Did email first
Tricky kind of bug
Dare you to find this in code review
Now I can’t mess up calling this
And
Helper functions
Tw
before we go further
This is a contrived example
Feel free to roll your eyes as I’m doing stupid things to make my point
Don’t use this as evidence for a future job
I have this value object class to track a City
Only important thing is that we’re storing our information in $value property
Want to add more functionality using TDD
First thing we need is a <slide>
Two major options in PHP community
This example uses PHPUnit to run our tests as the project is already using phpunit
Talk about the other framework later
In case you don’t know
Testing Framework
All tests are written in PHP so we don’t need to learn anything new
Organization is easy
All test files are placed inside a tests folder at the root of the project
A test is a PHP class method
Each test function starts with “test”
or …
uses the @test annotation
This is a personal preference thing. I learned PHPUnit before annoation option so I default to prefixing tests with test. Also uses less vertical space which helpful for presentations
Might notice assert function calls
Each test function contains one or more asserts
Asserts tell PHPUnit to compare an expected value to the value we got from our codeEach test contains one or more asserts
Compare output values <click>
Compare expected value vs output <click>
Check for greater than or equal <click>
A PHP class groups similar tests together
Ideally a test class for each application class with logic. Don’t need tests for classes with no logic.
A test class for common initial conditions
Might have class for tests involving a standard user and another class for administrator users
Each class ends with “Test” super important and PHPunit won’t “autoload” them.
Command line tool
Super powerful
Run a single file
Use filter to reduce runs
Example anything that involves users
Our examples today mostly command line
Running using
./vendor/bin/phpunit tests/FileTest.php
1. Add a new test
No tests for City because there wasn’t any logic to test
First step is to create the test file
<screen> is current file
Swap tests for src
And append test
That way can easily find tests for city class
Start with our blank file
Create class
Class name needs to match the file name -> new PHPunit doesn’t like mismatch
Extends PHPUnit\Framework\TestCase . TestCase class gives us asserts and setup logic we need
This is just boiler plate so far
Remember this when we talk about Pest
Let’s remember what we want to do because I’ve rambled
Not sure how I want to do this so let’s start coding and figure it out
Create the test function. We’re going to name the function based on what we’re testing to it’s easier to understand when future us comes back to it.
Create Our Initial Conditions
Run the code we’re going to test
Assert the results
Don’t like the useless variable here so we’ll get rid of it
Notice how small the actual test is. We're giving the test a very specific functionality to test and we're only asserting one thing. If we have more than one assert per test we run the risk of making it difficult to debug later when something breaks.
2. Run all tests and see the new one fail
Now we'll run PHPUnit to see that we do indeed get a failing test.
In this case, we haven't yet defined the method so we get an "undefined method" error.
Red message -> in an error state like we saw in red/green/refactor
3. Make a little change
To reiterate, our goal in this phase is to make the smallest change we can to allow our tests to pass.
Two options here: <click>
add in the obvious implementation
Obvious means is a few lines that we can’t possibility mess up the logic for
This case just call to mb_strlen
2 - Make the smallest possible change by returning true always.
It doesn't cover all the possible inputs but the goal in this step isn't to cover all the inputs it's to get our test to pass. We'll cover more inputs later.
We’re going to want to show another cycle of TDD so we’re going to just return true
4. Run all tests and see them all succeed
Now we run our test and verify that our test passes.
Notice green from red/green/refactor
5. Refactor
Our simple implementation of `somefunction()` is going to be wrong most of the time because of its current implementation. Now we need to add another test that checks for other cases where the string isn't empty.
As a general rule, it's a good idea to have tests for normal input, the extremes of inputs (very large or very small), and spots where we can think of oddities happening obviously very domain specific
We’re going to check for a case where the string isn’t empty to add an addition testing point
1. Add a new test
Add a new test
What we have currently
Add in the opposite
2. Run all tests and see the new one fail
This time we get a failure assertion that true is false
3. Make a little change
Look at our original code
Could change to return false but that would cause other tests to fail
Back to the obvious implementation we had before
4. Run all tests and see them all succeed
5. Refactor
We have working code that fulfills the requirements
Right?
Done?
Maybe?
Let’s look at how this looks in usage
Basic if block
I’m going to come across someFunction and have no idea what it is
Going to slow me down and that’s annoying
Excellent time to refactor and pick a new name
Lots of options
Don’t like this because its a verb so we could be performing an action
isEmpty sounds good to me
Sounds like a sentence
Back to our code now
After refactor
Subjectively better?
No happy accidents
Starting to get the hang of this
Adding a test now to check for a string that isn’t empty.
Could do !isEmpty() but isNotEmpty is actually easier for us to process as programmers so it’s nice to have
Also contrived example
1. Add a new test
Again small
Again written so we know what’s going on quickly
2. Run all tests and see the new one fail
3. Make a little change
In this case instead of returning `false` and then creating another test so we can write the functionality by going through all the TDD steps, we're just going to trust ourselves and create the obvious implementation of the `isNotEmpty()` function.
4. Run all tests and see them all succeed
Oh good we didn’t make any mistakes
5. Refactor to remove duplication
Now here is where it gets interesting.
The last two times we've hit this step we haven't had anything to do but now look at our `isEmpty()` and `isNotEmpty()` functions.
We can see some minor duplication in the two calls to `mb_strlen($this->string)`. Now we just need to determine how we want to resolve this.
2 options: Option 1 is to extract that duplication into a new function.
Call it length and copy duplication into body
Extracting a new function is favorite refactor because it makes the code more readable and because we'll most likely need the same logic again.
Now The replace the calls with the new function
The second option is to realize that `isNotEmpty()` returns the boolean opposite of `isEmpty()` and just use it
If I hadn’t been working through this example just to get to this who cares example I think I would have done this automatically.
The first option gives us the best flexibility for future expansion but second less code. Always a fond of less code
Finally, we need to run our tests again to verify that no accidents crept into our code as we made these changes.
That’s how we do unit tests
Generally that’s where these presentations stop but we can do better right
In our example, we worked out an example of tests where we only tested a single class.
Generally that’s where these presentations stop but we can do better right
Slower than unit tests
Working with local databases and services
Great for high coverage (discuss later)
Over on my Twitch stream slowly working on this
Tool to help with Pull Requests
Lots of ideas on what to do
Time to tackle another item off my backlog
Wanted to use all the newest/greatest projects in PHP space for this project so using Pest
Testing Framework
<click>Built on top of PHPUnit
Can use with existing PHPunit tests
There are some differences
Organization is easy
All test files are placed inside a tests folder at the root of the project
A test is a PHP function
Uses expectation API
Built on top of PHPUnit so we can still use assertion api
I love how expressive the expectation API is but tend to fall back to assertions
Command line tool
Super powerful
Again run with not parameters to run all tests
Run a single file
Use filter to reduce runs
Example anything that involves users
Maybe this is more complicated?
Let’s look at a flow diagram of what we’re doing
<Click through steps>
It’s a lot right?
Don’t feel like I can write an easy test for this
Tackle one small piece only
First test: Can access /organizations/all
Only thing that exists now:
GitHub service
Takes the current user’s OAuth token and creates a connection to GitHub using 3rd party package
Only thing that exists now:
GitHub service
Takes the current user’s OAuth token and creates a connection to GitHub
1. Add a new test
2. Run all tests and see the new one fail
3. Make a little change
To reiterate, our goal in this phase is to make the smallest change we can to allow our tests to pass.
Two options here: <click>
It doesn’t do anything but again smallest amount of code possible
4. Run all tests and see them all succeed
5. Refactor to remove duplication
Kept it DRY to start so we’re good
Second test the rest?
1. Add a new test
2. Run all tests and see the new one fail
3. Make a little change
To reiterate, our goal in this phase is to make the smallest change we can to allow our tests to pass.
Two options here: <click>
I’m going to ignore creating the blade file here because it’s not interesting and hard to read
getAllRepositoriesForCurrentUser
Break with process and see actually results
Uggg, look at all the abandoned side projects
<click> But do see ScottsValueObjects
External Dependency
Have zero control over it
Data might change
Worse it requires:
login
active connection to internet
Use a library
This case we’re using Mockery library
Allows us to specify return values from functions
Pest has support to override the service container for our mock
4. Run all tests and see them all succeed
Uggg, look at all the abandoned side projects
But do see ScottsValueObjects
5. Refactor to remove duplication
Again dry code so no refactoring
That’s a feature test
Small amount of testing code tests large amount of user land code
Allows for high code coverage
The "total number of lines of code" only includes lines that are performing operations and not declarations and white space.
As an example, this class
Single test to see that we can initialize our class
Let’s see what our coverage is
Only two lines are executable
Only the assignment is actually run during this test
Calcaluation on the board to help us
<result>
Manual isn’t going to work because our code is always changing
Thankfully
Need to also have XDEBUG or another tool installed
SET mode to coverage
Spits out same result
< 75% -> hard to feel confident making changes
> 90% -> fragile, expensive tests
Personally my team targets 80%
Missing critical stuff we target 95%
Want to make this part of our
Running at the command line also is a little rough so I like to include it in my CI/CD runs
Like to use Codecov but there’s a million of these SaaS companies that do this
Spits out results in our PR
Also shows lines that aren’t being covered by a test
1. Add a new test
2. Run all tests and see the new one fail
3. Make a little change
4. Run all tests and see them all succeed
5. Refactor to remove duplication