diff --git a/manifests/server/extension.pp b/manifests/server/extension.pp
index 438459f..86f2f9d 100644
--- a/manifests/server/extension.pp
+++ b/manifests/server/extension.pp
@@ -1,86 +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_comp = '='
       $package_require = []
       $package_before = Postgresql_psql["Add ${extension} extension to ${database}"]
     }
 
     'absent': {
       $command = "DROP EXTENSION \"${extension}\""
       $unless_comp = '!='
       $package_require = Postgresql_psql["Add ${extension} extension to ${database}"]
       $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}":
 
     psql_user        => $user,
     psql_group       => $group,
     psql_path        => $psql_path,
     connect_settings => $connect_settings,
 
     db               => $database,
     command          => $command,
     unless           => "SELECT t.count FROM (SELECT count(extname) FROM pg_extension WHERE extname = '${extension}') as t WHERE t.count ${unless_comp} 1",
   }
 
-  if($database != undef and defined(Postgresql::Server::Database[$database])) {
-    Postgresql::Server::Database[$database]->Postgresql_psql["Add ${extension} extension to ${database}"]
-  }
-
   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,
     }
-    if($database != undef and defined(Postgresql::Server::Database[$database])) {
-      Postgresql::Server::Database[$database]->Postgresql_psql["${database}: ${alter_extension_sql}"]
-    }
   }
 }
diff --git a/spec/unit/classes/globals_spec.rb b/spec/unit/classes/globals_spec.rb
index d4bceda..6789090 100644
--- a/spec/unit/classes/globals_spec.rb
+++ b/spec/unit/classes/globals_spec.rb
@@ -1,94 +1,95 @@
 require 'spec_helper'
 
 describe 'postgresql::globals', type: :class do
   context 'on a debian 6' do
     let (:facts) do
       {
         :os => {
           :family               => 'Debian',
           :name                 => 'Debian',
           :release => {
-            :full => '6.0'
+            :full => '6.0',
+            :major => '6'
           }
         },
         :osfamily               => 'Debian',
         :operatingsystem        => 'Debian',
         :operatingsystemrelease => '6.0',
         :lsbdistid              => 'Debian',
         :lsbdistcodename        => 'squeeze'
       }
     end
 
     describe 'with no parameters' do
       it 'should work' do
         is_expected.to contain_class('postgresql::globals')
       end
     end
 
     describe 'manage_package_repo => true' do
       let(:params) do
         {
           manage_package_repo: true
         }
       end
       it 'should pull in class postgresql::repo' do
         is_expected.to contain_class('postgresql::repo')
       end
     end
   end
 
   context 'on redhat family systems' do
     let (:facts) do
       {
         osfamily: 'RedHat',
         operatingsystem: 'RedHat',
         operatingsystemrelease: '7.1'
       }
     end
     describe 'with no parameters' do
       it 'should work' do
         is_expected.to contain_class('postgresql::globals')
       end
     end
 
     describe 'manage_package_repo on RHEL => true' do
       let(:params) do
         {
           manage_package_repo: true,
           repo_proxy: 'http://proxy-server:8080'
         }
       end
 
       it 'should pull in class postgresql::repo' do
         is_expected.to contain_class('postgresql::repo')
       end
 
       it do
         should contain_yumrepo('yum.postgresql.org').with(
           'enabled' => '1',
           'proxy'   => 'http://proxy-server:8080'
           )
       end
     end
 
     describe 'repo_baseurl on RHEL => mirror.localrepo.com' do
       let(:params) do
         {
           manage_package_repo: true,
           repo_baseurl: 'http://mirror.localrepo.com'
         }
       end
 
       it 'should pull in class postgresql::repo' do
         is_expected.to contain_class('postgresql::repo')
       end
 
       it do
         should contain_yumrepo('yum.postgresql.org').with(
           'enabled' => '1',
           'baseurl' => 'http://mirror.localrepo.com'
         )
       end
     end
   end
 end
diff --git a/spec/unit/classes/repo_spec.rb b/spec/unit/classes/repo_spec.rb
index edfeda3..3942d65 100644
--- a/spec/unit/classes/repo_spec.rb
+++ b/spec/unit/classes/repo_spec.rb
@@ -1,26 +1,27 @@
 require 'spec_helper'
 
 describe 'postgresql::repo', :type => :class do
   let :facts do
     {
       :os => {
         :name                 => 'Debian',
         :family               => 'Debian',
         :release => {
-          :full               => '6.0'
+          :full               => '6.0',
+          :major              => '6'
         }
       },
       :osfamily               => 'Debian',
       :operatingsystem        => 'Debian',
       :operatingsystemrelease => '6.0',
       :lsbdistid              => 'Debian',
       :lsbdistcodename        => 'squeeze',
     }
   end
 
   describe 'with no parameters' do
     it 'should instantiate apt_postgresql_org class' do
       is_expected.to contain_class('postgresql::repo::apt_postgresql_org')
     end
   end
 end
diff --git a/spec/unit/classes/server_spec.rb b/spec/unit/classes/server_spec.rb
index c78e60e..18013d8 100644
--- a/spec/unit/classes/server_spec.rb
+++ b/spec/unit/classes/server_spec.rb
@@ -1,167 +1,168 @@
 require 'spec_helper'
 
 describe 'postgresql::server', :type => :class do
   let :facts do
     {
       :os => {
         :family  => 'Debian',
         :name => 'Debian',
         :release => {
-          :full => '6.0'
+          :full => '6.0',
+          :major => '6'
         }
       },
       :osfamily => 'Debian',
       :operatingsystem => 'Debian',
       :lsbdistid => 'Debian',
       :lsbdistcodename => 'jessie',
       :operatingsystemrelease => '8.0',
       :concat_basedir => tmpfilename('server'),
       :kernel => 'Linux',
       :id => 'root',
       :path => '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
     }
   end
 
   describe 'with no parameters' do
     it { is_expected.to contain_class("postgresql::params") }
     it { is_expected.to contain_class("postgresql::server") }
     it { is_expected.to contain_exec('postgresql_reload').with({
       'command' => 'service postgresql reload',
     })
     }
     it 'should validate connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'service_ensure => running' do
     let(:params) do
       {
         :service_ensure    => 'running',
         :postgres_password => 'new-p@s$word-to-set'
       }
     end
     it { is_expected.to contain_class("postgresql::params") }
     it { is_expected.to contain_class("postgresql::server") }
     it { is_expected.to contain_class("postgresql::server::passwd") }
     it 'should validate connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
     it 'should set postgres password' do
       is_expected.to contain_exec('set_postgres_postgrespw').with({
         'command'     => '/usr/bin/psql -c "ALTER ROLE \"postgres\" PASSWORD ${NEWPASSWD_ESCAPED}"',
         'user'        => 'postgres',
         'environment' => [
           "PGPASSWORD=new-p@s$word-to-set",
           "PGPORT=5432",
           "NEWPASSWD_ESCAPED=$$new-p@s$word-to-set$$"
         ],
         'unless'      => "/usr/bin/psql -h localhost -p 5432 -c 'select 1' > /dev/null",
       })
     end
   end
 
   describe 'service_ensure => stopped' do
     let(:params) {{ :service_ensure => 'stopped' }}
     it { is_expected.to contain_class("postgresql::params") }
     it { is_expected.to contain_class("postgresql::server") }
     it 'shouldnt validate connection' do
       is_expected.not_to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'service_restart_on_change => false' do
     let(:params) {{ :service_restart_on_change => false }}
     it { is_expected.to contain_class("postgresql::params") }
     it { is_expected.to contain_class("postgresql::server") }
     it { is_expected.to_not contain_Postgresql_conf('data_directory').that_notifies('Class[postgresql::server::service]')
     }
     it 'should validate connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'service_restart_on_change => true' do
     let(:params) {{ :service_restart_on_change => true }}
     it { is_expected.to contain_class("postgresql::params") }
     it { is_expected.to contain_class("postgresql::server") }
     it { is_expected.to contain_Postgresql_conf('data_directory').that_notifies('Class[postgresql::server::service]')
     }
     it 'should validate connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'service_reload => /bin/true' do
     let(:params) {{ :service_reload => '/bin/true' }}
     it { is_expected.to contain_class("postgresql::params") }
     it { is_expected.to contain_class("postgresql::server") }
     it { is_expected.to contain_exec('postgresql_reload').with({
       'command' => '/bin/true',
     })
     }
     it 'should validate connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'service_manage => true' do
     let(:params) {{ :service_manage => true }}
     it { is_expected.to contain_service('postgresqld') }
   end
 
   describe 'service_manage => false' do
     let(:params) {{ :service_manage => false }}
     it { is_expected.not_to contain_service('postgresqld') }
     it 'shouldnt validate connection' do
       is_expected.not_to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'package_ensure => absent' do
     let(:params) do
       {
         :package_ensure => 'absent',
       }
     end
 
     it 'should remove the package' do
       is_expected.to contain_package('postgresql-server').with({
         :ensure => 'purged',
       })
     end
 
     it 'should still enable the service' do
       is_expected.to contain_service('postgresqld').with({
         :ensure => 'running',
       })
     end
   end
 
   describe 'needs_initdb => true' do
     let(:params) do
       {
         :needs_initdb => true,
       }
     end
 
     it 'should contain proper initdb exec' do
       is_expected.to contain_exec('postgresql_initdb')
     end
   end
 
   describe 'postgresql_version' do
     let(:pre_condition) do
       <<-EOS
       class { 'postgresql::globals':
         manage_package_repo => true,
         version             => '99.5',
         before              => Class['postgresql::server'],
       }
       EOS
     end
     it 'contains the correct package version' do
       is_expected.to contain_class('postgresql::repo').with_version('99.5')
     end
   end
 end