This document discusses microservices and whether they are better for developers or QA. It begins by introducing the author and their experience in QA. It then provides an overview of microservices, including definitions and differences from monolithic applications. Examples of implementing microservices are shown using Java code. The document concludes that microservices are more expensive and difficult to develop and test, but can be easier to test programmatically for those with object-oriented knowledge. It also includes questions, links to additional resources, and contact information.

1. MICROSERVICES: BETTER FOR DEVS OR
QA'S?
Aliona Tudan, senior QA at N-iX

2. ABOUT MYSELF
 7-8 years in QA
 Leading teams
 BI testing
 WS testing
 Back-end auto-tests writing & maintaining
 Java, Groovy

5. Client
Server

6. WTF?

7. WTF?REST

8. Hello dear Mr.Blah,
sorry for disturbing,
could you please...
Kind regards,
...

9. Hello dear Mr.Blah,
sorry for disturbing,
could you please...
Kind regards,
...
SOAP

10. ARCHITECTURE OF COMMUNICATION

11. ONE LAYER

12. MORE

16. Microservice applications are composed of small, independently
versioned, and scalable customer-focused services that
communicate with each other over standard protocols with well-
defined interfaces.
MICROSERVICE

18. In short, the microservice architectural style is an approach to developing a
single application as a suite of small services, each running in its own
process and communicating with lightweight mechanisms, often an HTTP
resource API. These services are built around business capabilities and
independently deployable by fully automated deployment machinery.
There is a bare minimum of centralized management of these services,
which may be written in different programming languages and use different
data storage technologies.
-- James Lewis and Martin Fowler

19. https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-overview-microservices

20. https://martinfowler.com/articles/microservice-trade-offs.html

21. DIFFERENCES
 A monolithic app contains domain-specific functionality and is normally
divided by functional layers, such as web, business, and data.
 You scale a monolithic app by cloning it on multiple servers/virtual
machines/containers.
 A microservice application separates functionality into separate smaller
services.
 The microservices approach scales out by deploying each service
independently, creating instances of these services across servers/virtual
machines/containers.
https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-overview-microservices

22. REAL LIFE

23. REAL LIFE

24. REAL LIFE

25. private static class EventDetails {
private static final String eventHubName = "Hub";
private static final String sasKeyName = "KeyName";
private static final String sasKey = "Key";
public static EventDetailsDto getEventDetails() {
final URI endpoint;
try {
endpoint = new URI("http://url.com");
} catch (URISyntaxException e) {
throw new RuntimeException("URI is not correct. Cause: " + e.getLocalizedMessage(), e);
}
EventDetailsDto eventDetailsDto = new EventDetailsDto();
eventDetailsDto.setEndpoint(endpoint);
eventDetailsDto.setEventHubName(eventHubName);
eventDetailsDto.setSasKeyName(sasKeyName);
eventDetailsDto.setSasKey(sasKey);
return eventDetailsDto;
}
}
JAVA CODE

26. public class EventDetailsDto{
private URI endpoint;
private String eventHubName;
private String sasKeyName;
private String sasKey;
public EventDetailsDto() {}
public URI getEndpoint() {
return endpoint;
}
public void setEndpoint(URI endpoint) {
this.endpoint = endpoint;
}
public String getEventHubName() {
return eventHubName;
}
public void setEventHubName(String eventHubName) {
this.eventHubName = eventHubName;
}
JAVA CODE

27. JAVA CODE
public String getSasKeyName() {
return sasKeyName;
}
public void setSasKeyName(String sasKeyName) {
this.sasKeyName = sasKeyName;
}
public String getSasKey() {
return sasKey;
}
public void setSasKey(String sasKey) {
this.sasKey = sasKey;
}
@Override
public String toString() {
return "EventDetailsDto{" +
"endpoint=" + endpoint +
", eventHubName='" + eventHubName + ''' +
", sasKeyName='" + sasKeyName + ''' +
", sasKey='" + sasKey + ''' +
'}';
}
}

28. public static void sendEvent(final EventDetailsDto detailsDto, String partitionKey, byte[] payloadBytes,
String streamNamespace) {
EventHubClient ehClient = null;
EventDetailsDto eventDetailsDto = detailsDto;
try {
if (eventDetailsDto == null) {
eventDetailsDto = EventDetails.getEventDetails();
}
ConnectionStringBuilder connStr = new ConnectionStringBuilder(eventDetailsDto.getEndpoint(),
eventDetailsDto.getEventHubName(), eventDetailsDto.getSasKeyName(), eventDetailsDto.getSasKey());
EventData eventData = new EventData(payloadBytes);
eventData.getProperties().put("StreamNamespace", streamNamespace);
ehClient = EventHubClient.createFromConnectionStringSync(connStr.toString());
ehClient.sendSync(eventData, partitionKey);
} catch (Throwable throwable) {
throw new RuntimeException("There was a trouble building connection to Azure: " +
throwable.getLocalizedMessage(), throwable);
} finally {
try {
ehClient.closeSync();
} catch (ServiceBusException e) {
throw new RuntimeException("Event to Azure Event Hub was not sent. Cause: " +
e.getLocalizedMessage(), e);
}
}
}
JAVA CODE

29. HOW TO APPLY IN TESTS?
Simply add scripts step into SOAP UI

30. SOAP UI SCRIPT
import lib.PushEvent;
def eventHubName =
context.getTestCase().getTestSuite().project.getPropertyValue("eventHubName");
def sasKeyName = "Key";
def sasKey = "Blahblahblah";
endpoint = new URI("http://blah.net");
EventDetailsDto eventDetailsDto = new EventDetailsDto();
eventDetailsDto.setEndpoint(endpoint);
eventDetailsDto.setEventHubName(eventHubName);
eventDetailsDto.setSasKeyName(sasKeyName);
eventDetailsDto.setSasKey(sasKey);
String partitionKey = "uuid";
byte[] payloadBytes =
"[{"EmailAddress":"test@test.com","TemplateId":"WelcomeEmail","TimeStamp":"
2017-04-20T13:26:25","Parameters":{"SenderName":“John
Doe"},"Random":"Random"}]".getBytes("UTF-8");
String streamNamespace = "Email";
PushEvent.sendEvent(eventDetailsDto, partitionKey,payloadBytes, streamNamespace);

31. CONCLUSIONS
 Microservices are more expensive
 More difficult for development
 More time for settings
 Easier to test when having OOP knowledge or desire to know OOP
 More difficult to test manually because of configurations
 More progress

32. QUESTIONS

33. LINKS
 Microsoft docs
 Martin Fowler: microservices
 Microservices and Rules Engines – a blast from the past - Udi Dahan

34. CONTACTS
Skype: ymkocv
Facebook: ymkocv
Email: ymkocv@gmail.com