feed.xml

<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="3.8.7">Jekyll</generator><link href="http://localhost:4000/feed.xml" rel="self" type="application/atom+xml" /><link href="http://localhost:4000/" rel="alternate" type="text/html" /><updated>2021-03-14T16:50:55+01:00</updated><id>http://localhost:4000/feed.xml</id><title type="html">Steve Hostettler</title><subtitle>Steve Hostettler's personal blog about automatic testing, Java, Java EE, and Architecture.</subtitle><entry><title type="html">Microservice Architecture - Part 3 (Diving into microservices)</title><link href="http://localhost:4000/2019/03/04/microservice-architecture-part-3.html" rel="alternate" type="text/html" title="Microservice Architecture - Part 3 (Diving into microservices)" /><published>2019-03-04T22:51:20+01:00</published><updated>2019-03-04T22:51:20+01:00</updated><id>http://localhost:4000/2019/03/04/microservice-architecture-part-3</id><content type="html" xml:base="http://localhost:4000/2019/03/04/microservice-architecture-part-3.html">&lt;h2 id=&quot;introduction&quot;&gt;Introduction&lt;/h2&gt;
&lt;p&gt;In &lt;a href=&quot;https://www.hostettler.net/2019/02/17/microservice-architecture-part-1.html&quot;&gt;Part 1&lt;/a&gt;, we configured, compiled, and deployed microservices. In &lt;a href=&quot;https://www.hostettler.net/2019/02/17/microservice-architecture-part-2.html&quot;&gt;Part 2&lt;/a&gt;, we configured and deployed non-functional services such
as security, and logging.
In this chapter, we will dive into the concept of microservices. First, we will discuss why the community came with yet another architecture paradigm. Secondly, we will 
look at some definitions and the main properties of such an architecture. Then we will detail some of the technologies, microservice architecture leverage to deliver maximum value. 
After that, we will analyse the pros and cons of this architecture. Finally, we will discuss some of the architecture patterns related to microservices.&lt;/p&gt;

&lt;h2 id=&quot;why-yet-another-architecture-paradigm&quot;&gt;Why (yet) another architecture paradigm&lt;/h2&gt;
&lt;p&gt;The microservice architecture can be seen as a reaction to the &lt;a href=&quot;https://en.wikipedia.org/wiki/Monolithic_application&quot;&gt;monolith architecture&lt;/a&gt;. In particular, the fact that the bigger the application, the slower the pace of change. 
A monolith application is self-contained. Modules mostly communicate through method calls. While monolith do present some advantages in terms of performance
(not scalability) and consistency for instance, they have a tendency to evolve to complex “thing” that run out of control.
Modifying a monolith requires to
rebuilt it completely and to ship it in one block. Furthermore, by its very nature, a monolith tend to favor API leaks and to decrease modularity. 
Finally, having one block means that scalability happens at
that granularity which might lead to a waste of resources as all the modules  will be scaled at the same time whereas not all the modules might 
need the same type of scalability or no scalability at all.&lt;/p&gt;

&lt;p&gt;Following the model provided by M. L. ABBOTT and M.T. FISHER [1], scalability follows three dimensions:&lt;/p&gt;
&lt;ol&gt;
  &lt;li&gt;X-axis : horizontal duplication&lt;/li&gt;
  &lt;li&gt;Y-axis : functional decomposition&lt;/li&gt;
  &lt;li&gt;Z-axis : data partitioning&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;While X and Z scalability is feasible with a monolith, Y (functional) scalability is not. It is all or nothing.&lt;/p&gt;

&lt;p&gt;The below figure presents a typical monolith architecture. Please note that,&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;usually a monolith is implemented as a multi-tiers architecture&lt;/li&gt;
  &lt;li&gt;monolith does not mean that it is not modular. It means that it is a “monolithic” unit of deployment. Everything is deployed together.&lt;/li&gt;
  &lt;li&gt;cross-cutting concerns at shared and the monolith instance level&lt;/li&gt;
  &lt;li&gt;inter service (modules) communication is usually method calls (vs inter process communication)&lt;/li&gt;
  &lt;li&gt;scalability happens at the monolith level&lt;/li&gt;
&lt;/ul&gt;
&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/Monolith.png&quot; alt=&quot;Monolith architecture&quot; /&gt;
  &lt;figcaption&gt;Monolith architecture&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;p&gt;Breaking the monolith apart in small pieces, enables to make architectural decision at that level. For instance, to choose the most appropriate programming language or technology
for each task. That being said adding heterogeneity  and increasing the number of deployment units, 
comes at a price in terms of necessary infrastructure and thus complexity.&lt;/p&gt;

&lt;h2 id=&quot;definitions&quot;&gt;Definition(s)&lt;/h2&gt;

&lt;p&gt;At this core, microservice is an architecture (MSA) that is an evolution of the service oriented architecture (SOA). It inherits  from SOA several key concepts. The most important one being
that business added value is delivered by combining a collection loosely coupled services.&lt;/p&gt;

&lt;p&gt;Reusing the definition of services from SOA, a service has the &lt;a href=&quot;https://en.wikipedia.org/wiki/Service-oriented_architecture&quot;&gt;following properties&lt;/a&gt;:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;It logically represents a business activity with a specified outcome.&lt;/li&gt;
  &lt;li&gt;It is self-contained.&lt;/li&gt;
  &lt;li&gt;It is a black box for its consumers (and the communication between consumer and provider is formalized by a contract).&lt;/li&gt;
  &lt;li&gt;It may consist of other underlying services.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These properties apply to microservices as well. The main difference between SOA and MSA is in the granularity of the services and some opinionated implementation choices. 
A key point to understand is that microservices have not been invented in isolation, they emerged alongside other game changers
 such as Agile, DevOps concepts, and Cloud computing.&lt;/p&gt;

&lt;p&gt;Adding these influences to the mix, adds the following properties:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;each service is expected be elastic (horizontal scalability), resilient (failover), composible, minimum, and self-contained.&lt;/li&gt;
  &lt;li&gt;each services must support automation, deployment, and testing as first class citizens.&lt;/li&gt;
  &lt;li&gt;each is specialized in one thing and in doing that thing right&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The term microservice has been coined around 2012 [2][3]. People trace it back to a workshop in Venice in 2011 but I was not able to find the proceedings.&lt;/p&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/microservices.PNG&quot; alt=&quot;Microservice architecture&quot; /&gt;
  &lt;figcaption&gt;Microservice architecture&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;h2 id=&quot;technologies&quot;&gt;Technologies&lt;/h2&gt;
&lt;p&gt;Two main technologies are usually linked to microservices:&lt;/p&gt;

&lt;h4 id=&quot;cloud-native-technologies&quot;&gt;Cloud native technologies&lt;/h4&gt;
&lt;p&gt;Due to their distributed nature, Microservices call for a distributed way of deploying and management. Therefore, they are inherently linked to cloud native technologies such as containers and containers orchestration.
As a matter of fact, without these technologies developing, building and deploying a microservice architecture would be so tedious and cumbersome that it would
quickly collapse under its own weight.&lt;/p&gt;

&lt;p&gt;Docker and &lt;a href=&quot;https://kubernetes.io/&quot;&gt;Kubernetes&lt;/a&gt; bring the ease of deployment and management that is required to deal with hundreds of units. You can see as Kubernetes as the Operating
System of the cloud and as Docker as the process of the cloud.
Thanks to Docker, developer do not have to deal with OS/platform specific configurations. If it works in the container (mostly Linux) it
will work in the cloud. Configuration can be scripted so the deployment is repeatable and automated. In association with Kubernetes, one can
easily manages the elasticity, and health of the microservice ecosystem. Not to mention that a number of 3rd party tools are
available as images that can be composed at will to provide crucial services such as logging, authentication, authorization, and monitoring.&lt;/p&gt;

&lt;h4 id=&quot;message-broker&quot;&gt;Message broker&lt;/h4&gt;
&lt;p&gt;Another technology often associated with microservices is the message broker. &lt;a href=&quot;https://en.wikipedia.org/wiki/Message_broker&quot;&gt;Message Brokers&lt;/a&gt; are basically bus that can exchange messages at
a very high speed in a distributed and elastic way. At the moment, &lt;a href=&quot;https://kafka.apache.org/&quot;&gt;Kafka&lt;/a&gt; is the most well-known of these. It is very often as a communication
layer between the microservices. Kafka helps dealing with maintaining consistency by propagating messages in a asynchronous and transactional way.
Message brokers are not a new concepts and they can be associated with the good old Enterprise Service Buses (ESB) of the Service Oriented Architecture era.
The main difference is that, in order to avoid the &lt;a href=&quot;https://www.thoughtworks.com/radar/techniques/recreating-esb-antipatterns-with-kafka&quot;&gt;ESB antipattern&lt;/a&gt;, message broker adopt a more lightweight approach. The big selling
arguments around ESBs was that they would allow proper composition, discovery, and monitoring of the services as well as message and protocol transformation.
The problem was that, at the end, all the business logic of the company was contained in the bus and thus it was extremely difficult to maintain.
Microservices over Message Brokers take a more decentralized approach by letting the responsibility of the transformation, and composition to microservices.&lt;/p&gt;

&lt;h2 id=&quot;additional-properties-of-microservices&quot;&gt;Additional properties of microservices&lt;/h2&gt;
&lt;p&gt;Some of the properties of microservices are not inherited from the definition but rather from some implementation decisions. 
Please note that some of these properties might sound counter intuitive at first but they emerged to solve practical problems. Especially to limit service coupling.&lt;/p&gt;

&lt;h4 id=&quot;single-database-per-service&quot;&gt;Single Database per service&lt;/h4&gt;
&lt;p&gt;Sharing databases across multiple microservices increases coupling. Changing a database model for one service might impact other services. Furthermore, depending of the usage
you might prefer a good old database or a key-value store. Having one database per service solves these problems at the expense of maintaining  more technologies, instances and models.&lt;/p&gt;

&lt;h4 id=&quot;low-cross-service-reuse&quot;&gt;Low cross-service reuse&lt;/h4&gt;
&lt;p&gt;This is, in my opinion, the most counter-intuitive thing. We have been told for years to reuse and to not duplicate code.  And here it is, code duplications is promoted. More specifically
the best practices is to not create “common” libraries. I would not be so “extreme” and simply say not to create common libraries with shared business code (for instance NO DTO).&lt;/p&gt;

&lt;h4 id=&quot;one-domain-per-service&quot;&gt;One Domain per service&lt;/h4&gt;
&lt;p&gt;This is the most intuitive of the rules, restrict your micro services to deal with one and only one business domain. For instance, do not mix services for sales and for accounting.
If within accounting, you have two accounting standards, then let’s have two services.&lt;/p&gt;

&lt;h4 id=&quot;service-granularity&quot;&gt;Service Granularity&lt;/h4&gt;
&lt;p&gt;Choosing the right granularity for your services is more an art than a science. There are numerous articles out there to help you choose the right granularity [4] [5].
Finding the right level of granularity is usually a tradeoff between thus between maintainability and scalability on one hand, and deployment complexity and performance on the other hand. 
It is always a choice between maintainability at the micro level (the service) and the macro level (the whole ecosystem).&lt;/p&gt;

&lt;p&gt;Although it is difficult to predict the actual penalty of microservices on the performance as it depends of the use case, [5] predicts a 10% penalty per hops (microservice to microservice communication) on the total roundtrip.
I like the &lt;a href=&quot;https://cloudsourceblog.com/2017/01/03/cooking-breakfast-and-microservice-granularity/&quot;&gt;breakfast example&lt;/a&gt; where a single macro service called &lt;code class=&quot;highlighter-rouge&quot;&gt;prepare breakfast&lt;/code&gt; ends up being 3, 12, or 60 services depending of the level
of granularity. Now imagine, we need to scale the 60 services to have … say 3 instances. All of a sudden you have 180 instances to maintain and to manage. This is becoming exponentially more complex.
In that example, the right level is probably 12 as it proposes some valuable reuse and still limit the complexity.
That being said, nothing stops you to have different level of granularity per domain depending of the expected evolutivity, reuse, and performance. As a rule it is better to start with coarser services and to go granular on a case by case basis.&lt;/p&gt;

&lt;p&gt;There are recommendations out there that a microservice should between 50 to 500 lines of codes. This is, in my opinion, the worst possible metric out there. It is way too dependent of the language and technology.&lt;/p&gt;

&lt;p&gt;The most important rule about the granularity is to respect the service boundaries:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;It doesn’t share database tables with another service.&lt;/li&gt;
  &lt;li&gt;It has a minimal amount of business entities,&lt;/li&gt;
  &lt;li&gt;It is  stateless (and if stateful it is on purpose).&lt;/li&gt;
  &lt;li&gt;It does take data (un)availability into accounts. For instance by implementing local caches for non-managed entities.&lt;/li&gt;
  &lt;li&gt;It is the single source of truth for the business entities it manages.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;architecture-patterns&quot;&gt;Architecture patterns&lt;/h2&gt;

&lt;h4 id=&quot;command-query-responsibility-segregation-cqrs&quot;&gt;Command Query Responsibility Segregation (CQRS)&lt;/h4&gt;
&lt;p&gt;Command Query Responsability Segregation is all about … guess what … reducing coupling. The idea is to have a different API for querying data and for creating/updating them. 
At its core, it seggregates the model and the storage to query data from the model and storage that keeps the single version of truth of a particular business entity.
The two APIs can be part of the same microservice or in two different microservices. One use case to have it on two separate microservices is to be able to scale out querying (or vice versa).&lt;/p&gt;

&lt;p&gt;As each microservice can have its own store, then you could imagine using Cassandra (which is known to be very efficient in writing) for persisting and Elasticseach for read (which is known to be very efficient in reading). 
Command and Query Responsibility Segregation (CQRS) was first introduced by Greg Young [6] and is itself an evolution of the Command Query Separation (CQS) by Bertrand Meyer [7]&lt;/p&gt;

&lt;p&gt;In the sample architecture, the instrument service has one view of the instrument model but the valuation service as another one. To be fully CQRS compliant, the instrument service should have
had a different model to persist and to query. As JPA does not support two entities on the same database object, we would have to use a constructs like JPA queries and &lt;code class=&quot;highlighter-rouge&quot;&gt;select new&lt;/code&gt; to support a 
different model for persistence and for reading. For more information on how to use the select new``, please refer to this &lt;a href=&quot;https://vladmihalcea.com/the-best-way-to-map-a-projection-query-to-a-dto-with-jpa-and-hibernate/&quot;&gt;article&lt;/a&gt;
and this &lt;a href=&quot;https://www.oracle.com/technetwork/articles/vasiliev-jpql-087123.html&quot;&gt;article&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;CQRS is very associated with Event sourcing (see below).&lt;/p&gt;
&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/CQRS_EventSourcing.png&quot; alt=&quot;CQRS + Event Sourcing architecture&quot; /&gt;
  &lt;figcaption&gt;CQRS + Event Sourcing architecture&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;h4 id=&quot;event-sourcing--message-bus&quot;&gt;Event sourcing &amp;amp; Message Bus&lt;/h4&gt;
&lt;p&gt;In an architecture where neither the data store nor the data model is supposed to be shared, keeping the consistency between the different stakeholders is challenging. Having distributed transactions that span
across multiple services is difficult to implement and even more difficult to maintain. That is why, instead of looking for consistency at any point in time, we are looking at eventual consistency.
Of course, eventual consistency might be a problem in some use cases and that must be assessed on a case by case basis.&lt;/p&gt;

&lt;p&gt;The fundamental concept behind Event Sourcing is that &lt;code class=&quot;highlighter-rouge&quot;&gt;All changes to an application state are stored as a sequence of events&lt;/code&gt; [8]. In other terms, changing the value of a given field for a given entity is stored as a message.
Ultimately, you can reconstruct the current state by replaying all the messages starting with the initial state.&lt;/p&gt;

&lt;p&gt;In the sample architecture (see below), the instrument service is writing any changes to a message broker that is distributed to all microservices that need it. In this case, to
the valuation service and to the regulatory reporting service. Instrument service has the single version of the truth and all other service will eventually be consistent. Of course, internally the instrument service 
must guarantee that updating its own store and the bus is made transactionally.&lt;/p&gt;

&lt;p&gt;Since the changes are stored in the bus, they can be replayed. For instance, when a new instance of a service joins so that it can update its internal state.&lt;/p&gt;

&lt;h4 id=&quot;api-composition--api-gateway&quot;&gt;API Composition / API Gateway&lt;/h4&gt;
&lt;p&gt;As we already discussed, non-functional concerns such as load-balancing, versioning, security (authentication, authorization, TLS termination) must be managed at the microservice level.&lt;/p&gt;

&lt;p&gt;Furthermore, maximizing microservice reusability implies granular services. The client could easily compose the microservices but this means a high coupling between the client and the
services as well as a lot of traffic between the client and the microservices.&lt;/p&gt;

&lt;p&gt;One way of mitigating this, is to add an API gateway in front of the microservices to avoid direct coupling between the client and the individual services. Besides, it will handle composition
locally in the application network. Finally, it will apply cross-cutting concerns uniformally on all the requests.&lt;/p&gt;

&lt;p&gt;The sample application relies on an application gateway to deliver authentication, versioning and TLS termination (see figure below)&lt;/p&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/micro-service-architecture.png&quot; alt=&quot;Network topology and high level component view of the micro-service architecture&quot; /&gt;
  &lt;figcaption&gt;Network topology and high level component view of the micro-service architecture&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;h2 id=&quot;pros-and-cons&quot;&gt;Pros and Cons&lt;/h2&gt;

&lt;p&gt;Let’s reflect on the pros and cons of the microservice architecture. Like any architecture, it is a tradeoff between a set of non-functional requirements.&lt;/p&gt;

&lt;h3 id=&quot;pros&quot;&gt;Pros&lt;/h3&gt;
&lt;p&gt;Fist the positive aspects&lt;/p&gt;

&lt;h4 id=&quot;scalability&quot;&gt;Scalability,&lt;/h4&gt;
&lt;p&gt;Scalability (both horizontal and vertical) can happen a very granular level. Therefore, no resources are wasted on scaling components that do not require it (like it would be the case
for a monolith). Furthermore, because it is easy to segregate stateful from stateless components, scalability happens most of the time on pure stateless microservices.
In a monolith, one stateful component forces the whole monolith scalability to take stafulness into account.&lt;/p&gt;

&lt;h4 id=&quot;failover-fault-tolerance-high-availability&quot;&gt;Failover, Fault Tolerance, High-Availability&lt;/h4&gt;
&lt;p&gt;In a very similar way to scalability, Failover, Fault Tolerance, and High-Availability can be targeted to the components that require it. Similarly,
statefulness can be limited to the few services that require it (if any).&lt;/p&gt;

&lt;h4 id=&quot;time-to-market-adaptability&quot;&gt;Time to market, Adaptability&lt;/h4&gt;
&lt;p&gt;Because the services are small and loosely coupled, they can be changed and deployed with limited risk of regression to other services. This increases time to market and is
a big step forward continuous delivery.&lt;/p&gt;

&lt;h4 id=&quot;team-independence&quot;&gt;Team Independence&lt;/h4&gt;
&lt;p&gt;Similarly  to the time to market, the loose couple implies low inter-team dependency. That being said, this is sort of by product to the microservice architecture.
A modular monolith should in theory achieve the same level of loose coupling. The problem is that when calls internal (rather than through the network), developer have
a higher tendency to break module boundaries thus increasing the coupling.&lt;/p&gt;

&lt;h4 id=&quot;technology-adaptability&quot;&gt;Technology Adaptability&lt;/h4&gt;
&lt;p&gt;Again,  loose coupling and low dependency enact new practices such as deciding which technology to choose on the case by case basis. That being said, depending of your organization,
this can be more of a curse than a blessing. You can very quickly end up with exotic technologies and languages that only the microservice creator knows.&lt;/p&gt;

&lt;h4 id=&quot;reusability&quot;&gt;Reusability&lt;/h4&gt;
&lt;p&gt;Thanks to the granularity, services are much more dedicated to a particular task. This is favoring  reusability by composition.&lt;/p&gt;

&lt;h3 id=&quot;cons&quot;&gt;Cons&lt;/h3&gt;
&lt;p&gt;Like any architecture, there is no free lunch:&lt;/p&gt;

&lt;h4 id=&quot;increased-resource-consumption&quot;&gt;Increased resource consumption&lt;/h4&gt;
&lt;p&gt;As a microservice architecture entails many more instances (e.g., VMs, JVMs) to run that its monolithic  counterpart. Furthermore, entities are very often replicated between the instances (to increase loose coupling).
All of that lead to higher overall resources (memory and CPU) consumption. This is compensated  by the fact that more resources are available than years ago before the cloud era.&lt;/p&gt;

&lt;h4 id=&quot;operational-overhead--deployment-complexity&quot;&gt;Operational Overhead / Deployment complexity&lt;/h4&gt;
&lt;p&gt;The profusion of services and their associated dependencies (DB, message broker, …) can very quickly lead to an operational nightmare. The operation team needs to master the concepts
and the related tools for monitoring the ecosystem (Docker, Kubernetes, ELK, …). This has a cost, both in terms of skills and manpower.&lt;/p&gt;

&lt;h4 id=&quot;cross-cutting-concerns&quot;&gt;Cross-Cutting concerns&lt;/h4&gt;
&lt;p&gt;Since the cross-cutting concerns are managed at the service level, it can significantly complexify deployment : a microservice might be straightforward  but let’s add it authentication,
authorization, logging, versioning, failover, balancing and it is a completely different story. Doing system testing on such environments can be very challenging.&lt;/p&gt;

&lt;h4 id=&quot;architecture-complexity--distributed-system&quot;&gt;Architecture Complexity : Distributed system&lt;/h4&gt;
&lt;p&gt;Microservices are distributed by nature and thus exposes developers to &lt;a href=&quot;https://www.rgoarchitects.com/Files/fallacies.pdf&quot;&gt;“The 8 fallacies of distributed computing”&lt;/a&gt; :&lt;/p&gt;
&lt;ol&gt;
  &lt;li&gt;The network is reliable.&lt;/li&gt;
  &lt;li&gt;Latency is zero.&lt;/li&gt;
  &lt;li&gt;Bandwidth is infinite.&lt;/li&gt;
  &lt;li&gt;The network is secure.&lt;/li&gt;
  &lt;li&gt;Topology doesn’t change.&lt;/li&gt;
  &lt;li&gt;There is one administrator.&lt;/li&gt;
  &lt;li&gt;Transport cost is zero.&lt;/li&gt;
  &lt;li&gt;The network is homogeneous.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;When designing your microservice architecture, you will have to think of all of the above. Another interesting law to remember is the [9] :&lt;/p&gt;
&lt;blockquote&gt;
  &lt;p&gt;Fowler’s first law of distributed computing : don’t distribute your objects&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;While Fowler’s rightfully insists in a this &lt;a href=&quot;https://www.martinfowler.com/articles/distributed-objects-microservices.html&quot;&gt;post&lt;/a&gt; that there is a huge difference between distributing objects and (micro) services. Therefore,
he underlines that his 2004 comment is not in any way applicable to microservice architecture. Although I agree that the two are very different, I think that it is interesting
to look at his entire &lt;a href=&quot;http://www.drdobbs.com/errant-architectures/184414966&quot;&gt;chapter&lt;/a&gt; that is available online. Before laying down the law, Fowler spend some time explaining how he came to that
conclusion. Most of the argument is that not choosing the granularity of the interfaces (API) will lead to poor performance and will massively increase complexity. This is also
very true for microservices.&lt;/p&gt;

&lt;p&gt;While there are architecture patterns and tools to deal with them, it just means extra-complexity
and therefore you should ask yourself where  it does and where it does not make sense.&lt;/p&gt;

&lt;h4 id=&quot;eventual-consistency&quot;&gt;Eventual consistency&lt;/h4&gt;

&lt;p&gt;Hereafter a summary of the main “pros” and “cons”. Please note that this is not an absolute evaluation. The weight that you should put in each of these is highly dependent of
your use-case and context. For instance, team independence is not a real concern in a small startup with 5 employees. On the other end, operation complexity tends to be less
of a problem if you already have skilled devops teams.&lt;/p&gt;

&lt;p&gt;&lt;br /&gt;&lt;/p&gt;

&lt;table&gt;
  &lt;thead&gt;
    &lt;tr&gt;
      &lt;th style=&quot;text-align: left&quot;&gt;Property&lt;/th&gt;
      &lt;th style=&quot;text-align: center&quot;&gt;Microservice&lt;/th&gt;
      &lt;th style=&quot;text-align: center&quot;&gt;Monolith&lt;/th&gt;
    &lt;/tr&gt;
  &lt;/thead&gt;
  &lt;tbody&gt;
    &lt;tr&gt;
      &lt;td style=&quot;text-align: left&quot;&gt;Scalability&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-plus&quot;&gt;+&lt;/span&gt;&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-minus&quot;&gt;-&lt;/span&gt;&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td style=&quot;text-align: left&quot;&gt;Release/Updatability, Time to marker&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-plus&quot;&gt;+&lt;/span&gt;&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-minus&quot;&gt;-&lt;/span&gt;&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td style=&quot;text-align: left&quot;&gt;Failover, Fault Tolerance, High Availability&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-plus&quot;&gt;+&lt;/span&gt;&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-minus&quot;&gt;-&lt;/span&gt;&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td style=&quot;text-align: left&quot;&gt;Team Independence&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-plus&quot;&gt;+&lt;/span&gt;&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-minus&quot;&gt;-&lt;/span&gt;&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td style=&quot;text-align: left&quot;&gt;Technology Adaptability&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-plus&quot;&gt;+&lt;/span&gt;&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-minus&quot;&gt;-&lt;/span&gt;&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td style=&quot;text-align: left&quot;&gt;Reusability&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-plus&quot;&gt;+&lt;/span&gt;&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-minus&quot;&gt;-&lt;/span&gt;&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td style=&quot;text-align: left&quot;&gt;Resources Consumption (like for like for a given throuput/volume)&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-minus&quot;&gt;-&lt;/span&gt;&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-plus&quot;&gt;+&lt;/span&gt;&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td style=&quot;text-align: left&quot;&gt;Operational Overhead&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-minus&quot;&gt;-&lt;/span&gt;&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-plus&quot;&gt;+&lt;/span&gt;&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td style=&quot;text-align: left&quot;&gt;Cross-Cutting Concerns (Security, Logging, Caching, Auditing, Configuration, …)&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-minus&quot;&gt;-&lt;/span&gt;&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-plus&quot;&gt;+&lt;/span&gt;&lt;/td&gt;
    &lt;/tr&gt;
    &lt;tr&gt;
      &lt;td style=&quot;text-align: left&quot;&gt;Architecture complexity (Distribution, Consistency, Governance, Integration testing, …)&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-minus&quot;&gt;-&lt;/span&gt;&lt;/td&gt;
      &lt;td style=&quot;text-align: center&quot;&gt;&lt;span class=&quot;table-grade-plus&quot;&gt;+&lt;/span&gt;&lt;/td&gt;
    &lt;/tr&gt;
  &lt;/tbody&gt;
&lt;/table&gt;

&lt;h2 id=&quot;closing-thoughts&quot;&gt;Closing Thoughts&lt;/h2&gt;

&lt;p&gt;To sum it up :  whereas microservice architecture is a powerful tool in your toolbox, it is in no way a silver bullet. Microservice architecture is very adapted when a  high level of elasticity is required but
it comes at a price in terms of complexity of operations. Architecture is always a tradeoff between non-functional requirements and therefore the first thing to do is to establish these NFRs.
If scalability and updatability is not an issue then having a modular monolith is probably more appropriate. Furthermore, there is nothing stopping you to adopt a hybrid approach by
starting to break a monolith in coarse services and to refine it as needed.&lt;/p&gt;

&lt;h2 id=&quot;bibliography&quot;&gt;Bibliography&lt;/h2&gt;
&lt;ul&gt;
  &lt;li&gt;[1] Martin L. Abbott and Michael T. Fisher. 2009. The Art of Scalability: Scalable Web Architecture, Processes, and Organizations for the Modern Enterprise (1st ed.). Addison-Wesley Professional.&lt;/li&gt;
  &lt;li&gt;[2] James Lewis. 2013. Micro services - Java, the Unix Way. 33rd Degree Conference, Krakow Poland. http://2012.33degree.org/talk/show/67&lt;/li&gt;
  &lt;li&gt;[3] Fred George. 2013. MicroService Architecture, https://www.slideshare.net/fredgeorge/micro-service-architecure&lt;/li&gt;
  &lt;li&gt;[4] Chistian Verstraete, 2017, https://cloudsourceblog.com/2017/01/03/cooking-breakfast-and-microservice-granularity/&lt;/li&gt;
  &lt;li&gt;[5] Shadija, D., Rezai, M., &amp;amp; Hill, R. (2017). Microservices: Granularity vs. Performance. In UCC 2017 Companion - Companion Proceedings of the 10th International Conference on Utility and Cloud Computing (pp. 215-220). Association for Computing Machinery, Inc. https://doi.org/10.1145/3147234.3148093&lt;/li&gt;
  &lt;li&gt;[6] Greg Young, 2010. CQRS Documents. https://cqrs.files.wordpress.com/2010/11/cqrs_documents.pdf&lt;/li&gt;
  &lt;li&gt;[7] Bertrand Meyer. 1988. Object-Oriented Software Construction (1st ed.). Prentice-Hall, Inc., Upper Saddle River, NJ, USA.&lt;/li&gt;
  &lt;li&gt;[8] Martin Fowler, 2005, Event Sourcing : https://martinfowler.com/eaaDev/EventSourcing.html&lt;/li&gt;
  &lt;li&gt;[9] Martin Fowler. 2002. Patterns of Enterprise Application Architecture. Addison-Wesley Longman Publishing Co., Inc., Boston, MA, USA.&lt;/li&gt;
&lt;/ul&gt;</content><author><name></name></author><summary type="html">Introduction In Part 1, we configured, compiled, and deployed microservices. In Part 2, we configured and deployed non-functional services such as security, and logging. In this chapter, we will dive into the concept of microservices. First, we will discuss why the community came with yet another architecture paradigm. Secondly, we will look at some definitions and the main properties of such an architecture. Then we will detail some of the technologies, microservice architecture leverage to deliver maximum value. After that, we will analyse the pros and cons of this architecture. Finally, we will discuss some of the architecture patterns related to microservices.</summary></entry><entry><title type="html">Microservice Architecture - Part 1 (A running microservice architecture)</title><link href="http://localhost:4000/2019/02/17/microservice-architecture-part-1.html" rel="alternate" type="text/html" title="Microservice Architecture - Part 1 (A running microservice architecture)" /><published>2019-02-17T22:51:20+01:00</published><updated>2019-02-17T22:51:20+01:00</updated><id>http://localhost:4000/2019/02/17/microservice-architecture-part-1</id><content type="html" xml:base="http://localhost:4000/2019/02/17/microservice-architecture-part-1.html">&lt;h2 id=&quot;introduction&quot;&gt;Introduction&lt;/h2&gt;
&lt;p&gt;This series of blog posts aims at helping students at the University of Geneva to develop their first application following micro-service principles. 
Besides explaining the concepts and implementation details of micro-service architecture, we will as well discuss software development practices such as software 
factories and innovative deployment options such as containers and container composition. All samples and a complete working application can be found &lt;a href=&quot;https://github.com/hostettler/microservices.git&quot;&gt;here on GitHub&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The following diagram represents the end-state of our microservice architecture. From a business perspective, it delivers &lt;a href=&quot;https://en.wikipedia.org/wiki/Regulatory_technology&quot;&gt;RegTech&lt;/a&gt; services. 
More specifically, it manages counterparties and financial instruments. It valuates a portfolio and finally provides some regulatory reporting.
You do not need deep financial knowledge, sufficient is to say that:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;A counterparty is an individual or a company participating in a financial transaction. For more &lt;a href=&quot;https://www.investopedia.com/terms/c/counterparty.asp&quot;&gt;details&lt;/a&gt;.&lt;/li&gt;
  &lt;li&gt;A financial instrument  is an asset that can be traded such as stocks, loans, and the likes. For more &lt;a href=&quot;https://www.investopedia.com/terms/f/financialinstrument.asp&quot;&gt;details&lt;/a&gt;.&lt;/li&gt;
  &lt;li&gt;Portfolio valuation is the action of evaluating the net value of a set of assets. For more &lt;a href=&quot;https://www.investopedia.com/terms/a/assetvaluation.asp&quot;&gt;details&lt;/a&gt;.&lt;/li&gt;
  &lt;li&gt;Financial institutions must comply to a set of regulations such as delivering monthly reports to state their financial health.&lt;/li&gt;
&lt;/ul&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/micro-service-architecture.png&quot; alt=&quot;Network topology and high level component view of the micro-service architecture&quot; /&gt;
  &lt;figcaption&gt;Network topology and high level component view of the micro-service architecture&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;p&gt;Besides, these “business” services, the architecture delivers a set of non-functional services such as:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;A Central logging mechanism to deal with the distributed nature of the architecture. It relies on a &lt;a href=&quot;https://github.com/gliderlabs/logspout&quot;&gt;Logspout&lt;/a&gt; companion container that sends the logs from all the containers to a concentrator called &lt;a href=&quot;https://www.elastic.co&quot;&gt;Logstash&lt;/a&gt; that in turn 
sends them to a database optimized for searching called &lt;a href=&quot;https://www.elastic.co&quot;&gt;ElasticSearch&lt;/a&gt;. Finally, &lt;a href=&quot;https://www.elastic.co&quot;&gt;Kibana&lt;/a&gt; provides visualization and analysis of the logs.&lt;/li&gt;
  &lt;li&gt;A Message broker to increase service decoupling and scalability. &lt;a href=&quot;https://kafka.apache.org/&quot;&gt;Kafka&lt;/a&gt; in this case.&lt;/li&gt;
  &lt;li&gt;An API-Gateway that provides routing, load-balancing and SSO to the micro-services by integrating an identity manager called &lt;a href=&quot;https://www.keycloak.org/&quot;&gt;Keycloack&lt;/a&gt;. Furthermore,  &lt;a href=&quot;https://konghq.com/kong/&quot;&gt;Kong&lt;/a&gt; delivers API-Gateway services (e.g., security, API composition and aggregation)
The API-Gateway also shields the user from knowing the ugly details of the network topology. Furthermore, it protects the backend by establishing a clear front vs back network separation,
 it exposes static resources and finally, it provides TLS termination.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;From a technology perspective, Microservices are implemented using JEE 8  microservice and its microprofile. More specifically, &lt;a href=&quot;https://thorntail.io/&quot;&gt;Thorntail&lt;/a&gt; [3]. 
Furthermore, microservices are packaged as &lt;a href=&quot;https://www.docker.com/&quot;&gt;Docker&lt;/a&gt; [1][2] container using &lt;a href=&quot;https://maven.apache.org/&quot;&gt;Maven&lt;/a&gt; [4] as a build tool.&lt;/p&gt;

&lt;p&gt;This chapter describes step by step how to compile and deploy the microservices themselves.
&lt;a href=&quot;https://www.hostettler.net/2019/02/17/microservice-architecture-part-2.html&quot;&gt;Part 2&lt;/a&gt; describes how to setup non-functional services such as SSO (Single Sign On), API concentration, and logging. Because of its
distributed nature, in 
a microservice architecture, the non-functional infrastructure is as important than the actual services.
&lt;a href=&quot;https://www.hostettler.net/2019/03/04/microservice-architecture-part-3.html&quot;&gt;Part 3&lt;/a&gt; dives deeper in what a microservice architecture actually is, its benefits and drawbacks, and some details on the related technologies.
Part 4 focuses on the software factory, putting everything together and testing the result. 
Finally, Part 5 does the autopsy of a microservice, detailing the associated design patterns.&lt;/p&gt;

&lt;h1 id=&quot;pre-requisites&quot;&gt;Pre-requisites&lt;/h1&gt;

&lt;div class=&quot;alert alert-info&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-info-circle&quot;&gt;&lt;/i&gt; &lt;b&gt;Note: &lt;/b&gt; This series of blog post leverages a lot of different technologies. Please take the time to install everything properly. It will save time later on. &lt;/div&gt;

&lt;p&gt;To execute the samples, you will need to install and to configure the following tools:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;a “reasonably” powerful computer with Linux (whatever recent distribution) or Windows (min. Windows 10) to support Docker. Mac is ok as well, but it requires some additional steps that will not be described here.&lt;/li&gt;
  &lt;li&gt;a working Docker environment to deploy the services locally.&lt;/li&gt;
  &lt;li&gt;a &lt;a href=&quot;https://jdk.java.net/11/&quot;&gt;JDK 11&lt;/a&gt; to compile and run the services&lt;/li&gt;
  &lt;li&gt;a Git client for collaboration&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://nodejs.org/&quot;&gt;NodeJS&lt;/a&gt; and the &lt;a href=&quot;https://angular.io/guide/quickstart&quot;&gt;Angular tooling&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://maven.apache.org/&quot;&gt;Apache Maven&lt;/a&gt; for the automation.&lt;/li&gt;
  &lt;li&gt;a bash interpreter (on Windows you can rely on Git bash that is usually installed with Git)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;On top of that you need to have:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;An intermediate level in Java&lt;/li&gt;
  &lt;li&gt;Some basic understanding of OS (including bash scripting) and networking (DNS, TCP, HTTP)&lt;/li&gt;
  &lt;li&gt;a great deal of patience and coffee&lt;/li&gt;
&lt;/ul&gt;

&lt;div class=&quot;alert alert-info&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-info-circle&quot;&gt;&lt;/i&gt; &lt;b&gt;Note: &lt;/b&gt; We will start a lot of containers, please grant at least 6GB RAM and 6GB swap to your docker-machine &lt;/div&gt;

&lt;h2 id=&quot;getting-the-backend-components-to-run&quot;&gt;Getting the backend components to run&lt;/h2&gt;
&lt;p&gt;First things first, let’s checkout the code and compile everything. Before you start complaining, 
yes, this section is tedious but we have to have the environment set up before diving into the wonderful world of microservices.
Let’s start by cloning the code from &lt;a href=&quot;https://github.com/hostettler/microservices.git&quot;&gt;GitHub&lt;/a&gt;.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;git clone https://github.com/hostettler/microservices.git&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
Cloning into 'microservices'...
remote: Enumerating objects: 875, done.
remote: Counting objects: 100% (875/875), done.
remote: Compressing objects: 100% (596/596), done.
remote: Total 875 (delta 279), reused 787 (delta 203), pack-reused 0
Receiving objects: 100% (875/875), 3.68 MiB | 912.00 KiB/s, done.
Resolving deltas: 100% (279/279), done.
&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Let’s check that Maven and Java are correctly installed.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;java &lt;span class=&quot;nt&quot;&gt;-version&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
openjdk version &quot;11.0.1&quot; 2018-10-16
OpenJDK Runtime Environment 18.9 (build 11.0.1+13)
OpenJDK 64-Bit Server VM 18.9 (build 11.0.1+13, mixed mode)
&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;mvn &lt;span class=&quot;nt&quot;&gt;-v&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-17T20:33:14+02:00)
Maven home: ...
Java version: 11.0.1, vendor: Oracle Corporation, runtime: ...
Default locale: en_US, platform encoding: Cp1252
OS name: &quot;windows 10&quot;, version: &quot;10.0&quot;, arch: &quot;amd64&quot;, family: &quot;windows&quot;
&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;The next step is to compile the project to produce the artifacts (i.e., binaries) that are required. To that end, 
we use Apache Maven. Maven is an opiniated build tool:&lt;/p&gt;
&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;Opinionated Software is a software product that believes a certain way of approaching a business process is inherently
 better and provides software crafted around that approach.
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;Namely, following its opinion makes our life easier and requires less efforts. For more information and tutorials please refer to this &lt;a href=&quot;https://maven.apache.org/guides/getting-started/maven-in-five-minutes.html&quot;&gt;Maven Tutorial&lt;/a&gt;. The output of the build process is a set of “JAR” files (i.e., JAVA library) that are stored in your local &lt;code class=&quot;highlighter-rouge&quot;&gt;~/.m2&lt;/code&gt; repository for later use.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;cd &lt;/span&gt;microservices/
&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;mvn clean &lt;span class=&quot;nb&quot;&gt;install&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Build Order:
[INFO]
[INFO] Parent Pom of the Pinfo Micro Services                             [pom]
[INFO] Counterparty Service                                               [war]
[INFO] Instrument Service                                                 [war]
[INFO] Valuation Service                                                  [war]
[INFO] Regulatory Reporting Service                                       [war]
[INFO] API Gateway Service                                                [war]
[INFO]
[INFO] -------------------&amp;lt; ch.unige:pinfo-micro-services &amp;gt;--------------------
[INFO] Building Parent Pom of the Pinfo Micro Services 0.2.0-SNAPSHOT     [1/6]
[INFO] --------------------------------[ pom ]---------------------------------
....
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] Parent Pom of the Pinfo Micro Services 0.2.0-SNAPSHOT SUCCESS [  3.216 s]
[INFO] Counterparty Service ............................... SUCCESS [ 42.866 s]
[INFO] Instrument Service ................................. SUCCESS [ 49.720 s]
[INFO] Valuation Service .................................. SUCCESS [ 32.623 s]
[INFO] Regulatory Reporting Service ....................... SUCCESS [ 23.048 s]
[INFO] API Gateway Service 0.2.0-SNAPSHOT ................. SUCCESS [ 22.796 s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 02:55 min
[INFO] Finished at: 2019-02-20T18:09:09+01:00
[INFO] ------------------------------------------------------------------------
&lt;/pre&gt;&lt;/figure&gt;

&lt;div class=&quot;alert alert-success&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-check-square&quot;&gt;&lt;/i&gt; &lt;b&gt;Tip: &lt;/b&gt; Congratulations, you compiled the microservices. &lt;/div&gt;

&lt;p&gt;At this point, you have manage to compile all of the Java code and you have created maven artifacts for each microservice (Java Archives a.k.a. JARs). However,  as we continue, we will see in the next chapters that a micro-service architecture is much more than a bunch of micro-services. We will need a lot of additional 3rd party tools and services.
These additional services (e.g., logging, security) are usually provided as container images that runs on Docker. 
To be able to run the microservices along side these “3rd” party tools, we need to package the microservice as Docker images.&lt;/p&gt;

&lt;p&gt;Simply put, Docker provides lightweight virtualization. It has a smaller footprint compare to the usual Virtual Machine approaches (Virtual Box, VM Ware).
The main difference is that the OS system layer is not replicated in each container but rather shared.&lt;/p&gt;

&lt;p&gt;Docker containers run Docker images that are merely lightweight Linux systems with additional softwares. For more about &lt;a href=&quot;https://www.docker.com/&quot;&gt;Docker&lt;/a&gt;
Let’s first check whether Docker is properly installed.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;docker &lt;span class=&quot;nt&quot;&gt;-v&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
Docker version 18.09.2, build 6247962
&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;docker run hello-world&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete
Digest: sha256:2557e3c07ed1e38f26e389462d03ed943586f744621577a99efb77324b0fe535
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

...
&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Before we continue, let’s have a look at a docker survival kit:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;docker ps&lt;/code&gt; displays all the running containers.&lt;/li&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;docker ps -a&lt;/code&gt;displays all stopped container (not running but still using some resources).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Based on that :&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;we can kill all running containers by running &lt;code class=&quot;highlighter-rouge&quot;&gt;docker kill $(docker ps -q)&lt;/code&gt;&lt;/li&gt;
  &lt;li&gt;remove all stopped containers by running &lt;code class=&quot;highlighter-rouge&quot;&gt;docker rm $(docker ps -a -q)&lt;/code&gt;&lt;/li&gt;
  &lt;li&gt;finally &lt;code class=&quot;highlighter-rouge&quot;&gt;docker system prune&lt;/code&gt; cleans up all dangling data.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;So the Docker daemon is up and running. Let’s create the Docker images for the microservices. This step will reuse the
JAR files created previously and package them along a Linux system so that every image can be run independently.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;mvn &lt;span class=&quot;nb&quot;&gt;install&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-Ppackage-docker-image&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] Parent Pom of the Pinfo Micro Services 0.2.0-SNAPSHOT SUCCESS [  6.114 s]
[INFO] Counterparty Service ............................... SUCCESS [ 59.134 s]
[INFO] Instrument Service ................................. SUCCESS [ 58.533 s]
[INFO] Valuation Service .................................. SUCCESS [ 42.806 s]
[INFO] Regulatory Reporting Service ....................... SUCCESS [ 33.979 s]
[INFO] API Gateway Service 0.2.0-SNAPSHOT ................. SUCCESS [ 14.134 s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 03:35 min
[INFO] Finished at: 2019-02-20T18:58:34+01:00
[INFO] ------------------------------------------------------------------------
&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;All the Docker images for the microservices have been created. Let’s double check:&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;docker image &lt;span class=&quot;nb&quot;&gt;ls&lt;/span&gt; | &lt;span class=&quot;nb&quot;&gt;grep &lt;/span&gt;unige&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
unige/regulatory-service       latest    5859668ecfb1        12 seconds ago       778MB
unige/valuation-service        latest    93516633b7b3        48 seconds ago       814MB
unige/instrument-service       latest    b1bded92050c        About a minute ago   814MB
unige/counterparty-service     latest    1789c8543673        2 minutes ago        780MB
unige/api-gateway              latest    b355613b0bbd        32 hours ago         371MB
&lt;/pre&gt;&lt;/figure&gt;

&lt;div class=&quot;alert alert-success&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-check-square&quot;&gt;&lt;/i&gt; &lt;b&gt;Tip: &lt;/b&gt; You now have Docker images for your microservices. At this point, we have Docker images for the microservices and for the api-gateway. &lt;/div&gt;

&lt;p&gt;Let’s start a Docker container with the counterparty microservice and map the port &lt;code class=&quot;highlighter-rouge&quot;&gt;28080&lt;/code&gt; of the container to the port &lt;code class=&quot;highlighter-rouge&quot;&gt;10080&lt;/code&gt; of the host.
In principle, this will start a Linux OS and then start the microservice as the first process (PID 1). This container provides all the service, you would
expect from any Linux system such as network, security, and isolation.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt; docker run &lt;span class=&quot;nt&quot;&gt;--name&lt;/span&gt; myCounterpartyService &lt;span class=&quot;nt&quot;&gt;-p&lt;/span&gt; 10080:28080 unige/counterparty-service:latest&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
2019-02-26 22:28:06,527 INFO  [org.jboss.as.server] (main) WFLYSRV0010: Deployed &quot;counterparty-service-0.2.0-SNAPSHOT.war&quot; (runtime-name : &quot;counterparty-service-0.2.0-SNAPSHOT.war&quot;)
2019-02-26 22:28:06,569 INFO  [org.wildfly.swarm] (main) THORN99999: Thorntail is Ready
&lt;/pre&gt;&lt;/figure&gt;
&lt;div class=&quot;alert alert-success&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-check-square&quot;&gt;&lt;/i&gt; &lt;b&gt;Tip: &lt;/b&gt; Open a browser and navigate to http://localhost:10080/counterparies It will display a long list of counterparties. &lt;/div&gt;
&lt;p&gt;This demonstrates that a web services is listening on port &lt;code class=&quot;highlighter-rouge&quot;&gt;10080&lt;/code&gt; of &lt;code class=&quot;highlighter-rouge&quot;&gt;localhost&lt;/code&gt;. More specifically, we started a container with the image of the counterparty microservice. The port &lt;code class=&quot;highlighter-rouge&quot;&gt;28080&lt;/code&gt; is mapped to port &lt;code class=&quot;highlighter-rouge&quot;&gt;10080&lt;/code&gt; so that we can test it.
Furthermore, we named the container &lt;code class=&quot;highlighter-rouge&quot;&gt;myCounterpartyService&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;As it is a fully running Linux system, you can connect to the container to inspect it. In another console, we can run a &lt;code class=&quot;highlighter-rouge&quot;&gt;docker ps&lt;/code&gt; command to list running containers.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;docker ps&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
CONTAINER ID        IMAGE                               COMMAND                  CREATED             STATUS              PORTS                     NAMES
dfb9acf07d79        unige/counterparty-service:latest   &quot;/bin/sh -c 'java -D…&quot;   42 seconds ago      Up 40 seconds       0.0.0.0:10080-&amp;gt;8080/tcp   myCounterpartyService
&lt;/pre&gt;&lt;/figure&gt;
&lt;p&gt;As you can see,  there is one running container name &lt;code class=&quot;highlighter-rouge&quot;&gt;myCounterpartyService&lt;/code&gt; that listen on port &lt;code class=&quot;highlighter-rouge&quot;&gt;10080&lt;/code&gt; of &lt;code class=&quot;highlighter-rouge&quot;&gt;localhost&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Let’s test it by connecting to &lt;code class=&quot;highlighter-rouge&quot;&gt;http://localhost:10080/counterparties/724500J4K3Q60O9QLF45&lt;/code&gt; either by using a browser or the &lt;code class=&quot;highlighter-rouge&quot;&gt;curl&lt;/code&gt; command line. &lt;code class=&quot;highlighter-rouge&quot;&gt;counterparties&lt;/code&gt; is the context name of the service and &lt;code class=&quot;highlighter-rouge&quot;&gt;724500J4K3Q60O9QLF45&lt;/code&gt;is the id of one particular counterparty we want the details on.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;curl &lt;span class=&quot;nt&quot;&gt;-X&lt;/span&gt; GET http://localhost:10080/counterparties/724500J4K3Q60O9QLF45&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
{&quot;lei&quot;:&quot;724500J4K3Q60O9QLF45&quot;,&quot;name&quot;:&quot;Ton Smit Onroerend Goed B.V.&quot;,&quot;legalAddress&quot;:{&quot;firstAddressLine&quot;:&quot;Van Teylingenweg 126&quot;,&quot;city&quot;:&quot;Kamerik&quot;,&quot;region&quot;:&quot;&quot;,&quot;country&quot;:&quot;NL&quot;,&quot;postalCode&quot;:&quot;3471GG&quot;},&quot;registration&quot;:{&quot;registrationAuthorityID&quot;:&quot;RA000463&quot;,&quot;registrationAuthorityEntityID&quot;:&quot;52431649&quot;,&quot;jurisdiction&quot;:&quot;NL&quot;,&quot;legalFormCode&quot;:&quot;54M6&quot;,&quot;category&quot;:&quot;&quot;,&quot;registrationDate&quot;:1545264000000,&quot;lastUpdated&quot;:1545264000000,&quot;registrationStatus&quot;:&quot;ISSUED&quot;,&quot;nextRenewalDate&quot;:1576800000000},&quot;status&quot;:&quot;ACTIVE&quot;}
&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;We can stop the service as follow:&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;docker stop myCounterpartyService&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;And check that nothing is running anymore:&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;docker ps&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
CONTAINER ID        IMAGE                  COMMAND          CREATED     STATUS       PORTS          NAMES
&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;So far we only ran one service, to run all the microservices (plus the message broker) we will compose the images by using &lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose&lt;/code&gt;.
&lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose&lt;/code&gt; is a way to script a series of complex Docker configuration to provide a coherent ecosystem.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nb&quot;&gt;cd &lt;/span&gt;docker-compose/
docker-compose &lt;span class=&quot;nt&quot;&gt;-f&lt;/span&gt; docker-compose-microservices.yml up&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
instrument-service    | 2019-02-28 07:55:54,602 INFO  [org.apache.kafka.clients.consumer.internals.AbstractCoordinator] (EE-ManagedExecutorService-default-Thread-1) [Consumer clientId=consumer-1, groupId=pinfo-microservices] Successfully joined group with generation 14
instrument-service    | 2019-02-28 07:55:54,606 INFO  [org.apache.kafka.clients.consumer.internals.ConsumerCoordinator] (EE-ManagedExecutorService-default-Thread-1) [Consumer clientId=consumer-1, groupId=pinfo-microservices] Setting newly assigned partitions [instrumentsReq-0]
valuation-service     | 2019-02-28 07:55:54,604 INFO  [org.apache.kafka.clients.consumer.internals.AbstractCoordinator] (EE-ManagedExecutorService-default-Thread-1) [Consumer clientId=consumer-1, groupId=pinfo-microservices] Successfully joined group with generation 14
valuation-service     | 2019-02-28 07:55:54,611 INFO  [org.apache.kafka.clients.consumer.internals.ConsumerCoordinator] (EE-ManagedExecutorService-default-Thread-1) [Consumer clientId=consumer-1, groupId=pinfo-microservices] Setting newly assigned partitions [instruments-0]
&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;In another console, check the running containers&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;docker ps&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt; 
CONTAINER ID        IMAGE                             COMMAND                  CREATED              STATUS              PORTS                                               NAMES
f7af748fe9ae        unige/valuation-service:latest    &quot;/bin/sh -c 'java -D…&quot;   3 minutes ago       Up 3 minutes        0.0.0.0:12080-&amp;gt;8080/tcp                             valuation-service
aea66ab35500        unige/instrument-service:latest   &quot;/bin/sh -c 'java -D…&quot;   3 minutes ago       Up 3 minutes        0.0.0.0:11080-&amp;gt;8080/tcp                             instrument-service
2df3d6a8d6aa        confluentinc/cp-kafka:5.1.0       &quot;/etc/confluent/dock…&quot;   33 hours ago         Up 4 minutes        0.0.0.0:9092-&amp;gt;9092/tcp                              kafka
f197de9c79fe        zookeeper:3.4.9                   &quot;/docker-entrypoint.…&quot;   33 hours ago         Up 4 minutes        2888/tcp, 0.0.0.0:2181-&amp;gt;2181/tcp, 3888/tcp          zookeeper
&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;Now we are ready to test the microservices. Let’s check again that we can query counterparties.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;curl &lt;span class=&quot;nt&quot;&gt;-X&lt;/span&gt; GET http://localhost:10080/counterparties/724500J4K3Q60O9QLF45&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
{&quot;lei&quot;:&quot;724500J4K3Q60O9QLF45&quot;,&quot;name&quot;:&quot;Ton Smit Onroerend Goed B.V.&quot;,&quot;legalAddress&quot;:{&quot;firstAddressLine&quot;:&quot;Van Teylingenweg 126&quot;,&quot;city&quot;:&quot;Kamerik&quot;,&quot;region&quot;:&quot;&quot;,&quot;country&quot;:&quot;NL&quot;,&quot;postalCode&quot;:&quot;3471GG&quot;},&quot;registration&quot;:{&quot;registrationAuthorityID&quot;:&quot;RA000463&quot;,&quot;registrationAuthorityEntityID&quot;:&quot;52431649&quot;,&quot;jurisdiction&quot;:&quot;NL&quot;,&quot;legalFormCode&quot;:&quot;54M6&quot;,&quot;category&quot;:&quot;&quot;,&quot;registrationDate&quot;:1545264000000,&quot;lastUpdated&quot;:1545264000000,&quot;registrationStatus&quot;:&quot;ISSUED&quot;,&quot;nextRenewalDate&quot;:1576800000000},&quot;status&quot;:&quot;ACTIVE&quot;}
&lt;/pre&gt;&lt;/figure&gt;
&lt;p&gt;Then let’s get a specific instrument&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;curl &lt;span class=&quot;nt&quot;&gt;-X&lt;/span&gt; GET http://localhost:11080/instrument/1&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
{&quot;id&quot;:1,&quot;brokerLei&quot;:&quot;254900LAW6SKNVPBBN21&quot;,&quot;counterpartyLei&quot;:&quot;969500CHL179N00GX059&quot;,&quot;originalCurrency&quot;:&quot;EUR&quot;,&quot;amountInOriginalCurrency&quot;:539926.20,&quot;dealDate&quot;:-61630035780000,&quot;valueDate&quot;:-61630035780000,&quot;instrumentType&quot;:&quot;B&quot;,&quot;isin&quot;:&quot;BE7261065565&quot;,&quot;quantity&quot;:5445,&quot;maturityDate&quot;:1577837340000}
&lt;/pre&gt;&lt;/figure&gt;
&lt;p&gt;Next, we will propagate all the instruments to the message broker for the valuation service to read them and compute the actual valuation.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;curl &lt;span class=&quot;nt&quot;&gt;-X&lt;/span&gt; POST http://localhost:11080/instrument/propagateAllInstruments&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;This is the actual result of the valuation of the portfolio.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;curl &lt;span class=&quot;nt&quot;&gt;-X&lt;/span&gt; GET http://localhost:12080/valuation?currency&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;USD&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
{&quot;breakdownByInstrumentType&quot;:{&quot;STOCK&quot;:376127254.270,&quot;LOAN&quot;:317483580.00,&quot;BOND&quot;:468433784.120,&quot;DEPOSIT&quot;:71056222.00,&quot;WARRANT&quot;:4847202.120},&quot;breakdownByCurrency&quot;:{&quot;CHF&quot;:70073308.00,&quot;SGD&quot;:66540948.00,&quot;EUR&quot;:913601713.74,&quot;GBP&quot;:102726326.00,&quot;USD&quot;:85005746.77},&quot;reportingCurrency&quot;:&quot;USD&quot;,&quot;currentValue&quot;:1237948042.510,&quot;percentile95&quot;:0.0,&quot;percentile99&quot;:0.0}
&lt;/pre&gt;&lt;/figure&gt;

&lt;div class=&quot;alert alert-success&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-check-square&quot;&gt;&lt;/i&gt; &lt;b&gt;Tip: &lt;/b&gt; Congrats, you just got all the microservies and the message broker running. &lt;/div&gt;

&lt;h1 id=&quot;bibliography&quot;&gt;Bibliography&lt;/h1&gt;
&lt;ul&gt;
  &lt;li&gt;[1] N. Poulton, (2017) Docker Deep Dive&lt;/li&gt;
  &lt;li&gt;[2] Turnbull, J. (2014). The Docker Book: Containerization is the new virtualization.&lt;/li&gt;
  &lt;li&gt;[3] Mauro Vocale, Luigi Fugaro (2018). Hands-On Cloud-Native Microservices with Jakarta EE&lt;/li&gt;
  &lt;li&gt;[4] Raghuram Bharathan, (2015). Apache Maven Cookbook&lt;/li&gt;
&lt;/ul&gt;</content><author><name></name></author><summary type="html">Introduction This series of blog posts aims at helping students at the University of Geneva to develop their first application following micro-service principles. Besides explaining the concepts and implementation details of micro-service architecture, we will as well discuss software development practices such as software factories and innovative deployment options such as containers and container composition. All samples and a complete working application can be found here on GitHub</summary></entry><entry><title type="html">Microservice Architecture - Part 2 (SSO, Logging, and all that)</title><link href="http://localhost:4000/2019/02/17/microservice-architecture-part-2.html" rel="alternate" type="text/html" title="Microservice Architecture - Part 2 (SSO, Logging, and all that)" /><published>2019-02-17T22:51:20+01:00</published><updated>2019-02-17T22:51:20+01:00</updated><id>http://localhost:4000/2019/02/17/microservice-architecture-part-2</id><content type="html" xml:base="http://localhost:4000/2019/02/17/microservice-architecture-part-2.html">&lt;p&gt;In &lt;a href=&quot;https://www.hostettler.net/2019/02/17/microservice-architecture-part-1.html&quot;&gt;part 1&lt;/a&gt;, we discussed how to compile and deploy the microservices. Remember that the microservices themselves are only a part of the microservice architecture. 
By its very nature, microservice architecture is distributed and that comes with a lot of benefits and some constraints.
One of these constraints is that all the non-functional features such as security, logging, testability have to take distribution into account.
Think of the microservice architecture as a city, where the microservice are people working in the city. In the city, you also need policemen, firefighters, teachers, healthcare providers to keep it up and running.
The higher the number of people working in the private sector (a.k.a., microservices), the higher the need for non-operational people (a.k.a., utilities).&lt;/p&gt;

&lt;h2 id=&quot;compiling-the-ui&quot;&gt;Compiling the UI&lt;/h2&gt;
&lt;p&gt;This sample microservice architecture does not focus much on the UI. It mainly serves the purpose of showing how to integrate
it with the rest of the architecture. We will not dive into details. Sufficient  to say, that the example was built with &lt;a href=&quot;https://angular.io/&quot;&gt;Angular 7.0&lt;/a&gt;
and the &lt;a href=&quot;https://github.com/akveo/ngx-admin&quot;&gt;ngx-admin dashboard&lt;/a&gt;.
In development, the UI is compiled by &lt;a href=&quot;https://www.npmjs.com/&quot;&gt;npm&lt;/a&gt; running on top of &lt;a href=&quot;https://nodejs.org/en/&quot;&gt;nodejs&lt;/a&gt;.&lt;/p&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;cd &lt;/span&gt;web-ui
&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;node &lt;span class=&quot;nt&quot;&gt;--version&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
10.15.0
&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;npm &lt;span class=&quot;nt&quot;&gt;--version&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
6.5.0
&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;npm &lt;span class=&quot;nb&quot;&gt;install&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
...
audited 31887 packages in 68.922s
&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;npm run-script build&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
69% building modules 1280/1296 modules 16 active ...components\footer\footer.component.scssDEPRECATION WARNING on line 1, column 8 of 
Including .css files with @import is non-standard behaviour which will be removed in future versions of LibSass.
Use a custom importer to maintain this behaviour. Check your implementations documentation on how to create a custom importer.

Date: 2019-02-21T09:13:40.912Z
Hash: e3a111b6560428e93784
Time: 76066ms
chunk {app-pages-pages-module} app-pages-pages-module.js, app-pages-pages-module.js.map (app-pages-pages-module) 3.16 MB  [rendered]
chunk {main} main.js, main.js.map (main) 1.92 MB [initial] [rendered]
chunk {polyfills} polyfills.js, polyfills.js.map (polyfills) 492 kB [initial] [rendered]
chunk {runtime} runtime.js, runtime.js.map (runtime) 8.84 kB [entry] [rendered]
chunk {scripts} scripts.js, scripts.js.map (scripts) 1.32 MB  [rendered]
chunk {styles} styles.js, styles.js.map (styles) 3.99 MB [initial] [rendered]
chunk {vendor} vendor.js, vendor.js.map (vendor) 7.17 MB [initial] [rendered]
&lt;/pre&gt;&lt;/figure&gt;
&lt;div class=&quot;alert alert-success&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-check-square&quot;&gt;&lt;/i&gt; &lt;b&gt;Tip: &lt;/b&gt; You just compiled the UI based on Angular 7.0 &lt;/div&gt;

&lt;h2 id=&quot;composing-the-microservices&quot;&gt;Composing the microservices&lt;/h2&gt;

&lt;p&gt;At this point, we have all the necessary components. Let’s put everything together by starting the different Docker compositions. The order in which we start the compositions is 
important as there are dependencies:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose-microservices.yml&lt;/code&gt; starts the &lt;a href=&quot;https://kafka.apache.org/&quot;&gt;Kafka&lt;/a&gt; message broker and the microservices. We already tested this in &lt;a href=&quot;https://www.hostettler.net/2019/02/17/microservice-architecture-part-1.html&quot;&gt;part 1&lt;/a&gt; to prove that all the microservices are available.&lt;/li&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose-log.yml&lt;/code&gt; starts an &lt;a href=&quot;https://www.elastic.co/elk-stack&quot;&gt;ElasticSearch, LogStash, and Kibana (ELK) suite&lt;/a&gt; alongside a Logspout companion container to take care of logs. This aggregates &lt;strong&gt;ALL&lt;/strong&gt; logs from all containers
and concentrate them into the ElasticSearch using Logstash. Kibana can then be used to analyze the logs and extract some intelligence, raise alerts and so on.&lt;/li&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose-api-gw.yml&lt;/code&gt; starts an api-gateway that routes the calls to the services and handle 
security by delegating authentication to an identity manager called &lt;a href=&quot;https://www.keycloak.org/&quot;&gt;keyloak&lt;/a&gt;. It also serves static content and as &lt;a href=&quot;https://en.wikipedia.org/wiki/TLS_termination_proxy&quot;&gt;TLS termination&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;div class=&quot;alert alert-warning&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-warning&quot;&gt;&lt;/i&gt; &lt;b&gt;Important: &lt;/b&gt; On Linux system you may get the following error message : max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]. If it is the case run the following command
in a console : sysctl -w vm.max_map_count=262144 &lt;/div&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;cd  &lt;/span&gt;docker-compose
&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;docker-compose &lt;span class=&quot;nt&quot;&gt;-f&lt;/span&gt; docker-compose-microservices.yml up &amp;amp;
&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;docker-compose &lt;span class=&quot;nt&quot;&gt;-f&lt;/span&gt; docker-compose-log.yml up &amp;amp;
&lt;span class=&quot;nv&quot;&gt;$ &lt;/span&gt;docker-compose &lt;span class=&quot;nt&quot;&gt;-f&lt;/span&gt; docker-compose-api-gw.yml up &amp;amp;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;figure class=&quot;console-output&quot;&gt;&lt;pre class=&quot;console-output&quot;&gt;
counterparty-service    | 2019-03-12 20:06:27,203 INFO  [stdout] (default task-1)         counterpar0_.registrationStatus as registr16_0_,
counterparty-service    | 2019-03-12 20:06:27,203 INFO  [stdout] (default task-1)         counterpar0_.status as status17_0_
counterparty-service    | 2019-03-12 20:06:27,203 INFO  [stdout] (default task-1)     from
counterparty-service    | 2019-03-12 20:06:27,205 INFO  [stdout] (default task-1)         Counterparty counterpar0_
kafka                   | [2019-03-12 20:10:15,744] INFO [GroupMetadataManager brokerId=1] Removed 0 expired offsets in 0 milliseconds. (kafka.coordinator.group.GroupMetadataManager)
kafka                   | [2019-03-12 20:20:15,651] INFO [GroupMetadataManager brokerId=1] Removed 0 expired offsets in 0 milliseconds. (kafka.coordinator.group.GroupMetadataManager)
kafka                   | [2019-03-12 20:30:15,652] INFO [GroupMetadataManager brokerId=1] Removed 0 expired offsets in 0 milliseconds. (kafka.coordinator.group.GroupMetadataManager)
kafka                   | [2019-03-12 20:40:15,652] INFO [GroupMetadataManager brokerId=1] Removed 0 expired offsets in 0 milliseconds. (kafka.coordinator.group.GroupMetadataManager)
kafka                   | [2019-03-12 20:50:15,654] INFO [GroupMetadataManager brokerId=1] Removed 0 expired offsets in 0 milliseconds. (kafka.coordinator.group.GroupMetadataManager)
...
kibana           | {&quot;type&quot;:&quot;response&quot;,&quot;@timestamp&quot;:&quot;2019-03-12T20:53:56Z&quot;,&quot;tags&quot;:[],&quot;pid&quot;:1,&quot;method&quot;:&quot;get&quot;,&quot;statusCode&quot;:302,&quot;req&quot;:{&quot;url&quot;:&quot;/&quot;,&quot;method&quot;:&quot;get&quot;,&quot;headers&quot;:{&quot;user-agent&quot;:&quot;curl/7.29.0&quot;,&quot;host&quot;:&quot;localhost:5601&quot;,&quot;accept&quot;:&quot;*/*&quot;},&quot;remoteAddress&quot;:&quot;127.0.0.1&quot;,&quot;userAgent&quot;:&quot;127.0.0.1&quot;},&quot;res&quot;:{&quot;statusCode&quot;:302,&quot;responseTime&quot;:3,&quot;contentLength&quot;:9},&quot;message&quot;:&quot;GET / 302 3ms - 9.0B&quot;}
kibana           | {&quot;type&quot;:&quot;response&quot;,&quot;@timestamp&quot;:&quot;2019-03-12T20:54:01Z&quot;,&quot;tags&quot;:[],&quot;pid&quot;:1,&quot;method&quot;:&quot;get&quot;,&quot;statusCode&quot;:302,&quot;req&quot;:{&quot;url&quot;:&quot;/&quot;,&quot;method&quot;:&quot;get&quot;,&quot;headers&quot;:{&quot;user-agent&quot;:&quot;curl/7.29.0&quot;,&quot;host&quot;:&quot;localhost:5601&quot;,&quot;accept&quot;:&quot;*/*&quot;},&quot;remoteAddress&quot;:&quot;127.0.0.1&quot;,&quot;userAgent&quot;:&quot;127.0.0.1&quot;},&quot;res&quot;:{&quot;statusCode&quot;:302,&quot;responseTime&quot;:8,&quot;contentLength&quot;:9},&quot;message&quot;:&quot;GET / 302 8ms - 9.0B&quot;}
....
api-gateway         | 192.168.128.15 - - [12/Mar/2019:20:02:36 +0000] &quot;POST /plugins HTTP/1.1&quot; 409 213 &quot;-&quot; &quot;curl/7.29.0&quot;                                                                        
api-gateway         | 2019/03/12 20:02:36 [notice] 41#0: *139 [lua] init.lua:393: insert(): ERROR: duplicate key value violates unique constraint &quot;plugins_cache_key_key&quot;                       &quot; 
api-gateway         | Key (cache_key)=(plugins:oidc::::) already exists., client: 192.168.128.15, server: kong_admin, request: &quot;POST /plugins HTTP/1.1&quot;, host: &quot;api-gateway:8001&quot;               
&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;If everything went according to plan, you now have a working application ecosystem at &lt;code class=&quot;highlighter-rouge&quot;&gt;https://localhost&lt;/code&gt; 
Point your browser to &lt;code class=&quot;highlighter-rouge&quot;&gt;https://localhost&lt;/code&gt; and you’ll get an nice UI.&lt;/p&gt;
&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/ui.png&quot; alt=&quot;Angular 7.0 UI to the financial-app&quot; /&gt;
  &lt;figcaption&gt;Angular 7.0 UI to the financial-app&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;p&gt;By pointing it to the counterparty microservice at &lt;code class=&quot;highlighter-rouge&quot;&gt;https://localhost/api/v1/counterparty&lt;/code&gt;, the API-gateway will detect that you are not authenticated and will redirect you
to the SSO platform to enter for credentials. Enter &lt;code class=&quot;highlighter-rouge&quot;&gt;user1/user1&lt;/code&gt;&lt;/p&gt;
&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/login.png&quot; alt=&quot;Keycloack SSO login form&quot; /&gt;
  &lt;figcaption&gt;Keycloack SSO login form&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;
&lt;p&gt;Once authenticated you get redirected to the orginal URL you requested (&lt;code class=&quot;highlighter-rouge&quot;&gt;https://localhost/api/v1/counterparty&lt;/code&gt;)&lt;/p&gt;
&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/counterparty-service.png&quot; alt=&quot;JSON result of the counterparty  microservice that returns all counterparties.&quot; /&gt;
  &lt;figcaption&gt;JSON result of the counterparty  microservice that returns all counterparties.&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;div class=&quot;alert alert-success&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-check-square&quot;&gt;&lt;/i&gt; &lt;b&gt;Tip: &lt;/b&gt; Kudos, you just completed the installation of a complete microservice ecosystem locally on your machine. &lt;/div&gt;

&lt;h2 id=&quot;dissecting-the-docker-composes&quot;&gt;Dissecting the docker-composes&lt;/h2&gt;
&lt;p&gt;As stated previously &lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose&lt;/code&gt; composes several containers together to deliver a solution. 
For instance, by starting the database first and then whatever service that requires a database.
Using &lt;a href=&quot;https://docs.docker.com/compose/&quot;&gt;docker-compose&lt;/a&gt; you set the same parameters, environment variables, 
volumes that you would when starting a container with the command line.&lt;/p&gt;

&lt;p&gt;From a general point of view, a docker-compose yaml file defines a series of services (e.g., database, microservice, web server) and then a series of “shared” services such as volumes, networks and so on.&lt;/p&gt;

&lt;p&gt;Let’s take the example of the &lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose-api-gw.yml&lt;/code&gt;  file.&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;First &lt;code class=&quot;highlighter-rouge&quot;&gt;version &quot;2.1&quot;&lt;/code&gt; defines the version of the syntax. Then &lt;code class=&quot;highlighter-rouge&quot;&gt;services&lt;/code&gt; defines a section with a series of services.&lt;/li&gt;
  &lt;li&gt;In the below example, the first service is called &lt;code class=&quot;highlighter-rouge&quot;&gt;kong-database&lt;/code&gt; and is based on a postgres database version 10 as stated by &lt;code class=&quot;highlighter-rouge&quot;&gt;image: postgres:10&lt;/code&gt;. The name of the container (for instance what
will appear if you run &lt;code class=&quot;highlighter-rouge&quot;&gt;docker ps&lt;/code&gt;) is &lt;code class=&quot;highlighter-rouge&quot;&gt;kong-database&lt;/code&gt;. The hostname will also be called &lt;code class=&quot;highlighter-rouge&quot;&gt;kong-database&lt;/code&gt;.&lt;/li&gt;
  &lt;li&gt;What follows, is a section that describes the networks the container is participating into. This is very useful to isolate the containers from one another from a network perspective.&lt;/li&gt;
  &lt;li&gt;The &lt;code class=&quot;highlighter-rouge&quot;&gt;environment&lt;/code&gt; section defines environment variables (similar to &lt;code class=&quot;highlighter-rouge&quot;&gt;-e&lt;/code&gt; in the command line).&lt;/li&gt;
  &lt;li&gt;The healthcheck section defines rules to state whether or not a container is ready for prime time
and heathly.&lt;/li&gt;
  &lt;li&gt;The &lt;code class=&quot;highlighter-rouge&quot;&gt;kong-database&lt;/code&gt; example does not expose ports but it could do so by defining a &lt;code class=&quot;highlighter-rouge&quot;&gt;ports&lt;/code&gt; section that list the mapping of the ports of the container to the port of the host system. &lt;code class=&quot;highlighter-rouge&quot;&gt;80:7070&lt;/code&gt;  means
the  port &lt;code class=&quot;highlighter-rouge&quot;&gt;7070&lt;/code&gt; of the container is mapped to the port &lt;code class=&quot;highlighter-rouge&quot;&gt;80&lt;/code&gt; (http) of the host system.&lt;/li&gt;
  &lt;li&gt;Finally, the volumes section maps volumes from the host systems to the directory in the container. This is very useful to save the state of the container (e.g., database files)
or to put custom configurations in place.&lt;/li&gt;
&lt;/ul&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-yaml&quot; data-lang=&quot;yaml&quot;&gt;&lt;span class=&quot;na&quot;&gt;version&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;2.1&quot;&lt;/span&gt;

&lt;span class=&quot;na&quot;&gt;services&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;

   &lt;span class=&quot;na&quot;&gt;kong-database&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;image&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;postgres:10&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;container_name&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;kong-database&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;hostname&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;kong-database&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;networks&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
     &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;backend-network&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;environment&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;POSTGRES_USER&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;kong&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;POSTGRES_PASSWORD&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;kong&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;POSTGRES_DB&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;kongdb&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;healthcheck&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;test&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;pi&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;CMD&quot;&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;pg_isready&quot;&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;-U&quot;&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;kong&quot;&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;-d&quot;&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;kongdb&quot;&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;]&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;interval&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;30s&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;timeout&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;30s&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;retries&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;3&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;volumes&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
      &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;pgdata-kong:/var/lib/postgresql/data&lt;/span&gt;
&lt;span class=&quot;nn&quot;&gt;...&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;After that very quick introduction to &lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose&lt;/code&gt; let’s have a look at the services delivered by the three &lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose&lt;/code&gt; files of the demo:&lt;/p&gt;

&lt;h4 id=&quot;docker-compose-logyml-providing-a-logging-infrastructure&quot;&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose-log.yml&lt;/code&gt;: Providing a logging infrastructure&lt;/h4&gt;
&lt;p&gt;Microservice architecture are distributed by nature and therefore cross-cutting concerns such as logging must take that aspect into account and aggregate the logs of the different containers.
Without that it would be difficult to follow a user request that goes across many services to deliver the final value.&lt;/p&gt;

&lt;p&gt;To implement it, we rely on the &lt;a href=&quot;https://github.com/gliderlabs/logspout&quot;&gt;logspout&lt;/a&gt; log router. Logspout primarly captures all logs of all the running containers and route them to
a log concentrator. Logspout in itself does not do anything with the logs, it just routes them to something. In our case, that something is &lt;a href=&quot;https://www.elastic.co/products/logstash&quot;&gt;Logstash&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Logstash is part of the ELK stack and is a pipeline that concentrates, aggregates, filters and stashes them in a database, usually &lt;a href=&quot;https://www.elastic.co/products/elasticsearch&quot;&gt;elasticsearch&lt;/a&gt;.
Kibana depends on Elasticsearch and gets its configuration from a volumes shared from the host (&lt;code class=&quot;highlighter-rouge&quot;&gt;./elk-pipeline/&lt;/code&gt;).
For more details about the Logstash configuration, please refer to &lt;code class=&quot;highlighter-rouge&quot;&gt;./elk-pipeline/logstash.conf&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href=&quot;https://www.elastic.co/products/elasticsearch&quot;&gt;Elastic Search&lt;/a&gt; stores, indexes and searches large amount of data. Like Logstash, it is distributed in nature.
Elasticsearch is starting first in &lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose-log.yml&lt;/code&gt; because other services such as Logstash and Kibana depends on it.
Elasticsearch maps a host volume (&lt;code class=&quot;highlighter-rouge&quot;&gt;esdata1&lt;/code&gt;) to its own data directory (&lt;code class=&quot;highlighter-rouge&quot;&gt;/usr/share/elasticsearch/data&lt;/code&gt;). Thanks to that mapping, data are not lost when the container is stopped or if it crashes.&lt;/p&gt;

&lt;p&gt;The final part of the puzzle is &lt;a href=&quot;https://www.elastic.co/products/kibana&quot;&gt;Kibana&lt;/a&gt; which visualizes the data stored in Elasticsearch to do business intelligence on the logs. This is very 
useful to get a clear and real time status of the solution. Kibana depends on Elasticsearch and exposes its interface to the port &lt;code class=&quot;highlighter-rouge&quot;&gt;5601&lt;/code&gt; of the host.&lt;/p&gt;

&lt;p&gt;&lt;br /&gt;&lt;/p&gt;

&lt;h4 id=&quot;docker-compose-api-gwyml--prodiving-api-gateway-services&quot;&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose-api-gw.yml&lt;/code&gt; : Prodiving api-gateway services&lt;/h4&gt;
&lt;p&gt;Microservice architecture are usually composed of a lot of services. Keeping track of these, providing and maintaining a clear API becomes very quickly challenging.
Besides, the granularity of microservices often call for a composition to deliver actual value add. Besides, different applications might have different needs. For instance, a mobile app might need a different API
than a web app.
Furthermore, we often want to secure some services. For instance, using &lt;a href=&quot;https://oauth.net/2/&quot;&gt;oauth2 protocol&lt;/a&gt; connected to an identity provider to offer Single Sign On (SSO) on the services.&lt;/p&gt;

&lt;p&gt;In our case, the API gateway is called &lt;a href=&quot;https://konghq.com/solutions/gateway/&quot;&gt;Kong&lt;/a&gt; and it requires a database. The &lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose-api-gw.yml&lt;/code&gt; describes the following services:&lt;/p&gt;

&lt;p&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;kong-database&lt;/code&gt; which is a postgress database version 10 that holds the API gateway configuration&lt;/p&gt;

&lt;p&gt;The api gateway itself &lt;code class=&quot;highlighter-rouge&quot;&gt;api-gateway&lt;/code&gt; that is based on a docker image that we built previously &lt;code class=&quot;highlighter-rouge&quot;&gt;unige/api-gateway&lt;/code&gt;  when we ran &lt;code class=&quot;highlighter-rouge&quot;&gt;mvn clean install -Ppackage-docker-image&lt;/code&gt; at the root of the project.
To get more details on how the image has been built, look at the &lt;code class=&quot;highlighter-rouge&quot;&gt;Dockerfile&lt;/code&gt; in the &lt;code class=&quot;highlighter-rouge&quot;&gt;api-gateway/src/main/docker&lt;/code&gt; directory. The image is based on &lt;code class=&quot;highlighter-rouge&quot;&gt;kong:1.1rc1-centos&lt;/code&gt; but it is customized in several ways:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;There is an additional &lt;a href=&quot;https://github.com/nokia/kong-oidc&quot;&gt;plugin&lt;/a&gt; to support openid&lt;/li&gt;
  &lt;li&gt;A customized &lt;code class=&quot;highlighter-rouge&quot;&gt;docker-entrypoint.sh&lt;/code&gt; to start Kong as root so that we can attach it to ports &lt;code class=&quot;highlighter-rouge&quot;&gt;80&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;443&lt;/code&gt; that are privileged.&lt;/li&gt;
  &lt;li&gt;A customer &lt;code class=&quot;highlighter-rouge&quot;&gt;nginx&lt;/code&gt; template to enable serving static content (the UI).&lt;/li&gt;
  &lt;li&gt;A shell script called &lt;code class=&quot;highlighter-rouge&quot;&gt;config-kong.sh&lt;/code&gt; that configures the API-gateway by defining the services and the routes to these services. By the way this file, is ran after the api-gateway is
started and labelled as healthy by the container called &lt;code class=&quot;highlighter-rouge&quot;&gt;api-gateway-init&lt;/code&gt;.
The first line defines a service called &lt;code class=&quot;highlighter-rouge&quot;&gt;counterparty-service&lt;/code&gt; that will route the request to the microservice &lt;code class=&quot;highlighter-rouge&quot;&gt;http://counterparty-service:8080/counterparties&lt;/code&gt;. The servicer &lt;code class=&quot;highlighter-rouge&quot;&gt;counterparty-service&lt;/code&gt; is the host name
given by the microservice configuration. The second line creates a route in the API-gateway to the previous service. In that case &lt;code class=&quot;highlighter-rouge&quot;&gt;/api/v1/counterparty&lt;/code&gt;, please note that the api-gateway can
take care of versioning. Finally, the last line configures the OpenId plugin to provide authentication by telling the plugin to use the &lt;code class=&quot;highlighter-rouge&quot;&gt;api-gateway&lt;/code&gt; client of the &lt;code class=&quot;highlighter-rouge&quot;&gt;apigw&lt;/code&gt; realm of the keycloak.&lt;/li&gt;
&lt;/ul&gt;

&lt;figure class=&quot;highlight&quot;&gt;&lt;pre&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span class=&quot;c&quot;&gt;#Creates the services.&lt;/span&gt;
curl &lt;span class=&quot;nt&quot;&gt;-S&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-s&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-i&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-X&lt;/span&gt; POST &lt;span class=&quot;nt&quot;&gt;--url&lt;/span&gt; http://api-gateway:8001/services &lt;span class=&quot;nt&quot;&gt;--data&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;name=counterparty-service&quot;&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--data&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;url=http://counterparty-service:8080/counterparties&quot;&lt;/span&gt;
...
&lt;span class=&quot;c&quot;&gt;#Creates the routes&lt;/span&gt;
curl &lt;span class=&quot;nt&quot;&gt;-S&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-s&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-i&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-X&lt;/span&gt; POST  &lt;span class=&quot;nt&quot;&gt;--url&lt;/span&gt; http://api-gateway:8001/services/counterparty-service/routes &lt;span class=&quot;nt&quot;&gt;--data&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;paths[]=/api/v1/counterparty&quot;&lt;/span&gt; 
...
&lt;span class=&quot;c&quot;&gt;#Enable the Open ID Plugin&lt;/span&gt;
curl &lt;span class=&quot;nt&quot;&gt;-S&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-s&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-i&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-X&lt;/span&gt; POST  &lt;span class=&quot;nt&quot;&gt;--url&lt;/span&gt; http://api-gateway:8001/plugins &lt;span class=&quot;nt&quot;&gt;--data&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;name=oidc&quot;&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--data&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;config.client_id=api-gateway&quot;&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--data&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;config.client_secret=798751a9-d274-4335-abf6-80611cd19ba1&quot;&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--data&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;config.discovery=https%3A%2F%2Flocalhost%2Fauth%2Frealms%2Fapigw%2F.well-known%2Fopenid-configuration&quot;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/figure&gt;

&lt;p&gt;A database for Keycloak the SSO software called &lt;code class=&quot;highlighter-rouge&quot;&gt;iam-db&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;The SSO service &lt;code class=&quot;highlighter-rouge&quot;&gt;iam&lt;/code&gt; that is based on Keycloak v4.8.3. Please note that a complete configuration is loaded initially using &lt;code class=&quot;highlighter-rouge&quot;&gt;master.realm.json&lt;/code&gt;. This configuration creates the required
realm, client and configuration to provide authentication to the api-gateway.&lt;/p&gt;

&lt;p&gt;&lt;br /&gt;&lt;/p&gt;

&lt;h4 id=&quot;docker-compose-microservicesyml--micro-services-and-message-broker&quot;&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;docker-compose-microservices.yml&lt;/code&gt; : Micro-services and message broker&lt;/h4&gt;
&lt;p&gt;Finally, the last of the composition are the microservices themselves. As you can see, most of the configuration is not required for the microservices themselves but for the infrastructure around it.
All the services belong to the &lt;code class=&quot;highlighter-rouge&quot;&gt;backend-network&lt;/code&gt; nertwork.&lt;/p&gt;

&lt;p&gt;First, it defines a &lt;a href=&quot;https://zookeeper.apache.org/&quot;&gt;ZooKeeper&lt;/a&gt; that provides distributed configuration management, naming and group services. Zookeeper maintains its state in two shared volumes that are respectively mapped
to the  &lt;code class=&quot;highlighter-rouge&quot;&gt;./target/zk-single-kafka-single/zoo1/data&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;./target/zk-single-kafka-single/zoo1/datalog&lt;/code&gt; directories of the host. Zookeeper is a mandatory component for the message broker.&lt;/p&gt;

&lt;p&gt;Second, it defines a Kafka container. &lt;a href=&quot;https://kafka.apache.org/&quot;&gt;Kafka&lt;/a&gt; is a robust and fast message broker that excels at exchanging messages in a distributed way. It has a dependency to Zookeeper
and exposes its port &lt;code class=&quot;highlighter-rouge&quot;&gt;9092&lt;/code&gt; to the same port on the host. It also saves its state on a mapped volume on the host.&lt;/p&gt;

&lt;p&gt;Then, the counterparty service is a actual microservice (Finally !!!) that exposes its port &lt;code class=&quot;highlighter-rouge&quot;&gt;8080&lt;/code&gt; to the port &lt;code class=&quot;highlighter-rouge&quot;&gt;10080&lt;/code&gt; of the host. This microservice is based on &lt;a href=&quot;https://thorntail.io/&quot;&gt;Thorntail&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The instrument service is special as it connects to the message broker (Kafka) to send messages that will be read later on by the valuation service.&lt;/p&gt;

&lt;p&gt;The other microservices : valuation-service and regulatory-service are more of the same.&lt;/p&gt;

&lt;div class=&quot;alert alert-success&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-check-square&quot;&gt;&lt;/i&gt; &lt;b&gt;Tip: &lt;/b&gt; Kudos, you completed the tour of the microservice sample. Next chapter dives into a bit of theory. &lt;/div&gt;</content><author><name></name></author><summary type="html">In part 1, we discussed how to compile and deploy the microservices. Remember that the microservices themselves are only a part of the microservice architecture. By its very nature, microservice architecture is distributed and that comes with a lot of benefits and some constraints. One of these constraints is that all the non-functional features such as security, logging, testability have to take distribution into account. Think of the microservice architecture as a city, where the microservice are people working in the city. In the city, you also need policemen, firefighters, teachers, healthcare providers to keep it up and running. The higher the number of people working in the private sector (a.k.a., microservices), the higher the need for non-operational people (a.k.a., utilities).</summary></entry><entry><title type="html">My two cents on SVN vs GIT</title><link href="http://localhost:4000/2016/02/27/my-two-cents-on-svn-vs-git.html" rel="alternate" type="text/html" title="My two cents on SVN vs GIT" /><published>2016-02-27T11:13:50+01:00</published><updated>2016-02-27T11:13:50+01:00</updated><id>http://localhost:4000/2016/02/27/my-two-cents-on-svn-vs-git</id><content type="html" xml:base="http://localhost:4000/2016/02/27/my-two-cents-on-svn-vs-git.html">&lt;div class=&quot;alert alert-warning&quot; role=&quot;alert&quot;&gt;&lt;i class=&quot;fa fa-warning&quot;&gt;&lt;/i&gt; &lt;b&gt;Important: &lt;/b&gt; This post is 3 years old and a lot has changed in the mean time. I would now recommend to upgrade to Git. 
Especially because the Cloud ecosystem is extremely dynamic. That being said, do it in a managed way starting by a low profile project. &lt;/div&gt;

&lt;hr /&gt;
&lt;p&gt;&lt;strong&gt;Executive summary&lt;/strong&gt; : Yes, Git is functionally richer and has several quality attributes that are really better than SVN but let’s face it : it comes with an extra layer of complexity. This complexity may (and did in several instances I am aware of) result in time to market issues, tensions during stressful phases, loss of commits, dreadful merges and major impacts on the release management process. Henceforth, the question is :&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Are the extra functionnalities worth the investment and the risks?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In my opinion, Git is worth the investment if your devellopers are meant to work off site / off line.
If not (e.g., standard banking and financial industries) and it you already have an up and running SVN based software factory then do not bother 
to migrate to Git for existing project. Try a proof of concept on a new &lt;strong&gt;low profile project&lt;/strong&gt; and do not hesitate to invest in training &lt;strong&gt;and&lt;/strong&gt;  to re-engineer you existing release management processes. Once your teams have some experience with it, you can decide to migrate the existing codebase. 
That’s beeing said, if you have no SCM then start with Git directly.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3 id=&quot;introduction&quot;&gt;Introduction&lt;/h3&gt;

&lt;p&gt;In many companies, SVN is still the SCM of choice (and yes some of them just finished up migrating from CVS). In the open-source world, the situation is very different. Indeed, Git is the de facto winner. As devellopers tend to stay up to date with the latest technologies, they want to migrate to the coolest new thing. I keep having discussions about GIT and whether or not a company or a department should migrate to it. In this blog post, I explain my position and argument on whether or not a company or department should move to Git.&lt;/p&gt;

&lt;h3 id=&quot;git-vs-svn&quot;&gt;Git vs SVN&lt;/h3&gt;
&lt;p&gt;There are plenty of very detailled comparison between Git and SVN out there. Among them let me cite the following articles [1] [2] [3].&lt;/p&gt;

&lt;p&gt;Here a selection of the most important functionnal and non-functional Git features.&lt;/p&gt;

&lt;h4 id=&quot;dencentrilization&quot;&gt;Dencentrilization&lt;/h4&gt;
&lt;p&gt;Let me start with the obvious, Git is dencentrilized by design. This is great for highly collaborative and disseminated teams. Actually, this is most important feature. Basically, Git has been designed to answer that problematic.
This has also nice side effects :&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;Working offline&lt;/li&gt;
  &lt;li&gt;Cloning a repository allows to quickly fork a project, make a couple of tests and submit a new version (by mean of pull requests) even if you do not have the commit rights.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is great but it is probably not the most useful features for teams working in closed business such as banking systems and other plateforms with very few mobility (for security reasons). Moreover, in these cases having conmit rights is definitely not an issue.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Disseminated teams are a very compelling argument to migrate from SVN to Git. Of course, the contraposition is also true&lt;/strong&gt;&lt;/p&gt;

&lt;h4 id=&quot;branches&quot;&gt;Branches&lt;/h4&gt;
&lt;p&gt;Branches are feared in SVN and first class citizens in Git. This is definitly a game changer as it allows much better release management procedures.&lt;/p&gt;

&lt;h4 id=&quot;performances&quot;&gt;Performances&lt;/h4&gt;
&lt;p&gt;In both performance (chekout, checkin) and space GIT is the winner. For instance, using GIT the Mozillia projects gained a factor 30x is terms of space.&lt;/p&gt;

&lt;h4 id=&quot;useful-features&quot;&gt;Useful features&lt;/h4&gt;

&lt;p&gt;GIT comes with some nice tools that really improve the productivity of experienced developers. Here is a non-exhaustive list:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;git bisect&lt;/code&gt; is great for investigating regressions and discover when that a given bug has been introduced.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;git stash&lt;/code&gt; takes all of the staged changes and stores them away somewhere. This is useful if you want to break apart a number of changes into several commits, or have changes that you don’t want to get rid of (i.e. “git reset”) but also don’t want to commit.
&lt;code class=&quot;highlighter-rouge&quot;&gt;git stash&lt;/code&gt; puts staged changes onto the stash and &lt;code class=&quot;highlighter-rouge&quot;&gt;git stash pop&lt;/code&gt; applies the changes to the current working copy. 
It operates as a FILO stack (e.g. “First In, Last Out”) stack in the default operation.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Branches are lightweight and merging is easy, and I mean really easy. It’s distributed, basically every repository is a branch. It’s much easier to develop concurrently and collaboratively than with Subversion, in my opinion. It also makes offline development possible.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h4 id=&quot;some-important-differences-to-know&quot;&gt;Some important differences to know&lt;/h4&gt;
&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;SVN has predicticable and simple version numbers, Git relies on UUID.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;GIT tracks contents rather than files&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;conclusion&quot;&gt;Conclusion&lt;/h3&gt;
&lt;p&gt;Yes, Git is functionally richer and has several quality attributes that are really better than SVN but let’s face it : it comes with an extra layer of complexity. This complexity may (and did in several instances I am aware of) result in time to market issues, tensions during stressful phases, loss of commits, dreadful merges and major impacts on the release management process.
In my opinion, Git is worth the investment if your devellopers are meant to work off site / off line.
If not (e.g., standard banking and financial industries) and it you already have an up and running SVN based software factory then do not bother 
to migrate to Git for existing project. Try a proof of concept on a new &lt;strong&gt;low profile project&lt;/strong&gt; and do not hesitate to invest in training &lt;strong&gt;and&lt;/strong&gt;  to re-engineer you existing release management processes. Once your teams have some experience with it, you can decide to migrate the existing codebase. 
That’s beeing said, if you have no SCM then start with Git directly.&lt;/p&gt;

&lt;h4 id=&quot;bibliography&quot;&gt;Bibliography&lt;/h4&gt;
&lt;p&gt;[1] http://stackoverflow.com/questions/871/why-is-git-better-than-subversion&lt;/p&gt;

&lt;p&gt;[2] https://git.wiki.kernel.org/index.php/GitSvnComparison&lt;/p&gt;

&lt;p&gt;[3] http://www.codeforest.net/git-vs-svn&lt;/p&gt;

&lt;p&gt;[4] http://nvie.com/posts/a-successful-git-branching-model/&lt;/p&gt;

&lt;p&gt;[5] https://github.com/nvie/gitflow&lt;/p&gt;

&lt;p&gt;[6] https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow&lt;/p&gt;</content><author><name></name></author><summary type="html">Important: This post is 3 years old and a lot has changed in the mean time. I would now recommend to upgrade to Git. Especially because the Cloud ecosystem is extremely dynamic. That being said, do it in a managed way starting by a low profile project.</summary></entry><entry><title type="html">A (small) hitchhiker’s guide to Data Warehousing</title><link href="http://localhost:4000/2016/02/10/data-warehouse.html" rel="alternate" type="text/html" title="A (small) hitchhiker’s guide to Data Warehousing" /><published>2016-02-10T14:07:42+01:00</published><updated>2016-02-10T14:07:42+01:00</updated><id>http://localhost:4000/2016/02/10/data-warehouse</id><content type="html" xml:base="http://localhost:4000/2016/02/10/data-warehouse.html">&lt;p&gt;In my current assignment, I had the opportunity to discuss with Data Warehouse (DWH) experts about its integration with the rest of the information system.  I noticed that not every stakeholders (included Data Warehouse professionals) use the same vocabulary.
During the discussions, people raised words such as &lt;a href=&quot;#dwh&quot;&gt;“Data Warehouse”&lt;/a&gt;, &lt;a href=&quot;#dmt&quot;&gt;“Data Marts”&lt;/a&gt;, &lt;a href=&quot;#ods&quot;&gt;ODS&lt;/a&gt;, &lt;a href=&quot;#lak&quot;&gt;“Data Lake”&lt;/a&gt; and so on. Some of the words were used interchangeably which does not help to follow the discussion. As I was not familiar  with several  of them, I decided to do my homework and to come up with a small glossary to provide a common ground for further discussions.&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;Disclaimer : I am not an expert in the field, I only tried to come up with a couple of definitions to get a common ground for further discussions.  Please experts in the field, help me to improve this!&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2 id=&quot;business-intelligence-bi&quot;&gt;Business Intelligence (B.I.)&lt;/h2&gt;

&lt;blockquote&gt;
  &lt;p&gt;Business intelligence is a set of methodologies, processes, architectures, and technologies that transform raw data into meaningful and useful information. It allows business users to make informed business decisions with real-time data that can put a company ahead of its competitors.&lt;/p&gt;

  &lt;p&gt;&lt;cite&gt;Boris Evelson - Forrester&lt;/cite&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Business Intelligence Systems usually (but not always) rely on a Data Warehouse to provide information out of raw operational data.
The following diagram shows the relationships between the different levels involved in making a  decision.
Information emerge from consolidated data thus helping the user to improve her knowledge on a given subject. Using this knowledge, she then can make a informed decision.&lt;/p&gt;
&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/B.I.png&quot; alt=&quot;How B.I. helps Decision making&quot; /&gt;
  &lt;figcaption&gt;How B.I. helps Decision making&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;p&gt;Business Intelligence Systems have the following properties:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;They leverage raw heterogeneous operational data&lt;/li&gt;
  &lt;li&gt;They enable multi-dimensional information and operations on it&lt;/li&gt;
  &lt;li&gt;They are driven by the business&lt;/li&gt;
  &lt;li&gt;They have to be performant and must not interfere with daily operations&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;data-warehouse-dwh-&quot;&gt;Data Warehouse (DWH) &lt;a id=&quot;dwh&quot;&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;DWHs are central repositories of integrated data from one or more disparate sources. Its purpose is to organize and homogenize data into information. User can then leverage this information into knowledge and therefore make informed decision (see B.I.).&lt;/p&gt;

&lt;p&gt;There are  three main approaches on how to build a data warehouse.&lt;/p&gt;

&lt;h3 id=&quot;william-inmons-approach&quot;&gt;William Inmon’s approach&lt;/h3&gt;

&lt;p&gt;According to &lt;a href=&quot;http://www.amazon.com/Building-Data-Warehouse-W-Inmon/dp/0471141615&quot;&gt;William Inmon&lt;/a&gt; that originally coined the term “Data Warehouse”, a data warehouse has the following properties:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Subject oriented : This implies that data are organized around the business and not around the sources. For instance, several accounting data sources are consolidated into one accounting data warehouse. The purpose of which is to letting information emerge out of data.&lt;/li&gt;
  &lt;li&gt;Integrated : Coming from different sources, data must be standardized to enable consistency and thus letting information emerge. For instance, customer identification must be normalized across different sources.&lt;/li&gt;
  &lt;li&gt;Non-volatile : Once in the data warehouse, data must not be altered. Therefore, data is available for future comparison.&lt;/li&gt;
  &lt;li&gt;Time-variant : Changes made on data over time are tracked. For instance, each and every change to a customer country of residence are tracked.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Inmon’s model follows a top-down approach. First, a complete (enterprise wide) Data Warehouse (DW) is created in &lt;a href=&quot;https://en.wikipedia.org/wiki/Third_normal_form&quot;&gt;third normal form&lt;/a&gt; (3NF : avoiding duplication and having referential integrity) and then, if required, &lt;a href=&quot;#dmt&quot;&gt;datamarts&lt;/a&gt; (DMT) are provisioned out of the DW. Datamarts in Inmon’s model are in 3NF from which the &lt;a href=&quot;https://en.wikipedia.org/wiki/Online_transaction_processing&quot;&gt;OLAP&lt;/a&gt; cubes are built.
For Inmon, data quality and coherency is paramount and thus the 3NF in the DW and the DMs.&lt;/p&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/Imnon.png&quot; alt=&quot;The Imnon Top-Down model&quot; /&gt;
  &lt;figcaption&gt;The Imnon Top-Down model&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;h3 id=&quot;ralph-kimballs-approach&quot;&gt;Ralph Kimball’s approach&lt;/h3&gt;
&lt;p&gt;According to &lt;a href=&quot;http://www.amazon.com/The-Data-Warehouse-Toolkit-Dimensional-ebook/dp/B004GXBZFQ&quot;&gt;Kimball&lt;/a&gt; another prominent actor in this field, “Data Warehouse is a system that extracts, cleans, conforms, and delivers source data into a dimensional data store and then supports and implements querying and analysis for the purpose of decision making.” This definition does not contradict Inmon’s properties. The difference lies in the architecture.&lt;/p&gt;

&lt;p&gt;Kimball’s model follows a bottom-up approach. First, some (Datamarts)(#dmt) (DM) emerge directly sourced from &lt;a href=&quot;https://en.wikipedia.org/wiki/Online_transaction_processing&quot;&gt;OLTP&lt;/a&gt; (Online Transaction Processing Systems) systems usually follow the company processes and organization.&lt;br /&gt;
The &lt;a href=&quot;#dmt&quot;&gt;Datamarts&lt;/a&gt; are either in 3NF (&lt;a href=&quot;#cube&quot;&gt;OLAP cubes&lt;/a&gt; are built on top of them) or de-normalized star schemas.&lt;/p&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/Kimball.png&quot; alt=&quot;The Kimball Bottum-Up model&quot; /&gt;
  &lt;figcaption&gt;The Kimball Bottum-Up model&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;h3 id=&quot;the-hybrid-model---a-typical-architecture&quot;&gt;The Hybrid model - A typical architecture&lt;/h3&gt;

&lt;p&gt;Both of these approaches have their pros and cons. Kimball’s model is easy to start with because of the bottom-up approach and hence you can start small and scale-up eventually. Moreover, the ROI is usually better with Kimball’s model. 
Because of this approach it is difficult to created re-usable data structures and operations (extraction) for different &lt;a href=&quot;#dmt&quot;&gt;datamarts&lt;/a&gt;. Finally, you may end-up with consistency problems. 
On the other hand, Inmon’s approach is structured and easier to maintain at the cost of being rigid and more expensive.&lt;/p&gt;

&lt;p&gt;Real-life DWH implementation often end-up using a hybrid architecure. The following architecture relies on the following biulding blocks:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;a staging layer to extract and sanitize data&lt;/li&gt;
  &lt;li&gt;an &lt;a href=&quot;#ods&quot;&gt;ODS&lt;/a&gt; to enable “close to the operation” data mining&lt;/li&gt;
  &lt;li&gt;an 3NF DWH with full history to enable the creation unanticipated &lt;a href=&quot;#dmt&quot;&gt;datamarts&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#dmt&quot;&gt;datamarts&lt;/a&gt; that rely either on 3NF or on the star schema for better performances&lt;/li&gt;
&lt;/ul&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/DWHArchitecture.png&quot; alt=&quot;A typical Hybrid Architecture&quot; /&gt;
  &lt;figcaption&gt;A typical Hybrid Architecture&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;h3 id=&quot;data-mart-dmt-&quot;&gt;Data Mart (DMT) &lt;a id=&quot;dmt&quot;&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;A datamart is essentially a basic building block of the data warehouse. 
It is subject-oriented subset of a Data Warehouse. Data mart does not explicitly imply the presence of a multi-dimensional technology such as OLAP and data mart does not explicitly imply the presence of summarized numerical data.&lt;/p&gt;

&lt;h3 id=&quot;operational-data-store-ods-&quot;&gt;Operational Data Store (ODS) &lt;a id=&quot;ods&quot;&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;An operational data store (ODS) is building block of Data warehouse used for immediate reporting with operational data.  An ODS contains lightly transformed and lightly integrated operational data with a (rather) short time window. The ODS is usually used when looking for specific events (settling a banking movement or looking for a specific operation). Full history is available in the DWH.&lt;/p&gt;

&lt;h3 id=&quot;olap-cubes-&quot;&gt;OLAP Cubes &lt;a id=&quot;cube&quot;&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;OLAP Cubes are multidimensional arrays of data comming from a relational database. It enables operations such as slicing and dicing (projection), drill down/up, roll-up. A datamart relying on a star schema provides equivalent functionalities. However, in a cube every projection/aggregation are pre-computed (this enables to discover new patterns) whether in a star schema only some projections/aggregations (the one you know are interrested) are pre-computed.&lt;/p&gt;

&lt;h1 id=&quot;conclusion&quot;&gt;Conclusion&lt;/h1&gt;
&lt;p&gt;Business Intelligence is a set of practices/methodologies that leverage raw data into decisions. Data warehouses, data marts and cubes are building blocks used to build Busines Intelligence system.&lt;/p&gt;</content><author><name></name></author><summary type="html">In my current assignment, I had the opportunity to discuss with Data Warehouse (DWH) experts about its integration with the rest of the information system. I noticed that not every stakeholders (included Data Warehouse professionals) use the same vocabulary. During the discussions, people raised words such as “Data Warehouse”, “Data Marts”, ODS, “Data Lake” and so on. Some of the words were used interchangeably which does not help to follow the discussion. As I was not familiar with several of them, I decided to do my homework and to come up with a small glossary to provide a common ground for further discussions.</summary></entry><entry><title type="html">Integration Tests with Docker And Arquillian</title><link href="http://localhost:4000/jee7,/tests,/integration/arquillian,/docker/2016/01/30/integration-tests-with-docker-and-arquillian.html" rel="alternate" type="text/html" title="Integration Tests with Docker And Arquillian" /><published>2016-01-30T23:38:50+01:00</published><updated>2016-01-30T23:38:50+01:00</updated><id>http://localhost:4000/jee7,/tests,/integration/arquillian,/docker/2016/01/30/integration-tests-with-docker-and-arquillian</id><content type="html" xml:base="http://localhost:4000/jee7,/tests,/integration/arquillian,/docker/2016/01/30/integration-tests-with-docker-and-arquillian.html">&lt;p&gt;Last month I decided to add a touch of &lt;a href=&quot;http://martinfowler.com/articles/microservices.html&quot;&gt;microservices&lt;/a&gt; to the JEE course I teach at the University of Geneva.
I ended up with a couple of microservices and as expected I came across the challenge of their integration testing.
This post is &lt;strong&gt;NOT&lt;/strong&gt; specifically about microservices. It rathers focuses on the JEE integration testing experience I encountered while building the microservices. A dedicated blog post will follow on my journey through the building of microservices with JEE.&lt;/p&gt;

&lt;h2 id=&quot;a-short-description-of-the-architecture&quot;&gt;A short description of the architecture&lt;/h2&gt;

&lt;p&gt;From a technological perspective, I am using JEE 7 on &lt;a href=&quot;http://wildfly.org/&quot;&gt;Wildfly&lt;/a&gt; with &lt;a href=&quot;http://wildfly.org/&quot;&gt;MySql&lt;/a&gt;. Therefore, my microservices are wars composed of 1-2 EJBs plus a restful service that exposes the logic. Typically, my microservices are composed of 4-5 classes of max 150 lines of codes each. On my laptop, a microservice deploys in less than 5 seconds. I mainly need to test EJBs and their database calls. I also want to test integration between microservices.&lt;/p&gt;

&lt;h3 id=&quot;why-docker&quot;&gt;Why Docker?&lt;/h3&gt;
&lt;p&gt;As it serves as a example for a course, I want it to be super easy to install/re-install 20 times if necessary. Furthermore, I want fast-paced deployment. To that end, Docker is a great tool because I do not have to bother on what laptop/computer the students work (provided they can run &lt;a href=&quot;https://www.docker.com/products/docker-toolbox&quot;&gt;Docker Toolbox&lt;/a&gt;). Moreover, all the tools/middlewares I am using for the course are already packaged as Docker images.&lt;/p&gt;

&lt;h2 id=&quot;building-a--docker-image-for-a-wildfly-integration-test-server&quot;&gt;Building a  Docker image for a Wildfly Integration Test Server&lt;/h2&gt;
&lt;p&gt;As mentioned previously, I propose to use Wildfly +  MySql as the runtime environment. However, at test time, I do not want to start both an application server and a database. More important, I want to get a fresh database for each and every test suite. Futhermore, I would like to use on a simpler setup for the application server. For instance, I do prefer to use an in memory H2 database instead of MySql. I also do not want to bother with LDAP/JAAS configuration, clustering, etc….
Of course, datasource name, realm name and more generally all the resources required by the microservices must be present with their production name.&lt;/p&gt;

&lt;p&gt;Ones of Wildfly’s great features is its ability to be configured using the command line.
The first step is to configure a data source relying on H2 that has the same name as the production one.&lt;/p&gt;

&lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;c&quot;&gt;# First step : Add the datasource&lt;/span&gt;
data-source add &lt;span class=&quot;nt&quot;&gt;--name&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;StudentsDS &lt;span class=&quot;nt&quot;&gt;--driver-name&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;h2 &lt;span class=&quot;nt&quot;&gt;--jndi-name&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$STUDENTS_DS&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--connection-url&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$H2_URI&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--user-name&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$H2_USER&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--password&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$H2_PWD&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--use-ccm&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;false&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--max-pool-size&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;25 &lt;span class=&quot;nt&quot;&gt;--blocking-timeout-wait-millis&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;5000
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;Then, let’s configure a realm.  This is helpful when integration tests rely on principals and do verify the security.
The file &lt;code class=&quot;highlighter-rouge&quot;&gt;jee7-demo-realm-users.properties&lt;/code&gt; (resp. &lt;code class=&quot;highlighter-rouge&quot;&gt;jee7-demo-realm-roles.properties&lt;/code&gt;) defines the users (resp. the roles) of the realm.&lt;/p&gt;

&lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;c&quot;&gt;# Add a property file realm&lt;/span&gt;
/subsystem&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;security/security-domain&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;jee7-demo-realm:add&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;cache-type&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;default&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;
/subsystem&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;security/security-domain&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;jee7-demo-realm/authentication&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;classic:add&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt;
/subsystem&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;security/security-domain&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;jee7-demo-realm/authentication&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;classic/login-module&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;UsersRoles       &lt;span class=&quot;se&quot;&gt;\&lt;/span&gt;
    :add&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;code&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;UsersRoles, &lt;span class=&quot;nv&quot;&gt;flag&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;required,                                                        &lt;span class=&quot;se&quot;&gt;\&lt;/span&gt;
         module-options&lt;span class=&quot;o&quot;&gt;={&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;usersProperties&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&amp;gt;&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;${&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;JBOSS_CUSTOMIZATION&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;/jee7-demo-realm-users.properties&quot;&lt;/span&gt;,   &lt;span class=&quot;se&quot;&gt;\&lt;/span&gt;
                         &lt;span class=&quot;s2&quot;&gt;&quot;rolesProperties&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&amp;gt;&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;${&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;JBOSS_CUSTOMIZATION&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;/jee7-demo-realm-roles.properties&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;})&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;Finally, let’s add an admin user in order to allows Arquilian or an IDE to interact with this application server.&lt;/p&gt;
&lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;/opt/jboss/wildfly/bin/add-user.sh admin admin
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Hereafter the complete configuration &lt;code class=&quot;highlighter-rouge&quot;&gt;config_wildfly.sh&lt;/code&gt;.&lt;/p&gt;

&lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;c&quot;&gt;#!/bin/bash&lt;/span&gt;

&lt;span class=&quot;c&quot;&gt;# Usage: execute.sh [WildFly mode] [configuration file]&lt;/span&gt;
&lt;span class=&quot;c&quot;&gt;#&lt;/span&gt;
&lt;span class=&quot;c&quot;&gt;# The default mode is 'standalone' and default configuration is based on the&lt;/span&gt;
&lt;span class=&quot;c&quot;&gt;# mode. It can be 'standalone.xml' or 'domain.xml'.&lt;/span&gt;

&lt;span class=&quot;nv&quot;&gt;JBOSS_HOME&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;/opt/jboss/wildfly
&lt;span class=&quot;nv&quot;&gt;JBOSS_CUSTOMIZATION&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$JBOSS_HOME&lt;/span&gt;/customization
&lt;span class=&quot;nv&quot;&gt;JBOSS_STANDALONE_CONFIG&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$JBOSS_HOME&lt;/span&gt;/standalone/configuration/
&lt;span class=&quot;nv&quot;&gt;JBOSS_CLI&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$JBOSS_HOME&lt;/span&gt;/bin/jboss-cli.sh
&lt;span class=&quot;nv&quot;&gt;JBOSS_MODE&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;${&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;:-&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;standalone&quot;&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;nv&quot;&gt;JBOSS_CONFIG&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;${&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;:-&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$JBOSS_MODE&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;.xml&quot;&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;k&quot;&gt;function &lt;/span&gt;wait_for_server&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
  &lt;span class=&quot;k&quot;&gt;until&lt;/span&gt; &lt;span class=&quot;sb&quot;&gt;`&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$JBOSS_CLI&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-c&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;:read-attribute(name=server-state)&quot;&lt;/span&gt; 2&amp;gt; /dev/null | &lt;span class=&quot;nb&quot;&gt;grep&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-q&lt;/span&gt; running&lt;span class=&quot;sb&quot;&gt;`&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;do
    &lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;sleep &lt;/span&gt;1
  &lt;span class=&quot;k&quot;&gt;done&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;nb&quot;&gt;echo&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;=&amp;gt; Starting WildFly server&quot;&lt;/span&gt;
&lt;span class=&quot;nv&quot;&gt;$JBOSS_HOME&lt;/span&gt;/bin/&lt;span class=&quot;nv&quot;&gt;$JBOSS_MODE&lt;/span&gt;.sh &lt;span class=&quot;nt&quot;&gt;-b&lt;/span&gt; 0.0.0.0 &lt;span class=&quot;nt&quot;&gt;-c&lt;/span&gt; &lt;span class=&quot;nv&quot;&gt;$JBOSS_CONFIG&lt;/span&gt; &amp;amp;

&lt;span class=&quot;nb&quot;&gt;echo&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;=&amp;gt; Waiting for the server to boot&quot;&lt;/span&gt;
wait_for_server

&lt;span class=&quot;nb&quot;&gt;echo&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;=&amp;gt; Executing the commands&quot;&lt;/span&gt;
&lt;span class=&quot;nb&quot;&gt;export &lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;STUDENTS_DS&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;java:/StudentsDS&quot;&lt;/span&gt;
&lt;span class=&quot;nb&quot;&gt;export &lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;H2_URI&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;jdbc:h2:mem:STUDENTS_DB;DB_CLOSE_DELAY=-1&quot;&lt;/span&gt;
&lt;span class=&quot;nb&quot;&gt;export &lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;H2_USER&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;sa&quot;&lt;/span&gt;
&lt;span class=&quot;nb&quot;&gt;export &lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;H2_PWD&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;sa&quot;&lt;/span&gt;

&lt;span class=&quot;nv&quot;&gt;$JBOSS_CLI&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-c&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class=&quot;no&quot;&gt;EOF&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt;
batch

echo &quot;Connection URL: &quot; &lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$CONNECTION_URL&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt;

# First step : Add the datasource
data-source add --name=StudentsDS --driver-name=h2 --jndi-name=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$STUDENTS_DS&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt; --connection-url=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$H2_URI&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt; --user-name=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$H2_USER&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt; --password=&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$H2_PWD&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt; --use-ccm=false --max-pool-size=25 --blocking-timeout-wait-millis=5000 

# Then configure a realm that relies on property files
/subsystem=security/security-domain=jee7-demo-realm:add(cache-type=default)
/subsystem=security/security-domain=jee7-demo-realm/authentication=classic:add()
/subsystem=security/security-domain=jee7-demo-realm/authentication=classic/login-module=UsersRoles       &lt;/span&gt;&lt;span class=&quot;se&quot;&gt;\&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt;
    :add(code=UsersRoles, flag=required,                                                        &lt;/span&gt;&lt;span class=&quot;se&quot;&gt;\&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt;
         module-options={&quot;usersProperties&quot;=&amp;gt;&quot;&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;${&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;JBOSS_CUSTOMIZATION&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt;/jee7-demo-realm-users.properties&quot;,   &lt;/span&gt;&lt;span class=&quot;se&quot;&gt;\&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt;
                         &quot;rolesProperties&quot;=&amp;gt;&quot;&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;${&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;JBOSS_CUSTOMIZATION&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;sh&quot;&gt;/jee7-demo-realm-roles.properties&quot;})

# Execute the batch
run-batch
&lt;/span&gt;&lt;span class=&quot;no&quot;&gt;EOF

&lt;/span&gt;&lt;span class=&quot;c&quot;&gt;# Finally, let's add an admin that can be used by the IDE to deploy the tests&lt;/span&gt;
/opt/jboss/wildfly/bin/add-user.sh admin admin 

&lt;span class=&quot;nb&quot;&gt;echo&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;=&amp;gt; Shutting down WildFly&quot;&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;[&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;$JBOSS_MODE&lt;/span&gt;&lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;standalone&quot;&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;]&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;then&lt;/span&gt;
  &lt;span class=&quot;nv&quot;&gt;$JBOSS_CLI&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-c&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;:shutdown&quot;&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;else&lt;/span&gt;
  &lt;span class=&quot;nv&quot;&gt;$JBOSS_CLI&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-c&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;/host=*:shutdown&quot;&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;fi&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The next step is to enhance the official Wildfly image called &lt;code class=&quot;highlighter-rouge&quot;&gt;jboss/wildfly:latest&lt;/code&gt; with the specific configurations required for integration testing. This following Dockerfile describes how to build the image that we will use for testing.
First, it adds the previous configuration files &lt;code class=&quot;highlighter-rouge&quot;&gt;./config_wildfly.sh ./jee7-demo-realm-roles.properties ./jee7-demo-realm-users.properties&lt;/code&gt; to the &lt;code class=&quot;highlighter-rouge&quot;&gt;/opt/jboss/wildfly/customization/&lt;/code&gt; of the image. Then we tell Docker to run the configuration &lt;code class=&quot;highlighter-rouge&quot;&gt;config_wildfly.sh&lt;/code&gt; and to do some cleanup. After what, it will record the states as a new image.&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;FROM jboss/wildfly:latest

ADD ./config_wildfly.sh ./jee7-demo-realm-roles.properties ./jee7-demo-realm-users.properties /opt/jboss/wildfly/customization/

RUN [&quot;/opt/jboss/wildfly/customization/config_wildfly.sh&quot;]
RUN rm -rf  /opt/jboss/wildfly/standalone/configuration/standalone_xml_history
CMD [&quot;/opt/jboss/wildfly/bin/standalone.sh&quot;, &quot;--debug&quot;, &quot;-b&quot;, &quot;0.0.0.0&quot;, &quot;-bmanagement&quot;, &quot;0.0.0.0&quot;]
EXPOSE 8787
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;Now we can build an image called &lt;code class=&quot;highlighter-rouge&quot;&gt;jee7-test-wildfly&lt;/code&gt; using the following command (in the directory where the &lt;code class=&quot;highlighter-rouge&quot;&gt;Dockerfile&lt;/code&gt; lives):&lt;/p&gt;
&lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;docker build &lt;span class=&quot;nt&quot;&gt;--no-cache&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-rm&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-t&lt;/span&gt; jee7-test-wildfly &lt;span class=&quot;nb&quot;&gt;.&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The following command runs the image we just built, exposes (and map) the port 8080, 9090 and 8787, and mount the local directory &lt;code class=&quot;highlighter-rouge&quot;&gt;/Users/XXXXXXXXXX/tmp/docker-deploy&lt;/code&gt; on the image’s &lt;code class=&quot;highlighter-rouge&quot;&gt;/opt/jboss/wildfly/standalone/deployments/&lt;/code&gt; directory. This is of course the directory in which the integration tests are to be deployed..&lt;/p&gt;

&lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;docker run &lt;span class=&quot;nt&quot;&gt;-d&lt;/span&gt;  &lt;span class=&quot;nt&quot;&gt;-p&lt;/span&gt; 8080:8080 &lt;span class=&quot;nt&quot;&gt;-p&lt;/span&gt; 9990:9990 &lt;span class=&quot;nt&quot;&gt;-p&lt;/span&gt; 8787:8787 &lt;span class=&quot;nt&quot;&gt;-v&lt;/span&gt; /Users/XXXXXXXXXX/tmp/docker-deploy:/opt/jboss/wildfly/standalone/deployments/:rw jee7-test-wildfly
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now that we do have a container running an application server with in memory database and a simple realm, we can configure the test harness.&lt;/p&gt;

&lt;h2 id=&quot;how-to-configure-arquillian&quot;&gt;How to configure Arquillian&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;http://arquillian.org/&quot;&gt;Arquillian&lt;/a&gt; is a JEE integration test framework. It allows to test JEE components such as EJBs or web services.
The first step it to tell Arquillian where the Wildfly server lives. The following &lt;code class=&quot;highlighter-rouge&quot;&gt;arquillian.xml&lt;/code&gt; file states that the integration tests should deploy on a Wildfly container that listens at &lt;code class=&quot;highlighter-rouge&quot;&gt;192.168.99.100&lt;/code&gt; (which is the Docker container address) on port &lt;code class=&quot;highlighter-rouge&quot;&gt;9990&lt;/code&gt; (which is the administration port). Furthermore, it declares the admin username and password.&lt;/p&gt;

&lt;div class=&quot;language-xml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;cp&quot;&gt;&amp;lt;?xml version=&quot;1.0&quot;?&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;arquillian&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;xmlns:xsi=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;http://www.w3.org/2001/XMLSchema-instance&quot;&lt;/span&gt;
	&lt;span class=&quot;na&quot;&gt;xmlns=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;http://jboss.org/schema/arquillian&quot;&lt;/span&gt;
	&lt;span class=&quot;na&quot;&gt;xsi:schemaLocation=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;http://jboss.org/schema/arquillian
  http://jboss.org/schema/arquillian/arquillian_1_0.xsd&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;

	&lt;span class=&quot;nt&quot;&gt;&amp;lt;container&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;qualifier=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;wildfly&quot;&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;default=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;true&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;
		&lt;span class=&quot;nt&quot;&gt;&amp;lt;configuration&amp;gt;&lt;/span&gt;
			&lt;span class=&quot;nt&quot;&gt;&amp;lt;property&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;name=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;managementAddress&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;192.168.99.100&lt;span class=&quot;nt&quot;&gt;&amp;lt;/property&amp;gt;&lt;/span&gt;
			&lt;span class=&quot;nt&quot;&gt;&amp;lt;property&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;name=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;managementPort&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;9990&lt;span class=&quot;nt&quot;&gt;&amp;lt;/property&amp;gt;&lt;/span&gt;
			&lt;span class=&quot;nt&quot;&gt;&amp;lt;property&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;name=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;username&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;admin&lt;span class=&quot;nt&quot;&gt;&amp;lt;/property&amp;gt;&lt;/span&gt;
			&lt;span class=&quot;nt&quot;&gt;&amp;lt;property&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;name=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;password&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;admin&lt;span class=&quot;nt&quot;&gt;&amp;lt;/property&amp;gt;&lt;/span&gt;
		&lt;span class=&quot;nt&quot;&gt;&amp;lt;/configuration&amp;gt;&lt;/span&gt;
		&lt;span class=&quot;nt&quot;&gt;&amp;lt;protocol&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;type=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;Servlet 3.0&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;
			&lt;span class=&quot;nt&quot;&gt;&amp;lt;property&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;name=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;host&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;192.168.99.100&lt;span class=&quot;nt&quot;&gt;&amp;lt;/property&amp;gt;&lt;/span&gt;
			&lt;span class=&quot;nt&quot;&gt;&amp;lt;property&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;name=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;port&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;8080&lt;span class=&quot;nt&quot;&gt;&amp;lt;/property&amp;gt;&lt;/span&gt;
		&lt;span class=&quot;nt&quot;&gt;&amp;lt;/protocol&amp;gt;&lt;/span&gt;
	&lt;span class=&quot;nt&quot;&gt;&amp;lt;/container&amp;gt;&lt;/span&gt;

	&lt;span class=&quot;nt&quot;&gt;&amp;lt;extension&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;qualifier=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;jacoco&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;
		&lt;span class=&quot;nt&quot;&gt;&amp;lt;property&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;name=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;includes&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;ch.demo.*&lt;span class=&quot;nt&quot;&gt;&amp;lt;/property&amp;gt;&lt;/span&gt;
	&lt;span class=&quot;nt&quot;&gt;&amp;lt;/extension&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/arquillian&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2 id=&quot;a-simple-integration-test&quot;&gt;A simple integration Test&lt;/h2&gt;

&lt;p&gt;Let us now write a simple integration test. First, we must tell Arquillian the it is in charge of running the test (&lt;code class=&quot;highlighter-rouge&quot;&gt;@RunWith(Arquillian.class)&lt;/code&gt;).&lt;/p&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;nd&quot;&gt;@RunWith&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Arquillian&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;class&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;StudentServiceImplTest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;To test a given component (let’s say an EJB), arquillian expects a well-formed Java component (either a jar or a war).
The following test is composend of a package contaning the EJB under test (&lt;code class=&quot;highlighter-rouge&quot;&gt;ch.demo&lt;/code&gt;), an empty &lt;code class=&quot;highlighter-rouge&quot;&gt;beans.xml&lt;/code&gt; to enable CDI and finally a &lt;code class=&quot;highlighter-rouge&quot;&gt;persistence.xml&lt;/code&gt; to enable JPA.&lt;/p&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;nd&quot;&gt;@Deployment&lt;/span&gt;
&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;JavaArchive&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;create&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
   &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;ShrinkWrap&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;create&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;JavaArchive&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;class&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;integration-test-demo.jar&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;addPackages&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kc&quot;&gt;true&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;ch.demo&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;
      &lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;addAsManifestResource&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;EmptyAsset&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;INSTANCE&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;beans.xml&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;
      &lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;addAsManifestResource&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;test-persistence.xml&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;persistence.xml&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;The previous JAR as well as the tests are packaged as a WAR and deployed on the application server declared in the &lt;code class=&quot;highlighter-rouge&quot;&gt;arquillian.xml&lt;/code&gt; file. The following test injects the EJB under test implementing the &lt;code class=&quot;highlighter-rouge&quot;&gt;StudentService&lt;/code&gt; interface and tests its &lt;code class=&quot;highlighter-rouge&quot;&gt;add&lt;/code&gt; method.&lt;/p&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;nd&quot;&gt;@Inject&lt;/span&gt;
&lt;span class=&quot;nc&quot;&gt;StudentService&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;nd&quot;&gt;@Test&lt;/span&gt;
&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;shouldAddReturnAllWithTheNewStudent&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
   &lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;nbStudentsBeforeTest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;getNbStudent&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;();&lt;/span&gt;
   &lt;span class=&quot;n&quot;&gt;service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;add&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Student&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;Doe&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;Jane&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Date&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(),&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;PhoneNumber&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;+33698075273&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)));&lt;/span&gt;
   &lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;nbStudentsAfterTest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;getAll&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;().&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;size&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;();&lt;/span&gt;
   &lt;span class=&quot;nc&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;assertSame&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;nbStudentsBeforeTest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;nbStudentsAfterTest&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
   &lt;span class=&quot;nc&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;assertEquals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;getAll&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;().&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;nbStudentsAfterTest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;getLastName&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(),&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;Doe&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2 id=&quot;maven-ide-integration-and-coverage&quot;&gt;Maven, IDE Integration and Coverage&lt;/h2&gt;
&lt;p&gt;Finally, let me add that it is possible to get coverage data from Arquillian by enabling extensions. In the following, it enables```jacoco``. This produces coverage data that can be used by the Eclipse ECL-EMMA plugin.&lt;/p&gt;

&lt;div class=&quot;language-xml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;nt&quot;&gt;&amp;lt;extension&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;qualifier=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;jacoco&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;
   &lt;span class=&quot;nt&quot;&gt;&amp;lt;property&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;name=&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;includes&quot;&lt;/span&gt;&lt;span class=&quot;nt&quot;&gt;&amp;gt;&lt;/span&gt;ch.demo.*&lt;span class=&quot;nt&quot;&gt;&amp;lt;/property&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/extension&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2 id=&quot;conclusion&quot;&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;Docker and Arquillian provide a nice and seamless way for JEE integration testing. Nevertheless, I had a hard time at the beginning because Arquillian error handling in case of undeployable test archive is not very good. In this case, make sure that you package your test correctly (in the method annotated &lt;code class=&quot;highlighter-rouge&quot;&gt;@Deployment&lt;/code&gt;). In particular, double check &lt;code class=&quot;highlighter-rouge&quot;&gt;beans.xml&lt;/code&gt;, &lt;code class=&quot;highlighter-rouge&quot;&gt;web.xml&lt;/code&gt; and the JAR/WAR structure. It really helped me to unzip the deployed test archive to figure out what when wrong in my code.&lt;/p&gt;</content><author><name></name></author><category term="JEE7," /><category term="Tests," /><category term="Integration" /><category term="Arquillian," /><category term="Docker" /><summary type="html">Last month I decided to add a touch of microservices to the JEE course I teach at the University of Geneva. I ended up with a couple of microservices and as expected I came across the challenge of their integration testing. This post is NOT specifically about microservices. It rathers focuses on the JEE integration testing experience I encountered while building the microservices. A dedicated blog post will follow on my journey through the building of microservices with JEE.</summary></entry><entry><title type="html">Cleaning Intermediate Docker Images</title><link href="http://localhost:4000/docker/2015/12/02/cleaning-intermediate-docker-images.html" rel="alternate" type="text/html" title="Cleaning Intermediate Docker Images" /><published>2015-12-02T01:56:34+01:00</published><updated>2015-12-02T01:56:34+01:00</updated><id>http://localhost:4000/docker/2015/12/02/cleaning-intermediate-docker-images</id><content type="html" xml:base="http://localhost:4000/docker/2015/12/02/cleaning-intermediate-docker-images.html">&lt;p&gt;I recently started to use Docker. It is a great tool that significantly increases developer’s productivity. However, I regularly encounter disk space problems when developing new images. Indeed, I sometimes end up with dangling images and containers. Hereafter, a simple script that cleans up most of them.&lt;/p&gt;

&lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;c&quot;&gt;#!/bin/bash&lt;/span&gt;
docker rmi &lt;span class=&quot;nt&quot;&gt;-f&lt;/span&gt; &lt;span class=&quot;sb&quot;&gt;`&lt;/span&gt;docker images | &lt;span class=&quot;nb&quot;&gt;grep&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;^&amp;lt;none&amp;gt;&quot;&lt;/span&gt; | &lt;span class=&quot;nb&quot;&gt;cut&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-c41-52&lt;/span&gt;&lt;span class=&quot;sb&quot;&gt;`&lt;/span&gt;
docker rmi &lt;span class=&quot;si&quot;&gt;$(&lt;/span&gt;docker images &lt;span class=&quot;nt&quot;&gt;-q&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-f&lt;/span&gt; &lt;span class=&quot;nv&quot;&gt;dangling&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;true&lt;/span&gt;&lt;span class=&quot;si&quot;&gt;)&lt;/span&gt;
docker &lt;span class=&quot;nb&quot;&gt;rm&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-v&lt;/span&gt; &lt;span class=&quot;si&quot;&gt;$(&lt;/span&gt;&lt;span class=&quot;nb&quot;&gt;echo&lt;/span&gt; &lt;span class=&quot;si&quot;&gt;$(&lt;/span&gt;docker ps &lt;span class=&quot;nt&quot;&gt;-q&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--no-trunc&lt;/span&gt;&lt;span class=&quot;si&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;si&quot;&gt;$(&lt;/span&gt;docker ps &lt;span class=&quot;nt&quot;&gt;-a&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-q&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;--no-trunc&lt;/span&gt;&lt;span class=&quot;si&quot;&gt;)&lt;/span&gt; | &lt;span class=&quot;nb&quot;&gt;sed&lt;/span&gt; &lt;span class=&quot;s1&quot;&gt;'s|\s|\n|g'&lt;/span&gt;  | &lt;span class=&quot;nb&quot;&gt;sort&lt;/span&gt; | &lt;span class=&quot;nb&quot;&gt;uniq&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-u&lt;/span&gt;&lt;span class=&quot;si&quot;&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;</content><author><name></name></author><category term="Docker" /><summary type="html">I recently started to use Docker. It is a great tool that significantly increases developer’s productivity. However, I regularly encounter disk space problems when developing new images. Indeed, I sometimes end up with dangling images and containers. Hereafter, a simple script that cleans up most of them.</summary></entry><entry><title type="html">Communication between Java Enterprise Applications</title><link href="http://localhost:4000/ears/jee/rmi/2014/12/26/communication-between-java-enterprise-applications.html" rel="alternate" type="text/html" title="Communication between Java Enterprise Applications" /><published>2014-12-26T22:51:48+01:00</published><updated>2014-12-26T22:51:48+01:00</updated><id>http://localhost:4000/ears/jee/rmi/2014/12/26/communication-between-java-enterprise-applications</id><content type="html" xml:base="http://localhost:4000/ears/jee/rmi/2014/12/26/communication-between-java-enterprise-applications.html">&lt;p&gt;Recently I came across the following problem : How to propagate information from one enterprise application to another in a transparent manner? Transparent meaning without changing the API, that is without adding transversal information to the services’ parameters. The typical use case is to propagate information such as the language, applicative security roles information (not the JAAS role), or the session-id. Moreover, I would like the information to be “request scoped” and to be automatically cleaned up at the end of the request. This is important to avoid memory leak and to enforce isolation for security reasons. Let me add that I currently work with JEE6 on WebSphere 8.5.5.&lt;/p&gt;

&lt;p&gt;I did some research among blogs and forums and I found the following solutions:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;Passing information in thread-local. This consists in putting information in a &lt;code class=&quot;highlighter-rouge&quot;&gt;Map&lt;/code&gt; stored in &lt;code class=&quot;highlighter-rouge&quot;&gt;ThreadLocal&lt;/code&gt;. Although this solution is very simple to implement, information is only transmitted inside the current thread. This means that &lt;code class=&quot;highlighter-rouge&quot;&gt;@Asynchronous&lt;/code&gt; calls will not get access to the information. Similarly, it is not transmitted through RMI calls that spread on several VMs, as it is usually the case on distributed applications.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Using the JNDI. This solution does not suffer of the above limitations as it is distributed by nature but scoping must be implemented on top of the existing JNDI implementation. I think that it may be possible to implement something like a custom CDI scope but it seems rather complex.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;TransactionSynchronizationRegistry (TSR). This alternative is well documented &lt;a href=&quot;http://www.adam-bien.com/roller/abien/entry/how_to_pass_context_in&quot;&gt;here&lt;/a&gt;. This solution works on a JEE application servers. It looks great at the first sight but it does not support any use case in which there is different transactions (or no transaction) involved. This invalidates any information sharing before a transaction as started, when a transaction has been suspended, or when a new transaction is started. Again, I can imagine that it would possible to propagate the content using interceptors but it is too much plumber code to me.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Work Area Service (WAS). This is basically the IBM implementation of solution 2 with scoping. Documentation is clear and it seems easy to implement. Of course, the main drawback is that it is vendor-specific. IBM started a &lt;a href=&quot;https://jcp.org/en/jsr/detail?id=149&quot;&gt;JSR&lt;/a&gt; long time ago but it was dropped.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Let us now enumerate several criteria to make a decision about which way to go:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;Supports of asynchronous calls : during a request it may be necessary to dispatch the processing among several threads and I would like the shared information to be accessible by any threads involved in this request.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Is (automatically) “request scoped” : if the shared information is not automatically collected at the end the request we may end up with memory leaks. Manual collection is never a good option.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Supports Remote Calls : for a given request, we may end up calling several services (EJBs) on others servers and I would like to have an automatic propagation of the information among the clusters nodes.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Performance : to be useful, the information sharing must be ubiquitous and therefore it must cheap in terms of resources.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Vendor Independence : as far as possible an application must rely on known and portable APIs such as JEE. Locking the application to a specific vendor is, in my opinions, is essentially a problem for maintenance. Migrating from one application server to another only happens rarely.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;table&gt;
&lt;tr&gt; 
&lt;th&gt;Solution&lt;/th&gt; &lt;th&gt;Async&lt;/th&gt; &lt;th&gt;Scope&lt;/th&gt; &lt;th&gt;RMI&lt;/th&gt; &lt;th&gt;Vendor Indep.&lt;/th&gt; &lt;/tr&gt;
&lt;tr&gt; &lt;td&gt;Thread-Local&lt;/td&gt; &lt;td&gt;X&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;td&gt;X&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;/tr&gt;
&lt;tr&gt; &lt;td&gt;JNDI&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;td&gt;X&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;/tr&gt;
&lt;tr&gt; &lt;td&gt;TSR&lt;/td&gt; &lt;td&gt;X&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;/tr&gt;
&lt;tr&gt; &lt;td&gt;WAS&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;td&gt;OK&lt;/td&gt; &lt;td&gt;X&lt;/td&gt; &lt;/tr&gt;
&lt;/table&gt;

&lt;p&gt;&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;As you can see there is no silver bullet here. I went for the vendor specific solution. It can be nicely encapsulated to isolate the dependency to vendor specific code. Furthermore, several servers have similar mechanism and it can be therefore adapted. Here is why it was not possible in my setup to use the other alternatives:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;The Thread-local solution is not acceptable because it does not support Remote Method Invocation on several virtual machines.&lt;/li&gt;
  &lt;li&gt;The JNDI solution requires to implement the scoping mechanism. This can be tricky and it is definitely not my area of expertise.&lt;/li&gt;
  &lt;li&gt;The TransactionSynchronizationRegistry is JEE compliant but it requires huge machinery to support asynchronous calls as well as transaction suspension and re-creation (&lt;code class=&quot;highlighter-rouge&quot;&gt;REQUIRES_NEW&lt;/code&gt;, &lt;code class=&quot;highlighter-rouge&quot;&gt;NOT_SUPPORTED&lt;/code&gt;, &lt;code class=&quot;highlighter-rouge&quot;&gt;NEVER&lt;/code&gt;). Basically, it does not work if there is not one and only one transaction throughout the request.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;bibliography&quot;&gt;Bibliography&lt;/h2&gt;
&lt;p&gt;[1] Adam Bien. HOW TO PASS CONTEXT IN STANDARD WAY - WITHOUT THREADLOCAL. http://www.adam-bien.com/roller/abien/entry/how_to_pass_context_in&lt;/p&gt;

&lt;p&gt;[2] Adam Bien. HOW TO PASS CONTEXT BETWEEN LAYERS WITH THREADLOCAL AND EJB 3.(1). http://www.adam-bien.com/roller/abien/entry/how_to_pass_context_with&lt;/p&gt;

&lt;p&gt;[3] IBM. Work area partition service. http://www-01.ibm.com/support/knowledgecenter/SSEQTJ_8.0.0/com.ibm.websphere.nd.multiplatform.doc/info/ae/workarea/concepts/cwa_partition.html&lt;/p&gt;</content><author><name></name></author><category term="EARS" /><category term="JEE" /><category term="RMI" /><summary type="html">Recently I came across the following problem : How to propagate information from one enterprise application to another in a transparent manner? Transparent meaning without changing the API, that is without adding transversal information to the services’ parameters. The typical use case is to propagate information such as the language, applicative security roles information (not the JAAS role), or the session-id. Moreover, I would like the information to be “request scoped” and to be automatically cleaned up at the end of the request. This is important to avoid memory leak and to enforce isolation for security reasons. Let me add that I currently work with JEE6 on WebSphere 8.5.5.</summary></entry><entry><title type="html">Fakes, Stubs, Dummy, Mocks, Doubles and all that…</title><link href="http://localhost:4000/2014/05/18/fakes-stubs-dummy-mocks-doubles-and-all-that.html" rel="alternate" type="text/html" title="Fakes, Stubs, Dummy, Mocks, Doubles and all that…" /><published>2014-05-18T10:58:00+02:00</published><updated>2014-05-18T10:58:00+02:00</updated><id>http://localhost:4000/2014/05/18/fakes-stubs-dummy-mocks-doubles-and-all-that</id><content type="html" xml:base="http://localhost:4000/2014/05/18/fakes-stubs-dummy-mocks-doubles-and-all-that.html">&lt;p&gt;In this post, I  look at the different kind of objects used for test purposes. By this, I mean objects that are used to make a test running. This article focuses on component testing, a.k.a. unit testing (I do not like the term unit testing because it is too often misunderstood with the technology behind, e.g., JUnit, testNG).
Although there already exists a great number of resources on that subject, it was very difficult to me to understand the differences between the different kinds of test objects. This is partly due to the fact that different authors use different terms for the same object and the same term for different objects [1]. To be as didactic as possible, I also chose to add some blocks of code. Please note, that these blocks are only here for the sake of clarity. This is not the way I would recommend to do stubbing, faking, and mocking. Consider  &lt;a href=&quot;https://code.google.com/p/mockito/&quot;&gt;Mockito&lt;/a&gt; and PowerMockito for that. These are amazing tools to that purpose. They deserve a post on their own to discuss good practices.
This post is in no way an exhaustive state of the art, I only tried to select the terms that, in my opinion, are clear and are consensual enough. To that end I used a number of sources that can be found in the bibliography section.&lt;/p&gt;

&lt;p&gt;Here are the main reasons to use different objects during the test phase and in production:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;Performances: the actual object contains slow algorithms and heavy calculation that may impair the test performances. A test should always be fast to not discourage regular run and therefore to identify problems as soon as possible. The worst case being the one in which the developer must deploy and run the entire application to test a single use case.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;States: sometimes the constellation under test happens rarely. This is for instances that occur with a low probability  such as race conditions, network failure, etc..&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Non-deterministic: this is the case of components that have interactions with the real-world such as sensors.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;The actual object does not exist: for instance, another team is working on it and is not yet ready.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;To instrument the actual dependency: for instance to spy the calls of the CUT to one of its dependencies.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;doubles-objects&quot;&gt;Doubles objects&lt;/h2&gt;
&lt;p&gt;Test double is the generic term that groups all the categories of objects that are used to fulfill one or several of the previous requirements.
The term comes has been coined by Gerard Meszaros in [2]
In rough terms, test doubles look like the actual object they double. They satisfy, to different extends the original interface and propose a sub-set of the behaviors that is expected by the specification. This helps to isolate the problem and reduce the double implementation to the strict minimum.&lt;/p&gt;

&lt;p&gt;There exists different kind of test doubles for different purposes. The have in common that they can be use instead of the actual component without breaking the contract syntactically.&lt;/p&gt;

&lt;p&gt;The next figure describes a simple test setup that do not use test doubles. To test the Component Under Test (CUT), the following test setup uses its actual dependencies (another component). This setup phase is trivial as there is nothing to do. The exercise phase calls the CUT with the proper parameters (direct inputs) that in turn calls it dependency (indirect outputs). Another Component returns its result to the CUT (indirect inputs) that uses it to complete the work and then finally returns the overall result (direct outputs). The terms “direct inputs”, “indirect outputs”, and so on come from [2].&lt;/p&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/TestSetup.png&quot; alt=&quot;Overview of a test setup&quot; /&gt;
  &lt;figcaption&gt;Overview of a test setup&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;p&gt;Now let us say that “AnotherComponent” is either too complex, not already implemented or has a non-deterministic behavior. In those cases, it is easier to use another implementation of “AnotherComponent” that behaves exactly has expected for a specific scenario.&lt;/p&gt;

&lt;p&gt;Hereafter, a simple example to illustrate the rest of the post. The class &lt;code class=&quot;highlighter-rouge&quot;&gt;CUTImpl&lt;/code&gt; that realizes the contract &lt;code class=&quot;highlighter-rouge&quot;&gt;CUT&lt;/code&gt; implements  the component under test. The CUT uses a component that realizes the interface &lt;code class=&quot;highlighter-rouge&quot;&gt;AnotherComponent&lt;/code&gt;. 
For the sake of clarity, the following example injects the dependencies through the constructor.
To improve loose coupling, it is possible to rely on dependency injection.&lt;/p&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTImpl&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;implements&lt;/span&gt; &lt;span class=&quot;no&quot;&gt;CUT&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
	
	&lt;span class=&quot;nc&quot;&gt;AnotherComponent&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;component&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

    &lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;CUTImpl&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;AnotherComponent&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;c&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;this&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;component&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;c&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

	&lt;span class=&quot;nd&quot;&gt;@Override&lt;/span&gt;
	&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;String&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;doBusiness&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;String&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;param&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;delta&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
		&lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;component&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;valueOf&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;param&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;toString&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;();&lt;/span&gt;
	&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;interface&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUT&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
	&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;String&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;doBusiness&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;String&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;delta&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;interface&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponent&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
	&lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;param&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponentImpl&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;implements&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponent&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

    &lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;param&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;param&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;kc&quot;&gt;null&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;throw&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;IllegalArgumentException&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;Param must be not null!&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;else&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;param&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;MAX_INTEGER&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;throw&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;IllegalStateException&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;Incrementing MAX_INTEGER will result in overflow!&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;else&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;param&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The following test uses real implementations of the the different components.&lt;/p&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTTest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

    &lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;testInc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;assertEquals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;inc(3) != 4&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTImpl&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponentImpl&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The question is what if:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;AnotherComponentImpl&lt;/code&gt; is not ready yet&lt;/li&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;AnotherComponentImpl&lt;/code&gt; depends itself on external services or specific hardware resources&lt;/li&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;AnotherComponentImpl&lt;/code&gt; has non-deterministic behaviors.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&quot;dummy-objects&quot;&gt;Dummy objects&lt;/h2&gt;

&lt;p&gt;Dummy objects are meant to satisfy compile-time check and runtime execution. Dummies do not take part to the test scenario.
Some method signatures of the CUT may require objects as parameters. If neither the test nor the CUT care about these objects, we may choose to pass in a Dummy Object. This can be a null reference, an empty object or a constant. Dummy objects are passed around (to dependencies for instance) but never actually used. Usually they are just used to fill parameter lists. They are meant to replace input/output parameters of the components that the CUT interacts with.&lt;/p&gt;

&lt;p&gt;In the current example, the parameter &lt;code class=&quot;highlighter-rouge&quot;&gt;delta&lt;/code&gt; of the &lt;code class=&quot;highlighter-rouge&quot;&gt;doBusiness&lt;/code&gt; method can be set to &lt;code class=&quot;highlighter-rouge&quot;&gt;null&lt;/code&gt; or any &lt;code class=&quot;highlighter-rouge&quot;&gt;Integer&lt;/code&gt; value without interfering with the test. Of course, this might be different for another test.&lt;/p&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTTest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

    &lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;testInc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;assertEquals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;inc(3) != 4&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTImpl&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponentImpl&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kc&quot;&gt;null&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2 id=&quot;stub-objects&quot;&gt;Stub objects&lt;/h2&gt;

&lt;p&gt;Stub objects provide simple answers to the CUT invocations. It does answer to scenarii that are not foreseen by the current test. In other terms it is a simplified fake object. Stub objects may trigger paths in the CUT that would otherwise not been executed.&lt;/p&gt;

&lt;p&gt;The next figure presents a test that relies on a test stub. First, the test case setups a stub object. This object responds to the expected CUT invokation in order to enact a given scenario. This is very useful to check indirect inputs with seldom values.&lt;/p&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/TestSTUB.png&quot; alt=&quot;Test setup that uses a test stub&quot; /&gt;
  &lt;figcaption&gt;Test setup that uses a test stub&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;p&gt;Back to the example, the following program illustrates how to use a stub to check specific indirect inputs.
This stub shows that the CUT relies on the fact that &lt;code class=&quot;highlighter-rouge&quot;&gt;AnotherComponent&lt;/code&gt; does not return &lt;code class=&quot;highlighter-rouge&quot;&gt;null&lt;/code&gt;, as it
would otherwise raise a &lt;code class=&quot;highlighter-rouge&quot;&gt;NullPointerException&lt;/code&gt;.&lt;/p&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponentStub&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;implements&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponent&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

    &lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;param&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;kc&quot;&gt;null&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTTest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

    &lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;testIncWhenAnotherComponentReturnsNull&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;c1&quot;&gt;//Without any modification of the CUT implement, this would raise an exception&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;assertEquals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;inc(3) != 4&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTImpl&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponentStub&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2 id=&quot;fake-objects&quot;&gt;Fake objects&lt;/h2&gt;
&lt;p&gt;Fake objects have working implementations, but  they may simplify some behaviors. This makes them not suitable for prime time. The idea is that the object actually displays some real behavior but not everything. While a Fake Object is typically built specifically for testing, it is not used as either a control point or an observation point by the test. The most common reasons for using fake objects is that the real component is not available yet, is too slow or cannot be used during tests because of side effects.&lt;/p&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/TestFAKE.png&quot; alt=&quot;Test setup that uses a fake&quot; /&gt;
  &lt;figcaption&gt;Test setup that uses a fake&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;p&gt;The following fake simulates most of the behaviors except for the limits (MAX_INTEGER, null, etc…)&lt;/p&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponentFake&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;implements&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponent&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

    &lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;param&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;param&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;As the fake covers many scenarios, it can be used to test the general behavior of the CUT.&lt;/p&gt;
&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTTest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

    &lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;testIncWhenAnotherComponentIsFake&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;no&quot;&gt;CUT&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;cut&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTImpl&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;AnotherComponentFake&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;());&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;assertEquals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;inc(3) != 4&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;cut&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;assertEquals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;inc(123) != 124&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;124&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;cut&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;123&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h1 id=&quot;mock-objects&quot;&gt;Mock objects&lt;/h1&gt;
&lt;p&gt;Partially implements the interface and provides a way to verify that the calls to the mock objects validate the specification.
Mock objects are pre-programmed with expectations that form a specification of the calls they are expected to receive.
In fact mocks are a certain kind of stub or fake. However, the additional feature mock objects offer on top of acting as simple stubs or fakes is that they provide a flexible way to specify more directly how your function under test should actually operate. In this sense they also act as a kind of recording device: They keep track of which of the mock object’s methods are called, with what kind of parameters, and how many times.&lt;/p&gt;

&lt;p&gt;Whenever the assertions are made on the fake object and not the CUT, then it is a mock.&lt;/p&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/TestMOCK.png&quot; alt=&quot;Test setup that uses a mock&quot; /&gt;
  &lt;figcaption&gt;Test setup that uses a mock&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;

&lt;p&gt;The following example uses &lt;a href=&quot;https://code.google.com/p/mockito/&quot;&gt;Mockito&lt;/a&gt; to provide easy Mocking. Note that the last assertion &lt;code class=&quot;highlighter-rouge&quot;&gt;Mockito.verify&lt;/code&gt; checks whether the mock was called with a given parameters. In other words, we check that the CUT did not filter the input parameter.&lt;/p&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kn&quot;&gt;package&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;ch.demo.business.service&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTTest&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

	&lt;span class=&quot;nd&quot;&gt;@Mock&lt;/span&gt;
	&lt;span class=&quot;nc&quot;&gt;AnotherComponent&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ac&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
	
	&lt;span class=&quot;nd&quot;&gt;@InjectMocks&lt;/span&gt;
	&lt;span class=&quot;no&quot;&gt;CUT&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;cut&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;CUTImpl&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;();&lt;/span&gt;

    &lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;testIncWhenAnotherComponentReturnsNull&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
		&lt;span class=&quot;nc&quot;&gt;Mockito&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;when&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ac&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;MAX_INTEGER&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;thenReturn&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;MAX_INTEGER&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
		&lt;span class=&quot;nc&quot;&gt;Mockito&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;when&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ac&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;thenReturn&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
		&lt;span class=&quot;nc&quot;&gt;Mockito&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;when&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ac&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;123&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;thenReturn&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;124&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
		
        &lt;span class=&quot;nc&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;assertEquals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;inc(Integer.MIN_INTEGER) != Integer.MIN_INTEGER + 1&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; 
                &lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;MIN_INTEGER&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;cut&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;MIN_INTEGER&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;assertEquals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;inc(3) != 4&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;4&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;cut&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;assertEquals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;inc(123) != 124&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;124&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;cut&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;123&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
        
        &lt;span class=&quot;c1&quot;&gt;//Verifies that the method inc of AnotherComponent was called with parameter Integer.MAX_INTEGER&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;Mockito&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;verify&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ac&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Matchers&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;eq&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;MAX_INTEGER&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
        &lt;span class=&quot;c1&quot;&gt;//Verifies that the inc method has been called three times.&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;Mockito&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;verify&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ac&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Mockito&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;times&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;inc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;anyInt&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;());&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2 id=&quot;test-spy&quot;&gt;Test Spy&lt;/h2&gt;
&lt;p&gt;According to Meszaros [2], a test spy is basically a recorder that is able to save the interactions between the CUT and the spy for later verifications.&lt;/p&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/TestSPY.png&quot; alt=&quot;Test setup that uses a test spy&quot; /&gt;
  &lt;figcaption&gt;Test setup that uses a test spy&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;
&lt;p&gt;On the other hand, &lt;a href=&quot;https://code.google.com/p/mockito/&quot;&gt;Mockito&lt;/a&gt; considers that a spy is an real implementation in which you change only some specific behaviors. Instead of specifying every behavior one by one, you take an existing object that does most of it and you only change very specific behaviors.&lt;/p&gt;

&lt;h2 id=&quot;conclusion&quot;&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;To sum up:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;A dummy is just there to enable compilation and is not supposed to be part of the test.&lt;/li&gt;
  &lt;li&gt;A fake is a partial implementation that can be used either in a component test or in a deployed setting.&lt;/li&gt;
  &lt;li&gt;A mock is a partial implementation that enables asserting on the component interactions.&lt;/li&gt;
  &lt;li&gt;A spy is either a recorder for later use or a proxy on a real implementation that is used to override some specific behaviors.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;bibliography&quot;&gt;Bibliography&lt;/h2&gt;

&lt;ul&gt;
  &lt;li&gt;[1] Martin Fowler &lt;a href=&quot;http://martinfowler.com/articles/mocksArentStubs.html&quot;&gt;Mock aren’t stubs&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;[2] Meszaros, Gerard (2007). xUnit Test Patterns: Refactoring Test Code. Addison-Wesley. ISBN 978-0-13-149505-0.&lt;/li&gt;
  &lt;li&gt;[3] &lt;a href=&quot;https://storage.googleapis.com/gtb/TotT-2008-06-12.pdf&quot;&gt;Friends you can depend on&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;[4] &lt;a href=&quot;http://en.wikipedia.org/wiki/Mock_object&quot;&gt;Wikipedia Mock Object&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;[5] &lt;a href=&quot;http://en.wikipedia.org/wiki/Test_double&quot;&gt;Wikipedia Test Doubles&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;[6] &lt;a href=&quot;http://en.wikipedia.org/wiki/Fake_object&quot;&gt;Wikipedia Fakes&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;[7] &lt;a href=&quot;http://en.wikipedia.org/wiki/Test_stubs&quot;&gt;Wikipedia Stubs&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;</content><author><name></name></author><summary type="html">In this post, I look at the different kind of objects used for test purposes. By this, I mean objects that are used to make a test running. This article focuses on component testing, a.k.a. unit testing (I do not like the term unit testing because it is too often misunderstood with the technology behind, e.g., JUnit, testNG). Although there already exists a great number of resources on that subject, it was very difficult to me to understand the differences between the different kinds of test objects. This is partly due to the fact that different authors use different terms for the same object and the same term for different objects [1]. To be as didactic as possible, I also chose to add some blocks of code. Please note, that these blocks are only here for the sake of clarity. This is not the way I would recommend to do stubbing, faking, and mocking. Consider Mockito and PowerMockito for that. These are amazing tools to that purpose. They deserve a post on their own to discuss good practices. This post is in no way an exhaustive state of the art, I only tried to select the terms that, in my opinion, are clear and are consensual enough. To that end I used a number of sources that can be found in the bibliography section. Here are the main reasons to use different objects during the test phase and in production:</summary></entry><entry><title type="html">Testing levels</title><link href="http://localhost:4000/unit%20tests/acceptance%20tests/tests%20levels/integration%20tests/verification/validation/2014/04/18/testing-levels.html" rel="alternate" type="text/html" title="Testing levels" /><published>2014-04-18T10:52:00+02:00</published><updated>2014-04-18T10:52:00+02:00</updated><id>http://localhost:4000/unit%20tests/acceptance%20tests/tests%20levels/integration%20tests/verification/validation/2014/04/18/testing-levels</id><content type="html" xml:base="http://localhost:4000/unit%20tests/acceptance%20tests/tests%20levels/integration%20tests/verification/validation/2014/04/18/testing-levels.html">&lt;h2 id=&quot;introduction&quot;&gt;Introduction&lt;/h2&gt;

&lt;p&gt;In this post, I would like to discuss number of definitions around the testing activity. Having these definitions in mind helps to organize this crucial activity. In a previous post, I discussed the difference between &lt;a href=&quot;&quot;&gt;verification and validation&lt;/a&gt;. If the difference is not clear to you, please have a look at it prior reading this post.&lt;/p&gt;

&lt;p&gt;Let me start with the definition of what is testing. Software testing helps to measure the quality of a software in terms of defects. It is crucial to understand that 
“testing shows the presence, not the absence of bugs” [1].&lt;/p&gt;

&lt;p&gt;This comes from the fact that exhaustive testing is not possible  due to a phenomena called the state space explosion [2]. The idea is that doing exhaustive testing would require a structure in memory that remembers all the tested states of the system. A state of the system being the concatenation of its variables. For instance, let us take a program that has two variables:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;an integer (4 bytes = 32 bits)&lt;/li&gt;
  &lt;li&gt;an array of ASCII characters of length 10 (10 bytes =  80 bits)
The number of states to explore is  2^112 ~ 5x10^33 states (remember that the number of atoms in the observable universe is 10^80) and the required amount of memory would be 7.2x10^22 Terabytes. Although many optimizations can be brought to a brute force approach [1,2], the problem remains huge. Therefore, exhaustive testing is not an option.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Another important point about defects is to understand from where they originate.
A (software) defect originates in a human &lt;strong&gt;mistake&lt;/strong&gt; (e.g., a misunderstanding) that produces a &lt;strong&gt;fault&lt;/strong&gt; (i.e., a defect, a bug). Under certain circumstances, the faulty code will end up doing something unexpected with respect to the user requirements. This is called a &lt;strong&gt;failure&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;To sum up, there is the following causality chain : Mistake –&amp;gt; Fault –&amp;gt; Failure.&lt;/p&gt;

&lt;p&gt;This demonstrates that testing is not only a matter of detecting the failure but that it can be done earlier. Of course the earlier the defect is detected the cheaper is it to address it. For instance, informing the developer about the business may avoid a mistake. Using automated code checker may detect some faults.&lt;/p&gt;

&lt;h2 id=&quot;testing-dimensions&quot;&gt;Testing dimensions&lt;/h2&gt;
&lt;p&gt;Testing can be characterized in terms of dimensions. These dimensions help to categorized the test types.&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;
    &lt;p&gt;What : This dimension describes what are the objectives of the tests. Test objectives vary from one approach to another.
Usually the objectives are the verification or  the validation of functionnal (e.g., portfolio performance) and non-functionnal (e.g., performance, security) requirements.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;How : This defines how the test objective is achieved. For instance, tests can be either static or dynamic, in isolation or in integration, or knowing the implementation.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;When : Test can be executed at different moment of the development process. For instance, component testing can be done very early in the development process, while user acceptance test can only be performed when the software is ready for prime time.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Who : Different kind of tests are run by different people (e.g., developer, testers , end-users, …) For instance, component testing can be done by programmers, while user acceptance test are performed by end-users.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;h3 id=&quot;testing-level&quot;&gt;Testing level&lt;/h3&gt;
&lt;p&gt;Testing levels have been addressed in a number of publications, blog posts and talks [3], [4], [5]. Testing levels describe test types by their quantity and when they occur in the software lifecycle. At the base, tests are done early in the development and extensively. The higher the level, the later the test occurs in the lifecycle. Moreover, while lower levels are usually done the the software supplier, higher levels tend to be performed by the customer.&lt;/p&gt;

&lt;figure class=&quot;image&quot;&gt;&lt;pre&gt;
  &lt;img src=&quot;/figures/TESTING_LEVELS.png&quot; alt=&quot;Testing Levels&quot; /&gt;
  &lt;figcaption&gt;Testing Levels&lt;/figcaption&gt;
&lt;/pre&gt;
&lt;/figure&gt;
&lt;p&gt;&lt;br /&gt;&lt;/p&gt;

&lt;h4 id=&quot;static-testing&quot;&gt;Static testing&lt;/h4&gt;
&lt;p&gt;This sort of testing do not require to execute the code. Tools crawl the code and look for patterns that can lead to fault. Example of tools are &lt;a href=&quot;http://findbugs.sourceforge.net/&quot;&gt;Findbugs&lt;/a&gt;, &lt;a href=&quot;http://sourceforge.net/p/pmd/bugs/&quot;&gt;PMD&lt;/a&gt;. This kind of testing is especially useful to detect complex mistakes involving thread-safety or typing.&lt;/p&gt;

&lt;h4 id=&quot;unit-testing&quot;&gt;Unit testing&lt;/h4&gt;
&lt;p&gt;Test objects are isolated components (classes, packages, programs, …)  To promote isolation, test objects such as stubs, fakes or mocks can be used. for more information see &lt;a href=&quot;&quot;&gt;Fakes, Stubs, Dummies, Mocks and all that&lt;/a&gt;. These tests happen during development and discovered bugs are fixed right away. Therefore, the management overhead is minimal. Both verification of functional and non.functional requirements can be addressed.&lt;/p&gt;

&lt;h4 id=&quot;integration-testing&quot;&gt;Integration testing&lt;/h4&gt;
&lt;p&gt;Integration testing (a.k.a. assembly testing) verifies the integration between several components. At this level, some components can still be faked to ease deployment and isolation.
Both verification of functional and non.functional requirements can be addressed.&lt;/p&gt;

&lt;h4 id=&quot;api-testing&quot;&gt;API testing&lt;/h4&gt;
&lt;p&gt;This is the first test level that addresses validation instead of verification. It tests the software using its contracts (API). This is pure blackbox testing usually by using webservices. Tools such as SoapUI are very good at testing the software API and semantics.&lt;/p&gt;

&lt;h4 id=&quot;gui-testing&quot;&gt;GUI testing&lt;/h4&gt;
&lt;p&gt;This level acts on the graphical user interface. Example of tools are &lt;a href=&quot;http://www.seleniumhq.org/&quot;&gt;Selenium&lt;/a&gt;&lt;/p&gt;

&lt;h4 id=&quot;system-testing&quot;&gt;System testing&lt;/h4&gt;
&lt;p&gt;This test level aims the system as a whole with every internal and external components.
Both verification of functional and non.functional requirements can be addressed.&lt;/p&gt;

&lt;h4 id=&quot;acceptance-testing&quot;&gt;Acceptance testing&lt;/h4&gt;
&lt;p&gt;Both verification of functional and non.functional requirements can be addressed.&lt;/p&gt;

&lt;h3 id=&quot;bibliography&quot;&gt;Bibliography&lt;/h3&gt;
&lt;p&gt;[1 ]Dijkstra (1969) J.N. Buxton and B. Randell, eds, Software Engineering Techniques, April 1970, p. 16. Report on a conference sponsored by the NATO Science Committee, Rome, Italy, 27–31 October 1969. Possibly the earliest documented use of the famous quote.&lt;/p&gt;

&lt;p&gt;[2] Antti Valmari. The state explosion problem. In Wolfgang Reisig and Grzegorz Rozenberg, editors, Lectures on Petri Nets I: Basic
Models, volume 1491 of Lecture Notes in Computer Science, pages 429D528. Springer, 1998.&lt;/p&gt;

&lt;p&gt;[3] Martin Fowler. TestPyramid. http://martinfowler.com/bliki/TestPyramid.html&lt;/p&gt;

&lt;p&gt;[4] Alister Scott. Yet another software testing pyramid. http://watirmelon.com/2011/06/10/yet-another-software-testing-pyramid/
[5] Alister Scott. Introducing the software testing ice-cream cone (anti-pattern). http://watirmelon.com/2012/01/31/introducing-the-software-testing-ice-cream-cone/&lt;/p&gt;</content><author><name></name></author><category term="Unit tests" /><category term="Acceptance Tests" /><category term="Tests Levels" /><category term="Integration Tests" /><category term="Verification" /><category term="Validation" /><summary type="html">Introduction</summary></entry></feed>