3rdparty/modules/postgresql/spec/acceptance/server/grant_role_spec.rb

   1 require 'spec_helper_acceptance'
   2
   3 describe 'postgresql::server::grant_role:', :unless => UNSUPPORTED_PLATFORMS.include?(fact('osfamily')) do
   4
   5   let(:db) { 'grant_role_test' }
   6   let(:user) { 'psql_grant_role_tester' }
   7   let(:group) { 'test_group' }
   8   let(:password) { 'psql_grant_role_pw' }
   9   let(:version) do
  10     if fact('osfamily') == 'RedHat' and fact('operatingsystemrelease') =~ /5/
  11       '8.1'
  12     end
  13   end
  14
  15   it 'should grant a role to a user' do
  16     begin
  17       pp = <<-EOS.unindent
  18         $db = #{db}
  19         $user = #{user}
  20         $group = #{group}
  21         $password = #{password}
  22         $version = '#{version}'
  23
  24         class { 'postgresql::server': }
  25
  26         # Since we are not testing pg_hba or any of that, make a local user for ident auth
  27         user { $user:
  28           ensure => present,
  29         }
  30
  31         postgresql::server::role { $user:
  32           password_hash => postgresql_password($user, $password),
  33         }
  34
  35         postgresql::server::database { $db:
  36           owner   => $user,
  37           require => Postgresql::Server::Role[$user],
  38         }
  39
  40         # Lets setup the base rules
  41         $local_auth_option = $version ? {
  42           '8.1'   => 'sameuser',
  43           default => undef,
  44         }
  45
  46         # Create a rule for the user
  47         postgresql::server::pg_hba_rule { "allow ${user}":
  48           type        => 'local',
  49           database    => $db,
  50           user        => $user,
  51           auth_method => 'ident',
  52           auth_option => $local_auth_option,
  53           order       => 1,
  54         }
  55
  56         # Create a role to grant to the user
  57         postgresql::server::role { $group:
  58           db      => $db,
  59           login   => false,
  60           require => Postgresql::Server::Database[$db],
  61         }
  62
  63         # Grant the role to the user
  64         postgresql::server::grant_role { "grant_role ${group} to ${user}":
  65           role  => $user,
  66           group => $group,
  67         }
  68       EOS
  69
  70       apply_manifest(pp, :catch_failures => true)
  71       apply_manifest(pp, :catch_changes => true)
  72
  73       ## Check that the role was granted to the user
  74       psql('--command="SELECT 1 WHERE pg_has_role(\'psql_grant_role_tester\', \'test_group\', \'MEMBER\') = true" grant_role_test', 'psql_grant_role_tester') do |r|
  75         expect(r.stdout).to match(/\(1 row\)/)
  76         expect(r.stderr).to eq('')
  77       end
  78     end
  79   end
  80
  81   it 'should grant a role to a superuser' do
  82     begin
  83       pp = <<-EOS.unindent
  84         $db = "#{db}"
  85         $user = "#{user}"
  86         $group = "#{group}"
  87         $password = #{password}
  88         $version = '#{version}'
  89
  90         class { 'postgresql::server': }
  91
  92         # Since we are not testing pg_hba or any of that, make a local user for ident auth
  93         user { $user:
  94           ensure => present,
  95         }
  96
  97         postgresql::server::role { $user:
  98           password_hash => postgresql_password($user, $password),
  99           superuser     => true,
 100         }
 101
 102         postgresql::server::database { $db:
 103           owner   => $user,
 104           require => Postgresql::Server::Role[$user],
 105         }
 106
 107         # Lets setup the base rules
 108         $local_auth_option = $version ? {
 109           '8.1'   => 'sameuser',
 110           default => undef,
 111         }
 112
 113         # Create a rule for the user
 114         postgresql::server::pg_hba_rule { "allow ${user}":
 115           type        => 'local',
 116           database    => $db,
 117           user        => $user,
 118           auth_method => 'ident',
 119           auth_option => $local_auth_option,
 120           order       => 1,
 121         }
 122
 123         # Create a role to grant to the user
 124         postgresql::server::role { $group:
 125           db      => $db,
 126           login   => false,
 127           require => Postgresql::Server::Database[$db],
 128         }
 129
 130         # Grant the role to the user
 131         postgresql::server::grant_role { "grant_role ${group} to ${user}":
 132           role  => $user,
 133           group => $group,
 134         }
 135       EOS
 136
 137       apply_manifest(pp, :catch_failures => true)
 138       apply_manifest(pp, :catch_changes => true)
 139
 140       ## Check that the role was granted to the user
 141       psql('--command="SELECT 1 FROM pg_roles AS r_role JOIN pg_auth_members AS am ON r_role.oid = am.member JOIN pg_roles AS r_group ON r_group.oid = am.roleid WHERE r_group.rolname = \'test_group\' AND r_role.rolname = \'psql_grant_role_tester\'" grant_role_test', 'psql_grant_role_tester') do |r|
 142         expect(r.stdout).to match(/\(1 row\)/)
 143         expect(r.stderr).to eq('')
 144       end
 145     end
 146   end
 147
 148   it 'should revoke a role from a user' do
 149     begin
 150       pp = <<-EOS
 151
 152         $db = "#{db}"
 153         $user = "#{user}"
 154         $group = "#{group}"
 155         $password = #{password}
 156         $version = '#{version}'
 157
 158         class { 'postgresql::server': }
 159
 160         # Since we are not testing pg_hba or any of that, make a local user for ident auth
 161         user { $user:
 162           ensure => present,
 163         }
 164
 165         postgresql::server::role { $user:
 166           password_hash => postgresql_password($user, $password),
 167         }
 168
 169         postgresql::server::database { $db:
 170           owner   => $user,
 171           require => Postgresql::Server::Role[$user],
 172         }
 173
 174         # Lets setup the base rules
 175         $local_auth_option = $version ? {
 176           '8.1'   => 'sameuser',
 177           default => undef,
 178         }
 179
 180         # Create a rule for the user
 181         postgresql::server::pg_hba_rule { "allow ${user}":
 182           type        => 'local',
 183           database    => $db,
 184           user        => $user,
 185           auth_method => 'ident',
 186           auth_option => $local_auth_option,
 187           order       => 1,
 188         }
 189
 190         # Create a role to grant to the user
 191         postgresql::server::role { $group:
 192           db      => $db,
 193           login   => false,
 194           require => Postgresql::Server::Database[$db],
 195         }
 196
 197         # Grant the role to the user
 198         postgresql::server::grant_role { "grant_role ${group} to ${user}":
 199           role  => $user,
 200           group => $group,
 201         }
 202
 203         postgresql::server::grant_role {"revoke ${group} from ${user}":
 204           ensure => absent,
 205           role   => $user,
 206           group  => $group,
 207         }
 208       EOS
 209       apply_manifest(pp, :catch_failures => true)
 210       apply_manifest(pp, :expect_changes => true)
 211
 212       psql('--command="SELECT 1 WHERE pg_has_role(\'psql_grant_role_tester\', \'test_group\', \'MEMBER\') = true" grant_role_test', 'psql_grant_role_tester') do |r|
 213         expect(r.stdout).to match(/\(0 rows\)/)
 214         expect(r.stderr).to eq('')
 215       end
 216     end
 217   end
 218
 219   it 'should not grant permission to a nonexistent user' do
 220      begin
 221        pp = <<-EOS
 222
 223          $db = "#{db}"
 224          $user = "#{user}"
 225          $group = "#{group}"
 226          $password = #{password}
 227
 228          class { 'postgresql::server': }
 229
 230          # Since we are not testing pg_hba or any of that, make a local user for ident auth
 231            user { $user:
 232            ensure => absent,
 233          }
 234
 235          postgresql::server::database { $db:
 236          }
 237
 238          # Create a role to grant to the nonexistent user
 239          postgresql::server::role { $group:
 240            db      => $db,
 241            login   => false,
 242            require => Postgresql::Server::Database[$db],
 243          }
 244
 245          # Grant the role to the nonexistent user
 246          postgresql::server::grant_role { "grant_role ${group} to ${user}":
 247            role  => $user
 248            group => $group,
 249          }
 250        EOS
 251        apply_manifest(pp, :expect_failures => true)
 252
 253        psql('--command="SELECT 1 WHERE pg_has_role(\'psql_grant_role_tester\', \'test_group\', \'MEMBER\') = true" grant_role_test', 'psql_grant_role_tester') do |r|
 254          expect(r.stdout).to match(/\(0 rows\)/)
 255          expect(r.stderr).to eq('')
 256        end
 257      end
 258    end
 259 end