diff --git a/manifests/server/extension.pp b/manifests/server/extension.pp
index 634b5c2..773530c 100644
--- a/manifests/server/extension.pp
+++ b/manifests/server/extension.pp
@@ -1,85 +1,85 @@
 # Activate an extension on a postgresql database
 define postgresql::server::extension (
   $database,
   $extension                   = $name,
   Optional[String[1]] $version = undef,
   String[1] $ensure            = 'present',
   $package_name                = undef,
   $package_ensure              = undef,
   $connect_settings            = $postgresql::server::default_connect_settings,
 ) {
   $user             = $postgresql::server::user
   $group            = $postgresql::server::group
   $psql_path        = $postgresql::server::psql_path
 
   case $ensure {
     'present': {
       $command = "CREATE EXTENSION \"${extension}\""
       $unless_mod = ''
       $package_require = []
-      $package_before = Postgresql_psql["Add ${extension} extension to ${database}"]
+      $package_before = Postgresql_psql["${database}: ${command}"]
     }
 
     'absent': {
       $command = "DROP EXTENSION \"${extension}\""
       $unless_mod = 'NOT '
-      $package_require = Postgresql_psql["Add ${extension} extension to ${database}"]
+      $package_require = Postgresql_psql["${database}: ${command}"]
       $package_before = []
     }
 
     default: {
       fail("Unknown value for ensure '${ensure}'.")
     }
   }
 
   if( $database != 'postgres' ) {
     # The database postgres cannot managed by this module, so it is exempt from this dependency
     Postgresql_psql {
       require => Postgresql::Server::Database[$database],
     }
   }
 
-  postgresql_psql {"Add ${extension} extension to ${database}":
+  postgresql_psql { "${database}: ${command}":
 
     psql_user        => $user,
     psql_group       => $group,
     psql_path        => $psql_path,
     connect_settings => $connect_settings,
 
     db               => $database,
     command          => $command,
     unless           => "SELECT 1 WHERE ${unless_mod}EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extension}')",
   }
 
   if $package_name {
     $_package_ensure = $package_ensure ? {
       undef   => $ensure,
       default => $package_ensure,
     }
 
     ensure_packages($package_name, {
       ensure  => $_package_ensure,
       tag     => 'postgresql',
       require => $package_require,
       before  => $package_before,
     })
   }
   if $version {
     if $version == 'latest' {
       $alter_extension_sql = "ALTER EXTENSION \"${extension}\" UPDATE"
       $update_unless = "SELECT 1 FROM pg_available_extensions WHERE name = '${extension}' AND default_version = installed_version"
     } else {
       $alter_extension_sql = "ALTER EXTENSION \"${extension}\" UPDATE TO '${version}'"
       $update_unless = "SELECT 1 FROM pg_extension WHERE extname='${extension}' AND extversion='${version}'"
     }
     postgresql_psql { "${database}: ${alter_extension_sql}":
       db               => $database,
       psql_user        => $user,
       psql_group       => $group,
       psql_path        => $psql_path,
       connect_settings => $connect_settings,
       command          => $alter_extension_sql,
       unless           => $update_unless,
     }
   }
 }
diff --git a/spec/unit/defines/server/extension_spec.rb b/spec/unit/defines/server/extension_spec.rb
index 6652496..5480057 100644
--- a/spec/unit/defines/server/extension_spec.rb
+++ b/spec/unit/defines/server/extension_spec.rb
@@ -1,156 +1,156 @@
 require 'spec_helper'
 
 describe 'postgresql::server::extension', :type => :define do
   let :pre_condition do
     "class { 'postgresql::server': }
      postgresql::server::database { 'template_postgis':
        template   => 'template1',
      }"
   end
 
   let :facts do
     {
       :osfamily => 'Debian',
       :operatingsystem => 'Debian',
       :operatingsystemrelease => '6.0',
       :kernel => 'Linux',
       :concat_basedir => tmpfilename('postgis'),
       :id => 'root',
       :path => '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
     }
   end
 
   let (:title) { 'postgis' }
   let (:params) { {
     :database => 'template_postgis',
   } }
 
   context "with mandatory arguments only" do
     it {
-      is_expected.to contain_postgresql_psql('Add postgis extension to template_postgis').with({
+      is_expected.to contain_postgresql_psql('template_postgis: CREATE EXTENSION "postgis"').with({
         :db      => 'template_postgis',
         :command => 'CREATE EXTENSION "postgis"',
       }).that_requires('Postgresql::Server::Database[template_postgis]')
     }
   end
 
   context "when setting package name" do
     let (:params) { super().merge({
       :package_name => 'postgis',
     }) }
 
     it {
       is_expected.to contain_package('postgis').with({
         :ensure  => 'present',
         :name    => 'postgis',
-      }).that_comes_before('Postgresql_psql[Add postgis extension to template_postgis]')
+      }).that_comes_before('Postgresql_psql[template_postgis: CREATE EXTENSION "postgis"]')
     }
   end
 
   context "when ensuring absence" do
     let (:params) { super().merge({
       :ensure       => 'absent',
       :package_name => 'postgis',
     }) }
 
     it {
-      is_expected.to contain_postgresql_psql('Add postgis extension to template_postgis').with({
+      is_expected.to contain_postgresql_psql('template_postgis: DROP EXTENSION "postgis"').with({
         :db      => 'template_postgis',
         :command => 'DROP EXTENSION "postgis"',
       }).that_requires('Postgresql::Server::Database[template_postgis]')
     }
 
     it {
       is_expected.to contain_package('postgis').with({
         :ensure  => 'absent',
         :name    => 'postgis',
       })
     }
 
     context "when keeping package installed" do
       let (:params) { super().merge({
         :package_ensure => 'present',
       }) }
 
       it {
-        is_expected.to contain_postgresql_psql('Add postgis extension to template_postgis').with({
+        is_expected.to contain_postgresql_psql('template_postgis: DROP EXTENSION "postgis"').with({
           :db      => 'template_postgis',
           :command => 'DROP EXTENSION "postgis"',
         }).that_requires('Postgresql::Server::Database[template_postgis]')
       }
 
       it {
         is_expected.to contain_package('postgis').with({
           :ensure  => 'present',
           :name    => 'postgis',
-        }).that_requires('Postgresql_psql[Add postgis extension to template_postgis]')
+        }).that_requires('Postgresql_psql[template_postgis: DROP EXTENSION "postgis"]')
       }
     end
   end
 
   context "when extension version is specified" do
     let (:params) { super().merge({
       :ensure       => 'absent',
       :package_name => 'postgis',
       :version      => '99.99.99',
     }) }
 
     it {
       is_expected.to contain_postgresql_psql('template_postgis: ALTER EXTENSION "postgis" UPDATE TO \'99.99.99\'').with({
         :db      => 'template_postgis',
         :unless  => "SELECT 1 FROM pg_extension WHERE extname='postgis' AND extversion='99.99.99'",
       }).that_requires('Postgresql::Server::Database[template_postgis]')
     }
   end
 
   context "when extension version is latest" do
     let (:params) { super().merge({
       :ensure       => 'absent',
       :package_name => 'postgis',
       :version      => 'latest',
     }) }
 
     it {
       is_expected.to contain_postgresql_psql('template_postgis: ALTER EXTENSION "postgis" UPDATE').with({
         :db      => 'template_postgis',
         :unless  => "SELECT 1 FROM pg_available_extensions WHERE name = 'postgis' AND default_version = installed_version",
       }).that_requires('Postgresql::Server::Database[template_postgis]')
     }
   end
 end
 
 describe 'postgresql::server::extension', :type => :define do
   let :pre_condition do
     "class { 'postgresql::server': }
      postgresql::server::database { 'template_postgis2':
        template   => 'template1',
      }"
   end
 
   let :facts do
     {
       :osfamily => 'Debian',
       :operatingsystem => 'Debian',
       :operatingsystemrelease => '6.0',
       :kernel => 'Linux',
       :concat_basedir => tmpfilename('postgis'),
       :id => 'root',
       :path => '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
     }
   end
 
   let (:title) { 'postgis_db2' }
   let (:params) { {
     :database => 'template_postgis2',
     :extension => 'postgis',
   } }
 
   context "with mandatory arguments only" do
     it {
-      is_expected.to contain_postgresql_psql('Add postgis extension to template_postgis2').with({
+      is_expected.to contain_postgresql_psql('template_postgis2: CREATE EXTENSION "postgis"').with({
         :db      => 'template_postgis2',
         :command => 'CREATE EXTENSION "postgis"',
       }).that_requires('Postgresql::Server::Database[template_postgis2]')
     }
   end
 end