diff --git a/manifests/run.pp b/manifests/run.pp
index 7c6408d..6ab40ae 100644
--- a/manifests/run.pp
+++ b/manifests/run.pp
@@ -1,693 +1,693 @@
 # @summary
 #   A define which manages a running docker container.
 #
 # @param restart
 # Sets a restart policy on the docker run.
 # Note: If set, puppet will NOT setup an init script to manage, instead
 # it will do a raw docker run command using a CID file to track the container
 # ID.
 #
 # If you want a normal named container with an init script and a restart policy
 # you must use the extra_parameters feature and pass it in like this:
 #
 #    extra_parameters => ['--restart=always']
 #
 # However, if your system is using sytemd this restart policy will be
 # ineffective because the ExecStop commands will run which will cause
 # docker to stop restarting it.  In this case you should use the
 # systemd_restart option to specify the policy you want.
 #
 # This will allow the docker container to be restarted if it dies, without
 # puppet help.
 #
 # @param verify_digest
 #   (optional) Make sure, that the image has not modified. Compares the digest 
 #   checksum before starting the docker image.
 #   To get the digest of an image, run the following command: 
 #     docker image inspect <<image>> --format='{{index .RepoDigests 0}}
 #
 # @param service_prefix
 #   (optional) The name to prefix the startup script with and the Puppet
 #   service resource title with.  Default: 'docker-'
 #
 # @param restart_service
 #   (optional) Whether or not to restart the service if the the generated init
 #   script changes.  Default: true
 #
 # @param restart_service_on_docker_refresh
 #   Whether or not to restart the service if the docker service is restarted.
 #   Only has effect if the docker_service parameter is set.
 #   Default: true
 #
 # @param manage_service
 #  (optional) Whether or not to create a puppet Service resource for the init
 #  script.  Disabling this may be useful if integrating with existing modules.
 #  Default: true
 #
 # @param docker_service
 #  (optional) If (and how) the Docker service itself is managed by Puppet
 #  true          -> Service['docker']
 #  false         -> no Service dependency
 #  anything else -> Service[docker_service]
 #  Default: false
 #
 # @param health_check_cmd
 # (optional) Specifies the command to execute to check that the container is healthy using the docker health check functionality.
 # Default: undef
 #
 # @param health_check_interval
 # (optional) Specifies the interval that the health check command will execute in seconds.
 # Default: undef
 #
 # @param restart_on_unhealthy
 # (optional) Checks the health status of Docker container and if it is unhealthy the service will be restarted.
 # The health_check_cmd parameter must be set to true to use this functionality.
 # Default: undef
 #
 # @param net
 #
 # The docker network to attach to a container.
 # Can be a String or Array (if using multiple networks)
 # Default: bridge
 #
 # @param extra_parameters
 # An array of additional command line arguments to pass to the `docker run`
 # command. Useful for adding additional new or experimental options that the
 # module does not yet support.
 #
 # @param systemd_restart
 # (optional) If the container is to be managed by a systemd unit file set the
 # Restart option on the unit file.  Can be any valid value for this systemd
 # configuration.  Most commonly used are on-failure or always.
 # Default: on-failure
 #
 # @param custom_unless
 # (optional) Specify an additional unless for the Docker run command when using restart.
 # Default: undef
 #
 # @param after_create
 # (optional) Specifies the command to execute after container is created but before it is started.
 # Default: undef
 #
 # @param remain_after_exit
 # (optional) If the container is to be managed by a systemd unit file set the
 # RemainAfterExit option on the unit file.  Can be any valid value for this systemd
 # configuration.
 # Default: Not included in unit file
 #
 # @param prepare_service_only
 # (optional) Prepare the service and enable it as usual but do not run it right away.
 # Useful when building VM images using masterless Puppet and then letting the Docker images
 # to be downloaded when a new VM is created.
 # Default: false
 #
 # @param image
 #
 # @param ensure
 #
 # @param command
 #
 # @param memory_limit
 #
 # @param cpuset
 #
 # @param ports
 #
 # @param labels
 #
 # @param expose
 #
 # @param volumes
 #
 # @param links
 #
 # @param use_name
 #
 # @param running
 #
 # @param volumes_from
 #
 # @param username
 #
 # @param hostname
 #
 # @param env
 #
 # @param env_file
 #
 # @param dns
 #
 # @param dns_search
 #
 # @param lxc_conf
 #
 # @param service_provider
 #
 # @param disable_network
 #
 # @param privileged
 #
 # @param detach
 #
 # @param extra_systemd_parameters
 #
 # @param pull_on_start
 #
 # @param after
 #
 # @param after_service
 #
 # @param depends
 #
 # @param depend_services
 #
 # @param tty
 #
 # @param socket_connect
 #
 # @param hostentries
 #
 # @param before_start
 #
 # @param before_stop
 #
 # @param after_start
 #
 # @param after_stop
 #
 # @param remove_container_on_start
 #
 # @param remove_container_on_stop
 #
 # @param remove_volume_on_start
 #
 # @param remove_volume_on_stop
 #
 # @param stop_wait_time
 #
 # @param syslog_identifier
 #
 # @param syslog_facility
 #
 # @param read_only
 #
 define docker::run(
   Optional[Pattern[/^[\S]*$/]]            $image,
   Optional[Enum[present,absent]]          $ensure                            = 'present',
   Optional[String]                        $verify_digest                     = undef,
   Optional[String]                        $command                           = undef,
   Optional[Pattern[/^[\d]*(b|k|m|g)$/]]   $memory_limit                      = '0b',
   Variant[String,Array,Undef]             $cpuset                            = [],
   Variant[String,Array,Undef]             $ports                             = [],
   Variant[String,Array,Undef]             $labels                            = [],
   Variant[String,Array,Undef]             $expose                            = [],
   Variant[String,Array,Undef]             $volumes                           = [],
   Variant[String,Array,Undef]             $links                             = [],
   Optional[Boolean]                       $use_name                          = false,
   Optional[Boolean]                       $running                           = true,
   Optional[Variant[String,Array]]         $volumes_from                      = [],
   Variant[String,Array,Undef]             $net                               = undef,
   Variant[String,Boolean]                 $username                          = false,
   Variant[String,Boolean]                 $hostname                          = false,
   Optional[Variant[String,Array]]         $env                               = [],
   Optional[Variant[String,Array]]         $env_file                          = [],
   Optional[Variant[String,Array]]         $dns                               = [],
   Optional[Variant[String,Array]]         $dns_search                        = [],
   Optional[Variant[String,Array]]         $lxc_conf                          = [],
   Optional[String]                        $service_prefix                    = 'docker-',
   Optional[String]                        $service_provider                  = undef,
   Optional[Boolean]                       $restart_service                   = true,
   Optional[Boolean]                       $restart_service_on_docker_refresh = true,
   Optional[Boolean]                       $manage_service                    = true,
   Variant[String,Boolean]                 $docker_service                    = false,
   Optional[Boolean]                       $disable_network                   = false,
   Optional[Boolean]                       $privileged                        = false,
   Optional[Boolean]                       $detach                            = undef,
   Optional[Variant[String,Array[String]]] $extra_parameters                  = undef,
   Optional[String]                        $systemd_restart                   = 'on-failure',
   Optional[Variant[String,Hash]]          $extra_systemd_parameters          = {},
   Optional[Boolean]                       $pull_on_start                     = false,
   Optional[Variant[String,Array]]         $after                             = [],
   Optional[Variant[String,Array]]         $after_service                     = [],
   Optional[Variant[String,Array]]         $depends                           = [],
   Optional[Variant[String,Array]]         $depend_services                   = ['docker.service'],
   Optional[Boolean]                       $tty                               = false,
   Optional[Variant[String,Array]]         $socket_connect                    = [],
   Optional[Variant[String,Array]]         $hostentries                       = [],
   Optional[String]                        $restart                           = undef,
   Variant[String,Boolean]                 $before_start                      = false,
   Variant[String,Boolean]                 $before_stop                       = false,
   Variant[String,Boolean]                 $after_start                       = false,
   Variant[String,Boolean]                 $after_stop                        = false,
   Optional[String]                        $after_create                      = undef,
   Optional[Boolean]                       $remove_container_on_start         = true,
   Optional[Boolean]                       $remove_container_on_stop          = true,
   Optional[Boolean]                       $remove_volume_on_start            = false,
   Optional[Boolean]                       $remove_volume_on_stop             = false,
   Optional[Integer]                       $stop_wait_time                    = 0,
   Optional[String]                        $syslog_identifier                 = undef,
   Optional[String]                        $syslog_facility                   = undef,
   Optional[Boolean]                       $read_only                         = false,
   Optional[String]                        $health_check_cmd                  = undef,
   Optional[Boolean]                       $restart_on_unhealthy              = false,
   Optional[Integer]                       $health_check_interval             = undef,
   Optional[Variant[String,Array]]         $custom_unless                     = [],
   Optional[String]                        $remain_after_exit                 = undef,
   Optional[Boolean]                       $prepare_service_only              = false,
 ) {
   include docker::params
 
   if ($socket_connect != []) {
     $sockopts = join(any2array($socket_connect), ',')
     $docker_command = "${docker::params::docker_command} -H ${sockopts}"
   } else {
     $docker_command = $docker::params::docker_command
   }
 
   $service_name = $docker::service_name
   $docker_group = $docker::docker_group
 
   if $restart {
     assert_type(Pattern[/^(no|always|unless-stopped|on-failure)|^on-failure:[\d]+$/], $restart)
   }
 
   if ($remove_volume_on_start and !$remove_container_on_start) {
     fail("In order to remove the volume on start for ${title} you need to also remove the container")
   }
 
   if ($remove_volume_on_stop and !$remove_container_on_stop) {
     fail("In order to remove the volume on stop for ${title} you need to also remove the container")
   }
 
   if $use_name {
     notify { "docker use_name warning: ${title}":
       message  => 'The use_name parameter is no-longer required and will be removed in a future release',
       withpath => true,
     }
   }
 
   if $systemd_restart {
     assert_type(Pattern[/^(no|always|on-success|on-failure|on-abnormal|on-abort|on-watchdog)$/], $systemd_restart)
   }
 
   $service_provider_real = $service_provider ? {
     undef   => $docker::params::service_provider,
     default => $service_provider,
   }
 
   if $detach == undef {
     $valid_detach = $service_provider_real ? {
       'systemd' => false,
       default   => $docker::params::detach_service_in_init,
     }
   } else {
     $valid_detach = $detach
   }
 
   $extra_parameters_array = any2array($extra_parameters)
   $after_array            = any2array($after)
   $depends_array          = any2array($depends)
   $depend_services_array  = any2array($depend_services)
 
   $docker_run_flags = docker_run_flags(
     {
       cpuset                => any2array($cpuset),
       disable_network       => $disable_network,
       dns                   => any2array($dns),
       dns_search            => any2array($dns_search),
       env                   => any2array($env),
       env_file              => any2array($env_file),
       expose                => any2array($expose),
       extra_params          => any2array($extra_parameters),
       hostentries           => any2array($hostentries),
       hostname              => $hostname,
       links                 => any2array($links),
       lxc_conf              => any2array($lxc_conf),
       memory_limit          => $memory_limit,
       net                   => $net,
       ports                 => any2array($ports),
       labels                => any2array($labels),
       privileged            => $privileged,
       socket_connect        => any2array($socket_connect),
       tty                   => $tty,
       username              => $username,
       volumes               => any2array($volumes),
       volumes_from          => any2array($volumes_from),
       read_only             => $read_only,
       health_check_cmd      => $health_check_cmd,
       restart_on_unhealthy  => $restart_on_unhealthy,
       health_check_interval => $health_check_interval,
       osfamily              => $facts['os']['family'],
     }
   )
 
   $sanitised_title = docker::sanitised_name($title)
 
   if empty($depends_array) {
     $sanitised_depends_array = []
   } else {
     $sanitised_depends_array = docker::sanitised_name($depends_array)
   }
 
   if empty($after_array) {
     $sanitised_after_array = []
   } else {
     $sanitised_after_array = docker::sanitised_name($after_array)
   }
 
   if $facts['os']['family'] == 'windows' {
     $exec_environment        = "PATH=${::docker_program_files_path}/Docker/;${::docker_systemroot}/System32/"
     $exec_timeout            = 3000
     $exec_path               = ["${::docker_program_files_path}/Docker/"]
     $exec_provider           = 'powershell'
     $cidfile                 = "${::docker_user_temp_path}/${service_prefix}${sanitised_title}.cid"
     $restart_check           = "${docker_command} inspect ${sanitised_title} -f '{{ if eq \\\"unhealthy\\\" .State.Health.Status }} {{ .Name }}{{ end }}' | findstr ${sanitised_title}" # lint:ignore:140chars
     $container_running_check = "\$state = ${docker_command} inspect ${sanitised_title} -f \"{{ .State.Running }}\"; if (\$state -ieq \"true\") { Exit 0 } else { Exit 1 }" # lint:ignore:140chars
   } else {
     $exec_environment        = 'HOME=/root'
     $exec_path               = ['/bin', '/usr/bin']
     $exec_timeout            = 0
     $exec_provider           = undef
     $cidfile                 = "/var/run/${service_prefix}${sanitised_title}.cid"
     $restart_check           = "${docker_command} inspect ${sanitised_title} -f '{{ if eq \"unhealthy\" .State.Health.Status }} {{ .Name }}{{ end }}' | grep ${sanitised_title}" # lint:ignore:140chars
     $container_running_check = "${docker_command} inspect ${sanitised_title} -f \"{{ .State.Running }}\" | grep true" # lint:ignore:140chars
   }
 
   if $restart_on_unhealthy {
     exec { "Restart unhealthy container ${title} with docker":
       command     => "${docker_command} restart ${sanitised_title}",
       onlyif      => $restart_check,
       environment => $exec_environment,
       path        => $exec_path,
       provider    => $exec_provider,
       timeout     => $exec_timeout,
     }
   }
 
   if $restart {
     if $ensure == 'absent' {
       exec { "stop ${title} with docker":
         command     => "${docker_command} stop --time=${stop_wait_time} ${sanitised_title}",
         onlyif      => "${docker_command} inspect ${sanitised_title}",
         environment => $exec_environment,
         path        => $exec_path,
         provider    => $exec_provider,
         timeout     => $exec_timeout,
       }
 
       exec { "remove ${title} with docker":
         command     => "${docker_command} rm -v ${sanitised_title}",
         onlyif      => "${docker_command} inspect ${sanitised_title}",
         environment => $exec_environment,
         path        => $exec_path,
         provider    => $exec_provider,
         timeout     => $exec_timeout,
       }
 
       file { $cidfile:
         ensure => absent,
       }
     } else {
       $run_with_docker_command = [
         "${docker_command} run -d ${docker_run_flags}",
         "--name ${sanitised_title} --cidfile=${cidfile}",
         "--restart=\"${restart}\" ${image} ${command}",
       ]
 
       $inspect = [ "${docker_command} inspect ${sanitised_title}", ]
 
       if $custom_unless {
         $exec_unless = concat($custom_unless, $inspect)
       } else {
         $exec_unless = $inspect
       }
 
       if versioncmp($facts['puppetversion'], '6') < 0 {
         exec { "run ${title} with docker":
           command     => join($run_with_docker_command, ' '),
           unless      => $exec_unless,
           environment => $exec_environment,
           path        => $exec_path,
           provider    => $exec_provider,
           timeout     => $exec_timeout,
         }
 
         if $running == false {
           exec { "stop ${title} with docker":
             command     => "${docker_command} stop --time=${stop_wait_time} ${sanitised_title}",
             onlyif      => $container_running_check,
             environment => $exec_environment,
             path        => $exec_path,
             provider    => $exec_provider,
             timeout     => $exec_timeout,
           }
         } else {
           exec { "start ${title} with docker":
             command     => "${docker_command} start ${sanitised_title}",
             unless      => $container_running_check,
             environment => $exec_environment,
             path        => $exec_path,
             provider    => $exec_provider,
             timeout     => $exec_timeout,
           }
         }
       } else {
         $docker_params_changed_args = {
           sanitised_title   => $sanitised_title,
           osfamily          => $facts['os']['family'],
           command           => join($run_with_docker_command, ' '),
           cidfile           => $cidfile,
           image             => $image,
           volumes           => $volumes,
           ports             => $ports,
           stop_wait_time    => $stop_wait_time,
           container_running => $running,
           # logfile_path      => ($facts['os']['family'] == 'windows') ? {
           # true    => ::docker_user_temp_path,
           # default => '/tmp',
           # },
         }
 
         $detect_changes = Deferred('docker_params_changed', [$docker_params_changed_args])
 
-        notify { 'docker_params_changed':
+        notify { "${title}_docker_params_changed":
           message  => $detect_changes,
         }
       }
     }
   } else {
     $docker_run_inline_start = template('docker/docker-run-start.erb')
     $docker_run_inline_stop  = template('docker/docker-run-stop.erb')
 
     case $service_provider_real {
       'systemd': {
         $initscript         = "/etc/systemd/system/${service_prefix}${sanitised_title}.service"
         $startscript        = "/usr/local/bin/docker-run-${sanitised_title}-start.sh"
         $stopscript         = "/usr/local/bin/docker-run-${sanitised_title}-stop.sh"
         $startstop_template = 'docker/usr/local/bin/docker-run.sh.epp'
         $init_template      = 'docker/etc/systemd/system/docker-run.erb'
         $mode               = '0644'
         $hasstatus          = true
       }
       'upstart': {
         $initscript         = "/etc/init.d/${service_prefix}${sanitised_title}"
         $init_template      = 'docker/etc/init.d/docker-run.erb'
         $mode               = '0750'
         $startscript        = undef
         $stopscript         = undef
         $startstop_template = undef
         $hasstatus          = true
       }
       default: {
         if $facts['os']['family'] != 'windows' {
           fail('Docker needs a Debian or RedHat based system.')
         }
         elsif $ensure == 'present' {
           fail('Restart parameter is required for Windows')
         }
 
         $hasstatus = $::docker::params::service_hasstatus
       }
     }
 
     if $syslog_identifier {
       $_syslog_identifier = $syslog_identifier
     } else {
       $_syslog_identifier = "${service_prefix}${sanitised_title}"
     }
 
     if $ensure == 'absent' {
       if $facts['os']['family'] == 'windows'{
         exec { "stop container ${service_prefix}${sanitised_title}":
           command     => "${docker_command} stop --time=${stop_wait_time} ${sanitised_title}",
           onlyif      => "${docker_command} inspect ${sanitised_title}",
           environment => $exec_environment,
           path        => $exec_path,
           provider    => $exec_provider,
           timeout     => $exec_timeout,
           notify      => Exec["remove container ${service_prefix}${sanitised_title}"],
         }
       }
       else {
         service { "${service_prefix}${sanitised_title}":
           ensure    => false,
           enable    => false,
           hasstatus => $hasstatus,
           provider  => $service_provider_real,
           notify    => Exec["remove container ${service_prefix}${sanitised_title}"],
         }
       }
       exec { "remove container ${service_prefix}${sanitised_title}":
         command     => "${docker_command} rm -v ${sanitised_title}",
         onlyif      => "${docker_command} inspect ${sanitised_title}",
         environment => $exec_environment,
         path        => $exec_path,
         refreshonly => true,
         provider    => $exec_provider,
         timeout     => $exec_timeout,
       }
 
       if $facts['os']['family'] != 'windows' {
         file { "/etc/systemd/system/${service_prefix}${sanitised_title}.service":
           ensure => absent,
         }
 
         if ($startscript) {
           file { $startscript:
             ensure => absent,
           }
         }
 
         if ($stopscript) {
           file { $stopscript:
             ensure => absent,
           }
         }
       } else {
         file { $cidfile:
           ensure => absent,
         }
       }
     } else {
       if ($startscript) {
         file { $startscript:
           ensure  => file,
           content => epp($startstop_template, {'script' => $docker_run_inline_start}),
           owner   => 'root',
           group   => $docker_group,
           mode    => '0770',
         }
       }
       if ($stopscript) {
         file { $stopscript:
           ensure  => file,
           content => epp($startstop_template, {'script' => $docker_run_inline_stop}),
           owner   => 'root',
           group   => $docker_group,
           mode    => '0770',
         }
       }
 
       file { $initscript:
         ensure  => file,
         content => template($init_template),
         owner   => 'root',
         group   => $docker_group,
         mode    => $mode,
       }
 
       if $manage_service {
         if $running == false {
           service { "${service_prefix}${sanitised_title}":
             ensure    => $running,
             enable    => false,
             hasstatus => $hasstatus,
             require   => File[$initscript],
           }
         } else {
           # Transition help from moving from CID based container detection to
           # Name-based container detection. See #222 for context.
           # This code should be considered temporary until most people have
           # transitioned. - 2015-04-15
           if $initscript == "/etc/init.d/${service_prefix}${sanitised_title}" {
             # This exec sequence will ensure the old-style CID container is stopped
             # before we replace the init script with the new-style.
             $transition_onlyif = [
               "/usr/bin/test -f /var/run/docker-${sanitised_title}.cid &&",
               "/usr/bin/test -f /etc/init.d/${service_prefix}${sanitised_title}",
             ]
 
             exec { "/bin/sh /etc/init.d/${service_prefix}${sanitised_title} stop":
               onlyif  => join($transition_onlyif, ' '),
               require => [],
             }
             -> file { "/var/run/${service_prefix}${sanitised_title}.cid":
               ensure => absent,
             }
             -> File[$initscript]
           }
 
           service { "${service_prefix}${sanitised_title}":
             ensure    => $running and !$prepare_service_only,
             enable    => true,
             provider  => $service_provider_real,
             hasstatus => $hasstatus,
             require   => File[$initscript],
           }
         }
 
         if $docker_service {
           if $docker_service == true {
             Service['docker'] -> Service["${service_prefix}${sanitised_title}"]
 
             if $restart_service_on_docker_refresh == true {
               Service['docker'] ~> Service["${service_prefix}${sanitised_title}"]
             }
           } else {
             Service[$docker_service] -> Service["${service_prefix}${sanitised_title}"]
 
             if $restart_service_on_docker_refresh == true {
               Service[$docker_service] ~> Service["${service_prefix}${sanitised_title}"]
             }
           }
         }
       }
       if $service_provider_real == 'systemd' and !$prepare_service_only {
         exec { "docker-${sanitised_title}-systemd-reload":
           path        => ['/bin/', '/sbin/', '/usr/bin/', '/usr/sbin/'],
           command     => 'systemctl daemon-reload',
           refreshonly => true,
           require     => [
             File[$initscript],
             File[$startscript],
             File[$stopscript],
           ],
           subscribe   => [
             File[$initscript],
             File[$startscript],
             File[$stopscript],
           ],
         }
 
         Exec["docker-${sanitised_title}-systemd-reload"] -> Service <| title == "${service_prefix}${sanitised_title}" |>
       }
 
       if $restart_service {
         if $startscript or $stopscript {
           [ File[$initscript], File[$startscript], File[$stopscript], ] ~> Service <| title == "${service_prefix}${sanitised_title}" |>
         }
         else {
           [ File[$initscript], ] ~> Service <| title == "${service_prefix}${sanitised_title}" |>
         }
       }
       else {
         if $startscript or $stopscript {
           [ File[$initscript], File[$startscript], File[$stopscript], ] -> Service <| title == "${service_prefix}${sanitised_title}" |>
         }
         else {
           [ File[$initscript], ] -> Service <| title == "${service_prefix}${sanitised_title}" |>
         }
       }
     }
   }
 }
diff --git a/spec/shared_examples/run.rb b/spec/shared_examples/run.rb
index 26d2701..112e5a5 100644
--- a/spec/shared_examples/run.rb
+++ b/spec/shared_examples/run.rb
@@ -1,472 +1,472 @@
 # frozen_string_literal: true
 
 shared_examples 'run' do |title, params, facts, defaults|
   # after                             = params['after']
   # after_create                      = params['after_create']
   # after_service                     = params['after_service']
   # after_start                       = params['after_start']
   # after_stop                        = params['after_stop']
   # before_start                      = params['before_start']
   # before_stop                       = params['before_stop']
   command                           = params['command']
   cpuset                            = params['cpuset']
   # custom_unless                     = params['custom_unless']
   # depend_services                   = params['depend_services']
   # depends                           = params['depends']
   # detach                            = params['detach']
   disable_network                   = params['disable_network']
   dns                               = params['dns']
   dns_search                        = params['dns_search']
   docker_service                    = params['docker_service']
   ensure_value                      = params['ensure']
   env                               = params['env']
   env_file                          = params['env_file']
   expose                            = params['expose']
   extra_parameters                  = params['extra_parameters']
   # extra_systemd_parameters          = params['extra_systemd_parameters']
   health_check_cmd                  = params['health_check_cmd']
   health_check_interval             = params['health_check_interval']
   hostentries                       = params['hostentries']
   hostname                          = params['hostname']
   image                             = params['image']
   labels                            = params['labels']
   links                             = params['links']
   lxc_conf                          = params['lxc_conf']
   manage_service                    = params['manage_service']
   memory_limit                      = params['memory_limit']
   net                               = params['net']
   ports                             = params['ports']
   privileged                        = params['privileged']
   # pull_on_start                     = params['pull_on_start']
   read_only                         = params['read_only']
   # remain_after_exit                 = params['remain_after_exit']
   # remove_container_on_start         = params['remove_container_on_start']
   # remove_container_on_stop          = params['remove_container_on_stop']
   # remove_volume_on_start            = params['remove_volume_on_start']
   # remove_volume_on_stop             = params['remove_volume_on_stop']
   restart                           = params['restart']
   restart_on_unhealthy              = params['restart_on_unhealthy']
   # restart_service                   = params['restart_service']
   restart_service_on_docker_refresh = params['restart_service_on_docker_refresh']
   running                           = params['running']
   service_prefix                    = params['service_prefix']
   service_provider                  = params['service_provider']
   socket_connect                    = params['socket_connect']
   stop_wait_time                    = params['stop_wait_time']
   syslog_identifier                 = params['syslog_identifier']
   # systemd_restart                   = params['systemd_restart']
   tty                               = params['tty']
   use_name                          = params['use_name']
   username                          = params['username']
   volumes                           = params['volumes']
   volumes_from                      = params['volumes_from']
   docker_group                      = defaults['docker_group']
 
   if socket_connect != []
     sockopts       = [socket_connect].join(',')
     docker_command = "#{defaults['docker_command']} -H #{sockopts}"
   else
     docker_command = defaults['docker_command']
   end
 
   if use_name
     it {
       is_expected.to contain_notify("docker use_name warning: #{title}").with(
         'message'  => 'The use_name parameter is no-longer required and will be removed in a future release',
         'withpath' => true,
       )
     }
   end
 
   service_provider_real = case service_provider.to_s
                           when 'undef'
                             defaults['service_provider']
                           else
                             service_provider
                           end
 
   docker_run_flags = get_docker_run_flags(
     'cpuset' => [cpuset],
     'disable_network'       => disable_network,
     'dns_search'            => [dns_search],
     'dns'                   => [dns],
     'env_file'              => [env_file],
     'env'                   => [env],
     'expose'                => [expose],
     'extra_params' => [extra_parameters],
     'health_check_cmd'      => health_check_cmd,
     'health_check_interval' => health_check_interval,
     'hostentries'           => [hostentries],
     'hostname'              => hostname,
     'labels'                => [labels],
     'links'                 => [links],
     'lxc_conf'              => [lxc_conf],
     'memory_limit'          => memory_limit,
     'net'                   => net,
     'osfamily'              => facts[:os]['family'],
     'ports'                 => [ports],
     'privileged'            => privileged,
     'read_only'             => read_only,
     'restart_on_unhealthy'  => restart_on_unhealthy,
     'socket_connect'        => [socket_connect],
     'tty'                   => tty,
     'username'              => username,
     'volumes_from'          => [volumes_from],
     'volumes'               => [volumes],
   )
 
   sanitised_title = title.gsub('[^0-9A-Za-z.\-_]', '-')
 
   if facts[:os]['family'] == 'windows'
     exec_environment        = "PATH=#{facts['docker_program_files_path']}/Docker/;#{facts['docker_systemroot']}/System32/"
     exec_timeout            = 3000
     exec_path               = ["#{facts['docker_program_files_path']}/Docker/"]
     exec_provider           = 'powershell'
     cidfile                 = "#{facts['docker_user_temp_path']}/#{service_prefix}#{sanitised_title}.cid"
     restart_check           = "#{docker_command} inspect #{sanitised_title} -f '{{ if eq \\\"unhealthy\\\" .State.Health.Status }} {{ .Name }}{{ end }}' | findstr #{sanitised_title}"
     container_running_check = "\$state = #{docker_command} inspect #{sanitised_title} -f \"{{ .State.Running }}\"; if (\$state -ieq \"true\") { Exit 0 } else { Exit 1 }"
   else
     exec_environment        = 'HOME=/root'
     exec_path               = ['/bin', '/usr/bin']
     exec_timeout            = 0
     exec_provider           = nil
     cidfile                 = "/var/run/#{service_prefix}#{sanitised_title}.cid"
     restart_check           = "#{docker_command} inspect #{sanitised_title} -f '{{ if eq \"unhealthy\" .State.Health.Status }} {{ .Name }}{{ end }}' | grep #{sanitised_title}"
     container_running_check = "#{docker_command} inspect #{sanitised_title} -f \"{{ .State.Running }}\" | grep true"
   end
 
   if restart_on_unhealthy
     it {
       is_expected.to contain_exec("Restart unhealthy container #{title} with docker").with(
         'command'     => "#{docker_command} restart #{sanitised_title}",
         'onlyif'      => restart_check,
         'environment' => exec_environment,
         'path'        => exec_path,
         'provider'    => exec_provider,
         'timeout'     => exec_timeout,
       )
     }
   end
 
   if restart.to_s != 'undef'
     if ensure_value == 'absent'
       it {
         is_expected.to contain_exec("stop #{title} with docker").with(
           'command'     => "#{docker_command} stop --time=#{stop_wait_time} #{sanitised_title}",
           'onlyif'      => "#{docker_command} inspect #{sanitised_title}",
           'environment' => exec_environment,
           'path'        => exec_path,
           'provider'    => exec_provider,
           'timeout'     => exec_timeout,
         )
 
         is_expected.to contain_exec("remove #{title} with docker").with(
           'command'     => "#{docker_command} rm -v #{sanitised_title}",
           'onlyif'      => "#{docker_command} inspect #{sanitised_title}",
           'environment' => exec_environment,
           'path'        => exec_path,
           'provider'    => exec_provider,
           'timeout'     => exec_timeout,
         )
 
         is_expected.to contain_file(cidfile).with(
           'ensure' => 'absent',
         )
       }
     else
       run_with_docker_command = [
         "#{docker_command} run -d #{docker_run_flags}",
         "--name #{sanitised_title} --cidfile=#{cidfile}",
         "--restart=\"#{restart}\" #{image} #{command}",
       ]
 
       # inspect = [
       #   "#{docker_command} inspect #{sanitised_title}",
       # ]
 
       # exec_unless = if custom_unless
       #                 custom_unless << inspect
       #               else
       #                 inspect
       #               end
 
       if facts[:puppetversion].to_i < 6
         it {
           is_expected.to contain_exec("run #{title} with docker").with(
             'command'     => run_with_docker_command.join(' '),
             ## todo:
             ## fix the following strange behavior:
             ## expected that the catalogue would contain Exec[run command with docker] with unless set to [["docker inspect command"]]
             ## but it is set to [["docker inspect command"], "docker inspect command"]
             # 'unless'      => exec_unless,
             'environment' => exec_environment,
             'path'        => exec_path,
             'provider'    => exec_provider,
             'timeout'     => exec_timeout,
           )
         }
 
         if !running
           it {
             is_expected.to contain_exec("stop #{title} with docker").with(
               'command'     => "#{docker_command} stop --time=#{stop_wait_time} #{sanitised_title}",
               'onlyif'      => container_running_check,
               'environment' => exec_environment,
               'path'        => exec_path,
               'provider'    => exec_provider,
               'timeout'     => exec_timeout,
             )
           }
         else
           it {
             is_expected.to contain_exec("start #{title} with docker").with(
               'command'     => "#{docker_command} start #{sanitised_title}",
               'unless'      => container_running_check,
               'environment' => exec_environment,
               'path'        => exec_path,
               'provider'    => exec_provider,
               'timeout'     => exec_timeout,
             )
           }
         end
       else
         docker_params_changed_args = {
           'sanitised_title'   => sanitised_title,
           'osfamily'          => facts[:os]['family'],
           'command'           => run_with_docker_command.join(' '),
           'cidfile'           => cidfile,
           'image'             => image,
           'volumes'           => volumes,
           'ports'             => ports,
           'stop_wait_time'    => stop_wait_time,
           'container_running' => running,
           'logfile_path'      => facts[:os]['family'] == 'windows' ? facts['docker_user_temp_path'] : '/tmp',
         }
 
         detect_changes = get_docker_params_changed(docker_params_changed_args)
 
         it {
-          is_expected.to contain_notify('docker_params_changed').with(
+          is_expected.to contain_notify("#{title}_docker_params_changed").with(
             'message' => detect_changes,
           )
         }
       end
     end
   else
     case service_provider_real
     when 'systemd'
       hasstatus          = true
       initscript         = "/etc/systemd/system/#{service_prefix}#{sanitised_title}.service"
       mode               = '0644'
       startscript        = "/usr/local/bin/docker-run-#{sanitised_title}-start.sh"
       stopscript         = "/usr/local/bin/docker-run-#{sanitised_title}-stop.sh"
     when 'upstart'
       hasstatus          = true
       initscript         = "/etc/init.d/#{service_prefix}#{sanitised_title}"
       mode               = '0750'
       startscript        = nil
       stopscript         = nil
     else
       hasstatus = defaults['service_hasstatus']
     end
 
     _syslog_identifier = if syslog_identifier
                            syslog_identifier
                          else
                            "#{service_prefix}#{sanitised_title}"
                          end
 
     if ensure_value == 'absent'
       if facts[:os]['family'] == 'windows'
         it {
           is_expected.to contain_exec("stop container #{service_prefix}#{sanitised_title}").with(
             'command'     => "#{docker_command} stop --time=#{stop_wait_time} #{sanitised_title}",
             'onlyif'      => "#{docker_command} inspect #{sanitised_title}",
             'environment' => exec_environment,
             'path'        => exec_path,
             'provider'    => exec_provider,
             'timeout'     => exec_timeout,
           ).that_notifies(
             "Exec[remove container #{service_prefix}#{sanitised_title}]",
           )
         }
       else
         it {
           is_expected.to contain_service("#{service_prefix}#{sanitised_title}").with(
             'ensure'    => false,
             'enable'    => false,
             'hasstatus' => hasstatus,
             'provider'  => service_provider_real,
           )
         }
       end
 
       it {
         is_expected.to contain_exec("remove container #{service_prefix}#{sanitised_title}").with(
           'command'     => "#{docker_command} rm -v #{sanitised_title}",
           'onlyif'      => "#{docker_command} inspect #{sanitised_title}",
           'environment' => exec_environment,
           'path'        => exec_path,
           'refreshonly' => true,
           'provider'    => exec_provider,
           'timeout'     => exec_timeout,
         )
       }
 
       if facts[:os]['family'] != 'windows'
         it {
           is_expected.to contain_file("/etc/systemd/system/#{service_prefix}#{sanitised_title}.service").with(
             'ensure' => 'absent',
           )
         }
 
         if startscript
           it {
             is_expected.to contain_file(startscript).with(
               'ensure' => 'absent',
             )
           }
         end
 
         if stopscript
           it {
             is_expected.to contain_file(stopscript).with(
               'ensure' => 'absent',
             )
           }
         end
       else
         it {
           is_expected.to contain_file(cidfile).with(
             'ensure' => 'absent',
           )
         }
       end
     else
       if startscript
         it {
           is_expected.to contain_file(startscript).with(
             'ensure'  => 'file',
             'owner'   => 'root',
             'group'   => docker_group,
             'mode'    => '0770',
           )
         }
       end
 
       if stopscript
         it {
           is_expected.to contain_file(stopscript).with(
             'ensure'  => 'file',
             'owner'   => 'root',
             'group'   => docker_group,
             'mode'    => '0770',
           )
         }
       end
 
       it {
         is_expected.to contain_file(initscript).with(
           'ensure'  => 'file',
           'owner'   => 'root',
           'group'   => docker_group,
           'mode'    => mode,
         )
       }
 
       if manage_service
         if !running
           it {
             is_expected.to contain_service("#{service_prefix}#{sanitised_title}").with(
               'ensure'    => running,
               'enable'    => false,
               'hasstatus' => hasstatus,
             ).that_requires(
               "File[#{initscript}]",
             )
           }
         else
           if initscript == "/etc/init.d/#{service_prefix}#{sanitised_title}"
             transition_onlyif = [
               "/usr/bin/test -f /var/run/docker-#{sanitised_title}.cid &&",
               "/usr/bin/test -f /etc/init.d/#{service_prefix}#{sanitised_title}",
             ]
 
             it {
               is_expected.to contain_exec("/bin/sh /etc/init.d/#{service_prefix}#{sanitised_title} stop").with(
                 'onlyif' => transition_onlyif.join(' '),
               ).that_comes_before(
                 "File[/var/run/#{service_prefix}#{sanitised_title}.cid]",
               )
 
               is_expected.to contain_file("/var/run/#{service_prefix}#{sanitised_title}.cid").with(
                 'ensure' => 'absent',
               ).that_comes_before(
                 "File[#{initscript}]",
               )
             }
           end
 
           it {
             is_expected.to contain_service("#{service_prefix}#{sanitised_title}").with(
               'ensure'    => running,
               'enable'    => true,
               'provider'  => service_provider_real,
               'hasstatus' => hasstatus,
             ).that_requires(
               "File[#{initscript}]",
             )
           }
 
           if docker_service
             if docker_service.to_s == 'true'
               it {
                 is_expected.to contain_service('docker').that_comes_before("Service[#{service_prefix}#{sanitised_title}]")
               }
 
               if restart_service_on_docker_refresh.to_s == 'true'
                 it {
                   is_expected.to contain_service('docker').that_notifies("Service[#{service_prefix}#{sanitised_title}]")
                 }
               end
             else
               it {
                 is_expected.to contain_service('docker').with('name' => docker_service).that_comes_before("Service[#{service_prefix}#{sanitised_title}]")
               }
 
               if restart_service_on_docker_refresh.to_s == 'true'
                 it {
                   is_expected.to contain_service('docker').with('name' => docker_service).that_notifies("Service[#{service_prefix}#{sanitised_title}]")
                 }
               end
             end
           end
         end
       end
 
       if service_provider_real == 'systemd'
         it {
           is_expected.to contain_exec("docker-#{sanitised_title}-systemd-reload").with(
             'path'        => ['/bin/', '/sbin/', '/usr/bin/', '/usr/sbin/'],
             'command'     => 'systemctl daemon-reload',
             'refreshonly' => true,
           ).that_requires(
             [
               "File[#{initscript}]",
               "File[#{startscript}]",
               "File[#{stopscript}]",
             ],
           ).that_subscribes_to(
             [
               "File[#{initscript}]",
               "File[#{startscript}]",
               "File[#{stopscript}]",
             ],
           ).that_comes_before(
             "Service[#{service_prefix}#{sanitised_title}]",
           )
         }
       end
     end
   end
 end