P2P Cycle

What is the P2P Process in SAP ?

The P2P cycle is the process of qcquiring goods or services from external vendors, receiving them, verifying them and processing vendor payments. It integrates MM and FI modules.

- P2P is the process of procuring goods/services and making payments to vendors. It starts with a purchase requisition and ends with payment settlement. It includes steps like PR, PO, GR, IR and Payment.

What are Key Steps  in P2P cycle ?

Purchase requisition (Optional) - ME51N

Purchase order Creation - ME21N (Manage Purchase Orders)

Goods Receipt - MIGO (Post Goods Receipt)

Invoice Receipt - MIRO(Create Supplier Invoice)

Payment to Vendor - F110 (App. Manage Automatic Payment)

What is the accounting entry at the time of goods receipt in SAP S/4HANA ?

Dr Inventory A/C

Cr GR/IR Clearing A/C

Note - No Vendor accounting entry is posted at this stage. 

What are the common T-codes used in P2P ?

ME21N - Create Purchase Order

MIGO - Goods Receipt 

MIRO - Invoice Receipt

F110 - Automatic Payment Run 

F-53 - Manual Payment

How is GST handled in the P2P cycle in india ?

GST is configured using tax procedures (TAXINN). During  Invoice posting (MIRO), input GST is automatically calculated based on tax codes. 

What master data is involved in P2P ?

ME51N - Create Purchase Requisition

ME54N - Approve Purchase Requisition

ME21N - Create Purchase Order

ME28 - Approve Purchase Order

MIGO - Post Goods Receipt

MIRO - Post Invoice

FBL1N - Display Vendor Line Item

F-44 - Clear Vendor Account 

F-53 - Manual Payment Processing

F110 - Automatic Payment Run

Tosca with Jenkins Integration.

Integrating Jenkins with Tricentis Tosca is a practical step for teams looking to bring more automation testing and consistency into their CI/CD pipelines. This setup allows you to execute Tosca test cases automatically from Jenkins, helping ensure smoother, more reliable test cycles with less manual intervention. below are the steps for setting up the Tosca Jenkins Integration using the Tricentis CI Plugin and ToscaCIClient.

Prerequisites for integration:

To connect Jenkins with Tricentis Tosca successfully, organizations need to have certain tools and conditions ready. First, you must have the Jenkins plugin for Tricentis Tosca. This plugin helps link the automation features of both systems. Make sure the plugin works well with your version of Jenkins because updates might change how it performs.

Next, it is important to have a set up Tricentis test automation environment. This is necessary for running functional and regression tests correctly within the pipeline. Check that the Tosca Execution Client is installed and matches your CI requirements. For the best results, your Tosca Server should also be current and operational.

Finally, prepare your GitHub repository for configuration. This allows Jenkins to access the code, run test cases, and share results smoothly. With these steps completed, organizations can build effective workflows that improve testing results and development efforts.

Step-by-step guide to configuring Tosca in Jenkins

Achieving the integration requires systematic configuration of Tosca within Jenkins. Below is a simple guide:

Step 1: Install Jenkins Plugin – Tricentis Continuous Integration

1. Go to Jenkins Dashboard → Manage Jenkins → Manage Plugins.

2. Search for Tricentis Continuous Integration in the Available tab.

3. Install the plugin and restart Jenkins if prompted.

Step 2: Configure Jenkins Job with Tricentis Continuous Integration

Once you’ve installed the plugin, follow these steps to add it to your Jenkins job:

• Go to your Jenkins job or create a new Freestyle project.
• Click on Configure.
• Scroll to Build Steps section.
• Click Add build step → Select Tricentis Continuous Integration from the dropdown.

Configure the Plugin Parameters

Once the plugin is installed, configure the Build Step in your Jenkins job using the following fields:

S. No	Field Name	Pipeline Property	Required	Description
1	Tricentis client path	tricentisClientPath	Yes	Path to ToscaCIClient.exe or ToscaCIJavaClient.jar. If using .jar, make sure JRE 1.7+ is installed and JAVA_HOME is set on Jenkins agent.
2	Endpoint	endpoint	Yes	Webservice URL that triggers execution. Remote: http://servername:8732/TOSCARemoteExecutionService/ DEX: http://servername:8732/DistributionServerService/ManagerService.svc
3	TestEvents	testEvents	Optional	Only for Distributed Execution. Enter TestEvents (names or system IDs) separated by semicolons. Leave the Configuration File empty if using this.
4	Configuration file	configurationFilePath	Optional	Path to a .xml test configuration file (for detailed execution setup). Leave TestEvents empty if using this.

Step 3: Create a Tosca Agent (Tosca Server)

Create an Agent (from Tosca Server)

You can open the DEX Monitor in one of the following ways:

• In your browser, by entering the address http://:/Monitor/.
  Directly from Tosca Commander.
• To do so, right-click a TestEvent and select one of the following context menu entries:
  Open Event View takes you to the TestEvents overview page.
  Open Agent View takes you to the Agents overview page.

Navigate the DEX Monitor

The menu bar on the left side of the screen allows you to switch between views:

• The Agent View, where you can monitor, recover, configure, and restart your Agents.
• The Event View, where you can monitor and cancel the execution of your TestEvents.

Enter:

• Agent Name (e.g., Agent2)
• Assign a Machine Name

This agent will be responsible for running your test event.

Step 4: Create and Configure a TestEvent (Tosca Commander)

• Open Tosca Commander
• Navigate to: Project > Execution > TestEvents
• Click Create TestEvent
• Provide a name like Sample

• Step 4.1: Assign Required ExecutionList
• Select the ExecutionList (this is where you define which test cases will run)
• Select an Execution Configuration
• Assign the Agent created in Step 3
• Step 4.2: Save and Copy Node Path
• Save the TestEvent

  

• TestEvent → Copy Node Path

  

• Paste this into the TestEvents field in Jenkins build step

  

Step 5: How the Integration Works

Execution Flow:

• Jenkins triggers test execution using ToscaCIClient.
• The request reaches the Tosca Distribution Server (ManagerService).
• Tosca Server coordinates with AOS to retrieve test data from the Common Repository.
• The execution task is distributed to a DEX Agent.
• DEX Agent runs the test cases and sends the results back.
• Jenkins build is updated with the execution status (Success/Failure).

Step 6: Triggering Execution via Jenkins

Once you’ve entered all required fields:

• Save the Jenkins job
• Click Build Now in Jenkins

What Happens Next:

• The configured DEX Agent will be triggered.
• You’ll see a progress bar and test status directly in the DEX Monitor.

  

• Upon completion, the Jenkins build status (Pass or failure) reflects the outcome of the test execution.

  

Step 7: View Test Reports in Jenkins

To visualize test results:

• Go to Manage Jenkins > Manage Plugins > Available
• Search and install Test Results Analyzer
• Once installed, configure Jenkins to collect results (e.g., via JUnit or custom publisher if using Tosca XML outputs)

Notes: 

Why should I integrate Tosca with Jenkins?

Integrating Tosca with Jenkins enables continuous testing, reduces manual effort, and ensures faster, more reliable software delivery.

Can I use Tosca Distributed Execution (DEX) with Jenkins?

Yes, Jenkins supports both Remote Execution and Distributed Execution (DEX) using the ToscaCIClient.

Do I need to install a plugin for Tosca Jenkins Integration?

Yes, you need to install the Tricentis Continuous Integration plugin from the Jenkins Plugin Manager to enable integration.

What types of test cases can be executed via Jenkins?

You can execute any automated Tosca test cases, including UI, API, and end-to-end tests, configured in Tosca Commander.

Is Tosca Jenkins Integration suitable for Agile and DevOps teams?

Absolutely. This integration supports Agile and DevOps practices by enabling faster feedback and automated testing in every build cycle.

How do I view Tosca test results in Jenkins?

Install the Test Results Analyzer plugin or configure Jenkins to read Tosca’s test output via JUnit or a custom result publisher.

What is an AI Co-Pilot?

An AI Co-Pilot is an artificial intelligence assistant designed to help users perform tasks more efficiently by providing contextual suggestions, automating repetitive actions, and enhancing productivity within existing workflows. It typically works alongside users, offering real-time support without taking independent action.

However, more recently, AI Agents or Agentic AI have arrived as the new kid on the block who seems to be drawing all the limelight (and for good reason!).

What is Agentic AI?  

Agentic AI refers to autonomous AI systems capable of not only assisting users but also acting independently to complete multi-step goals without constant human intervention. These systems leverage advanced automation, conversational interfaces, and decision-making capabilities to deliver end-to-end task execution.

Tosca is evolving with AI!

Tricentis has introduced Agentic AI into Tosca, taking automation to the next level.

While Tosca Copilot acts as an assistive AI—helping with queries, test summaries, and troubleshooting—Agentic AI goes further by autonomously creating, adapting, and executing tests from natural language.

Key Highlights:

Copilot = Assistive AI → boosts usability & guidance

Agentic AI = Autonomous AI → drives end-to-end test automation

Reported 85% faster test creation & 60% productivity gains

This marks a big shift in how QA teams can leverage AI to accelerate testing and improve software delivery.

QA Terminology

Below are the most commonly used QA terminologies that every QA professional ought to know. Make sure you’re familiar with all of them:

1. Test Case: A set of actions used to determine if a system behaves as expected in a given scenario.
2. Bug/Defect: A problem or error that hinders a software program from functioning as expected.
3. Smoke Testing: Basic tests to check if a new software version is stable enough for more in-depth testing.
4. Regression Testing: Verifying if previously working functionality still works after new changes.
5. Unit Testing: Testing the smallest testable parts of an application in isolation (e.g., functionality like a button, link, dropdown, etc). If an application were a physical machine, it would be like testing the quality of the nuts, bolts and transistors before assembled into a more recognizable part of the machine, for instance a control panel. This testing is commonly done by developers.
6. Integration Testing: Testing in which individual components or units are added one by one and tested progressively until the group of components are successfully tested. If an application were a physical machine, integration testing would be like testing how the previously tested nuts and bolts work together once assembled. For example, a control panel, which is only a part of a machine, must have many components or units that must be assembled to test that the panel itself works as it should.
7. System Testing: Testing the integrated parts together to ensure it meets the requirements. If an application were a machine, in addition to a control panel, there would be other machine parts similarly assembled and tested. System testing is like seeing whether the entire machine works as expected.
8. UAT (User Acceptance Testing): The final testing phase where actual users try the software to make sure it works in real-life scenarios. The users can be individual people or a company for which the product/software was created.
9. Test Suite: A collection of test cases that have been grouped for a specific purpose.
10. Sanity Testing: Testing that uses a subset of regression tests to quickly check that a new software build/version works as expected. Some people consider this the same as smoke testing.
11. Black Box Testing: Testing software based on output, without knowing its internal workings. For example, when an end-user interacts with the website’s UI without having access to the code.
12. White Box Testing: Testing software with knowledge of its internal workings.
13. Test Plan: A detailed document outlining the testing strategy, objectives, resources, schedule, and deliverables.
14. Test Script: Step-by-step instructions for a particular test.
15. Test Scenario: A high-level idea of what to test. It can have multiple test cases.
16. Exploratory Testing: Testing the software without a set plan, exploring and learning the application.
17. Boundary Testing: Testing the limits (edges or boundaries) of the software input.
18. Functional Testing: Testing that software features work as expected. This is an umbrella term under which several of the other types of testing already defined are grouped (i.e., Sanity, Smoke, Regression, UAT).
19. Non-functional Testing: Testing non-operational aspects of a software, like performance, usability, or security.
20. Test Environment: A controlled setting where testing is conducted.

What is Tosca Copilot ?

Tosca Copilot is a generative AI-powered assistant integrated into Tricentis Tosca, designed to enhance user productivity in testing. It utilizes advanced large language models (LLMs) to help users quickly find, understand, and optimize test assets. Tosca Copilot facilitates tasks like explaining test cases, converting natural language to Tosca Query Language (TQL), and summarizing test execution results, ultimately aiming to boost efficiency and quality across the testing lifecycle. 

Tosca Copilot is part of the broader Tricentis Copilot program, which includes AI-powered assistants for other Tricentis products like Testim and qTest. This program aims to accelerate test creation, improve test quality, and simplify testing across the entire software development lifecycle.

Here's how Tosca Copilot can help you:

• Test Case Generation: Automatically create test cases from natural language descriptions or user stories, including edge cases and variations, accelerating the test design process.
• Test Optimization: Streamline your test suite by identifying and suggesting removal of unused, duplicate, or unlinked test cases, or by recommending optimizations to existing ones for better coverage and efficiency.
• Test Result Insights: Understand failed tests faster with actionable insights generated by Tosca Copilot, aiding in quick troubleshooting and issue resolution.
• Maintenance and Refactoring: Perform maintenance tasks like renaming test steps, cleaning up labels, or searching for specific test artifacts using chat commands.
• Onboarding and Learning: New team members can quickly grasp complex test cases and Tosca functionalities through explanations provided by the Copilot, according to Tricentis. 

How it works:

Tosca Copilot leverages advanced Large Language Models (LLMs) to understand natural language requests and interact with Tosca, performing actions like: 

• Converting natural language instructions into Tosca Query Language (TQL) queries for finding and managing test assets.
• Generating test case descriptions, steps, and data from user stories or specifications.
• Analyzing execution logs and providing insights into test failures in easily understandable language. 

Benefits:

• Time Savings: Reduced manual effort for creating tests, generating data, and analyzing results translates to faster testing cycles and quicker time-to-market.
• Increased Productivity: Testers can focus on more strategic tasks, and new team members can get up to speed faster with the Copilot's assistance.
• Cost Savings: By optimizing test suites, reducing redundant efforts, and minimizing manual maintenance, Tosca Copilot helps lower overall testing costs.
• Improved Software Quality: Automated test generation and defect analysis lead to higher test coverage, early bug detection, and ultimately, better quality software. 

In conclusion, Tosca Copilot helps streamline test automation by assisting with various tasks throughout the testing lifecycle. It utilizes generative AI to enhance productivity, accelerate learning, reduce costs, and ultimately deliver higher quality software.

Tosca Copilot's capabilities:

Natural Language Interaction:

Tosca Copilot allows users to interact with Tosca using natural language, making it easier to query and understand test assets. 

Test Case Explanation:

It can explain the functionality of a test case in plain language, providing insights into its purpose and steps. 

TQL Query Generation:

Users can convert their natural language queries into Tosca Query Language (TQL) to search and filter test assets effectively. 

Test Optimization:

Tosca Copilot helps in identifying unused or unlinked test assets, duplicates, and other inefficiencies, enabling users to streamline their test libraries. 

Troubleshooting:

It aids in understanding failed test executions by summarizing the results and providing insights into potential causes. 

Integration with Microsoft Azure OpenAI Service:

Tosca Copilot leverages the power of Microsoft Azure OpenAI Service, ensuring enterprise-level data privacy and security compliance.