Skip navigation
All Places > DevTest Community > Blog > 2017 > March
2017

When it comes to testing, core Java developers around the world tend to be a "do-it-yourself" bunch. And this is certainly true for testing components such as Java objects while they are under development. Testing Java classes and Java Remote Method Invocation (RMI) servers requires hours of tricky coding and test client development, so often developers will wait until much later in the development process to test, when the object is being rolled into a larger system.

 

Prior to the introduction of tools like CA’s DevTest Framework for Java & RMI, Java class or framework testing was only possible with a programmer's IDE in Java or JavaScript. Since this code-based approach can only be used by the developer, often when they are in the middle of coding the app, the tests that emerge often take the "happy path" of testing only for the conditions the developer expects.

 

Better unit and regression testing practices (with JUnit/Ant and other tools) have become par for the course in enterprise Java development. This offers a starting point for quality, but unit testing alone is simply too manual to properly exercise your components early in development, when problems are much easier to fix.

 

To really exercise these complex components early, we need to stop writing code to test code. We need to test the functionality and performance of the component - not create new volume of scripts to test. We need to help the QA and business requirements owners test to functionally validate our components, earlier in the project. CA’s DevTest was built from the ground up for this purpose. The DevTest framework includes CA Application Test and CA Service Virtualization.

 

Features Include

  • Inline testing.Break the code-compile-run-curse cycle, and never write a test client again. Execute test while you're authoring and adjusting them. You will have to see to believe the level of continual feedback you get while you are developing with DevTest.
  • Built on and for Java. DevTest is pure Java, and is innately aware of Java objects and RMI at a granular level, whether they are under development or "legacy" components you need to leverage. As you should expect, DevTest runs on any Java-ready client (Unix/Linux, Win, OSX) and can easily test objects on any Java-compliant server.
  • Easy enough for non-developers. DevTest is no-code automated testing, meaning developers save time by no longer having to script tests. Non-programming QA and business requirements team members can also get involved in testing the functional logic of these components.
  • Multiple systems. One DevTest test case can follow a complex workflow and validate multiple web sites, web services, Java objects and application servers. DevTest supports active sessions, SSL, authentication and magic strings, so it lets you test systems just as your end users will. On the back end, DevTest provides live interaction and deep testing of any component or service you can access over the Internet.
  • Across the full development lifecycle. Test components iteratively during development with immediate point-and-click responses. Then roll those same unit and functional tests into regression tests included in your Ant/Make builds. Then take those same test cases and turn them into load and stress tests that can run continuously

 

Benefits

  • DevTest for Java/RMI provides an ideal automated testing environment for Java objects and components, offering a new level of breadth and depth that allows the entire team to own quality.
  • True no-code automated testing with compelling features for both developers and QA professionals.
  • Eliminates the need to program test clients and maintain fragile test scripts.
  • Provides an immediate way to accelerate "test first," XP development practices.
  • Brings QA into the iterative development cycle for early and continuous testing.
  • Works with any J2EE application server (Java App Server, WebLogic, WebSphere, JBoss, more).
  • Leverages and runs with your existing build and deploy environment of JUnit/Ant scripts.
  • Point-and-click testing of Java classes, RMI, and other objects (CORBA, etc.) in a way no other product can.
  • Browse, analyze and make live assertions against any available logic or controls in the application.
  • Manage properties and test assertions.
  • Turn your Java/RMI test runs into load tests, and scheduled regression and performance tests over time.
  • Great for analyzing and testing legacy code and objects that you may need to integrate.
  • Test instrument your custom application code with the powerful Extension SDK.
  • Built for the future keep your test cases and extend them to web interfaces, EJBs, JMS queues, JDBC databases, web services and JMX metrics.
  • Share test cases and test runs as simple XML files and incorporate them into your existing groupware, issue tracking and requirements management processes.


CA’s Application Test - The Test Harness for Custom Java Applications

Are you running proprietary or custom software? Where most testing solutions would give up, DevTest’s integration abilities let developers "test enable" software. With minimal incremental effort, developers can make their code testable with our simple API. The whole team can get rich metrics and debugging information on applications behind the scenes.

The more complex your enterprise applications are, the more compelling testing with DevTest becomes. Quality is not just a tool you can buy, it is an experience your whole team needs to own.

 

Take a closer look at DevTest today – check out our latest intro product tours:

 

 

CA Application Test provides a single platform to execute the automated tests across systems, APIs and services. Test execution can be performed cross-browser and on mobile, and can use real devices, simulators, labs or cloud platforms. CA Application Test builds portable, executable test suites that are easy to extend, easy to chain into workflows with other tests, and simple to integrate with existing test repositories. With workflows the results from one test can be used to feed and kick off the next test saving hours of time and enabling continuous testing.


Multiple verification steps can be chained together. A test step is a workflow test case element that performs a basic action to validate a business function in the system under test. Steps can be used to invoke portions of the system under test. These steps are typically chained together to build workflows as test cases in the model editor. From each step, you can create filters to extract data or create assertions to validate response data.


The tool can include any type of different component verification steps. Below is an example of a multi-step test that crosses various layers of a financial application.

 


Multi-step test cases can be then staged together into test suites and then executed in a single command. A test suite can be combination of different tests, so if user wants to setup sequentially test one channel e.g. Web and then Test Mobile they could accomplish that as well.

 

You can test the interface. You can test your source code. But how do you know the "loosely coupled" components of your application are talking to each other? Messaging is the core connection point for any distributed application. Until now, your options for testing the integration that connects the dots on your infrastructure were largely manual endeavors.

The automated testing tool that speaks the language of your systems

CA Application Test, part of CA’s DevTest Framework, for JMS provides teams with a no-code way to discretely and deeply test messaging queues of almost any known flavor. Rather than forcing you to custom code or adapt a test client, CA Application Test can become a test harness that publishes and subscribes to JMS frameworks. Finally, without a massive implementation effort, you can decouple your systems for flexibility, and test for reliability at the same time.

Features

CA Application Test was built from the ground up for distributed architectures. If your strategy relies on JMS messaging to enable cross-component and cross-application integration, you should take a closer look at CA Application Test for JMS.

  • Inline testing. You'll never write a test client again. And you will execute while you're testing. You would have to see it to believe the level of information you can get while you are designing and maintaining JMS frameworks with CA Application Test. Break the code-compile-run-curse cycle.
  • Built on and for JMS standards. CA Application Test can talk and listen to most known JMS frameworks. As you migrate systems, you can get a wealth of reusable test cases and accompanying validation of your asynchronous messaging environment over time.
  • Multiple roles. CA Application Test is no-code automated testing, meaning developers can invoke JMS calls without having to script tests, and non-programming team members in QA and business requirements teams can also get involved in testing on their own terms.
  • Multiple systems. CA Application Test is pure Java, and is innately aware of Java objects, EJBs, RMI, JMS queues, JDBC databases, web services and JMX metrics. As you should expect, CA Application Test runs on any Java-ready client (Unix/Linux/Solaris, Win, OSX) and can easily test any server that routes JMS. CA APPLICATION TEST provides live interaction and deep testing of any JMS messaging you can access locally or over the Internet.
  • Across the full development lifecycle. Roll the same unit and functional tests you design into regression tests included in your Ant/Make builds. Then take those same test cases and turn them into load and stress tests that can run continuously from CA Application Test Server.

 

Benefits

  • Advanced publish and subscribe abstraction layer to test and load JMS frameworks for any message queue protocol (TIBCO, IBM MQseries, more).
  • Allows you to rapidly and deeply exercise JMS messaging queues across disparate systems, including guaranteed delivery settings and JNDI.
  • Create and/or assume temporary JMS Queues and Topics to snoop through the entire life cycle of a message as it move from message handler to message handler.
  • Validate that web services, EJBs and Message Driven Beans (MDB) are receiving/sending the appropriate message payloads.
  • True no-code automated testing with compelling features for both developers and QA professionals
  • Eliminates the need to program test clients and maintain fragile test scripts.
  • Provides an immediate way to enable "test first," XP development practices.
  • Brings QA into the iterative development cycle by including JMS calls within their test cases.
  • Works with any J2EE application server (Java App Server, WebLogic, WebSphere, JBoss, more).
  • Leverages your existing build and deploy environment of JUnit/Ant.
  • Browse, analyze and make live assertions against any available logic or controls in the application.
  • Manage properties and test assertions.
  • Instantly turn all unit/functional/regression test runs into load tests and scheduled performance tests.
  • Set alerts for boundary or failure conditions within any test run.
  • Test instrument your custom application code with the powerful CA Application Test Extension SDK.
  • Share test cases created in CA Application Test and test runs as simple XML files and incorporate them into your groupware, issue tracking and requirements management processes.

 

The Test Harness for Custom Applications

Are you running proprietary or custom software? Where most testing solutions would give up, CA Application Test's integration abilities let developers "test enable" software. With minimal incremental effort, developers can make their code testable with our simple API. The whole team can get rich metrics and debugging information on applications behind the scenes.

Testing Software AG/WebMethods-powered Integration, Business Process and SOA applications Enterprises adopt the Software AG suite to accelerate the development and alignment of IT around the core processes of the business. But whether you are approaching Software AG (webMethods) solutions as an enterprise integration challenge, or using the company's IT governance platform, CentraSite, as a way to embark on an SOA strategy, quality is essential from the start. CA's DevTest Framework includes CA Service Virtualization and CA Application Test and offers Software AG (webMethods) customers a no-code way to test, validate and virtualize every layer and every phase of Software AG implementations - at design time, run time and change time - ensuring trust in your critical business applications.

 

Ensuring Quality and Agility for webMethods Customers

The possibilities for deploying Software AG (webMethods) solutions for enterprise application integration (EAI), or as an enabler for SOA (Service-Oriented Architecture) initiatives, are as limitless as the ways a company can configure its business processes. But one aspect that all Software AG (webMethods) customers share is a need to integrate heterogeneous technology assets - from legacy apps to newer technologies - to build a larger business context. Conventional testing methodologies can be both costly, and ineffective in these environments.

Why is achieving test automation so critical in Software AG (webMethods) integrations?

 

  • High cost and effort of test creation and maintenance. Conventional UI-oriented and unit test coding approaches take a procedural approach that results in brittle tests that are invalidated by dynamic change in the system.
  • Lack of complete validation of the business workflow. Many testing tools oversimplify the approach for messaging and BPM workflow testing to only component testing at a single endpoint or messaging technology type.
  • Quality must maintain a business context across multiple layers of the application. In order to validate that a business requirement is met, integration testing must not skip verification of any of the layers in the architecture, whether these layers are newly integrated, or under the authority of a third party.
  • Inability to test at every stage of the application lifecycle. Testing as an "acceptance" phase or event prior to deployment can no longer provide sufficient coverage for a constantly changing, heterogeneous application structure. Quality must be a continuous part of design, development, build and deployment in order to ensure trust in the application.
  • Constraints due to unavailable or "not yet ready" services and components limits agility and lengthens delivery times for needed functionality. Virtualization of these components is needed to enable distributed teams to design and deliver functionality in parallel.

 

Benefits

  • CA’s DevTest framework is a comprehensive automated testing, validation and virtualization tool built from the ground up for SOA and composite application integration. If your integration strategy relies on SAG solutions, CA Application Test's declarative, no-code testing approach offers a compelling solution for maximizing delivered quality and minimizing business risk.
  • Native integration with CentraSite Active SOA. Out of the box, DevTest directly interacts with SoftwareAG's CentraSite platform, providing an immediate reference point for adding Quality to your overall Service Management and SOA Governance efforts. The ability to validate Policies - and SOA endpoints - both at a management and an implementation level with CA Application Test, ensures reliability and Trust that the system will work as defined.
  • Built for messaging standards. CA Application Test can talk and listen to webMethods Broker messaging layers, as well as most known JMS/MQ frameworks. As many implementations must integrate with - or migrate functionality from - other systems, teams using CA Application Test can get a wealth of reusable test cases and accompanying validation of the asynchronous messaging environment over time.
  • BPM Process-aware functional and load testing and verification. Break the code-compile-run-curse cycle. CA Application Test is no-code automated testing that normalizes your integration layers into a common, point-and-click test interface, allowing developers and business stakeholders to validate software in business process terms. Tests are highly reusable as orchestrated validation suites. CA Application Test extends the value of these efforts to performance testing activities, to verify that scalability or latency issues do not appear in production.
  • Multiple integrated systems. CA Application Test is pure Java, and natively tests Java objects, EJBs, RMI, JMS queues, JDBC databases, as well as web services (WSDL/SOAP) and file systems. As you should expect, CA Application Test runs on any Java-ready client (Unix/Linux/Solaris, Win, OSX) and can easily test any server that routes JMS. CA Application Test provides live interaction and deep testing of any applications assembled using SoftwareAG integration platforms.

 

 Features of CA Application Test for Software AG

  • Make live assertions against available services and implementation layers in SAG and webMethods-based integrations, both for business functionality, SLA validation, and as load and performance testing for IT Operations activities.
  • Create and/or assume temporary Broker JMS Queues and Topics to snoop through the entire life cycle of a message as it moves from message handler to message handler. Validate every layer of SOA or composite apps, ensuring web services, HTTP, Broker, and JMS endpoints are receiving/sending the appropriate message payloads at a unit level, or as part of the same test workflow.
  • Ensure integrity of migrations by validating file systems and transferred data within any JDBC data source. No need to program test clients and maintain fragile test scripts. Developers and QA teams stay engaged in testing throughout the application lifecycle with a high level of test automation and reuse. Business process owners can utilize CA Application Test's subprocesses to understand the validity of a process - even if they do not know exactly what components are tested.
  • Rich test metrics and feedback (SNMP and others) from webMethods Optimize, with monitoring and alerting to report boundary or failure conditions within Integration Server or Broker.
  • Virtualize dependent components with CA Service Virtualization across all technology layers within the SoftwareAG implementation, including Web Services, messaging services, data sources and underlying systems, allowing 24/7 availability of a valid environment for testing and validation for parallel development and integration.
  • Create a baseline test from a set of transactions in the using the Application Insight functionality.

 

DevTest for Software AG/webMethods - Testing, Validation and Virtualization Across the Platform

 

 

CA Application Test coverage for Software AG integration efforts.

CA Application Test provides teams with a 360-degree view of the quality and reliability of the application, and its underlying implementation layers, throughout its lifecycle at design time, run time, and change time.

Extending quality within your implementation process

The partnership of CA’s DevTest and Software AG extends beyond software, because an SOA strategy isn't something you buy, it is something you do. Best practices for Lifecycle Quality using CA Application Test fits within Software AG's best practice methodologies, and the end result is increased reliability and reduced cost and implementation risk.

In addition, enterprise applications will always contain some legacy or custom functionality that needs to be tested in order to fully validate a business process. CA Application Test Trace Kit's integration abilities let developers "test enable" software. Test Runner lets you incorporate tests into a continuous build workflow. Or, use Test Runner with JUnit to run standard JUnit tests in Ant or some other build tool. The whole team can get rich metrics and debugging information on applications behind the scenes.

The Continuous Validation Service in CA Application Test orchestrates the testing and validation aspects of IT, Integration workflows, and SOA Governance, to ensure reliability and instill trust throughout the lifecycle of the application. CA Application Test is part of CA’s DevTest Framework and conducts live regression, functional and performance monitoring of critical business workflows on a continuous basis, providing an actionable way to enforce that expected business policies are being met.

The Challenge: Solving the Unintended Consequences of Change in Enterprise Apps

Distributed enterprise applications will naturally evolve over time, as they leverage highly interdependent and changing services and technologies, which are assembled to build the finished application at runtime. Continuous integration is moving from a best practice to a do-or-die IT tactic. With so many heterogeneous components working together as an application, there is no specified "release date" for a new BPM process flow, or a new build of the components underlying your enterprise applications. When a service is added or changed, it has the potential to cause a "ripple effect" on other dependent upstream and downstream workflows.

 

In order to manage the business risk of this change, companies seek to employ IT Governance practices, to ensure that Management, Policy and Testing are all incorporated into the application development and deployment strategy. CA Application’s Test "Always On" testing provides a key enabler for quality, ensuring that expected Policies and business requirements are reliably met.

How the Continuous Validation Service Works

The Continuous Validation Service in CA Application Test can be used as a shared provider of both scheduled and event-based regression and performance test suites. When a change to an underlying application is made, when a new service is promoted for use, or if an unexpected error or performance expectation is not met, CA Application Test can communicate with the enterprise's stakeholders, or report this activity to an SOA governance, ALM collaboration tool, or IT monitoring platform.

 

 

With Continuous Validation in your environment, you gain a strategy for mitigating risk in your enterprise applications at build time, run time and change time, bridging the trust gap between Governance initiatives, and the actual software development and deployment lifecycle.

Benefits

Thorough, repeatable validation and testing that runs according to your process, and takes your entire extended application into account, pays measurable dividends: avoided failures, reduced testing and release costs, alignment of IT with business goals and policies, and best of all a good night's sleep.

 

  • For integration activities, instead of having to figure out if a given build succeeded or failed by poring through unit tests that might provide little result data, the CA Application Test can report detailed conditions directly to the tester or governance platform as a gateway for the release. This protects the integrity of the existing workflows already in play, and drastically accelerates the process of build/adjust during release thanks to Application Test’s deep contextual feedback to the developer.
  •  For live deployed applications, CA Application Test provides extreme visibility into the entire SOA architecture, both at a component and system-wide level, as it continually evolves. The ability to manage such extensive and detailed test suites, with a project hierarchy for flexibly building and scheduling test processes, with automated dashboards for stakeholders to use, creates an easy to use collaborative system for enterprise quality teams. 
  • For governance practices, deeply enhanced dynamic test registry and test suite management tools give your team an actionable set of verification assets, thereby ensuring that SOA Policies for the compliance and behavioral needs of the business are actually being met by the combined services


What is the cost of application failure in your mission-critical applications? Mandating a Policy or a Service Level Agreement is a great way to start, but real functional and performance verification with CA Application Test is where the rubber meets the road. CA Application Test can provide you with a picture of the health of your Critical Software on a continuous basis, which is what you need if you are relying on mission-critical enterprise applications.

To learn how to use the Continuous Validation Service go to:
https://docops.ca.com/devtest-solutions/10-0/en/using/using-ca-application-test/using-devtest-portal-with-ca-application-test/monitor-with-cvs-continuous-validation-service

 

Invoke and verify is a term unique to CA Application Test and refers to the products ability to test and validate response across all layers of an applications with a single test. This unique ability makes CA Application Test a great fit for organizations that need to test applications that must work with legacy systems, custom applications, ESBs and back-end databases. For example, if we want to check that an order was placed from a Mobile device under test, we may look within an enterprise service or Order Management System to validate the proper order entry - only when these two/three validations are complete can we state that we have validated the functionality.

 

In CA Application Test, API and non-API tests are created in the same way, using a code-less visual designer, one test can include API and non-API tests. SOAP, REST, general HTTP based APIs, JMS Messaging, Java, and more are supported. Users can model a single test case with steps that invoke and verify an API’s behavior and performance, as well as validate database calls, SOAP messages and many more types of transaction Test can contain a mix of any type of underlying technology step types, across any number of APIs.

 

  1. First, Application Test Connects to an object on the application server, or over the Internet.
  2. Next, Application Test Gathers information about the component, showing you available methods for interacting with it.
  3. Then, you can Invoke, or the target system with a method, to create a result.
  4. CA Application Test then gets the Response from that object as a behavior - so you can make a test assertion against that behavior as part of your testing process.
  5. CA Application Test can then React to that response and invokes the next step in the testing workflow.

 

Since CA Application Test is an integrated testing suite, the value of Functional Tests continues, and tests are Reused in other processes. For instance, you can save the response data within a database, use that data to validate the behavior of another component or sequence of steps, save that functional test sequence as part of a business workflow, check the workflow in deployment at load, and then monitor its performance within a set of workflows... the list goes on.

 

To learn how to use the invoke ability in CA Application Test 10.0 visit:

https://docops.ca.com/devtest-solutions/10-0/en/using/using-ca-application-test/using-devtest-workstation-with-ca-application-test/running-test-cases-and-suites/lisa-invoke

 

To see a quick tour of CA Application Test visit:

https://youtu.be/BAPRlADX8qQ