The DevOps Guide to Functionize Integrations

What is DevOps?

Today’s software companies require good DevOps practices in order to release their applications faster with high quality. The DevOps movement appeared over a decade ago, yet many companies are still maturing their practices. DevOps is a set of collaborative practices that bridge the gap between developers and IT operations. These practices strive to streamline software delivery and remove any bottlenecks to pushing code to production. They also aim to minimize or eliminate downtime due to software faults.

Why is test automation important for DevOps?

DevOps is all about efficiency and speed, delivering software as fast as possible. Sadly, testing slows down the delivery of software in many organizations. Manual testing takes too long to find issues and automated testing often makes it hard for developers to diagnose problems quickly. Automation is a crucial element to helping development teams move faster. Yet, oftentimes automated testing is run in a silo, disconnected from the rest of the tools used by developers.

This is where DevOps comes in. Many organizations give DevOps specialists the responsibility of integrating disparate systems together. This helps to streamline tools into a unified toolchain, often represented by the “DevOps Infinity”.

‍

How Functionize fits into DevOps

Functionize integrates with a multitude of tools to seamlessly fit into your existing DevOps process:

1. Test Management: link manual tests with automated tests, so you can see automation results in your test management tool. This allows you to report all test results from a single place.
2. Application Lifecycle Management: log bugs from failed automated tests, so developers can easily see what needs to be fixed. Track bug status from Functionize so testers know when to validate the fix.
3. CI/CD: trigger Functionize orchestrations along with your CI build. This allows you to trace failures to specific builds, so it’s easier to know which change caused problems.
4. Monitoring & Alerts: notify anyone who wants to stay on top of test results. You can update your team for all executions or just failures only.

Test Management

Companies with more than one QA team usually rely on a test management solution to centralize test cases and test results. These tools are even more crucial if different QA teams use different automation tools. In these cases, your test management solution provides a “single pane of glass” to prepare for releases. Anyone involved in testing can see which tests passed and which failed to answer the key question: “Are we ready to release?”

Functionize integrates with multiple test management tools, including TestRail and Xray. They all follow this flow:

1. Create your test using Architect once your manual test is ready to be automated.
2. Then, link your Functionize test with your manual test for traceability.
3. Run your tests using the Functionize Test Cloud, and your orchestration results will be visible from your test management solution.

The main benefit of using these integrations is that anyone can be involved in creating automated tests, no code required. This allows you to build up your automation coverage very quickly. Test execution results are visible to anyone who has access to TestRail or Xray—no need to purchase extra licenses. Tests autonomously keep up-to-date as your application changes over time, thanks to machine learning. The integrations are easy to set up and allow for easy navigation between both tools.  

Check out this video to see the Functionize + TestRail integration in action:

Application Lifecycle Management

Most development teams use an application lifecycle management tool (ALM) tool like Jira to track releases and backlogs. This allows developers to stay on top of new features, enhancements, and bugs. Testers are responsible for logging the bugs that they find into Jira. Developers then use the tool to inform testers when the bug is fixed.

This defect submission and validation process is painfully cumbersome and slow. This is because screenshots and the steps to reproduce the bug need to be manually entered. Without full details, there is often a back-and-forth Q&A as the developer requests more information from the tester. Even worse, when bugs are fixed it’s difficult for testers to know which test needs to be rerun for validation. 

Functionize integrates with Jira and helps to close this gap between developers and testers. Bugs logged from Functionize tests are automatically linked to the test results. This allows developers to know exactly how to reproduce the bug to find the issue. Testers benefit from the traceability, as well. Jira defect fields are visible from the Functionize side, including the Jira defect status, so testers know when bugs are ready for retesting.  

Test traceability is a beautiful thing, and it’s even more impactful when access is shared! Anyone from Jira can click into the Functionize results to view the test results, no license required. 

Check out this video to see the Functionize + Jira integration in action:

Continuous Integration

Development teams use continuous integration (CI) tools to check in, package, and validate code changes before being pushed into a later environment. CI tools execute tests to provide developers with a quick feedback loop of their code quality. The goal is to make sure that code changes did not break any existing tests. The challenge with many organizations is that they only execute unit tests along with their CI pipeline.

‍

We believe that CI tools should run more than just unit tests. After all, unit tests only check to make sure each function in your code works as expected. Functional UI tests are so much more valuable to test what users will actually experience. Unfortunately, most organizations run these tests separate from the CI pipeline, which makes it harder to trace back when code changes led to failures. 

Functionize provides multiple ways to integrate with CI tools, including: Jenkins, Azure DevOps, CircleCI, GitHub, Bamboo, TravisCI, and GitLab. Simply connect your builds to a Functionize orchestration. That way, you can run a full smoke suite along with each build. After all, when you catch issues earlier in the process, bugs are much easier to fix.

Monitoring & Alerts

Keeping everyone on the same page is a major part of the DevOps philosophy. The challenge with test automation is that not everyone has access to proper tools, or the ability to interpret test results. These days, most companies use Slack channels to stay on top of updates. Functionize integrates with Slack to provide a configurable feed of test results. Luckily Functionize test results are easy to understand, without the need to read code, so anyone can jump in for more details.

Check out this video to see Functionize, Jenkins, and Slack all integrated together:

Site Reliability Engineers or other members of IT Operations may rely on alerts from tools like PagerDuty to be informed of production issues. Functionize also integrates with PagerDuty so that key members are alerted of issues quickly to find the fastest path to resolution. Check out this guide for more details on the Functionize + PagerDuty Integration.

Conclusions

Functionize will seamlessly fit into any DevOps process, to improve efficiency and collaboration across the SDLC. Maybe you want to report manual and automated tests from a single place. Or create traceability between bugs and tests. Perhaps you need to run tests along with your CI pipeline, or alert everyone as tests are monitored. Our native integrations are easy solutions to all these and more. Even better, you can build custom integrations using APIs or the Functionize CLI to integrate with any other tools you rely on. Check out this guide: Integrating with our APIs or contact support@functionize.com for more info.