diff --git a/functional/test_purge.py b/functional/test_purge.py
index ef742ef..fd652a9 100644
--- a/functional/test_purge.py
+++ b/functional/test_purge.py
@@ -11,7 +11,6 @@
 #    under the License.
 
 import time
-import uuid
 
 from oslo_concurrency import processutils
 
@@ -50,44 +49,3 @@
         stacks = dict((stack.id, stack) for stack in
                       self.client.stacks.list(show_deleted=True))
         self.assertNotIn(stack_identifier.split('/')[1], stacks)
-
-    def test_purge_project_id(self):
-        stack_identifier = self.stack_create(template=self.template)
-        self._stack_delete(stack_identifier)
-        stacks = dict((stack.id, stack) for stack in
-                      self.client.stacks.list(show_deleted=True))
-        self.assertIn(stack_identifier.split('/')[1], stacks)
-        fake_project_id = uuid.uuid4().hex
-        time.sleep(1)
-        cmd = "heat-manage purge_deleted -p %s 0" % fake_project_id
-        processutils.execute(cmd, shell=True)
-
-        stacks = dict((stack.id, stack) for stack in
-                      self.client.stacks.list(show_deleted=True))
-        self.assertIn(stack_identifier.split('/')[1], stacks)
-
-        time.sleep(1)
-        cmd = "heat-manage purge_deleted 0"
-        processutils.execute(cmd, shell=True)
-        stacks = dict((stack.id, stack) for stack in
-                      self.client.stacks.list(show_deleted=True))
-        self.assertNotIn(stack_identifier.split('/')[1], stacks)
-
-        # Test with tags
-        stack_identifier = self.stack_create(template=self.template,
-                                             tags="foo,bar")
-        self._stack_delete(stack_identifier)
-
-        time.sleep(1)
-        cmd = "heat-manage purge_deleted -p %s 0" % fake_project_id
-        processutils.execute(cmd, shell=True)
-        stacks = dict((stack.id, stack) for stack in
-                      self.client.stacks.list(show_deleted=True))
-        self.assertIn(stack_identifier.split('/')[1], stacks)
-
-        time.sleep(1)
-        cmd = "heat-manage purge_deleted 0"
-        processutils.execute(cmd, shell=True)
-        stacks = dict((stack.id, stack) for stack in
-                      self.client.stacks.list(show_deleted=True))
-        self.assertNotIn(stack_identifier.split('/')[1], stacks)
diff --git a/scenario/templates/test_server_signal.yaml b/scenario/templates/test_server_signal.yaml
new file mode 100644
index 0000000..dfb1155
--- /dev/null
+++ b/scenario/templates/test_server_signal.yaml
@@ -0,0 +1,104 @@
+heat_template_version: 2013-05-23
+description: |
+  Template which uses a wait condition to confirm that a minimal
+  signalling works in a created network
+parameters:
+  key_name:
+    type: string
+  flavor:
+    type: string
+  image:
+    type: string
+  subnet_cidr:
+    type: string
+    default: 10.100.0.0/16
+  timeout:
+    type: number
+  public_net:
+    type: string
+    default: public
+  private_net:
+    type: string
+    default: heat-net
+  dns_servers:
+    type: comma_delimited_list
+    default: ["8.8.8.8", "8.8.4.4"]
+resources:
+  sg:
+    type: OS::Neutron::SecurityGroup
+    properties:
+      name: the_sg
+      description: Ping and SSH
+      rules:
+      - protocol: icmp
+      - protocol: tcp
+        port_range_min: 22
+        port_range_max: 22
+
+  floating_ip:
+    type: OS::Neutron::FloatingIP
+    properties:
+      floating_network: {get_param: public_net}
+
+  network:
+    type: OS::Neutron::Net
+
+  subnet:
+    type: OS::Neutron::Subnet
+    properties:
+      network: {get_resource: network}
+      ip_version: 4
+      cidr: {get_param: subnet_cidr}
+      dns_nameservers: {get_param: dns_servers}
+
+  router:
+    type: OS::Neutron::Router
+    properties:
+      external_gateway_info:
+        network: {get_param: public_net}
+
+  router_interface:
+    type: OS::Neutron::RouterInterface
+    properties:
+      router: {get_resource: router}
+      subnet: {get_resource: subnet}
+
+  wait_handle:
+    type: OS::Heat::WaitConditionHandle
+
+  server:
+    type: OS::Nova::Server
+    properties:
+      image: {get_param: image}
+      flavor: {get_param: flavor}
+      key_name: {get_param: key_name}
+      networks:
+      - subnet: {get_resource: subnet}
+      security_groups:
+      - {get_resource: sg}
+      user_data_format: RAW
+      user_data:
+        str_replace:
+          template: |
+            #!/bin/sh
+            wc_notify --data-binary '{"status": "SUCCESS", "data": "test complete"}'
+          params:
+            wc_notify: { get_attr: ['wait_handle', 'curl_cli'] }
+
+  server_floating_ip_assoc:
+    type: OS::Neutron::FloatingIPAssociation
+    properties:
+      floatingip_id: {get_resource: floating_ip}
+      port_id: {get_attr: [server, addresses, {get_resource: network}, 0, port]}
+
+  wait_condition:
+    type: OS::Heat::WaitCondition
+    properties:
+      handle: {get_resource: wait_handle}
+      timeout: {get_param: timeout}
+
+outputs:
+  server_ip:
+    value: {get_attr: [floating_ip, floating_ip_address]}
+  wc_data:
+    value: {get_attr: [wait_condition, data]}
diff --git a/scenario/test_server_signal.py b/scenario/test_server_signal.py
new file mode 100644
index 0000000..de42f02
--- /dev/null
+++ b/scenario/test_server_signal.py
@@ -0,0 +1,74 @@
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import json
+
+from heat_integrationtests.common import exceptions
+from heat_integrationtests.scenario import scenario_base
+
+
+class ServerSignalIntegrationTest(scenario_base.ScenarioTestsBase):
+    """Test a server in a created network can signal to heat."""
+
+    def test_server_signal(self):
+        """Check a server in a created network can signal to heat."""
+        parameters = {
+            'key_name': self.keypair_name,
+            'flavor': self.conf.instance_type,
+            'image': self.conf.image_ref,
+            'timeout': self.conf.build_timeout,
+        }
+
+        # Launch stack
+        sid = self.launch_stack(
+            template_name="test_server_signal.yaml",
+            parameters=parameters,
+            expected_status=None
+        )
+
+        # Check status of all resources
+        for res in ('sg', 'floating_ip', 'network', 'router', 'subnet',
+                    'router_interface', 'wait_handle', 'server',
+                    'server_floating_ip_assoc'):
+            self._wait_for_resource_status(
+                sid, res, 'CREATE_COMPLETE')
+
+        server_resource = self.client.resources.get(sid, 'server')
+        server_id = server_resource.physical_resource_id
+        server = self.compute_client.servers.get(server_id)
+
+        try:
+            self._wait_for_resource_status(
+                sid, 'wait_condition', 'CREATE_COMPLETE')
+        except (exceptions.StackResourceBuildErrorException,
+                exceptions.TimeoutException):
+            raise
+        finally:
+            # attempt to log the server console regardless of WaitCondition
+            # going to complete. This allows successful and failed cloud-init
+            # logs to be compared
+            self._log_console_output(servers=[server])
+
+        stack = self.client.stacks.get(sid)
+
+        wc_data = json.loads(
+            self._stack_output(stack, 'wc_data'))
+        self.assertEqual({'1': 'test complete'}, wc_data)
+
+        server_ip = self._stack_output(stack, 'server_ip')
+
+        # Check that created server is reachable
+        if not self._ping_ip_address(server_ip):
+            self._log_console_output(servers=[server])
+            self.fail(
+                "Timed out waiting for %s to become reachable" % server_ip)