diff --git a/lib/puppet/type/postgresql_psql.rb b/lib/puppet/type/postgresql_psql.rb
index 2ae0797..8e04be4 100644
--- a/lib/puppet/type/postgresql_psql.rb
+++ b/lib/puppet/type/postgresql_psql.rb
@@ -1,159 +1,160 @@
 # frozen_string_literal: true
 
 Puppet::Type.newtype(:postgresql_psql) do
   newparam(:name) do
     desc 'An arbitrary tag for your own reference; the name of the message.'
     isnamevar
   end
 
   newproperty(:command) do
     desc 'The SQL command to execute via psql.'
 
     defaultto { @resource[:name] }
 
     # If needing to run the SQL command, return a fake value that will trigger
     # a sync, else return the expected SQL command so no sync takes place
     def retrieve
       if @resource.should_run_sql
         :notrun
       else
         should
       end
     end
 
     def sync
       output, status = provider.run_sql_command(value)
       raise("Error executing SQL; psql returned #{status}: '#{output}'") unless status == 0
     end
   end
 
   newparam(:unless) do
     desc <<-DOC
          An optional SQL command to execute prior to the main :command;
          this is generally intended to be used for idempotency, to check
          for the existence of an object in the database to determine whether
          or not the main SQL command needs to be executed at all.'
     DOC
 
     # Return true if a matching row is found
     def matches(value)
       output, status = provider.run_unless_sql_command(value)
       fail("Error evaluating 'unless' clause, returned #{status}: '#{output}'") unless status == 0 # rubocop:disable Style/SignalException
       # rubocop:enable Style/NumericPredicate
 
       result_count = output.strip.to_i
       debug("Found #{result_count} row(s) executing 'unless' clause")
       result_count > 0
     end
   end
 
   newparam(:onlyif) do
     desc <<-DOC
          An optional SQL command to execute prior to the main :command;
          this is generally intended to be used for idempotency, to check
          for the existence of an object in the database to determine whether
          or not the main SQL command needs to be executed at all.
     DOC
 
     # Return true if a matching row is found
     def matches(value)
       output, status = provider.run_unless_sql_command(value)
       status = output.exitcode if status.nil?
 
       raise("Error evaluating 'onlyif' clause, returned #{status}: '#{output}'") unless status == 0
       result_count = output.strip.to_i
       debug("Found #{result_count} row(s) executing 'onlyif' clause")
       result_count > 0
     end
   end
 
   newparam(:connect_settings) do
     desc 'Connection settings that will be used when connecting to postgres'
   end
 
   newparam(:db) do
     desc 'The name of the database to execute the SQL command against, this overrides any PGDATABASE value in connect_settings'
   end
 
   newparam(:port) do
     desc 'The port of the database server to execute the SQL command against, this overrides any PGPORT value in connect_settings.'
   end
 
   newparam(:search_path) do
     desc 'The schema search path to use when executing the SQL command'
   end
 
   newparam(:psql_path) do
     desc 'The path to psql executable.'
     defaultto('psql')
   end
 
   newparam(:psql_user) do
     desc 'The system user account under which the psql command should be executed.'
     defaultto('postgres')
   end
 
   newparam(:psql_group) do
     desc 'The system user group account under which the psql command should be executed.'
     defaultto('postgres')
   end
 
   newparam(:cwd, parent: Puppet::Parameter::Path) do
     desc 'The working directory under which the psql command should be executed.'
     defaultto('/tmp')
   end
 
   newparam(:environment) do
     desc "Any additional environment variables you want to set for a
       SQL command. Multiple environment variables should be
       specified as an array."
 
     validate do |values|
       Array(values).each do |value|
         unless %r{\w+=}.match?(value)
           raise ArgumentError, "Invalid environment setting '#{value}'"
         end
       end
     end
   end
 
   newparam(:refreshonly, boolean: true) do
     desc "If 'true', then the SQL will only be executed via a notify/subscribe event."
 
     defaultto(:false)
     newvalues(:true, :false)
   end
 
   newparam(:sensitive, boolean: true) do
     desc "If 'true', then the executed command will not be echoed into the log. Use this to protect sensitive information passing through."
 
     defaultto(:false)
     newvalues(:true, :false)
   end
 
-  autorequire(:class) { ['Postgresql::Server::Service'] }
+  autorequire(:anchor) { ['postgresql::server::service::begin'] }
+  autorequire(:service) { ['postgresqld'] }
 
   def should_run_sql(refreshing = false)
     onlyif_param = @parameters[:onlyif]
     unless_param = @parameters[:unless]
     return false if !onlyif_param.nil? && !onlyif_param.value.nil? && !onlyif_param.matches(onlyif_param.value)
     return false if !unless_param.nil? && !unless_param.value.nil? && unless_param.matches(unless_param.value)
     return false if !refreshing && @parameters[:refreshonly].value == :true
     true
   end
 
   def refresh
     property(:command).sync if should_run_sql(true)
   end
 
   private
 
   def set_sensitive_parameters(sensitive_parameters)
     # Respect sensitive commands
     if sensitive_parameters.include?(:unless)
       sensitive_parameters.delete(:unless)
       parameter(:unless).sensitive = true
     end
     super(sensitive_parameters)
   end
 end
diff --git a/spec/unit/defines/server/database_spec.rb b/spec/unit/defines/server/database_spec.rb
index f0984f7..3290dc7 100644
--- a/spec/unit/defines/server/database_spec.rb
+++ b/spec/unit/defines/server/database_spec.rb
@@ -1,83 +1,83 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
 
 describe 'postgresql::server::database', type: :define do
   let :facts do
     {
       os: {
         family: 'Debian',
         name: 'Debian',
         release: { 'full' => '8.0', 'major' => '8' },
       },
       kernel: 'Linux',
       id: 'root',
       path: '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
     }
   end
   let :title do
     'test'
   end
 
   let :pre_condition do
     "class {'postgresql::server':}"
   end
 
   it { is_expected.to contain_postgresql__server__database('test') }
-  it { is_expected.to contain_postgresql_psql('CREATE DATABASE "test"') }
+  it { is_expected.to contain_postgresql_psql('CREATE DATABASE "test"').that_requires('Service[postgresqld]') }
 
   context "with comment set to 'test comment'" do
     let(:params) { { comment: 'test comment' } }
 
     it { is_expected.to contain_postgresql_psql("COMMENT ON DATABASE \"test\" IS 'test comment'").with_connect_settings({}) }
   end
 
   context 'with specific db connection settings - default port' do
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     let(:params) do
       { connect_settings: { 'PGHOST' => 'postgres-db-server',
                             'DBVERSION' => '9.1' } }
     end
 
     it { is_expected.to contain_postgresql_psql('CREATE DATABASE "test"').with_connect_settings('PGHOST' => 'postgres-db-server', 'DBVERSION' => '9.1').with_port(5432) }
   end
 
   context 'with specific db connection settings - including port' do
     let :pre_condition do
       "class {'postgresql::globals':}
 
        class {'postgresql::server':}"
     end
 
     let(:params) do
       { connect_settings: { 'PGHOST' => 'postgres-db-server',
                             'DBVERSION' => '9.1',
                             'PGPORT'    => '1234' } }
     end
 
     it { is_expected.to contain_postgresql_psql('CREATE DATABASE "test"').with_connect_settings('PGHOST' => 'postgres-db-server', 'DBVERSION' => '9.1', 'PGPORT' => '1234').with_port(nil) }
   end
 
   context 'with global db connection settings - including port' do
     let :pre_condition do
       "class {'postgresql::globals':
            default_connect_settings => { 'PGHOST'    => 'postgres-db-server',
                                          'DBVERSION' => '9.2',
                                          'PGPORT'    => '1234' }
        }
 
        class {'postgresql::server':}"
     end
 
     it { is_expected.to contain_postgresql_psql('CREATE DATABASE "test"').with_connect_settings('PGHOST' => 'postgres-db-server', 'DBVERSION' => '9.2', 'PGPORT' => '1234').with_port(nil) }
   end
 
   context 'with different owner' do
     let(:params) { { owner: 'test_owner' } }
 
     it { is_expected.to contain_postgresql_psql('ALTER DATABASE "test" OWNER TO "test_owner"') }
   end
 end
diff --git a/spec/unit/defines/server/grant_spec.rb b/spec/unit/defines/server/grant_spec.rb
index fa61e48..e2d12d5 100644
--- a/spec/unit/defines/server/grant_spec.rb
+++ b/spec/unit/defines/server/grant_spec.rb
@@ -1,398 +1,398 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
 
 describe 'postgresql::server::grant', type: :define do
   let :facts do
     {
       os: {
         family: 'Debian',
         name: 'Debian',
         release: { 'full' => '8.0', 'major' => '8' },
       },
       kernel: 'Linux',
       id: 'root',
       path: '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
     }
   end
 
   let :title do
     'test'
   end
 
   context 'plain' do
     let :params do
       {
         db: 'test',
         role: 'test',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
   end
 
   context 'sequence' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'usage',
         object_type: 'sequence',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it do
       is_expected.to contain_postgresql_psql('grant:test')
         .with_command(%r{GRANT USAGE ON SEQUENCE "test" TO\s* "test"}m)
         .with_unless(%r{SELECT 1 WHERE has_sequence_privilege\('test',\s* 'test', 'USAGE'\)}m)
     end
   end
 
   context 'SeQuEnCe case insensitive object_type match' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'usage',
         object_type: 'SeQuEnCe',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it do
       is_expected.to contain_postgresql_psql('grant:test')
         .with_command(%r{GRANT USAGE ON SEQUENCE "test" TO\s* "test"}m)
         .with_unless(%r{SELECT 1 WHERE has_sequence_privilege\('test',\s* 'test', 'USAGE'\)}m)
     end
   end
 
   context 'all sequences' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'usage',
         object_type: 'all sequences in schema',
         object_name: 'public',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it do
       is_expected.to contain_postgresql_psql('grant:test')
         .with_command(%r{GRANT USAGE ON ALL SEQUENCES IN SCHEMA "public" TO\s* "test"}m)
         .with_unless(%r{SELECT 1 WHERE NOT EXISTS \(\s*SELECT sequence_name\s* FROM information_schema\.sequences\s* WHERE sequence_schema='public'\s* EXCEPT DISTINCT\s* SELECT object_name as sequence_name\s* FROM .* WHERE .*grantee='test'\s* AND object_schema='public'\s* AND privilege_type='USAGE'\s*\)}m) # rubocop:disable Layout/LineLength
     end
   end
 
   context 'with specific db connection settings - default port' do
     let :params do
       {
         db: 'test',
         role: 'test',
         connect_settings: { 'PGHOST' => 'postgres-db-server',
                             'DBVERSION' => '9.1' },
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it { is_expected.to contain_postgresql_psql('grant:test').with_connect_settings('PGHOST' => 'postgres-db-server', 'DBVERSION' => '9.1').with_port(5432) }
   end
 
   context 'with specific db connection settings - including port' do
     let :params do
       {
         db: 'test',
         role: 'test',
         connect_settings: { 'PGHOST' => 'postgres-db-server',
                             'DBVERSION' => '9.1',
                             'PGPORT'    => '1234' },
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it { is_expected.to contain_postgresql_psql('grant:test').with_connect_settings('PGHOST' => 'postgres-db-server', 'DBVERSION' => '9.1', 'PGPORT' => '1234') }
   end
 
   context 'with specific db connection settings - port overriden by explicit parameter' do
     let :params do
       {
         db: 'test',
         role: 'test',
         connect_settings: { 'PGHOST' => 'postgres-db-server',
                             'DBVERSION' => '9.1',
                             'PGPORT' => '1234' },
         port: 5678,
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it { is_expected.to contain_postgresql_psql('grant:test').with_connect_settings('PGHOST' => 'postgres-db-server', 'DBVERSION' => '9.1', 'PGPORT' => '1234').with_port('5678') }
   end
 
   context 'with specific schema name' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'all',
         object_name: ['myschema', 'mytable'],
         object_type: 'table',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it do
       is_expected.to contain_postgresql_psql('grant:test')
         .with_command(%r{GRANT ALL ON TABLE "myschema"."mytable" TO\s* "test"}m)
         .with_unless(%r{SELECT 1 WHERE has_table_privilege\('test',\s*'myschema.mytable', 'INSERT'\)}m)
     end
   end
 
   context 'with a role defined' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'all',
         object_name: ['myschema', 'mytable'],
         object_type: 'table',
       }
     end
 
     let :pre_condition do
       <<-EOS
       class {'postgresql::server':}
       postgresql::server::role { 'test': }
       EOS
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it { is_expected.to contain_postgresql__server__role('test') }
     it do
       is_expected.to contain_postgresql_psql('grant:test') \
-        .that_requires(['Class[postgresql::server::service]', 'Postgresql::Server::Role[test]'])
+        .that_requires(['Service[postgresqld]', 'Postgresql::Server::Role[test]'])
     end
   end
 
   context 'with a role defined to PUBLIC' do
     let :params do
       {
         db: 'test',
         role: 'PUBLIC',
         privilege: 'all',
         object_name: ['myschema', 'mytable'],
         object_type: 'table',
       }
     end
 
     let :pre_condition do
       <<-EOS
       class {'postgresql::server':}
       postgresql::server::role { 'test': }
       EOS
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it { is_expected.to contain_postgresql__server__role('test') }
     it do
       is_expected.to contain_postgresql_psql('grant:test')
         .with_command(%r{GRANT ALL ON TABLE "myschema"."mytable" TO\s* PUBLIC}m)
         .with_unless(%r{SELECT 1 WHERE has_table_privilege\('public',\s*'myschema.mytable', 'INSERT'\)}m)
     end
   end
 
   context 'function' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'execute',
         object_name: 'test',
         object_arguments: ['text', 'boolean'],
         object_type: 'function',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it do
       is_expected.to contain_postgresql_psql('grant:test')
         .with_command(%r{GRANT EXECUTE ON FUNCTION test\(text,boolean\) TO\s* "test"}m)
         .with_unless(%r{SELECT 1 WHERE has_function_privilege\('test',\s* 'test\(text,boolean\)', 'EXECUTE'\)}m)
     end
   end
 
   context 'function with schema' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'execute',
         object_name: ['myschema', 'test'],
         object_arguments: ['text', 'boolean'],
         object_type: 'function',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__grant('test') }
     it do
       is_expected.to contain_postgresql_psql('grant:test')
         .with_command(%r{GRANT EXECUTE ON FUNCTION myschema.test\(text,boolean\) TO\s* "test"}m)
         .with_unless(%r{SELECT 1 WHERE has_function_privilege\('test',\s* 'myschema.test\(text,boolean\)', 'EXECUTE'\)}m)
     end
   end
 
   context 'standalone not managing server' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'execute',
         object_name: ['myschema', 'test'],
         object_arguments: ['text', 'boolean'],
         object_type: 'function',
         group: 'postgresql',
         psql_path: '/usr/bin',
         psql_user: 'postgres',
         psql_db: 'db',
         port: 1542,
         connect_settings: {},
       }
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.not_to contain_class('postgresql::server') }
   end
 
   context 'invalid object_type' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'usage',
         object_type: 'invalid',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.and_raise_error(%r{parameter 'object_type' expects a match for Pattern}) }
   end
 
   context 'invalid object_name - wrong type' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'all',
         object_name: 1,
         object_type: 'table',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to compile.and_raise_error(%r{parameter 'object_name' expects a value of type (Array|Undef, Array,) or String, got Integer}) }
   end
 
   context 'invalid object_name - insufficent array elements' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'all',
         object_name: ['oops'],
         object_type: 'table',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     if Puppet::Util::Package.versioncmp(Puppet.version, '5.2.0') >= 0
       it { is_expected.to compile.and_raise_error(%r{parameter 'object_name' variant 1 expects size to be 2, got 1}) }
     else
       it { is_expected.to compile.and_raise_error(%r{parameter 'object_name' variant 0 expects size to be 2, got 1}) }
     end
   end
 
   context 'invalid object_name - too many array elements' do
     let :params do
       {
         db: 'test',
         role: 'test',
         privilege: 'all',
         object_name: ['myschema', 'mytable', 'oops'],
         object_type: 'table',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     if Puppet::Util::Package.versioncmp(Puppet.version, '5.2.0') >= 0
       it { is_expected.to compile.and_raise_error(%r{parameter 'object_name' variant 1 expects size to be 2, got 3}) }
     else
       it { is_expected.to compile.and_raise_error(%r{parameter 'object_name' variant 0 expects size to be 2, got 3}) }
     end
   end
 end
diff --git a/spec/unit/defines/server/reassign_owned_by_spec.rb b/spec/unit/defines/server/reassign_owned_by_spec.rb
index 62174a1..19ea8f1 100644
--- a/spec/unit/defines/server/reassign_owned_by_spec.rb
+++ b/spec/unit/defines/server/reassign_owned_by_spec.rb
@@ -1,47 +1,47 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
 
 describe 'postgresql::server::reassign_owned_by', type: :define do
   let :facts do
     {
       os: {
         family: 'Debian',
         name: 'Debian',
         release: { 'full' => '8.0', 'major' => '8' },
       },
       kernel: 'Linux',
       id: 'root',
       path: '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
     }
   end
 
   let :title do
     'test'
   end
 
   let :params do
     {
       db: 'test',
       old_role: 'test_old_role',
       new_role: 'test_new_role',
     }
   end
 
   let :pre_condition do
     <<-MANIFEST
       class {'postgresql::server':}
       postgresql::server::role{ ['test_old_role','test_new_role']: }
     MANIFEST
   end
 
   it { is_expected.to compile.with_all_deps }
   it { is_expected.to contain_postgresql__server__reassign_owned_by('test') }
 
   it {
     is_expected.to contain_postgresql_psql('reassign_owned_by:test:REASSIGN OWNED BY "test_old_role" TO "test_new_role"')
       .with_command('REASSIGN OWNED BY "test_old_role" TO "test_new_role"')
       .with_onlyif(%r{SELECT tablename FROM pg_catalog.pg_tables WHERE\s*schemaname NOT IN \('pg_catalog', 'information_schema'\) AND\s*tableowner = 'test_old_role'.*}m)
-      .that_requires('Class[Postgresql::Server::Service]')
+      .that_requires('Service[postgresqld]')
   }
 end
diff --git a/spec/unit/defines/server/role_spec.rb b/spec/unit/defines/server/role_spec.rb
index 5e3e005..7180ec2 100644
--- a/spec/unit/defines/server/role_spec.rb
+++ b/spec/unit/defines/server/role_spec.rb
@@ -1,178 +1,178 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
 
 describe 'postgresql::server::role', type: :define do
   let :facts do
     {
       os: {
         family: 'Debian',
         name: 'Debian',
         release: { 'full' => '8.0', 'major' => '8' },
       },
       kernel: 'Linux',
       id: 'root',
       path: '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
     }
   end
 
   let :title do
     'test'
   end
 
   let :params do
     {
       password_hash: 'new-pa$s',
     }
   end
 
   let :pre_condition do
     "class {'postgresql::server':}"
   end
 
   it { is_expected.to contain_postgresql__server__role('test') }
   it 'has create role for "test" user with password as ****' do
     is_expected.to contain_postgresql_psql('CREATE ROLE test ENCRYPTED PASSWORD ****')
       .with('command'     => 'Sensitive [value redacted]',
             'sensitive'   => 'true',
             'unless'      => "SELECT 1 FROM pg_roles WHERE rolname = 'test'",
             'port'        => '5432')
   end
   it 'has alter role for "test" user with password as ****' do
     is_expected.to contain_postgresql_psql('ALTER ROLE test ENCRYPTED PASSWORD ****')
       .with('command'     => 'Sensitive [value redacted]',
             'sensitive'   => 'true',
             'unless'      => 'Sensitive [value redacted]',
             'port'        => '5432')
   end
 
   context 'with specific db connection settings - default port' do
     let :params do
       {
         password_hash: 'new-pa$s',
         connect_settings: { 'PGHOST'     => 'postgres-db-server',
                             'DBVERSION'  => '9.1',
                             'PGUSER'     => 'login-user',
                             'PGPASSWORD' => 'login-pass' },
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to contain_postgresql__server__role('test') }
     it 'has create role for "test" user with password as ****' do
       is_expected.to contain_postgresql_psql('CREATE ROLE test ENCRYPTED PASSWORD ****')
         .with_command('Sensitive [value redacted]')
         .with_sensitive('true')
         .with_unless("SELECT 1 FROM pg_roles WHERE rolname = 'test'")
         .with_port(5432)
         .with_connect_settings('PGHOST' => 'postgres-db-server', 'DBVERSION' => '9.1', 'PGUSER' => 'login-user', 'PGPASSWORD' => 'login-pass')
-        .that_requires('Class[postgresql::server::service]')
+        .that_requires('Service[postgresqld]')
     end
     it 'has alter role for "test" user with password as ****' do
       is_expected.to contain_postgresql_psql('ALTER ROLE test ENCRYPTED PASSWORD ****')
         .with('command' => 'Sensitive [value redacted]', 'sensitive' => 'true',
               'unless'  => 'Sensitive [value redacted]', 'port' => '5432',
               'connect_settings' => { 'PGHOST' => 'postgres-db-server', 'DBVERSION' => '9.1',
                                       'PGUSER' => 'login-user', 'PGPASSWORD' => 'login-pass' })
     end
   end
 
   context 'with specific db connection settings - including port' do
     let :params do
       {
         password_hash: 'new-pa$s',
         connect_settings: { 'PGHOST' => 'postgres-db-server',
                             'DBVERSION'  => '9.1',
                             'PGPORT'     => '1234',
                             'PGUSER'     => 'login-user',
                             'PGPASSWORD' => 'login-pass' },
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it { is_expected.to contain_postgresql__server__role('test') }
     it 'has create role for "test" user with password as ****' do
       is_expected.to contain_postgresql_psql('CREATE ROLE test ENCRYPTED PASSWORD ****')
         .with('command'   => 'Sensitive [value redacted]',
               'sensitive' => 'true', 'unless' => "SELECT 1 FROM pg_roles WHERE rolname = 'test'",
               'connect_settings' => { 'PGHOST' => 'postgres-db-server', 'DBVERSION' => '9.1',
                                       'PGPORT' => '1234', 'PGUSER' => 'login-user', 'PGPASSWORD' => 'login-pass' })
     end
     it 'has alter role for "test" user with password as ****' do
       is_expected.to contain_postgresql_psql('ALTER ROLE test ENCRYPTED PASSWORD ****')
         .with('command' => 'Sensitive [value redacted]', 'sensitive' => 'true',
               'unless'  => 'Sensitive [value redacted]',
               'connect_settings' => { 'PGHOST' => 'postgres-db-server', 'DBVERSION' => '9.1',
                                       'PGPORT' => '1234', 'PGUSER' => 'login-user', 'PGPASSWORD' => 'login-pass' })
     end
   end
 
   context 'with update_password set to false' do
     let :params do
       {
         password_hash: 'new-pa$s',
         update_password: false,
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it 'does not have alter role for "test" user with password as **** if update_password is false' do
       is_expected.not_to contain_postgresql_psql('ALTER ROLE test ENCRYPTED PASSWORD ****')
     end
   end
 
   context 'with ensure set to absent' do
     let :params do
       {
         ensure: 'absent',
       }
     end
 
     let :pre_condition do
       "class {'postgresql::server':}"
     end
 
     it 'has drop role for "test" user if ensure absent' do
-      is_expected.to contain_postgresql_psql('DROP ROLE "test"').that_requires('Class[postgresql::server::service]')
+      is_expected.to contain_postgresql_psql('DROP ROLE "test"').that_requires('Service[postgresqld]')
     end
   end
 
   context 'without including postgresql::server' do
     it { is_expected.to compile }
     it { is_expected.to contain_postgresql__server__role('test') }
   end
 
   context 'standalone not managing server' do
     let :params do
       {
         password_hash: 'new-pa$s',
         connect_settings: { 'PGHOST' => 'postgres-db-server',
                             'DBVERSION'  => '9.1',
                             'PGPORT'     => '1234',
                             'PGUSER'     => 'login-user',
                             'PGPASSWORD' => 'login-pass' },
         psql_user: 'postgresql',
         psql_group: 'postgresql',
         psql_path: '/usr/bin',
         module_workdir: '/tmp',
         db: 'db',
       }
     end
 
     let :pre_condition do
       ''
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.not_to contain_class('postgresql::server') }
   end
 end
diff --git a/spec/unit/defines/server/tablespace_spec.rb b/spec/unit/defines/server/tablespace_spec.rb
index 6d7bc49..336a4f7 100644
--- a/spec/unit/defines/server/tablespace_spec.rb
+++ b/spec/unit/defines/server/tablespace_spec.rb
@@ -1,65 +1,65 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
 
 describe 'postgresql::server::tablespace', type: :define do
   let :facts do
     {
       os: {
         family: 'Debian',
         name: 'Debian',
         release: { 'full' => '8.0', 'major' => '8' },
       },
       kernel: 'Linux',
       id: 'root',
       path: '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
     }
   end
 
   let :title do
     'test'
   end
 
   let :params do
     {
       location: '/srv/data/foo',
     }
   end
 
   let :pre_condition do
     "class {'postgresql::server':}"
   end
 
   it { is_expected.to contain_file('/srv/data/foo').with_ensure('directory') }
   it { is_expected.to contain_postgresql__server__tablespace('test') }
-  it { is_expected.to contain_postgresql_psql('CREATE TABLESPACE "test"').that_requires('Class[postgresql::server::service]') }
+  it { is_expected.to contain_postgresql_psql('CREATE TABLESPACE "test"').that_requires('Service[postgresqld]') }
 
   context 'with different owner' do
     let :params do
       {
         location: '/srv/data/foo',
         owner: 'test_owner',
       }
     end
 
     it { is_expected.to contain_postgresql_psql('ALTER TABLESPACE "test" OWNER TO "test_owner"') }
   end
 
   context 'with manage_location set to false' do
     let :params do
       {
         location: '/srv/data/foo',
         manage_location: false,
       }
     end
 
     let :pre_condition do
       "
       class {'postgresql::server':}
       file {'/srv/data/foo': ensure => 'directory'}
       "
     end
 
     it { is_expected.to contain_file('/srv/data/foo').with_ensure('directory') }
   end
 end