International Business Machines Corporation

Saurabh Sinha

Shriram Rajagopalan

Satish Chandra

Maja Vukovic

Suresh Thummalapenta

Tara Lynn Astigarraga

Anup Kalia

John Joseph Rofrano

Jin Xiao

Chen Lin

Raghav Batta

Vibha Singhal Sinha

Pankaj Dhoolia

Vugranam Chakravarthy Sreedhar

Yandrapally Rahulkrishna

Hao Chen

Leigh Allen Williamson

Nishant Kumar Sinha

Senthil Kumar Kumarasamy Mani

Giriprasad Sridhara

Lian Xue Hu

Mangala Gowri, Iii

Federico Eduardo Carpi

Juan Ariel Brusco Cannata

Anand Krishna Vaishampayan

Vijay Ekambaram

Shu Tao

Rachel Tzoref-Brill

Richard Baxter Hull

Monika Gupta

Eli Arbel

Debdoot Mukherjee

Ganesan Ramalingam

John H Field

Senthil K Mani

Rudrapatna Kallikote Shyamasundar

Nerla Jean-Louis

Kevin Wahlmeier

Srinivas Mangipudi

John Jeffrey Dillon

Vasanta K Lakshmi

Rahul Krishna Yandrapally

Raghavan Komondoor

Kommineni Vasanta Lakshmi

William Jacob Cobb, Jr

Yandrapally RahulKrishna

Michael Shane Goode

Achin K Das

A system, computer program product, and method are presented for executing a validation test on at least a portion of a refactored application. The refactored application is resident within a partitioned computing architecture including a plurality of partitions and communication between the partitions uses one or more boundary methods. The refactored application is at least partially similar to a transformed monolithic application. The method includes automatically generating one or more test sequences for exercising one or more functional behaviors for each boundary method of the one or more boundary methods.

Validating inter-partition communication in microservice decomposition

Systems, computer-implemented methods, and computer program products to facilitate generation of microservices from a monolithic application based on runtime traces are provided. According to an embodiment, a system can comprise a memory that stores computer executable components and a processor that executes the computer executable components stored in the memory. The computer executable components can comprise a model component that learns cluster assignments of classes in a monolithic application based on runtime traces of executed test cases. The computer executable components can further comprise a cluster component that employs the model component to generate clusters of the classes based on the cluster assignments to identify one or more microservices of the monolithic application.

Generation of microservices from a monolithic application based on runtime traces

Systems, computer-implemented methods and/or computer program products that facilitate generating code for template specification in a quote to cash (Q2C) solution are provided. In one embodiment, a computer-implemented method comprises: generating, by a system operatively coupled to a processor, a data model by specifying from a universal template which fields and attributes to include in the data model; mapping, by the system, external data into the data model; and generating, by the system, a code for template specification based on the data model, one or more business rules and a first code template.

Generating a quote to cash solution

A computer implemented method for testing rules by a computing device including selecting a current version of a rule and prior version of the rule, comparing the prior version of the rule and the current version of the rule to each other to identify a type of change made in the current version of the rule with respect to the prior version of the rule, and testing the prior version of a rule and the current version of the rule using a common data set, the testing being based on the identified type of change. The test result is provided to a user.

System and method for differential testing of evolving rules

Techniques for automated generation of inputs for testing microservice-based applications. In one example, a computer-implemented method includes: traversing, by a system operatively coupled to a processor, a user interface of a microservices-based application by performing actions on user interface elements of the user interface; and generating, by the system, an aggregated log of user interface event sequences and application program interface call sets based on the traversing. The computer-implemented method also includes: determining, by the system, respective user interface event sequences that invoke the application program interface call sets; and generating, by the system, respective test inputs based on the respective user interface event sequences that invoke the application program interface call sets.

Automated test input generation for integration testing of microservice-based web applications

Systems and techniques that facilitate automated generation of relevant and adequate test datasets based on guarded commands are provided. In various embodiments, a query generation component can generate a query language query based on a first guarded command. In various aspects, an execution component can execute the query language query on a data table to return one or more datasets for testing the first guarded command. In various embodiments, the query generation component can comprise an initialization component that can initialize conditions of a WHERE clause of the query language query based on the first guarded command. In various instances, the query generation component can further comprise a transformation component that can transform the conditions of the WHERE clause of the query language query based on a sequence of guarded commands on which the first guarded command depends. In various cases, the query generation component can further comprise a translation component that can convert the transformed conditions of the WHERE clause of the query language query into query language syntax.

Generation of test datasets for guarded commands

Technology for dividing a monolith computer program into a plurality of functions and creating a microservice for each function of the model's computer program. The micro-services are semantically and functionally equivalent, taken collectively, to the model's computer program from which they came. In some embodiments, the monolith computer program is written in an object oriented programming language suitable for execution by a virtual machine (VM). In some embodiments, the microservices are in representational state transfer (REST) form and respectively corresponding application programming interface (API).

Generation of equivalent microservices to replace existing object-oriented application

A method, system, and computer program product for decomposing monolithic applications to form microservices are provided. The method identifies a set of classes within a monolithic application. A set of horizontal clusters are generated by performing horizontal clustering to the set of classes to decompose the classes based on a first functionality type. The method generates a set of vertical clusters by performing vertical clustering to the set of classes to decompose the classes based on a second functionality type. A subset of classes occurring in a common horizontal cluster and vertical cluster are identified as a functional unit. The method merges one or more functional units to form a microservice.

Forming microservices from monolithic applications

A system includes a memory that stores computer-executable components and a processor, operably coupled to the memory, that executes the computer-executable components stored in the memory. The computer-executable components include a deployment generator component that analyzes current component versions of application services and determines differences with previous deployment versions of the application services deployed to a target computing environment. A service deployment output component generates instructions to selectively update the application services to the target computing environment based on the determined differences between the previous deployment versions and the current component versions of the application services.

Model-based differencing to selectively generate and deploy images in a target computing environment

Techniques for automated generation of inputs for testing microservice-based applications are provided. In one example, a computer-implemented method traverses a user interface of a microservices-based application by performing actions on user interface elements of the user interface, and generates an aggregated log of user interface event sequences and application program interface call sets based on the traversing. The computer-implemented method also determines respective user interface event sequences that invoke application program interface call sets and generates respective test inputs based on the user interface event sequences that invoke the application program interface call sets.

A contract generation system that automatically generates cost models for new business contracts is provided. The system receives a new contract comprising a set of key-value pairs, each key-value pair comprising a question and an answer that correspond to a field of information in a document for the new contract. The system computes a similarity measure between the new contract and an existing contract based on a set of variance definitions for determining differences between the set of key-value pairs of the new contract and a corresponding set of key-value pairs of the existing contract. The system generates a cost model of the new contract based on the similarity measure and a cost model of the existing contract.

Creating cost models using standard templates and key-value pair differential analysis

Techniques are provided for automated resiliency testing. In one example, a computer-implemented method comprises analyzing, by a system operatively coupled to a processor, an annotated state transition graph of a user interface of a microservices-based application, wherein the annotated state transition graph has edges annotated with application program interface call subgraphs. The computer-implemented method also comprises generating, by the system, an ordered list of the application program interface call subgraphs based on the analyzing.

Prioritizing resiliency tests of microservices

One embodiment provides a method of identifying discrepancies of an application operating on multiple operating platforms, the method including: utilizing at least one processor to execute computer code that performs the steps of: obtaining a first source code associated with an application of a first operating platform, the first source code including at least one feature of the application; generating, based on the first source code, a first context graph; obtaining a second source code associated with the application of a second operating platform, the second source code including the at least one feature of the application; generating, based on the second source code, a second context graph; comparing the first and second context graph; and identifying, based on the comparison, at least one discrepancy. Other variants and embodiments are broadly contemplated herein.

Automatically detecting feature mismatches between mobile application versions on different platforms

Growing community of inventors

Danbury, CT, United States of America

Saurabh Sinha