The database plugin in IntelliJ IDEA is a useful tool to work with data in databases. As long as we got a JDBC driver to connect to the database we can configure a data source. And then we can run queries, inspect the contents of tables and change data with the database tool window. It is not uncommon to have multiple data sources, for example development and test environment databases, which will have the same tables. When we open the tables or run queries we don’t have a visual feedback to see to which data source such a table belongs. To have a visual feedback we can colorize our data source. This means we assign a color to a data source and when we open a table from that data source the tab color in the editor window will have a different color than other tabs or the background color of the data source objects have a color.
In a previous post we learned about the
Writable interface and how the GString implementation implements this interface. In Groovy we can also use a closure as an implementation of the
Writable interface. The
Closure class has the method
asWritable() that will return a version of the closure with an implementation of the
writeTo() method. The
Writer object that is used as an argument for the
writeTo() method will be passed as argument to the closure. The
asWritable() method also adds a
toString() implementation for the closure to return the result of a closure as a
The Groovy API has the interface Writable. Classes that implement this interface are capable of writing their selves to a
java.io.Writer object. The interface has one method
writeTo() where the code is that writes the contents to a given
Writer instance. Most implementations will also use the implementation of the
writeTo() method in their
The GString implementation in Groovy also implements the
Writable interface. This means we can redirect the GString contents to some
Writer instance if we want to. In the following code we use a
FileWriter to write the contents of a GString to a file:
To convert a
byte array to a
String we can simply use the
new String(byte) constructor. But if the array contains non-printable bytes we don’t get a good representation. In Groovy we can use the method
encodeHex() to transform a
byte array to a hex
String value. The
byte elements are converted to their hexadecimal equivalents.
In a previous post we learned how we can use Hibernate native SQL queries in our Grails application. We can also execute custom SQL with Groovy SQL. We must create a new instance of
groovy.sql.Sql in our code to execute SQL code. The easiest way is to use a
javax.sql.DataSource as a constructor argument for the
groovy.sql.Sql class. In a Grails application context we already have a
DataSource and we can use it to inject it into our code. We must use the name
dataSource to reference the default datasource in a Grails application.
Sometimes we want to use Hibernate native SQL in our code. For example we might need to invoke a selectable stored procedure, we cannot invoke in another way. To invoke a native SQL query we use the method
createSQLQuery() which is available from the Hibernate session object. In our Grails code we must then first get access to the current Hibernate session. Luckily we only have to inject the
sessionFactory bean in our Grails service or controller. To get the current session we invoke the
getCurrentSession() method and we are ready to execute a native SQL query. The query itself is defined as a
String value and we can use placeholders for variables, just like with other Hibernate queries.
In our Grails applications we might have fields that need the same combination of constraints. For example we want all email fields in our application to have a maximum size of 256 characters and must apply to the email constraint. If we have different classes with an email field, like domain classes and command objects, we might end of duplicating the constraints for this field. But in Grails we can combine multiple constraints for a field into a single constraint with a new name. We do this in
grails-app/conf/Config.groovy where we add the configuration property
grails.gorm.default.constraints. Here we can define global constraints with can be used in our Grails application.
For many years now it has been good practice to write unit tests for your source-code.
And also to use test coverage reporting to see how much of your code is covered by tests.
Although line + branch coverage reporting is quite useful, it doesn’t tell you how good your unit tests actually are. Hence it’s even possibly to achieve 100% coverage without even a single assert in your tests.
Being interested in better ways of testing I attended the “Mutation testing” workshop during this years Joy of Coding conference.
Mutation testing is a radical different approach of executing and analyzing the result and coverage of your unit tests. Instead of measuring how much of your code is “accessed from” your unit tests it determines how much of your code is actually “tested by” your unit tests.
IntelliJ IDEA 13 added the Terminal tool window to the IDE. We can open a terminal window with Tools | Open Terminal…. To change the font of the terminal we must open the preferences and select IDE Settings | Editor | Colors & Fonts | Console Font. Here we can choose a font and change the font size:
In the latest Grails releases we can execute our tests in so-called forked mode. This means a separate JVM is started with an isolated classpath from the Grails build system. When we want to run our tests in forked mode from within IntelliJ IDEA we get the following error:
Error running forked test-app: Could not load grails build listener class (Use --stacktrace to see the full trace). To make running tests in forked mode work with IntelliJ IDEA we must add one of the IntelliJ IDEA supplied JAR files to the Grails classpath.