Jorgonor

Power up your integration tests with Mock Server

Wed, 02 Apr 2025 06:09:00 +0000

What is Mock Server?

Mock Server is a considerably useful tool when testing integrations against HTTP services. It is especially useful for integration tests. With Mock Server, it is possible to launch an HTTP server within our test suite and define how it should behave when receiving specific requests from a client application.

Additionally, Mock Server is able to verify that the client is making the expected requests when a particular execution flow is being executed.

In what scenarios is Mock Server useful?

API First Development: If you are using the API First development methodology, Mock Server can be helpful to quickly have a backend application to integrate without needing any real application developed.
Isolation: Integration tests will be completely isolated from a pre-production or integration environment. This brings two additional benefits: it adds reproducibility to our tests and simplifies their setup by removing external dependencies.
Execution Speed: Tests will run faster as they do not depend on the network or external services.

Deploying Mock Server as a Docker container

Mock Server can be deployed as a Java application in a Docker container. This can be achieved with the following docker-compose:

services:
  mockServer:
    image: mockserver/mockserver:5.14.0
    ports:
      - 12345:1080
    environment:
      MOCKSERVER_WATCH_INITIALIZATION_JSON: "true"
      MOCKSERVER_PROPERTY_FILE: /config/mockserver.properties
      MOCKSERVER_INITIALIZATION_JSON_PATH: /config/initializerJson.json
    volumes:
      - type: bind
        source: .
        target: /config

Running this docker-compose with the command docker-compose up will create a Docker container accessible at the URL http://localhost:12345.

To define the expected behavior of the external HTTP server, there are two preferred options: either use the Mock Server REST API or a JSON initialization file.

If you are integrating a service and you know the expected responses for specific inputs or want to test specific scenarios, you can define various request matchers, such as:

Using the HTTP request path.
Using a matcher with the HTTP request body expecting a JSON.
Using a matcher with the HTTP request body matching a regular expression.
Using a matcher for the HTTP request headers.

If you want to get into the details, check out this GitHub repository, which contains an example of Mock Server deployed with Docker. You can download the repository and deploy it with docker-compose up. Once the Docker container is ready, access http://localhost:12345/mockserver/dashboard to view the created expectations and the state of Mock Server.

MockServer Dashboard

Integration Tests in Java with Mock Server

Installation and Configuration

To start using Mock Server in your Java project, you will need to add the necessary dependencies to your build file.
If you are using Gradle, add the following lines to your build.gradle file:

testImplementation 'org.mock-server:mockserver-netty:5.11.2'
testImplementation 'org.mock-server:mockserver-client-java:5.11.2'

Basic Example

Let’s look at an example use case: a middleware library to a REST API for managing book reservations. The library will have a method to retrieve available books and another method to reserve a book.
Using Mock Server, we can mock an HTTP server directly from our tests. To initialize it, simply invoke the ClientAndServer.startClientAndServer(<port>) method before each test.

class LibraryClientTestImpl {

  private static final int DEFAULT_PORT = 8181;

  private final LibraryClient libraryClient = new LibraryClientImpl(
    new LibraryClientConfig()
      .setBaseUrl("http://localhost:" + DEFAULT_PORT)
      .setTimeout(1000)
  );

  private ClientAndServer clientAndServer;

  @BeforeEach
  void setUp() {
    // Start a Mock Server
    clientAndServer = ClientAndServer.startClientAndServer(DEFAULT_PORT);
  }

  @AfterEach
  void tearDown() {
    // Stop the Mock Server
    clientAndServer.stop();
  }

  @Test
  void testGetBooks() {

    final String responseBody = "[{"
      + " \"isbn\": \"9781593279509\", "
      + " \"title\":\"Eloquent Javascript\", "
      + " \"author\":\"Marijin Haverbeke\""
      + "}, {"
      + " \"isbn\": \"9781801072977\", "
      + " \"title\":\"Microservices with Spring Boot and Spring Cloud\", "
      + " \"author\":\"Magnus Larsson\" "
      + "}, {"
      + " \"isbn\": \"9780596004651\", "
      + " \"title\":\"Head First Java\", "
      + " \"author\":\"Kathy Sierra\""
      + "}]";

    // Define an expectation for when a client makes a GET request to the /v1/books endpoint
    clientAndServer.when(HttpRequest.request()
      .withMethod("GET")
      .withPath("/v1/books"))
      .respond(
        HttpResponse.response()
          .withStatusCode(200)
          .withHeader("Content-Type", "application/json")
          .withBody(responseBody)
      );

    // Trigger the request through the library client to test it
    List<Book> books = libraryClient.getBooks();
    Book book;

    Assertions.assertEquals(3, books.size());

    // Verify the first book

    book = books.get(0);

    Assertions.assertEquals("9781593279509", book.getIsbn());
    Assertions.assertEquals("Eloquent Javascript", book.getTitle());
    Assertions.assertEquals("Marijin Haverbeke", book.getAuthor());

    // Verify the remaining books...

    // Verify that Mock Server received the GET /v1/books request exactly once.

    RequestDefinition[] requests =
      clientAndServer.retrieveRecordedRequests(HttpRequest.request()
        .withMethod("GET")
        .withPath("/v1/books"));
    
    Assertions.assertEquals(1, requests.length);
  }

  // ...

In the test, you can see how an expectation is defined programmatically, similar to how we would create a stub in a unit test. Once the expectation is configured, the request is executed to retrieve the available books from the API, and the received data is verified against the expected results defined in the stub.

As an extra step, we also validate that the request was made to Mock Server and that the request was executed only once.

Get started with Mock Server

Mock Server is a very useful tool for validating scenarios that may occur when integrating with a third-party API. It is a tool worth considering when an application needs to ensure proper integration with a third-party API, adding quality and coverage to ensure that the contract is fulfilled in every build of the application.

Test containers with Spring Boot. Persistence layer integration testing

Sun, 28 Jul 2024 10:30:00 +0000

Nowadays, there is no doubt that the quality of software and its flexibility are directly linked to the ability to verify if it still works after a change, a refactor or a new functionality. Time and effort are dedicated developing automated tests for our applications in order to keep adapting to changes while making sure our software keeps doing what it was doing before.

A technology that can help us considerably when verifying that our software works as expected is Test containers. Test containers is an open-source framework that allows us to deploy infrastructure dependencies of our application when running tests, so that we can test the application against real infrastructure dependencies.

We can deploy relational databases, non-relational databases, messaging brokers as well as any software deployable within a Docker container. We just need our tests to be able to communicate with a Docker daemon and deploy the test containers that we have configured in our test code.

¿What problems do Test containers solve?

By allowing us to automatically deploy infrastructure dependencies of our application, test containers makes it easier for us to write integration tests that make sure that the components of our application work correctly on the specific infrastructure. Without test containers, we would have to manage the instance of this infrastructure dependency externally. Using a shared external instance introduces problems and limitations when initializing schemes, fixture data, concurrent test executions by some developers, manual infrastructure deploy and so on.

With test containers, our tests always start with a new instance dedicated only for that test execution and we do not have to worry about all these situations.

Test containers in Spring Boot

Let’s put our hands on Test containers! In this article the purpose is going to be to test the persistence layer of a microservice. The microservice is a simple locations REST API, already used in other website articles such as Java 21 service with virtual threads performance test. The source code is available in the Github repository Spring Boot Location API. In order to start the service it is necessary to have Docker installed and a Java 21 JDK or higher.

The idea of this exercise is to prove that the application is able to use PostgreSQL and MongoDB as its persistence engine. Let’s start with PostgreSQL.

Adding the PostgreSQL infrastructure tests

ext {
    springBootVersion = '3.2.8'
    springDependencyManagementVersion = '1.1.4'
}

plugins {
    id 'java'
    id 'org.springframework.boot' version "${springBootVersion}"
    id 'io.spring.dependency-management' version "${springDependencyManagementVersion}"
}

dependencies {
    // Other dependencies...


    testImplementation 'org.springframework.boot:spring-boot-testcontainers'
    testImplementation 'org.testcontainers:postgresql'

}

Adding all these dependencies to our build.gradle file we are adding the module to use test containers in Spring Boot and also the test container module to be able to support PostgreSQL test containers. The next step is going to be configuring the docker image we need to use in our test container. In order to use it in our Spring Boot tests it is going to be necessary to initialize it as a Spring bean.

@TestConfiguration(proxyBeanMethods = false)
public class LocationApiTestContainersConfiguration {

    @Bean
    @ServiceConnection
    PostgreSQLContainer<?> postgresqlContainer() {

        return new PostgreSQLContainer<>(DockerImageName.parse("postgres:16-alpine"))
            .withUrlParam("binaryTransfer", "true")
            .withUrlParam("rewriteBatchedInserts", "true");
    }
// ...


}

With the @ServiceConnection annotation, Spring is going to configure the connection details against the deployed docker container. Now that our tests are able to start a PostgreSQL instance, it is already possible to write the infrastructure integration tests.

public abstract class PersistenceIntegrationTest {

    @Autowired
    LocationRepository locationRepository;

    @Test
    void testLocationDoesNotExist() {
        LocationId locationId = new LocationId(1);

        Assertions.assertThatThrownBy(() -> locationRepository.get(locationId))
                .isInstanceOf(EntityNotFoundException.class);
    }

    // ...

}

The design pattern Template method test pattern has been chosen in order to be able to reuse our tests for each of the supported persistence engines. The abstract class PersistenceIntegrationTest is going to be used as a test template some test classes implementations may extend.

@Import(LocationApiTestContainersConfiguration.class)
@ActiveProfiles("postgres")
@SpringBootTest(classes = {TestLocationApiApplication.class})
@Rollback
public class PostgresIntegrationTest extends PersistenceIntegrationTest {
}

The PostgresIntegrationTest inherits the PersistenceIntegrationTest test methods and enables the postgres Spring profile. This profile is going to be the one used in the application to activate the PostgreSQL persistence and it will also initialize the LocationRepository implementation responsible for persisting our domain objects into the PostgreSQL RDBMS.

Adding the MongoDB infrastructure tests

The first step is to add the required modules for the mongo test container.

dependencies {

    // Other dependencies...


    testImplementation 'org.testcontainers:mongodb'
}

And the required bean to start the mongo test container.

@TestConfiguration(proxyBeanMethods = false)
public class LocationApiTestContainersConfiguration {
    // ...


    @Profile("mongo")
    @Bean
    @ServiceConnection
    MongoDBContainer mongoContainer() {
        return new MongoDBContainer("mongo:6.0.16");
    }
}

As the last step, another inheritor class of the PersistenceIntegrationTest is created in order to execute the MongoDB infrastructure integration tests.

@Import(LocationApiTestContainersConfiguration.class)
@ActiveProfiles("mongo")
@SpringBootTest(classes = {TestLocationApiApplication.class})
public class MongoIntegrationTest extends PersistenceIntegrationTest {
}

At this point a project framework has been created in order to use a CI environment that guarantees in each build that our application still works against both database engines and also the exact docker image version of the database that we are using in our production environments.

Test containers and Github Actions

Closing the article, I wanted to remark the use of Github Actions as a simple and available CI engine. In the example repository it can be checked that Github Actions builds the artifact with Gradle, executing the tests with test containers as a build requirement.

Java 21 service with virtual threads performance test

Wed, 15 May 2024 15:00:00 +0000

I’m back to share the results of a comparison I was curious about: comparing the scalability of a simple microservice developed with Spring Boot. The idea behind this exercise is to test how Virtual Threads (one of the most famous Java 21 new features) impact on service availability.

The service will be responsible for providing a simple REST API to store, read, modify, and delete locations in a PostgreSQL database. The code is available in the GitHub repository spring-boot-location-api.

In order to develop this microservice I’ve used the traditional technological stack of Spring Boot, with the Spring Web and Spring Data JDBC starters. To the most curious, in the repository branch webflux-r2dbc I’ve also added an equivalent reactive implementation using Spring Webflux and Spring Data R2DBC.

How to execute the load tests

To measure the availability with and without virtual threads, I will use the command-line program siege, which provides a straightforward interface for executing load tests. Let’s take a look at an example:

siege -b -c 1200 -t 60s http://127.0.0.1:8080/location/1

This command will launch 1,200 concurrent HTTP requests (using the -c option) against the specified endpoint for 60 seconds (using the -t option). With this command, the availability of the endpoint that responds to GET requests can be measured with the different microservice configurations.

Virtual threads and blocking services

Let’s check the benefits of using Virtual Threads in a traditional blocking application. Traditional blocking applications typically use a thread to handle each incoming request. By default, the JVM uses an operating system thread to handle these HTTP requests. By enabling Virtual Threads, the Java machine will scale better in scenarios where multiple threads are blocked by I/O operations, as Virtual Threads are specifically optimized for such workloads and do not require the same resources as an OS thread.

In Spring Boot applications, we can activate Virtual Threads simply by adding the property:

spring.threads.virtual.enabled=true

Comparing the HTTP GET method

Let’s see what the results of our location API are with and without Virtual Threads by sending a request that will execute a query against the database.

Test with Virtual Threads disabled

{
    "transactions":                        53754,
    "availability":                        98.75,
    "data_transferred":                     8.61,
    "response_time":                        1.10,
    "transaction_rate":                   901.61,
    "throughput":                           0.14,
    "concurrency":                        989.58,
    "successful_transactions":             53764,
    "failed_transactions":                   681,
    "longest_transaction":                 31.17,
    "shortest_transaction":                 0.00
}

Test with Virtual Threads enabled

{
    "transactions":                        60490,
    "availability":                        99.24,
    "data_transferred":                     9.69,
    "response_time":                        0.99,
    "transaction_rate":                  1011.20,
    "concurrency":                        998.96,
    "successful_transactions":             60509,
    "failed_transactions":                   465,
    "longest_transaction":                 12.33,
    "shortest_transaction":                 0.00 
}

The availability provided by the solution with virtual threads is superior. Additionally, it is capable of handling 13% more requests within the same time interval without any changes to our code, resulting in significantly improved scalability.

Comparing the HTTP POST method

Now let’s examine the performance of the location persistence endpoint. This test has consistently been conducted with an empty table to ensure equal conditions between executions with and without virtual threads.

Test with Virtual Threads disnabled

{   
    "transactions":                        45858,
    "availability":                        98.29,
    "data_transferred":                     5.51,
    "response_time":                        1.28,
    "transaction_rate":                   772.28,
    "concurrency":                        988.10,
    "successful_transactions":             45885,
    "failed_transactions":                   800,
    "longest_transaction":                 11.32,
    "shortest_transaction":                 0.00
}

Test with Virtual Threads enabled

{
    "transactions":                        53267,
    "availability":                        99.28,
    "data_transferred":                     6.40,
    "response_time":                        1.11,
    "transaction_rate":                   894.79,
    "concurrency":                        996.25,
    "successful_transactions":             53277,
    "failed_transactions":                   385,
    "longest_transaction":                 35.83,
    "shortest_transaction":                 0.00
}

In this case the service availability provided by the virtual threads solution is also better, being able to respond to 16% more requests.

Summing up

Definitely, virtual threads offer performance advantages for our blocking Java services. If your projects are already using Java 21 or migrating those that receive heavier loads to this version do not require a significant effort, it could be a good idea to consider starting to use virtual threads in your Java services as soon as possible.

How to log SQL queries using Entity Framework 6 like in EF Core

Mon, 29 May 2017 20:00:00 +0000

Watching the SQL queries Entity Framework executes is quite useful when a slow query needs optimization. If you’re already using ASP.NET Core, you might have already noticed that the debugging stream already outputs these SQL queries for you. But, if you’re working with ASP.NET MVC or ASP.NET Web API projects, by default you won’t see the SQL queries executed by EF.

Even though, there’s a very simple trick to be able to see the actual SQL. Simply add the following code in your DbContext constructor.

Once this piece of code has been added, you will be able to see the SQL queries your code executes in the Output tab. Have a look at the screenshot below.

With the output generated by the Debugger.Log method it’s possible to find out slow queries. A good idea would be even to generate a neat report from these messages. However, for quick and dirty debugging, this trick works.

Why properties are evil in C#

Sat, 04 Feb 2017 16:30:00 +0000

As many of you might already know, properties are a neat way to define getters and setters. Many languages, such as C#, Delphi, Javascript or PHP support them and they are first-class citizens in the .NET ecosystem. Although properties are a handy resource, some property implementations can turn out to be evil. Very evil. Let’s dive into them.

Side-effects in property code

Causing side-effects is the worst practice when using properties, and it’s more spread than it seems at first. What can we consider side-effects? Modifying a nested object state, making a database query that modifies database state or change values in other fields that have nothing to do with the actual Property are side-effects examples. Properties are an abstraction to fields, so noone will expect that when I get a value in a property, other values change. This principle is also applicable to getters and setters in languages where properties are not available.

Slow properties

Properties are an abstraction to fields and fields are expected to be as fast as reading/writing a memory address. If you are reviewing why your code is slow, you are not going to expect a property is the responsible at first. Use methods instead of properties for slow methods, even better if you can make these methods async if I/O is involved.

Properties as method arguments

Some APIs, use properties as method arguments. Imagine a ZIP compressor that works like this.

var zip = new ZIPCompressor();
zip.InputFiles = new string[] { "foo.txt", "bar.odt", "baz.png" };
zip.OutputFile = "file.zip";
zip.Compress();

InputFiles and OutputFile are not natural ZipCompressor properties, they look more like Compress method arguments. Wouldn’t it be cleaner if instead of properties, regular method arguments were used?

var zip = new ZIPCompressor();
var inputFiles = new string[] { "foo.txt", "bar.odt", "baz.png" };
var outputFile = "file.zip";
zip.Compress(inputFiles, outputFile);

This code smell can be found with methods that would need several arguments because of high configuration. In these cases it’s better to define a value object that would have the default arguments already set. We could simply instantiate it and set the properties we need to customize the configuration to our needs.

var zip = new ZIPCompressor();
var zipCompressionSettings = new ZIPCompressionSettings();
zipCompressionSettings.InputFiles = new string[] { "foo.txt", "bar.odt", "baz.png" };
zipCompressionSettings.OutputFile = "file.zip";
zip.Compress(zipCompressionSettings);

This way code is far cleaner. Code is not going to mislead the reader to think that the code is mutating the ZIPCompressor object and the API user would not have to remember to reset all these properties in future calls to the Compress method.

When to use properties then?

Rule of thumb, use them as getters and setters. Just that. Some other legitimate cases would be caching values or making helper methods to object attributes. For example, calculate the Age from the BirthDate. The best advice is to keep always in mind that properties are an abstraction to fields. Keep that in mind when writing your properties and WTFs will decrease in your codebase.

Entity Framework 6 and "There is already an open DataReader"

Sat, 06 Aug 2016 16:30:00 +0000

Entity Framework is an amazing ORM. It has differences with other ORMs like Hibernate or Doctrine, but at the same time feels more comfortable. Two key differences with other ORMs are LINQ as its query language (LINQ it’s a compiled language, if you like to rename stuff you know how many errors this feature can prevent) and being able to use foreign key values without having to join with the related entity.

But, it has a poor proxy pattern. Navigation properties, the Entity Framework name for relationships between entities, can be accessed with lazy loading like in other ORMs, but in Entity Framework you must load the entire result set in a list before traversing it or an exception will show up saying “There is already an open DataReader associated with this Connection”. This happens because Entity Framework attempts to start a new data reader while it is already reading the data reader for the previous collection.

While it’s not a big deal when you have an upfront database design that won’t ever change, this usually breaks code when a new relationship is added to an entity that already exists if you need to use this new relationship in data transfer objects or in every place where you are retrieving data from this entity. So, what can we do to make our codebase more reliable and prevent production errors? SQL Server has a feature called Multiple Active Result Sets (MARS). This feature allows the client code to open more than one DataReader at the same time. It clearly fixes it, while I don’t recommend using it in development because this error is actually telling us that we are probably doing something wrong. In development, this exception can help you to prevent performance problems lead by lazy loading with big datasets. When retrieving data from a navigation property, there is a 99% chance that what you actually wanted to do was to load your data eagerly. So, if you don’t have MARS enabled in Debug Mode, these issues will show up with the so-called exception. But if you don’t want your production code to fail unexpectedly after a database update, then enable MARS only in Release. The only needed change is to change your Connection String like this.

Data Source=MSSQL; Initial Catalog=AdventureWorks; Integrated Security=SSPI; MultipleActiveResultSets=True

Hope this helps!

ETagFilePathResult, an ActionResult to save bandwidth in ASP.NET MVC.

Mon, 04 Jul 2016 21:00:00 +0000

ASP.NET MVC provides several ways to serve files from controllers, but all of them require to serve the entire file content through the network, something that will make our website slow and more expensive while it’s ridiculous to transfer the same content over the network every time the resource is requested. Client-side HTTP caching can easily prevent downloading all those extra bytes. In this post we offer a solution to it without doing any complicated stuff, using the ActionResult abstract class to integrate a solution based on ETags in ASP.NET MVC to implement the client-side caching.

Why do I need to return static files from a controller?

It might seem ridiculous to return static files from a controller. Well, it is not. In several scenarios it is very useful and secures your web application. For instance, when there are private resources that might be readable only for a subset of users you must validate in the controller if the resource is readable for the user who requests it, if not you’re creating a security hole by mistake. Other use cases are dynamically generated files backed by a server-side cache, or even customized stylesheets backed on a server file too.

Alright, but let me see the code!

This class is analogous to other classes that are already in ASP.NET MVC like FilePathResult or FileStreamResult. While these classes work, they do not implement any client-side caching mechanism. So, with ETagFilePathResult an ETag will be calculated from the server file full path and the file last write time and returned to the client, letting the client know that the resource can be cached and indexed by this ETag.

public ActionResult Image(int id)
{
    // Find the image that matches with the incoming id.
    return new ETagFilePathResult(
        imagePath, "image/png", Request.Headers["If-None-Match"]
    );
}

public class ETagFilePathResult : ActionResult
{
    private string fileName;
    private string contentType;
    private string previousETag;
    private string uniqueSource;

    public ETagFilePathResult(string fileName, string contentType,
            string previousETag, string uniqueSource = "")
    {
        this.fileName = fileName;
        this.contentType = contentType;
        this.previousETag = previousETag;
        this.uniqueSource = uniqueSource ?? "";
    }

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }

        HttpResponseBase response = context.HttpContext.Response;
        response.ContentType = contentType;

        FileInfo fileInfo = new FileInfo(fileName);
        string eTag = CalculateETag(fileInfo);

        response.Headers.Add("Content-Length", fileInfo.Length.ToString());
        response.Cache.SetCacheability(HttpCacheability.ServerAndPrivate);
        response.Cache.SetETag(eTag);

        if (eTag == previousETag)
        {
            response.StatusCode = (int) HttpStatusCode.NotModified;
        }
        else
        {
            response.TransmitFile(fileName);
            response.Flush();
        }
    }

    protected virtual string CalculateETag(FileInfo fileInfo)
    {            
        string hashSource;
        byte[] bContentsToHash, hash;

        hashSource = String.Join("-", new string[] {
            fileInfo.FullName,
            fileInfo.LastWriteTime.ToString(),
            uniqueSource
        );
        bContentsToHash = Encoding.Unicode.GetBytes(hashSource);
        hash = ((HashAlgorithm) CryptoConfig.CreateFromName("MD5"))
                                            .ComputeHash(bContentsToHash);

        string eTag = BitConverter.ToString(hash)
                                  .Replace("-", string.Empty)
                                  .ToLower();

        return eTag;
    }
}

The next time the browser asks for this resource, it will add an If-None-Match header with the ETag, and the server will check if that ETag matches the current file stored in the filesystem. If it does, it returns only an HTTP Not Modified status code, and doesn’t transmit the file content to the client, authorizing the browser to keep using the same copy it downloaded previously for this resource. Isn’t it cool? And no extra code needed in your controller!

Given this code, it is pretty straightforward to implement alternatives, such as an ActionResult that serves a file from a stream or a byte array and etags it. In this case we would not be able to use the last write time, but we could simply hash the content of the stream and calculate the ETag from that.

I hope this helps and if you implement any alternative don’t hesitate to share in comments!

Nativescript. The native alternative to Ionic.

Fri, 06 May 2016 21:00:00 +0000

If we had to pick an emerging and changing field in technology throughout development today, Mobile application development would be the most accurate choice. Tools and frameworks in this field are more exposed to bigger changes. That is why, new hybrid mobile app frameworks are emerging again and one of these new frameworks is Nativescript. Nativescript is a new open-source technology by Telerik that enables developing native apps using Javascript or Typescript, that can run on Android, iOS and, in the near future, Windows, with the Windows Universal Apps flavour. This native feature is what puts the de facto hybrid mobile app framework Ionic in peril, making it possible to be replaced by Nativescript, a more performant alternative.

How native is Nativescript?

I guess you’re surprised that Nativescript supports developing native mobile apps using Javascript as the programming language, using also a subset of CSS for UI customization and XML for component view definition and layouts. This new technology uses the native UI components in the mobile platform where the app runs, making the user experience faster, smoother and more familiar. Invoking native platform methods is also possible, and you don’t have to use a different language, you can simply use them from Javascript. This feature is amazing, allowing you to use the good native things while you use Javascript as the glue-code to put everything together and leave heavy-weight operations and UI to the device native APIs. But, how does this work? To make this possible, Nativescript uses different Javascript engines depending on the platform, and expose Javascript objects with the native APIs, calling native APIs like if they were just methods and objects in Javascript. A thorough explanation is available in this post focusing on the Javascript/Native bridge mechanism. Also, a less extense but maybe easier explanation can be found in the next video.

Community and plugins

Nativescript community is growing day by day. A Slack channel is available and they are also putting some effort in the project internationalization.

Many plugins have already been developed to be able to use native components in Nativescript, and there is also an official marketplace of plugins called the Telerik Verified Plugins Marketplace Some good examples are, an Admob plugin, Sqlite, Social Share or Firebase. And, remember, you will always be able to use the native Javascript bridge if you need to invoke native platform methods.

There are also utilities that make using Nativescript less painful for those who are not used to the terminal. Telerik is developing a Visual Studio Code extension that can be installed from the following link. With this extension, you can launch your application from the IDE without having to execute manually the Nativescript commands.

Is it a mature technology?

Nativescript is a new technology and there are still some points where it can be improved. After having tested the tool, its development workflow could be difficult to the beginner, and there are some execution options, like livesync, where finding that you have some error in the XML markup might get unnoticed. I guess some of these things will get improved in future releases.

Apart from this, a key point is the community. Ionic, the framework that made hybrid-app development mainstream, has a mature community and it’s still a Javascript framework widely used, so here is a big challenge for the Nativescript team in order to grow a community around it.

Native against standard.

Ionic is in a tough situation. Ionic’s team is working on Ionic 2 which will give support to Angular.js 2. This new framework is a revolution in Frontend development, and it was a must to have it in its version 2, but that has made them lose steam against technologies like Facebook’s React Native or Nativescript in things like performance. Nativescript 2.0 also supports Angular.js 2, what could be summed up as that Ionic might be less competitive than Nativescript for those developers who start an app from scratch.

All in all, hybrid apps framework market is in a revolution (again). There are good prospects for solutions that are closer to native, while Ionic should consider including some of them in their framework unless these native-UI solutions are not so valued by developers as they should be. We’ll see in the near future if Nativescript becomes the reference in hybrid app development, or Ionic Framework stands still in its current top position.

Ilmerge. The target assembly lists itself as an external reference

Fri, 05 Feb 2016 19:00:00 +0000

I’ve made my mind to do this post just because I saw there wasn’t a solution to what happened to me with this problem, even though the solution to it was pretty naive to me. The thing is, in an ASP.NET project, I have a publish profile with precompilation enabled and with the advanced precompile option “Merge all outputs to a single assembly” enabled too. I decided to set to this output assembly my project name, something that seemed to me the right thing to do. But then, suddenly a misterious error showed up.

An error occurred when merging assemblies: ILMerge.Merge: The target assembly ‘Whatever’ lists itself as an external reference

I didn’t have a reference to the same project anywhere, what was this error about? After googling for a while, I decided to do the silliest attempt to solve the issue, that kind of change you don’t think is going to fix it, but, why not trying? I changed the output assembly name. And the error vanished. And everything worked. So I had wasted a morning because of something so simple…

I hope this post now prevents you from losing yours. Please try it out, because in my case it worked!

PHP7. The new PHP version is here.

Tue, 27 Oct 2015 18:00:00 +0000

PHP7 is here. Well, the final release hasn’t been released yet, but next 12th November is scheduled to be released so maybe when you are reading this post the stable final release might be released. And, what does this new language version provide? The killer feature promised is performance. Zend has published the next infographic where you can see how they announce a 2x performance improvement. This might be a half of servers, software twice faster, so it is a considerable enhancement for the whole PHP ecosystem.

Performance

Zend did also publish this infographic showing the performance boost in PHP frameworks widely used, such as Magento or Drupal. This infographic shows how PHP7 is capable of serving more requests per second than even HHVM, Facebook’s project to improve PHP performance. At the bottom of the infographic, it is shown how PHP is the fastest dynamic language resolving Mandelbrot fractals problem. So, we have again another reason to use PHP, performance.

New features

PHP7 also provides new features, that have been added to the language to make it more modern. Syntactic sugar is always a good thing, that is why we are going to enumerate some of these new features in the language.

Spaceship operator

In the first place, we are going to explain the weird new feature, the Spaceship operator (<=>). This operator compares values returning what is expected by comparators, -1 if the first operand is less than the second, 0 if both operands are equal and 1 if the first operador is greater than the second.

<?php
$a = 1;
$b = 2;

echo $a <=> $b;

This operator is not a huge boost, but it is another weird thing more to the language. The only use case that comes to my mind is to use it inside anonymous functions used by sorting functions, like usort.

A language with better typing

PHP is a dynamic language, but sometimes it is useful to be able to define the type of a function argument or which type a function returns. In previous PHP versions, only class types were allowed to be defined in function arguments. PHP7 will allow also scalar types to be hinted in function arguments. It also adds the possibility to define which type a function returns. Be ready to have a better autocompletion support for the language in IDEs, because I suppose almost all PHP7 frameworks will make an extensive use of this new feature.

Coalesce operator

This flow structure has been the most written piece of code during my professional PHP life.

<?php

$x = array(
/* $_POST values */
);

$value = isset($x['value']) ?
    $x['value'] : null;

Don’t you agree? Haven’t you ever used this flow structure? To avoid a Notice when you don’t check if the key exists in an array, you are forced to write this piece of code. Some developers used the @ operator, that suppresses warnings generated by the statement surrounded by it. That is not a solution, that was just hiding an error.

<?php
$x = array(
/* $_POST values */
);

$value = @$x['value']);

In PHP7, we will be able to use the coalesce operator that will allow a neater way to solve this problem.

<?php
$x = array(
/* $_POST values */
);

$value = $x['value']) ?? null;

Group use declarations

From PHP5.3 forward, PHP has namespaces. If you use classes from another namespace, the use statement allows to use simply the class name instead of its full namespace name. Before PHP7, you had to write a use statement for each class. With PHP7, group use declarations can be used, writing only one line per package making it clearer what classes and namespaces are being used.

<?php
// Before
use some\namespace\ClassA;
use some\namespace\ClassB;
use some\namespace\ClassC as AliasClassC;

// Now
use some\namespace\{ClassA, ClassB, ClassC as AliasClassC};

Integer division

intdiv function will provide a way to execute the integer division without any trick.

<?php
// Before
$a = floor(4 / 3);

// Now
$a = intdiv(4, 3);

Expressions in constants

Now, constants will be able to store the result of an expression. Before, PHP threw an exception.

<?php

class A
{
    const DAY_SECONDS = 24 * 60 * 60;
}

Backwards compatibility

The biggest of problems with new major language versions, it’s cool to introduce new features and huge improvements but normally these features introduce BC breaks (backwards compatibility breaks). So, if a project is not under automatic testing or, at least, has a manual procedure established to know it does what is expected, we have a great problem if we have to migrate it to a newer language major version.

Regarding PHP7, it has been promised it won’t be a pain to migrate from PHP5 to it. Even though, some changes are worth to take a look before moving on.

Exception handling changes

The exception hierarchy has been modified. In PHP7 we will have exceptions and errors. Some structures that threw an uncatchable fatal error, now will throw an Error that could be catched with a try/catch statement, because this Error class will implement the Throwable interface that will be the new way to catch any exception or error in a block of code.

This will allow catching errors that before stopped the program flow, or simply triggered unmeaningful warnings, like the division by zero. Now, we can even catch a division by zero error and do something special about it.

New Objects cannot be assigned by reference

In PHP7, an object created with a new statement cannot be assigned by reference in the same statement to a variable. This piece of code was widely used in previous PHP versions because of some performance reasons, so if you are migrating a legacy project or you’re used to use this piece of code in your applications, it’s a good moment to stop using it.

<?php

$a = &new \stdClass();

More BC issues

The explained issues are the most important to me, but you can find other BC issues like removed functions in the official migration link or in this Github repository with examples.

PHP7 is here to make the Web better

In my opinion, it is a new version with little breaking compatibility changes, something positive, but it this mantra has also made impossible to do more ambitious changes to the language that might have considerably improved the language. But I suppose PHP mantainers don’t want a Python3 happening in PHP.

Other features I miss are more types and functions for the PHP internals. A decimal type would be great to do fixed numeric operations, something basic for high-level languages. So, to finish with this post, developers must keep updated, so it is important to know which are the new features provided by this new version because sooner or later this version will become the standard. And the sooner the better. PHP7 has performance and behaviour improvements that can’t be skipped. PHP7 is here to make the Web better.

Metabase. A revolutionary reporting tool

Sat, 24 Oct 2015 16:30:00 +0000

Metabase is a new open source tool built with Clojure that provides a new way to avoid wasting time on programming your company’s reports. With a very simple UI, users can configure their own reports and charts by themselves. Users would be able to retrieve very simple information almost instantly, without having to make a request to the IT team and waiting for them to develop the appropriate report. As a result, company’s business intelligence process gets considerably improved regarding timing and information feedback.

Databases can be plugged in Metabase simply by setting the server where the database lives, the database name and its credentials. A name inside the application that will be visible by users can be set. And it supports four database engines, MySQL, MongoDB, PostgreSQL and H2.

How to set it up.

Metabase can be downloaded from this URL http://www.metabase.com/start/. As I use Linux, I’m going to explain how I have installed it using the “Other platforms” option.

Simply run

java -jar metabase.jar

After this step, you can open a browser and open the default Metabase URL http://localhost:3000. To get started, your personal information will be asked to set up your user. Apart from that, you can set up the first database or set it up afterwards. For more information on how to set it up in a production environment http://www.metabase.com/docs.

Creating questions

Simply click on “New Questions”, if you have already set up your database, all the database tables are ready to use. Metabase uses database metadata to populate the available filters depending on the column type. For example, if the data is “numeric”, it allows different filters such as “Greater than”, “Less than”, while when a column is a string, these filters are not available. It is also intelligent to use your schema foreign keys, so you can filter your information also by a related table column!

Questions can be added to the dashboard so that users can analyze information at a glance. And visualization is customizable. You can choose from many different views that can be used to customize how your users want to see information.

Drawbacks

Unfortunately, as many other JVM solutions, Metabase has a high memory footprint. Without real users load in my personal computer running Linux Metabase is using about 700 MB. Even though, it’s not a lot when installed on a server and with the amount of work it can save you this shouldn’t put you off of using this awesome open-source solution.

Let’s use metabase!

Metabase is a solution that can save your company loads of time and money. Remember that these kind of solutions have a considerable value, and Metabase is free! Apart from that, if some developers are working on reporting solutions, they will be free to work on other important tasks. So, if you aren’t using any business intelligence solution, Metabase is a good solution for you.

Symfony2 is not slow

Fri, 09 Oct 2015 10:30:00 +0000

If you are working on Web Development you must have read eventually a benchmark. What several times is not that obvious is that the benchmark you read might not be comparing the different tecchnologies fairly, just because of time and knowledge constraints. And Symfony2 is not an exception, as a framework with several files and features it is always at the lower positions of the ranking. Even though, Symfony2 is not slow.

One of the most popular benchmarks on the Internet is the one from TechEmpower that solves a set of problems with more than a hundred of technologies with an awesome detail. Although, it is still impossible to be able to develop each solution fairly for such an amount of technologies, programming languages and frameworks.

Focusing on Symfony2, anybody that has spent more than an evening working with it knows that to put it in a production environment with a good performance some extra tweaks must be done. But this is just having to change some settings in the configuration files, nothing to do with the code you’ve developed. As an example, I will show the optimization that has given me better results, an optimization for the ORM that comes with Symfony2, Doctrine2.

doctrine:
    orm:
        metadata_cache_driver: apc
        result_cache_driver: apc
        query_cache_driver: apc

As you can see in the previous example, different sorts of caches can be configured for Doctrine2. The metadata cache (metadata_cache_driver) allows that every mapping file between your entities and your database tables can be reused, without the need to read the file from disk. But the killer setting is query_cache_driver. When this option is enabled, Doctrine2 only has to transform a query from DQL to SQL once and, as this forces a compile process behind the scenes, it avoids this work written in PHP in every request. It will be done once and after that cached. In the real world, when I used this setting for the first time, I noticed that an API endpoint that was taking a second to finish only took about 50 milliseconds. It was 20x times faster only because I changed a line in a configuration file!!! About cache engines, Symfony2 offers other cache engines, not only APC like Redis and Memcache.

And this is just one of the optimizations that can be done. The Internet is full of resources with tutorials and instructions to improve your Symfony2 application performance critically like this one.

How to migrate MySQL to MariaDB

Sun, 06 Sep 2015 15:00:00 +0000

As you might already know, MariaDB is the alternative to Oracle MySQL. The MariaDB team mantains two releases right now, one that is compatible with MySQL called MariaDB 5.5 and a new one for brand new installations, MariaDB 10. We are going to migrate to MariaDB 5.5, which is the recommended for easy migrations without headaches.

I have tested this under Ubuntu 14.04. Open a shell, and type/paste the following instructions to do your migration:

sudo bash
apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 0xcbcb082a1bb943db
apt-get update
apt-get install mariadb-server

And everything is up and ready. You won't have to change even your database connection configuration, the applications that were using the MySQL driver will keep working perfectly.

And to finish the post, a warning, do not test this in live environment unless you have tested it properly!

Functional PHP

Sun, 06 Sep 2015 15:00:00 +0000

Functional programming. What is that thing some software gurus talk about? I am going to try to explain it with a basic example in PHP to show you how you can use this paradigm for your daily work, demistifying its difficulty in the process. And, yeah, you can use functional programming in PHP, well, with a PHP flavour.

What is functional programming?

The functional programming paradigm is not modern at all. It is based on Lambda Calculus. One of the first languages that allowed programming using this technique was Lisp.

Functional programming is all about functions and data structures, there are no objects in there. Pure functional programming languages do not allow mixing data with behaviour. But some pieces of this paradigm have been used since the beginning of other languages, like function pointers in C. Usually, pure functional languages like Haskell have capabilities that are out of the scope of this post, like Currying, Pattern Matching and Lazy Initialization.

Given it is usually difficult to understand, we are going to show an example of functional programming using PHP. The example in this post is quite simple, and it solves a mundane problem using functional programming, filtering a collection or array.

An example

<?php

function index_and_value_are_even($arr)
{
    $result = [];
    foreach($arr as $index => $value) {
        if ($value % 2 == 0 && $index % 2 == 0) {
            $result[$index] = $value;
        }
    }

    return $result;
}

var_export(index_and_value_are_even([1, 2, 3]));

This code fragment exports an empty array, provided the array values and indices are not even in any element.

In many applications, pieces of code like these can be found, traversing a collection and applying a filter over it is a common task. It is not a bad way to solve the problem, it is simple, standard and easy, but if we solve it like this, we have to write tons of syntax that we actually don't need, repeating the same pattern over and over again and, in real world applications, the problem solved by the foreach body isn't usually just like in the example, it can also be a cumbersome piece of code.

Let's see how this function would be implemented using the functional paradigm.

<?php
function is_even($n)
{
    return $n % 2 == 0;
}

function index_and_value_are_even($arr) {
    return array_filter($arr, function($index, $value) {
        return is_even($index) && is_even($value);
    });
}

Isn't this solution much better? It's obviously a subjective matter but in my opinion the code is more expressive using functional programming.

Even though this piece of code is incorrect. array_filter native function doesn't send the index to the called filter function. This can make this function useless for your needs, more if the array keys have a meaning in your application. But, we are programmers, aren't we? Let's do our own implementation.

<?php

function array_filter_with_indices(array $arr, callable $fn)
{
    $result = [];
    foreach($arr as $key => $value) {
        if ($fn($key, $value)) {
            $result[$key] = $value;
        }
    }

    return $result;
}

Yes, it's a pretty straightforward implementation. Now we can reuse this filter function applying an anonymous function over it to decide which elements fulfill the provided conditions. This implementation also preserves the original indices, not like the native array_filter.

<?php
['1' => 'value1', 'abc' => 'value3', ...]

Another thing of note in this code is that it uses Type Hinting, a mechanism to check if the function arguments belong to the type the function expects. As you can see, it's possible to type hint an argument as callable. This kind of type hinting has been added in version 5.4, so check this before you decide to use it in your application.

I hope you've got the gist of this technique. Don't mind using it in real world applications!!