diff --git a/AUTHORS b/AUTHORS
index 31110a6..e874317 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1,42 +1,44 @@
 Alan Jenkins <alan.christopher.jenkins@gmail.com>
 Alessandro Lorenzi <alessandro@lm-net.it>
 Alexander Schaber <alexander@schaber.info>
 Andrea Cervesato <andrea.cervesato@kqi.it>
 Andreas Ntaflos <andreas.ntaflos@rise-world.com>
 Andreas Paul <xorpaul@gmail.com>
 Ben Ford <ben.ford@puppetlabs.com>
 Benedikt Trefzer <benedikt.trefzer@cirrax.com>
 Benjamin Akhras <b@akhras.at>
 Blerim Sheqa <blerim.sheqa@icinga.com>
 David Raison <david@tentwentyfour.lu>
 Dirk Goetz <dirk.goetz@netways.de>
 Erez Zarum <erez@tracx.com>
 Ewoud Kohl van Wijngaarden <ewoud@kohlvanwijngaarden.nl>
+Fionera <fionera@fionera.de>
 Florian Baumann <flo@noqqe.de>
 Gunnar Beutner <gunnar.beutner@netways.de>
+Henry Pauli <henry@mixict.nl>
 James Fryman <james@fryman.io>
 Jan-Otto Kröpke <kroepke@outlook.com>
 Jerome Charaoui <jcharaoui@cmaisonneuve.qc.ca>
 Lennart Betz <lennart.betz@netways.de>
 Markus Frosch <markus.frosch@icinga.com>
 Matthias Baur <m.baur@syseleven.de>
 Matthias Ritter <matthias.ritter@dm.de>
 Michael Friedrich <michael.friedrich@icinga.com>
 Ott, Jörn WI (Fa. Allgeier Experts / Goetzfried) <Joern.Ott@schufa.de>
 Philipp Dallig <philipp.dallig@gmail.com>
-Rowan Ruseler <rruseler@eagleeyenetworks.com>
+Rowan Ruseler <rowanruseler@gmail.com>
 Rudy Gevaert <rudy.gevaert@ugent.be>
-Simon Hoenscheid <sh@example42.com>
+Simon Hoenscheid <code@simonhoenscheid.de>
 Stefan Kleindl <stefan.kleindl@rise-world.com>
 Thomas Dalichow <thomas.dalichow@publicispixelpark.de>
 Thomas Gelf <thomas@gelf.net>
 Thorsten Kahler <kahler@hrz.uni-marburg.de>
 Till Adam <till.adam@dm.de>
 Tim Meusel <tim@bastelfreak.de>
 Tom De Vylder <tom@penumbra.be>
 Tomas Barton <barton.tomas@gmail.com>
 Wyatt Alt <wyatt.alt@gmail.com>
 Zach Leslie <xaque208@gmail.com>
 jas01 <Through github>
 murmur <hristo.mohamed@gmail.com>
 paladox <paladox@users.noreply.github.com>
diff --git a/spec/defines/objects_spec.rb b/spec/defines/objects_spec.rb
index 30dc73a..5e292d1 100644
--- a/spec/defines/objects_spec.rb
+++ b/spec/defines/objects_spec.rb
@@ -1,228 +1,228 @@
 require 'spec_helper'
 
 facts = {
   :kernel   => 'Linux',
   :os => {:family => 'Debian', :name => 'Debian'},
   :osfamily => 'Debian' }
 
 
 describe('icinga2::object', :type => :define) do
   let(:title) do
     'foo'
   end
 
   let(:pre_condition) do
     [
       "class { 'icinga2': }"
     ]
   end
 
   before(:each) do
     # Fake assert_private function from stdlib to not fail within this test
     Puppet::Parser::Functions.newfunction(:assert_private, :type => :rvalue) { |args| }
   end
 
   on_supported_os.each do |os, complete_facts|
     let(:facts) do
       complete_facts
     end
 
     context "#{os} with object_type => 'foobar'" do
       let(:params) do
         {
           :object_type => 'foobar',
           :target      => '/bar/baz',
           :order       => '10'
         }
       end
 
       case facts[:osfamily]
       when 'Debian'
         before(:each) do
-          @icinga2_user = 'root'
+          @icinga2_user = 'nagios'
           @icinga2_group = 'nagios'
         end
       when 'Windows'
         before(:each) do
           @icinga2_user = null
           @icinga2_group = null
         end
       else
         before(:each) do
-          @icinga2_user = 'root'
+          @icinga2_user = 'icinga'
           @icinga2_group = 'icinga'
         end
       end
 
       it { is_expected.to contain_concat('/bar/baz')
         .with({
           'owner' => @icinga2_user,
           'group' => @icinga2_group
         }).that_notifies('Class[icinga2::service]') }
 
       it { is_expected.to contain_concat__fragment('foo')
         .with({
           'target' => '/bar/baz',
           'order'  => '10'
          }).with_content(/object foobar "foo" \{/) }
 
       it { should compile }
     end
   end
 
   let(:facts) do
     facts
   end
 
   context "with template => true" do
     let(:params) do
       {
         :template    => true,
         :object_type => 'foobar',
         :target      => '/bar/baz',
         :order       => '10'
       }
     end
 
     it { is_expected.to contain_concat__fragment('foo')
       .with_content(/template foobar "foo" \{/) }
   end
 
   context "with import => ['bar', 'baz']" do
     let(:params) do
       {
         :import      => ['bar', 'baz'],
         :object_type => 'foobar',
         :target      => '/bar/baz',
         :order       => '10'
       }
     end
 
     it { is_expected.to contain_concat__fragment('foo')
       .with_content(/import "bar"\n  import "baz"\n/) }
   end
 
   context "with apply_target => 'Service', object_type => 'Service' (same value)" do
     let(:params) do
       {
         :apply_target => 'Service',
         :object_type  => 'Service',
         :target       => '/bar/baz',
         :order        => '10'
       }
     end
 
     it { is_expected.to raise_error(Puppet::Error, /must be different/) }
   end
 
   context "with apply => true, apply_target => 'Host'" do
     let(:params) do
       {
         :apply        => true,
         :apply_target => 'Host',
         :object_type  => 'foobar',
         :target       =>  '/bar/baz',
         :order        => '10'
       }
     end
 
     it { is_expected.to contain_concat__fragment('foo')
       .with_content(/apply foobar \"foo\" to Host \{/) }
   end
 
   context "with apply => true, apply_target => 'Service'" do
     let(:params) do
       {
         :apply        => true,
         :apply_target => 'Service',
         :object_type  => 'foobar',
         :target       =>  '/bar/baz',
         :order        => '10'
       }
     end
 
     it { is_expected.to contain_concat__fragment('foo')
       .with_content(/apply foobar \"foo\" to Service \{/) }
   end
 
   context "with apply => 'item in array', prefix => true" do
     let(:params) do
       {
         :apply       => 'item in array',
         :prefix      => true,
         :object_type => 'foobar',
         :target      =>  '/bar/baz',
         :order       => '10'
       }
     end
 
     it { is_expected.to contain_concat__fragment('foo')
       .with_content(/apply foobar \"foo\" for \(item in array\) \{/) }
   end
 
   context "with apply => 'key => value in hash', prefix => 'some string'" do
     let(:params) do
       {
         :apply       => 'key => value in hash',
         :prefix      => 'some string',
         :object_type => 'foobar',
         :target      =>  '/bar/baz',
         :order       => '10'
       }
     end
 
     it { is_expected.to contain_concat__fragment('foo')
       .with_content(/apply foobar \"some string\" for \(key => value in hash\) \{/) }
   end
 end
 
 
 on_icinga_objects = {
   'ApiUser'             => 'icinga2::object::apiuser',
   'CheckCommand'        => 'icinga2::object::checkcommand',
   'Dependency'          => 'icinga2::object::dependency',
   'Endpoint'            => 'icinga2::object::endpoint',
   'EventCommand'        => 'icinga2::object::eventcommand',
   'Host'                => 'icinga2::object::host',
   'HostGroup'           => 'icinga2::object::hostgroup',
   'Notification'        => 'icinga2::object::notification',
   'NotificationCommand' => 'icinga2::object::notificationcommand',
   'ScheduledDowntime'   => 'icinga2::object::scheduleddowntime',
   'Service'             => 'icinga2::object::service',
   'ServiceGroup'        => 'icinga2::object::servicegroup',
   'TimePeriod'          => 'icinga2::object::timeperiod',
   'User'                => 'icinga2::object::user',
   'UserGroup'           => 'icinga2::object::usergroup',
   'Zone'                => 'icinga2::object::zone',
 }
 
 on_icinga_objects.each do |otype, rtype|
   describe(rtype, :type => :define) do
     let(:title) do
       'foo'
     end
 
     let(:pre_condition) do
       [
         "class { 'icinga2': }"
       ]
     end
 
     let(:facts) do
       facts
     end
 
     context "with all defaults" do
       let(:params) do
         {
           :target =>  '/bar/baz'
         }
       end
 
       it { is_expected.to contain_icinga2__object("icinga2::object::#{otype}::foo")
         .with_object_type(otype) }
 
       it { should compile }
     end
   end
 end