Stateful Mocks

[briguy202]

We're using Microcks and loving it! However, there's one missing feature we had previously in a different mocking product that I'm curious if Microcks has that I've missed or has on its roadmap which is to allow for stateful mock responses.

The scenario is suppose I have an API that creates resources via a POST call. When emitting a new resource we could easily apply the Faker-based generated data to return the response; however, without state, subsequent GET calls for that same "created" resource is lost - if relying on Faker again on the GET, one would receive a vastly different response. When testing APIs in isolation, the predetermined responses work perfectly, but in end-to-end scenarios where one API's response must feed into the next's call, being able to hold state would be helpful.

[ghost]

To solve a similar issue i used an external webdis which is a http redis api to store data.
Then with microcks SCRIPT_DISPATCHER i wrote a groovy script that called webdis and stored data in the webdis and then when i needed it i pulled data from the webdis.
We could maybe add somewhat of a store directly accessible in the context of the script

[lbroudoux]

Thanks for starting the discussion! Happing to know you're loving Microcks!
BTW, have you ever considered declaring yourself as an adopter? 😉

@apoorva256: it could be nice to get more details on how you're doing things at the SCRIPT_DISPATCHER level to appreciate your solution. Considering that we already have some "Backend as a Service" in Microcks with Direct APIs, it could be something we build internally on top of this feature.

[ghost]

I was in a situation where my frontend called an mocked api(POST with information) that returned an id and then called another api with that id and that other api needed the information.
first api request script

import groovy.json.JsonBuilder
import groovy.json.JsonOutput
import groovy.json.JsonSlurper

def webdisUrl = 'http://webdis:7379';


// get post body params

if (mockRequest.requestContent == null) {
    return 'error';
}

def json = new JsonSlurper().parseText(mockRequest.requestContent);

// encode json in base64

def base64 = JsonOutput.toJson(json).bytes.encodeBase64().toString();

// send to Redis with 120000 ms timer(key will auto destroy in 120 sec)

def uuid = UUID.randomUUID().toString();
def req = new URL("${webdisUrl}/SET/$uuid/$base64/PX/120000").getText();

requestContext.put('id', "$uuid");
return 'TEMPLATED_RESPONSE';

second api request script

import groovy.json.JsonSlurper

def webdisUrl = 'http://webdis:7379/';

// get uuid

def uri = mockRequest.getRequest().getRequestURI();
def parts = uri.split('/');
def uuid = parts[parts.length - 1];

// get base64 encoded json from redis

def req = new URL("${webdisUrl}GET/$uuid").getText();
log.info(req);
def base64 = (new JsonSlurper().parseText(req))['GET'];
byte[] jsonStringBytes = base64.decodeBase64();
String jsonString = new String(jsonStringBytes);
log.info(jsonString);

// decode json

def json = new JsonSlurper().parseText(jsonString);

requestContext.put('data', json['data']);

return 'TEMPLATED_RESPONSE';

[lbroudoux]

I love this approach of setting TTL to a document. We could do exactly the same thing but still using Microcks'DB as the store for documents instead of relying on external Redis.

I think this one works pretty well with a well-designed API where id is on the path and because you provide the TEMPLATE_RESPONSE... but I don't think we could generalize this approach for each and every API...

@briguy202 What's your thought on this?