freighthop 0.0.6 → 0.1.0

data/modules/postgresql/spec/system/server/role_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper_system'
+
+describe 'postgresql::server::role:' do
+  after :all do
+    # Cleanup after tests have ran
+    puppet_apply("class { 'postgresql::server': ensure => absent }") do |r|
+      r.exit_code.should_not == 1
+    end
+  end
+
+  it 'should idempotently create a user who can log in' do
+    pp = <<-EOS.unindent
+      $user = "postgresql_test_user"
+      $password = "postgresql_test_password"
+
+      class { 'postgresql::server': }
+
+      # Since we are not testing pg_hba or any of that, make a local user for ident auth
+      user { $user:
+        ensure => present,
+      }
+
+      postgresql::server::role { $user:
+        password_hash => postgresql_password($user, $password),
+      }
+    EOS
+
+    puppet_apply(pp) do |r|
+      r.exit_code.should_not == 1
+      r.refresh
+      r.exit_code.should == 0
+    end
+
+    # Check that the user can log in
+    psql('--command="select datname from pg_database" postgres', 'postgresql_test_user') do |r|
+      r.stdout.should =~ /template1/
+      r.stderr.should == ''
+      r.exit_code.should == 0
+    end
+  end
+
+  it 'should idempotently alter a user who can log in' do
+    pp = <<-EOS.unindent
+      $user = "postgresql_test_user"
+      $password = "postgresql_test_password2"
+
+      class { 'postgresql::server': }
+
+      # Since we are not testing pg_hba or any of that, make a local user for ident auth
+      user { $user:
+        ensure => present,
+      }
+
+      postgresql::server::role { $user:
+        password_hash => postgresql_password($user, $password),
+      }
+    EOS
+
+    puppet_apply(pp) do |r|
+      r.exit_code.should_not == 1
+      r.refresh
+      r.exit_code.should == 0
+    end
+
+    # Check that the user can log in
+    psql('--command="select datname from pg_database" postgres', 'postgresql_test_user') do |r|
+      r.stdout.should =~ /template1/
+      r.stderr.should == ''
+      r.exit_code.should == 0
+    end
+  end
+
+  it 'should idempotently create a user with a cleartext password' do
+    pp = <<-EOS.unindent
+      $user = "postgresql_test_user2"
+      $password = "postgresql_test_password2"
+
+      class { 'postgresql::server': }
+
+      # Since we are not testing pg_hba or any of that, make a local user for ident auth
+      user { $user:
+        ensure => present,
+      }
+
+      postgresql::server::role { $user:
+        password_hash => $password,
+      }
+    EOS
+
+    puppet_apply(pp) do |r|
+      r.exit_code.should_not == 1
+      r.refresh
+      r.exit_code.should == 0
+    end
+
+    # Check that the user can log in
+    psql('--command="select datname from pg_database" postgres', 'postgresql_test_user2') do |r|
+      r.stdout.should =~ /template1/
+      r.stderr.should == ''
+      r.exit_code.should == 0
+    end
+  end
+end

data/modules/postgresql/spec/system/server/table_grant_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper_system'
+
+describe 'postgresql::server::table_grant:' do
+  after :all do
+    # Cleanup after tests have ran
+    puppet_apply("class { 'postgresql::server': ensure => absent }") do |r|
+      r.exit_code.should_not == 1
+    end
+  end
+
+  it 'should grant access so a user can insert in a table' do
+    begin
+      pp = <<-EOS.unindent
+        $db = 'table_grant'
+        $user = 'psql_grant_tester'
+        $password = 'psql_table_pw'
+
+        class { 'postgresql::server': }
+
+        # Since we are not testing pg_hba or any of that, make a local user for ident auth
+        user { $user:
+          ensure => present,
+        }
+
+        postgresql::server::role { $user:
+          password_hash => postgresql_password($user, $password),
+        }
+
+        postgresql::server::database { $db: }
+
+        # Create a rule for the user
+        postgresql::server::pg_hba_rule { "allow ${user}":
+          type        => 'local',
+          database    => $db,
+          user        => $user,
+          auth_method => 'ident',
+          order       => 1,
+        }
+
+        postgresql_psql { 'Create testing table':
+          command => 'CREATE TABLE "test_table" (field integer NOT NULL)',
+          db      => $db,
+          unless  => "SELECT * FROM pg_tables WHERE tablename = 'test_table'",
+          require => Postgresql::Server::Database[$db],
+        }
+
+        postgresql::server::table_grant { 'grant insert test':
+          privilege => 'INSERT',
+          table     => 'test_table',
+          db        => $db,
+          role      => $user,
+          require   => Postgresql_psql['Create testing table'],
+        }
+      EOS
+
+      puppet_apply(pp) do |r|
+        r.exit_code.should_not == 1
+        r.refresh
+        r.exit_code.should == 0
+      end
+
+      ## Check that the user can create a table in the database
+      psql('--command="create table foo (foo int)" postgres', 'psql_grant_tester') do |r|
+        r.stdout.should =~ /CREATE TABLE/
+        r.stderr.should be_empty
+        r.exit_code.should == 0
+      end
+    ensure
+      psql('--command="drop table foo" postgres', 'psql_grant_tester')
+    end
+  end
+end

data/modules/postgresql/spec/system/server/tablespace_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper_system'
+
+describe 'postgresql::server::tablespace:' do
+  after :all do
+    # Cleanup after tests have ran
+    puppet_apply("class { 'postgresql::server': ensure => absent }") do |r|
+      r.exit_code.should_not == 1
+    end
+  end
+
+  it 'should idempotently create tablespaces and databases that are using them' do
+    pp = <<-EOS.unindent
+      class { 'postgresql::server': }
+
+      file { '/tmp/pg_tablespaces':
+        ensure => 'directory',
+        owner  => 'postgres',
+        group  => 'postgres',
+        mode   => '0700',
+      }~>
+      # This works around rubies that lack Selinux support, I'm looking at you RHEL5
+      exec { "chcon -u system_u -r object_r -t postgresql_db_t /tmp/pg_tablespaces":
+        refreshonly => true,
+        path        => "/bin:/usr/bin",
+        onlyif      => "which chcon",
+        before      => File["/tmp/pg_tablespaces/space1", "/tmp/pg_tablespaces/space2"]
+      }
+
+      postgresql::server::tablespace { 'tablespace1':
+        location => '/tmp/pg_tablespaces/space1',
+      }
+      postgresql::server::database { 'tablespacedb1':
+        encoding   => 'utf8',
+        tablespace => 'tablespace1',
+      }
+      postgresql::server::db { 'tablespacedb2':
+        user       => 'dbuser2',
+        password   => postgresql_password('dbuser2', 'dbuser2'),
+        tablespace => 'tablespace1',
+      }
+
+      postgresql::server::role { 'spcuser':
+        password_hash => postgresql_password('spcuser', 'spcuser'),
+      }
+      postgresql::server::tablespace { 'tablespace2':
+        location => '/tmp/pg_tablespaces/space2',
+        owner    => 'spcuser',
+      }
+      postgresql::server::database { 'tablespacedb3':
+        encoding   => 'utf8',
+        tablespace => 'tablespace2',
+      }
+    EOS
+
+    puppet_apply(pp) do |r|
+      r.exit_code.should_not == 1
+      r.refresh
+      r.exit_code.should == 0
+    end
+
+    # Check that databases use correct tablespaces
+    psql('--command="select ts.spcname from pg_database db, pg_tablespace ts where db.dattablespace = ts.oid and db.datname = \'"\'tablespacedb1\'"\'"') do |r|
+      r.stdout.should =~ /tablespace1/
+      r.stderr.should == ''
+      r.exit_code.should == 0
+    end
+
+    psql('--command="select ts.spcname from pg_database db, pg_tablespace ts where db.dattablespace = ts.oid and db.datname = \'"\'tablespacedb3\'"\'"') do |r|
+      r.stdout.should =~ /tablespace2/
+      r.stderr.should == ''
+      r.exit_code.should == 0
+    end
+  end
+end

data/modules/postgresql/spec/system/server_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper_system'
+
+describe 'server:' do
+  after :all do
+    # Cleanup after tests have ran
+    puppet_apply("class { 'postgresql::server': ensure => absent }") do |r|
+      r.exit_code.should_not == 1
+    end
+  end
+
+  it 'test loading class with no parameters' do
+    pp = <<-EOS.unindent
+      class { 'postgresql::server': }
+    EOS
+
+    puppet_apply(pp) do |r|
+      r.exit_code.should == 2
+      r.refresh
+      r.exit_code.should == 0
+    end
+  end
+
+  describe port(5432) do
+    it { should be_listening }
+  end
+
+  describe 'setting postgres password' do
+    it 'should install and successfully adjust the password' do
+      pp = <<-EOS.unindent
+        class { 'postgresql::server':
+          postgres_password          => 'foobarbaz',
+          ip_mask_deny_postgres_user => '0.0.0.0/32',
+        }
+      EOS
+
+      puppet_apply(pp) do |r|
+        [0,2].should include(r.exit_code)
+        r.stdout.should =~ /\[set_postgres_postgrespw\]\/returns: executed successfully/
+        r.refresh
+        r.exit_code.should == 0
+      end
+
+      pp = <<-EOS.unindent
+        class { 'postgresql::server':
+          postgres_password          => 'TPSR$$eports!',
+          ip_mask_deny_postgres_user => '0.0.0.0/32',
+        }
+      EOS
+
+      puppet_apply(pp) do |r|
+        [0,2].should include(r.exit_code)
+        r.stdout.should =~ /\[set_postgres_postgrespw\]\/returns: executed successfully/
+        r.refresh
+        r.exit_code.should == 0
+      end
+
+    end
+  end
+end
+
+describe 'server without defaults:' do
+  before :all do
+    puppet_apply(<<-EOS.unindent)
+      if($::operatingsystem =~ /Debian|Ubuntu/) {
+        # Need to make sure the correct utf8 locale is ready for our
+        # non-standard tests
+        file { '/etc/locale.gen':
+          content => "en_US ISO-8859-1\nen_NG UTF-8\nen_US UTF-8\n",
+        }~>
+        exec { '/usr/sbin/locale-gen':
+          logoutput => true,
+          refreshonly => true,
+        }
+      }
+    EOS
+  end
+
+  context 'test installing non-default version of postgresql' do
+    after :all do
+      psql('--command="drop database postgresql_test_db" postgres')
+      pp = <<-EOS.unindent
+        class { 'postgresql::globals':
+          ensure              => absent,
+          manage_package_repo => true,
+          version             => '9.3',
+        }
+        class { 'postgresql::server':
+          ensure => absent,
+        }
+      EOS
+      puppet_apply(pp) do |r|
+        r.exit_code.should_not == 1
+      end
+    end
+
+    it 'perform installation and create a db' do
+      pp = <<-EOS.unindent
+        class { "postgresql::globals":
+          version             => "9.3",
+          manage_package_repo => true,
+          encoding            => 'UTF8',
+          locale              => 'en_US.UTF-8',
+        }
+        class { "postgresql::server": }
+        postgresql::server::db { "postgresql_test_db":
+          user     => "foo1",
+          password => postgresql_password('foo1', 'foo1'),
+        }
+        postgresql::server::config_entry { 'port':
+          value => '5432',
+        }
+      EOS
+
+      puppet_apply(pp) do |r|
+        r.exit_code.should == 2
+        r.refresh
+        r.exit_code.should == 0
+      end
+
+      psql('postgresql_test_db --command="select datname from pg_database limit 1"') do |r|
+        r.exit_code.should == 0
+      end
+    end
+
+    describe port(5432) do
+      it { should be_listening }
+    end
+  end
+
+  unless ((node.facts['osfamily'] == 'RedHat' and node.facts['lsbmajdistrelease'] == '5') ||
+    node.facts['osfamily'] == 'Debian')
+
+    context 'override locale and encoding' do
+      after :each do
+        puppet_apply "class { 'postgresql::server': ensure => absent }" do |r|
+          r.exit_code.should_not == 1
+        end
+      end
+
+      it 'perform installation with different locale and encoding' do
+        pp = <<-EOS.unindent
+          class { 'postgresql::server':
+            locale   => 'en_NG',
+            encoding => 'UTF8',
+          }
+        EOS
+
+        puppet_apply(pp) do |r|
+          r.exit_code.should == 2
+          r.refresh
+          r.exit_code.should == 0
+        end
+
+        # Remove db first, if it exists for some reason
+        shell('su postgres -c "dropdb test1"')
+        shell('su postgres -c "createdb test1"')
+        shell('su postgres -c \'psql -c "show lc_ctype" test1\'') do |r|
+          r.stdout.should =~ /en_NG/
+        end
+
+        shell('su postgres -c \'psql -c "show lc_collate" test1\'') do |r|
+          r.stdout.should =~ /en_NG/
+        end
+      end
+    end
+  end
+end
+
+describe 'server with firewall:' do
+  after :all do
+    puppet_apply("class { 'postgresql::server': ensure => absent }") do |r|
+      r.exit_code.should_not == 1
+    end
+  end
+
+  context 'test installing postgresql with firewall management on' do
+    it 'perform installation and make sure it is idempotent' do
+      pending('no support for firewall with fedora', :if => (node.facts['operatingsystem'] == 'Fedora'))
+      pp = <<-EOS.unindent
+        class { 'firewall': }
+        class { "postgresql::server":
+          manage_firewall => true,
+        }
+      EOS
+
+      puppet_apply(pp) do |r|
+        r.exit_code.should == 2
+        r.refresh
+        r.exit_code.should == 0
+      end
+    end
+  end
+end
+
+describe 'server without pg_hba.conf:' do
+  after :all do
+    puppet_apply("class { 'postgresql::server': ensure => absent }") do |r|
+      r.exit_code.should_not == 1
+    end
+  end
+
+  context 'test installing postgresql without pg_hba.conf management on' do
+    it 'perform installation and make sure it is idempotent' do
+      pp = <<-EOS.unindent
+        class { "postgresql::server":
+          manage_pg_hba_conf => false,
+        }
+      EOS
+
+      puppet_apply(pp) do |r|
+        r.exit_code.should == 2
+        r.refresh
+        r.exit_code.should == 0
+      end
+    end
+  end
+end

data/modules/postgresql/spec/system/validate_db_connection_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper_system'
+
+describe 'postgresql::validate_db_connection:' do
+  before :all do
+    # Setup postgresql server and a sample database for tests to use.
+    pp = <<-EOS.unindent
+      $db = 'foo'
+      class { 'postgresql::server': }
+
+      postgresql::server::db { $db:
+        user     => $db,
+        password => postgresql_password($db, $db),
+      }
+    EOS
+
+    puppet_apply(pp) do |r|
+      r.exit_code.should_not == 1
+    end
+  end
+
+  after :all do
+    # Remove postgresql server after all tests have ran.
+    puppet_apply("class { 'postgresql::server': ensure => absent }") do |r|
+      r.exit_code.should_not == 1
+    end
+  end
+
+  it 'should run puppet with no changes declared if socket connectivity works' do
+    pp = <<-EOS.unindent
+      postgresql::validate_db_connection { 'foo':
+        database_name => 'foo',
+        run_as        => 'postgres',
+      }
+    EOS
+
+    puppet_apply(pp) do |r|
+      r.exit_code.should == 0
+    end
+  end
+
+  it 'should keep retrying if database is down' do
+    # So first we shut the db down, then background a startup routine with a
+    # sleep 10 in front of it. That way rspec-system should continue while
+    # the pause and db startup happens in the background.
+    shell("/etc/init.d/postgresql* stop")
+    shell('nohup bash -c "sleep 10; /etc/init.d/postgresql* start" > /dev/null 2>&1 &')
+
+    pp = <<-EOS.unindent
+      postgresql::validate_db_connection { 'foo':
+        database_name => 'foo',
+        tries         => 30,
+        sleep         => 1,
+        run_as        => 'postgres',
+      }
+    EOS
+
+    puppet_apply(pp) do |r|
+      r.exit_code.should == 0
+    end
+  end
+
+  it 'should run puppet with no changes declared if db ip connectivity works' do
+    pp = <<-EOS.unindent
+      postgresql::validate_db_connection { 'foo':
+        database_host     => 'localhost',
+        database_name     => 'foo',
+        database_username => 'foo',
+        database_password => 'foo',
+      }
+    EOS
+
+    puppet_apply(pp) do |r|
+      r.exit_code.should == 0
+    end
+  end
+
+  it 'should fail catalogue if database connectivity fails' do
+    pp = <<-EOS.unindent
+      postgresql::validate_db_connection { 'foobarbaz':
+        database_host     => 'localhost',
+        database_name     => 'foobarbaz',
+        database_username => 'foobarbaz',
+        database_password => 'foobarbaz',
+      }
+    EOS
+
+    puppet_apply(pp) do |r|
+      r.exit_code.should == 4
+    end
+  end
+end

data/modules/postgresql/spec/unit/classes/client_spec.rb

@@ -3,9 +3,34 @@ require 'spec_helper'
 describe 'postgresql::client', :type => :class do
   let :facts do
     {
-      :postgres_default_version => '8.4',
       :osfamily => 'Debian',
+      :operatingsystem => 'Debian',
+      :operatingsystemrelease => '6.0',
     }
   end
-  it { should include_class("postgresql::client") }
+
+  describe 'with parameters' do
+    let :params do
+      {
+        :package_ensure => 'absent',
+        :package_name => 'mypackage',
+      }
+    end
+
+    it 'should modify package' do
+      should contain_package("postgresql-client").with({
+        :ensure => 'absent',
+        :name => 'mypackage',
+        :tag => 'postgresql',
+      })
+    end
+  end
+
+  describe 'with no parameters' do
+    it 'should create package with postgresql tag' do
+      should contain_package('postgresql-client').with({
+        :tag => 'postgresql',
+      })
+    end
+  end
 end

data/modules/postgresql/spec/unit/classes/globals_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'postgresql::globals', :type => :class do
+  let :facts do
+    {
+      :osfamily => 'Debian',
+      :operatingsystem => 'Debian',
+      :operatingsystemrelease => '6.0',
+    }
+  end
+
+  describe 'with no parameters' do
+    it 'should work' do
+      should include_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
+      should include_class("postgresql::repo")
+    end
+  end
+end

data/modules/postgresql/spec/unit/classes/lib/devel_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'postgresql::lib::devel', :type => :class do
+  let :facts do
+    {
+      :osfamily => 'Debian',
+      :operatingsystem => 'Debian',
+      :operatingsystemrelease => '6.0',
+    }
+  end
+  it { should include_class("postgresql::lib::devel") }
+end

data/modules/postgresql/spec/unit/classes/{postgresql_java_spec.rb → lib/java_spec.rb}

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
-describe 'postgresql::java', :type => :class do
+describe 'postgresql::lib::java', :type => :class do
 
   describe 'on a debian based os' do
     let :facts do {
-      :osfamily                 => 'Debian',
-      :postgres_default_version => 'foo',
+      :osfamily => 'Debian',
+      :operatingsystem => 'Debian',
+      :operatingsystemrelease => '6.0',
     }
     end
     it { should contain_package('postgresql-jdbc').with(
@@ -16,12 +17,13 @@ describe 'postgresql::java', :type => :class do
 
   describe 'on a redhat based os' do
     let :facts do {
-      :osfamily                 => 'RedHat',
-      :postgres_default_version => 'foo',
+      :osfamily => 'RedHat',
+      :operatingsystem => 'RedHat',
+      :operatingsystemrelease => '6.4',
     }
     end
     it { should contain_package('postgresql-jdbc').with(
-      :name   => 'postgresql-jdbc',
+      :name => 'postgresql-jdbc',
       :ensure => 'present'
     )}
     describe 'when parameters are supplied' do
@@ -29,22 +31,10 @@ describe 'postgresql::java', :type => :class do
         {:package_ensure => 'latest', :package_name => 'somepackage'}
       end
       it { should contain_package('postgresql-jdbc').with(
-        :name   => 'somepackage',
+        :name => 'somepackage',
         :ensure => 'latest'
       )}
     end
   end
 
-  describe 'on any other os' do
-    let :facts do {
-      :osfamily                 => 'foo',
-      :postgres_default_version => 'foo',
-    }
-    end
-
-    it 'should fail without all the necessary parameters' do
-      expect { subject }.to raise_error(/Module postgresql does not provide defaults for osfamily: foo/)
-    end
-  end
-
 end