Video: How software testers can add value in a world of microservices?

Last month Wojciech talked at the National Software Testing Conference in London about how software testers can add value in a world of microservices.

The video presentation can be purchased from 31 Media http://www.softwaretestingconference.com/product/video-presentations-2018/. Please note we do not receive any commision on the sales of that video, all money goes to 31Media.

How to mock and also passthrough HTTP(S) requests to multiple systems?

You can use API mocks to isolate yourself from backed and third party dependencies. There are cases where it would be advisable to lookup responses in the API mock but when none are found, forward (passthrough) the request to the real backed or third party service. In Traffic Parrot you can passthrough to one domain at a time. So how to deal with a situation when there are more than one domain you would like to mock? The solution is to use multiple Traffic Parrot instances, each mocking and passing though to a different domain.

Mock and pass through to multiple domains

To configure passthough, open Traffic Parrot and click on HTTP->Passthough.

How to configure passthough 

 

How to resolve "Address already in use" issue?

Updated Privacy Policy

We have updated the Privacy Policy. Please find the latest version available at https://trafficparrot.com/privacy-policy.html

How software testers can add value in a microservices world?

Ever wondered how to test microservices?

Wojciech will talk at the National Software Testing Conference in London on the 23rd of May 2018 about just that!

He will talk about a global media company that decided to move their infrastructure to Docker/Kubernetes and microservices. He will cover QAs daily responsibilities in that environment, microservices testing risks and how QAs can provide value in a microservices environment where 93% of code test coverage is done by automated tests written by developers.

Sign up now for this talk and many more at http://www.softwaretestingconference.com/ 

Dynamic API mocks

We have just published a new tutorial on how to create dynamic responses in your API mocks.

Simulating systems communicating with file transfers to save time and enable automated testing

Sending and receiving files is a common way of exchanging information in many industries. Two main ones are banking (for example SWIFT) and telecommunications (for example mobile number porting). They are typically shared over local filesystems, NFS or FTP/SFTP.

This raises issues like:

• Setting up test data in the third party or backend systems slows down developers and testers on your team
• Creating response files based on request files without the third party or backend system is done manually

You can create files manually, but:

• Creating files manually will not work when you are running automated tests
• Crafting files manually is error-prone
• Crafting files manually is time-consuming
• Sometimes response files need to be present within only a few seconds because the application times out otherwise, so there is no time to create them manually

Traffic Parrot comes with help. It now supports service virtualization, simulating and mocking of systems communicating with file transfers over local filesystems, network filesystems like NFS or mounted shared filesystems (with beta FTP and SFTP available).

Simulating systems communicating with files

You can:

• Consume request files
• Produce response files
• Record and replay communication with files
• Create manually request to response file mappings
• Generate dynamic response file names (scriptability)
• Generate dynamic response file content based on request file content (scriptability)

Example of a request to response file mapping

For more information have a look at the files transfers documentation.

Get access to Traffic Parrot Beta

Do you need service virtualization, API mocking or system simulation for one of these protocols?

• FIX
• FAST
• FIXatdl
• SWIFT
• AMQP
• MQTT
• RabbitMQ
• SonicMQ
• CORBA
• GRPC
• FTP
• SFTP
• .NET WCF
• RMI
• MTP
• TIBCO EMS
• CICS
• SAP RFC
• JDBC
• Mongo

Join the Traffic Parrot Beta programme to get access to them and other features.

Running free IBM® MQ for Developers

Sometimes when mocking or virtualising systems communicating with IBM WebSphere MQ you do not have the admin rights to create new queues on your existing IBM instance, that could be used by Traffic Parrot.

One solution is to use the free IBM MQ for Developers.

We have created a tutorial how to spin it up in a mater of a couple of hours by using AWS free tier EC2 Linux box.

View the tutorial here.

The Best QA Software Testing Directory (Top Tools and Companies in 2018)

Check out position number 9 in the The Best QA Software Testing Directory!

Simulating IBM® MQ JMS systems with dynamic mock responses

We have just added a new section to the tutorials about Simulating IBM® MQ JMS systems with dynamic mock responses. It will show you how to create dynamic mock JMS IBM MQ responses. Read more here.

How software testers can create dynamic mocked JSON responses, no programming skills needed!

The recommended way of creating mocks or stubs of third party or backed systems and APIs is to keep them as simple as possible.  Unfortunately, sometimes it is not possible to keep things simple, and it is necessary to create more complex systems or API simulators. In this example, we will go through an example how to create a simulator of an API that will dynamically generate a list of items in a response based on a request.

Let us assume that your application will send the following requests to a backend API:

{
  "orderId": 3,
  "storeId": 2244,
  "orderItems": [
    {
      "partnumber": "101",
      "quantity": 1
    },
    {
      "partnumber": "102",
      "quantity": 3
    }
  ]
}

And, let us assume that the response from that backend API looks like this:

{
  "orderAccepted": true,
  "orderItems": [
    {
      "orderItemId": 101,
      "quantity": 1
    },
    {
      "orderItemId": 102,
      "quantity": 3
    }
  ],
  "subordersCount": 2
}

Notice, that the request contains a list of items "orderItems" that is then populated in the response. So, to create the response dynamically, we need to parse the request JSON and create the response JSON based on the request. We can do that using the Traffic Parrot jsonPathList helper.

Let us also assume that we would like to accept the order only if the number of items in the request is even and reject it if the number is odd. To do that we can use the ifEven helper.

Here is a response body that you can copy and paste into Traffic Parrot that will generate a response dynamically based on the request:

{
  "orderAccepted": {{#ifEven (size (jsonPathList request.body '$.orderItems'))}}true{{else}}false{{/ifEven}},
  "orderItems": 
    [
      {{#each (jsonPathList request.body '$.orderItems') }}
           {
          "orderItemId": {{ jsonPath this '$.orderItemId' }},
          "quantity": {{ jsonPath this '$.quantity' }}
        }
        {{#unless @last}},{{/unless}}
      {{/each}}
    ]
  "subordersCount": {{size (jsonPathList request.body '$.orderItems')}}

}

Configuring a HTTP response in Traffic Parrot

This approach does not require knowledge of any programming languages, so almost anybody can do it. You can use this approach for HTTP(S), JMS, MQ and Files simulators. To get started with Traffic Parrot have a look at the quick start guide. Contact us for a free initial 30-minute consultation.

Mocking and simulating JMS IBM® WebSphere MQ

We have just published a new tutorial on how to mock and simulate JMS IBM® WebSphere MQ. It explains how to use Traffic Parrot systems simulation to allow for testing your application in isolation. Read more.

Getting started with stubbing, mocking and service virtualization

We have started creating a series of tutorials on stubbing, mocking, API simulation and service virtualization. The first chapter is on getting started with stubbing, mocking and service virtualization!

How can I simulate an outside system that uses MQ?

"In a real test scenario I have one test system which connects to outside system using MQ in production. How can I simulate that outside system in my test environment? Let me give example: XYZ Bank sends a message to processing system with XML fields of ACCNO, NAME, AMT, DATE etc. I am a tester of XYZ Bank Application. I want to verify the request and response. How can I do that? I am a sender and receiver but other system is outside my test environment. How to simulate it?" (source)

The simulator you are referring to is typically called a mock, stub or virtual service. If you would like to simulate the outside system to enable testing of your application you should use a mocking tool (also called service virtualization). Just make sure you use a tool that supports IBM MQ. An example of a tool that can simulate and mock IBM MQ for the purpose of testing is Traffic Parrot.