diff --git a/etc/tempest.conf.sample b/etc/tempest.conf.sample
index 097cfb9..7f39118 100644
--- a/etc/tempest.conf.sample
+++ b/etc/tempest.conf.sample
@@ -11,6 +11,12 @@
 build_timeout=600
 catalog_type=compute
 
+[image]
+username=admin
+password=********
+tenant=admin
+auth_url=http://localhost:5000/v2.0
+
 [environment]
 image_ref=3
 image_ref_alt=4
diff --git a/tempest/common/rest_client.py b/tempest/common/rest_client.py
index 1530313..7dd3a86 100644
--- a/tempest/common/rest_client.py
+++ b/tempest/common/rest_client.py
@@ -2,9 +2,14 @@
 import httplib2
 import logging
 import sys
+import time
 from tempest import exceptions
 
 
+# redrive rate limited calls at most twice
+MAX_RECURSION_DEPTH = 2
+
+
 class RestClient(object):
 
     def __init__(self, config, user, key, auth_url, service, tenant_name=None):
@@ -107,7 +112,7 @@
         self.log.error('Response Headers: ' + str(resp))
         self.log.error('Response Body: ' + str(resp_body))
 
-    def request(self, method, url, headers=None, body=None):
+    def request(self, method, url, headers=None, body=None, depth=0):
         """A simple HTTP request interface."""
 
         self.http_obj = httplib2.Http()
@@ -138,6 +143,10 @@
             self._log(req_url, body, resp, resp_body)
             if 'overLimit' in resp_body:
                 raise exceptions.OverLimit(resp_body['overLimit']['message'])
+            elif depth < MAX_RECURSION_DEPTH:
+                delay = resp['Retry-After'] if 'Retry-After' in resp else 60
+                time.sleep(int(delay))
+                return self.request(method, url, headers, body, depth + 1)
             else:
                 raise exceptions.RateLimitExceeded(
                     message=resp_body['overLimitFault']['message'],
diff --git a/tempest/config.py b/tempest/config.py
index 2995447..b100530 100644
--- a/tempest/config.py
+++ b/tempest/config.py
@@ -56,7 +56,7 @@
     @property
     def use_ssl(self):
         """Specifies if we are using https."""
-        return bool(self.get("use_ssl", False))
+        return self.get("use_ssl", 'false') != 'false'
 
     @property
     def username(self):
diff --git a/tempest/services/image/service.py b/tempest/services/image/service.py
index efeacb3..2cf053f 100644
--- a/tempest/services/image/service.py
+++ b/tempest/services/image/service.py
@@ -49,7 +49,8 @@
             service_token = config.images.service_token
             self._client = client.Client(config.images.host,
                                          config.images.port,
-                                         auth_tok=service_token)
+                                         auth_tok=service_token,
+                                         creds=creds)
         else:
             raise NotImplementedError
 
diff --git a/tempest/services/nova/json/keypairs_client.py b/tempest/services/nova/json/keypairs_client.py
index 59057ab..9c912ef 100644
--- a/tempest/services/nova/json/keypairs_client.py
+++ b/tempest/services/nova/json/keypairs_client.py
@@ -14,7 +14,7 @@
                         'Accept': 'application/json'}
 
     def list_keypairs(self):
-        resp, body = self.client.get("/os-keypairs")
+        resp, body = self.client.get("os-keypairs")
         body = json.loads(body)
         #Each returned keypair is embedded within an unnecessary 'keypair'
         #element which is a deviation from other resources like floating-ips,
@@ -24,7 +24,7 @@
         return resp, body['keypairs']
 
     def get_keypair(self, key_name):
-        resp, body = self.client.get("/os-keypairs/%s" % str(key_name))
+        resp, body = self.client.get("os-keypairs/%s" % str(key_name))
         body = json.loads(body)
         return resp, body['keypair']
 
@@ -33,10 +33,10 @@
         if pub_key:
             post_body['keypair']['public_key'] = pub_key
         post_body = json.dumps(post_body)
-        resp, body = self.client.post("/os-keypairs",
+        resp, body = self.client.post("os-keypairs",
                                 headers=self.headers, body=post_body)
         body = json.loads(body)
         return resp, body['keypair']
 
     def delete_keypair(self, key_name):
-        return self.client.delete("/os-keypairs/%s" % str(key_name))
+        return self.client.delete("os-keypairs/%s" % str(key_name))
diff --git a/tempest/services/nova/json/security_groups_client.py b/tempest/services/nova/json/security_groups_client.py
index 34cf807..0e6b6cf 100644
--- a/tempest/services/nova/json/security_groups_client.py
+++ b/tempest/services/nova/json/security_groups_client.py
@@ -10,6 +10,8 @@
         self.client = rest_client.RestClient(config, username, key,
                                              auth_url, catalog_type,
                                              tenant_name)
+        self.headers = {'Content-Type': 'application/json',
+                        'Accept': 'application/json'}
 
     def list_security_groups(self, params=None):
         """List all security groups for a user"""
@@ -24,19 +26,63 @@
 
         resp, body = self.client.get(url)
         body = json.loads(body)
-        return resp, body
+        return resp, body['security_groups']
 
-    def list_security_groups_with_detail(self, params=None):
-        """List security groups with detail"""
-
-        url = 'os-security-groups/detail'
-        if params != None:
-            param_list = []
-            for param, value in params.iteritems():
-                param_list.append("%s=%s&" % (param, value))
-
-            url += '?' + ' '.join(param_list)
-
+    def get_security_group(self, security_group_id):
+        """Get the details of a Security Group"""
+        url = "os-security-groups/%s" % str(security_group_id)
         resp, body = self.client.get(url)
         body = json.loads(body)
-        return resp, body
+        return resp, body['security_group']
+
+    def create_security_group(self, name, description):
+        """
+        Creates a new security group.
+        name (Required): Name of security group.
+        description (Required): Description of security group.
+        """
+        post_body = {
+            'name': name,
+            'description': description,
+        }
+        post_body = json.dumps({'security_group': post_body})
+        resp, body = self.client.post('os-security-groups',
+                                        post_body, self.headers)
+        body = json.loads(body)
+        return resp, body['security_group']
+
+    def delete_security_group(self, security_group_id):
+        """Deletes the provided Security Group"""
+        return self.client.delete('os-security-groups/%s'
+                                   % str(security_group_id))
+
+    def create_security_group_rule(self, parent_group_id, ip_proto, from_port,
+                                      to_port, **kwargs):
+        """
+        Creating a new security group rules.
+        parent_group_id :ID of Security group
+        ip_protocol : ip_proto (icmp, tcp, udp).
+        from_port: Port at start of range.
+        to_port  : Port at end of range.
+        Following optional keyword arguments are accepted:
+        cidr     : CIDR for address range.
+        group_id : ID of the Source group
+        """
+        post_body = {
+            'parent_group_id': parent_group_id,
+            'ip_protocol': ip_proto,
+            'from_port': from_port,
+            'to_port': to_port,
+            'cidr': kwargs.get('cidr'),
+            'group_id': kwargs.get('group_id'),
+        }
+        post_body = json.dumps({'security_group_rule': post_body})
+        url = 'os-security-group-rules'
+        resp, body = self.client.post(url, post_body, self.headers)
+        body = json.loads(body)
+        return resp, body['security_group_rule']
+
+    def delete_security_group_rule(self, group_rule_id):
+        """Deletes the provided Security Group rule"""
+        return self.client.delete('os-security-group-rules/%s'
+                                      % str(group_rule_id))
diff --git a/tempest/services/nova/json/servers_client.py b/tempest/services/nova/json/servers_client.py
index 605bd46..e0a26de 100644
--- a/tempest/services/nova/json/servers_client.py
+++ b/tempest/services/nova/json/servers_client.py
@@ -146,10 +146,13 @@
             if server_status == 'ERROR':
                 raise exceptions.BuildErrorException(server_id=server_id)
 
-            if int(time.time()) - start >= self.build_timeout:
+            timed_out = int(time.time()) - start >= self.build_timeout
+
+            if server_status != status and timed_out:
                 message = 'Server %s failed to reach %s status within the \
                 required time (%s s).' % (server_id, status,
                                           self.build_timeout)
+                message += ' Current status: %s.' % server_status
                 raise exceptions.TimeoutException(message)
 
     def list_addresses(self, server_id):
diff --git a/tempest/tests/test_security_group_rules.py b/tempest/tests/test_security_group_rules.py
new file mode 100644
index 0000000..c07f869
--- /dev/null
+++ b/tempest/tests/test_security_group_rules.py
@@ -0,0 +1,238 @@
+from nose.plugins.attrib import attr
+from tempest import openstack
+import unittest2 as unittest
+from tempest import exceptions
+from tempest.common.utils.data_utils import rand_name
+import time
+
+
+class SecurityGroupsTest(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.os = openstack.Manager()
+        cls.client = cls.os.security_groups_client
+
+    @attr(type='positive')
+    def test_security_group_rules_create(self):
+        """
+        Positive test: Creation of Security Group rule
+        should be successfull
+        """
+        try:
+            #Creating a Security Group to add rules to it
+            s_name = rand_name('securitygroup-')
+            s_description = rand_name('description-')
+            resp, securitygroup =\
+            self.client.create_security_group(s_name, s_description)
+            securitygroup_id = securitygroup['id']
+            #Adding rules to the created Security Group
+            parent_group_id = securitygroup['id']
+            ip_protocol = 'tcp'
+            from_port = 22
+            to_port = 22
+            resp, rule =\
+            self.client.create_security_group_rule(parent_group_id,
+                                                   ip_protocol, from_port,
+                                                   to_port)
+            self.assertEqual(200, resp.status)
+        finally:
+            #Deleting the Security Group rule, created in this method
+            group_rule_id = rule['id']
+            self.client.delete_security_group_rule(group_rule_id)
+            #Deleting the Security Group created in this method
+            resp, _ = self.client.delete_security_group(securitygroup_id)
+
+    @attr(type='positive')
+    def test_security_group_rules_create_with_optional_arguments(self):
+        """
+        Positive test: Creation of Security Group rule
+        with optional arguments
+        should be successfull
+        """
+        try:
+            #Creating a Security Group to add rules to it
+            s_name = rand_name('securitygroup-')
+            s_description = rand_name('description-')
+            resp, securitygroup =\
+            self.client.create_security_group(s_name, s_description)
+            securitygroup_id1 = securitygroup['id']
+            #Creating a Security Group so as to assign group_id to the rule
+            s_name2 = rand_name('securitygroup-')
+            s_description2 = rand_name('description-')
+            resp, securitygroup =\
+            self.client.create_security_group(s_name2, s_description2)
+            securitygroup_id2 = securitygroup['id']
+            #Adding rules to the created Security Group with optional arguments
+            parent_group_id = securitygroup_id1
+            ip_protocol = 'tcp'
+            from_port = 22
+            to_port = 22
+            cidr = '10.2.3.124/24'
+            group_id = securitygroup_id2
+            resp, rule =\
+            self.client.create_security_group_rule(parent_group_id,
+                                                   ip_protocol,
+                                                   from_port, to_port,
+                                                   cidr=cidr,
+                                                   group_id=group_id)
+            self.assertEqual(200, resp.status)
+        finally:
+            #Deleting the Security Group rule, created in this method
+            group_rule_id = rule['id']
+            self.client.delete_security_group_rule(group_rule_id)
+            #Deleting the Security Groups created in this method
+            resp, _ = self.client.delete_security_group(securitygroup_id1)
+            resp, _ = self.client.delete_security_group(securitygroup_id2)
+
+    @attr(type='positive')
+    def test_security_group_rules_create_delete(self):
+        """
+        Positive test: Deletion of Security Group rule
+        should be successfull
+        """
+        try:
+            #Creating a Security Group to add rule to it
+            s_name = rand_name('securitygroup-')
+            s_description = rand_name('description-')
+            resp, securitygroup =\
+            self.client.create_security_group(s_name, s_description)
+            securitygroup_id = securitygroup['id']
+            #Adding rules to the created Security Group
+            parent_group_id = securitygroup['id']
+            ip_protocol = 'tcp'
+            from_port = 22
+            to_port = 22
+            resp, rule =\
+            self.client.create_security_group_rule(parent_group_id,
+                                                   ip_protocol,
+                                                   from_port, to_port)
+        finally:
+            #Deleting the Security Group rule, created in this method
+            group_rule_id = rule['id']
+            self.client.delete_security_group_rule(group_rule_id)
+            #Deleting the Security Group created in this method
+            resp, _ = self.client.delete_security_group(securitygroup_id)
+
+    @attr(type='negative')
+    def test_security_group_rules_create_with_invalid_id(self):
+        """
+        Negative test: Creation of Security Group rule should FAIL
+        with invalid Parent group id
+        """
+        #Adding rules to the invalid Security Group id
+        parent_group_id = rand_name('999')
+        ip_protocol = 'tcp'
+        from_port = 22
+        to_port = 22
+        try:
+            resp, rule =\
+            self.client.create_security_group_rule(parent_group_id,
+                                                   ip_protocol,
+                                                   from_port, to_port)
+        except exceptions.NotFound:
+            pass
+        else:
+            self.fail('Security Group rule should not be created '
+                      'with invalid parent group id')
+
+    @attr(type='negative')
+    def test_security_group_rules_create_with_invalid_ip_protocol(self):
+        """
+        Negative test: Creation of Security Group rule should FAIL
+        with invalid ip_protocol
+        """
+        #Creating a Security Group to add rule to it
+        s_name = rand_name('securitygroup-')
+        s_description = rand_name('description-')
+        resp, securitygroup = self.client.create_security_group(s_name,
+                                                                s_description)
+        #Adding rules to the created Security Group
+        parent_group_id = securitygroup['id']
+        ip_protocol = rand_name('999')
+        from_port = 22
+        to_port = 22
+        try:
+            resp, rule =\
+            self.client.create_security_group_rule(parent_group_id,
+                                                   ip_protocol,
+                                                   from_port, to_port)
+        except exceptions.BadRequest:
+            pass
+        else:
+            self.fail('Security Group rule should not be created '
+                      'with invalid ip_protocol')
+        #Deleting the Security Group created in this method
+        resp, _ = self.client.delete_security_group(securitygroup['id'])
+
+    @attr(type='negative')
+    def test_security_group_rules_create_with_invalid_from_port(self):
+        """
+        Negative test: Creation of Security Group rule should FAIL
+        with invalid from_port
+        """
+        #Creating a Security Group to add rule to it
+        s_name = rand_name('securitygroup-')
+        s_description = rand_name('description-')
+        resp, securitygroup = self.client.create_security_group(s_name,
+                                                                s_description)
+        #Adding rules to the created Security Group
+        parent_group_id = securitygroup['id']
+        ip_protocol = 'tcp'
+        from_port = rand_name('999')
+        to_port = 22
+        try:
+            resp, rule =\
+            self.client.create_security_group_rule(parent_group_id,
+                                                   ip_protocol,
+                                                   from_port, to_port)
+        except exceptions.BadRequest:
+            pass
+        else:
+            self.fail('Security Group rule should not be created'
+                      'with invalid from_port')
+        #Deleting the Security Group created in this method
+        resp, _ = self.client.delete_security_group(securitygroup['id'])
+
+    @attr(type='negative')
+    def test_security_group_rules_create_with_invalid_to_port(self):
+        """
+        Negative test: Creation of Security Group rule should FAIL
+        with invalid from_port
+        """
+        #Creating a Security Group to add rule to it
+        s_name = rand_name('securitygroup-')
+        s_description = rand_name('description-')
+        resp, securitygroup = self.client.create_security_group(s_name,
+                                                                s_description)
+        #Adding rules to the created Security Group
+        parent_group_id = securitygroup['id']
+        ip_protocol = 'tcp'
+        from_port = 22
+        to_port = rand_name('999')
+        try:
+            resp, rule =\
+            self.client.create_security_group_rule(parent_group_id,
+                                                   ip_protocol,
+                                                   from_port, to_port)
+        except exceptions.BadRequest:
+            pass
+        else:
+            self.fail('Security Group rule should not be created'
+                      'with invalid from_port')
+        #Deleting the Security Group created in this method
+        resp, _ = self.client.delete_security_group(securitygroup['id'])
+
+    @attr(type='negative')
+    def test_security_group_rules_delete_with_invalid_id(self):
+        """
+        Negative test: Deletion of Security Group rule should be FAIL
+        with invalid rule id
+        """
+        try:
+            self.client.delete_security_group_rule(rand_name('999'))
+        except exceptions.NotFound:
+            pass
+        else:
+            self.fail('Security Group Rule should not be deleted '
+                      'with nonexistant rule id')
diff --git a/tempest/tests/test_security_groups.py b/tempest/tests/test_security_groups.py
new file mode 100644
index 0000000..bbbe777
--- /dev/null
+++ b/tempest/tests/test_security_groups.py
@@ -0,0 +1,226 @@
+from nose.plugins.attrib import attr
+from tempest import openstack
+import unittest2 as unittest
+from tempest import exceptions
+from tempest.common.utils.data_utils import rand_name
+import time
+
+
+class SecurityGroupsTest(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.os = openstack.Manager()
+        cls.client = cls.os.security_groups_client
+
+    @attr(type='positive')
+    def test_security_groups_create_list_delete(self):
+        """Positive test:Should return the list of Security Groups"""
+        try:
+            #Create 3 Security Groups
+            security_group_list = list()
+            for i in range(3):
+                s_name = rand_name('securitygroup-')
+                s_description = rand_name('description-')
+                resp, securitygroup =\
+                self.client.create_security_group(s_name, s_description)
+                self.assertEqual(200, resp.status)
+                security_group_list.append(securitygroup)
+            #Fetch all Security Groups and verify the list
+            #has all created Security Groups
+            resp, fetched_list = self.client.list_security_groups()
+            self.assertEqual(200, resp.status)
+            #Now check if all the created Security Groups are in fetched list
+            missing_sgs =\
+            [sg for sg in security_group_list if sg not in fetched_list]
+            self.assertFalse(missing_sgs,
+                             "Failed to find Security Group %s in fetched list"
+                             % ', '.join(m_group['name']
+                                            for m_group in missing_sgs))
+        finally:
+            #Delete all the Security Groups created in this method
+            for securitygroup in security_group_list:
+                resp, _ =\
+                self.client.delete_security_group(securitygroup['id'])
+                self.assertEqual(202, resp.status)
+
+    @attr(type='smoke')
+    def test_security_group_create_delete(self):
+        """Security Group should be created, verified and deleted"""
+        try:
+            s_name = rand_name('securitygroup-')
+            s_description = rand_name('description-')
+            resp, securitygroup = \
+            self.client.create_security_group(s_name, s_description)
+            self.assertEqual(200, resp.status)
+            self.assertTrue('id' in securitygroup)
+            securitygroup_id = securitygroup['id']
+            self.assertFalse(securitygroup_id is None)
+            self.assertTrue('name' in securitygroup)
+            securitygroup_name = securitygroup['name']
+            self.assertEqual(securitygroup_name, s_name,
+                             "The created Security Group name is "
+                             "not equal to the requested name")
+        finally:
+            #Delete Security Group created in this method
+            resp, _ = self.client.delete_security_group(securitygroup['id'])
+            self.assertEqual(202, resp.status)
+
+    @attr(type='smoke')
+    def test_security_group_create_get_delete(self):
+        """Security Group should be created, fetched and deleted"""
+        try:
+            s_name = rand_name('securitygroup-')
+            s_description = rand_name('description-')
+            resp, securitygroup =\
+            self.client.create_security_group(s_name, s_description)
+            self.assertEqual(200, resp.status)
+            #Now fetch the created Security Group by its 'id'
+            resp, fetched_group =\
+            self.client.get_security_group(securitygroup['id'])
+            self.assertEqual(200, resp.status)
+            self.assertEqual(securitygroup, fetched_group,
+                             "The fetched Security Group is different "
+                             "from the created Group")
+        finally:
+            #Delete the Security Group created in this method
+            resp, _ = self.client.delete_security_group(securitygroup['id'])
+            self.assertEqual(202, resp.status)
+
+    @attr(type='negative')
+    def test_security_group_get_nonexistant_group(self):
+        """
+        Negative test:Should not be able to GET the details
+        of nonexistant Security Group
+        """
+        security_group_id = []
+        resp, body = self.client.list_security_groups()
+        for i in range(len(body)):
+            security_group_id.append(body[i]['id'])
+        #Creating a nonexistant Security Group id
+        while True:
+            non_exist_id = rand_name('999')
+            if non_exist_id not in security_group_id:
+                break
+        try:
+            resp, body = \
+            self.client.get_security_group(non_exist_id)
+        except exceptions.NotFound:
+            pass
+        else:
+            self.fail('Should not be able to GET the details from a '
+                      'nonexistant Security Group')
+
+    @attr(type='negative')
+    def test_security_group_create_with_invalid_group_name(self):
+        """
+        Negative test: Security Group should not be created with group name as
+        an empty string/with white spaces/chars more than 255
+        """
+        s_description = rand_name('description-')
+        #Create Security Group with empty string as group name
+        try:
+            resp, _ = self.client.create_security_group("", s_description)
+        except exceptions.BadRequest:
+            pass
+        else:
+            self.fail('Security Group should not be created '
+                      'with EMPTY Name')
+        #Create Security Group with white space in group name
+        try:
+            resp, _ = self.client.create_security_group(" ", s_description)
+        except exceptions.BadRequest:
+            pass
+        else:
+            self.fail('Security Group should not be created '
+                      'with WHITE SPACE in Name')
+        #Create Security Group with group name longer than 255 chars
+        s_name = 'securitygroup-'.ljust(260, '0')
+        try:
+            resp, _ = self.client.create_security_group(s_name, s_description)
+        except exceptions.BadRequest:
+            pass
+        else:
+            self.fail('Security Group should not be created '
+                      'with more than 255 chars in Name')
+
+    @attr(type='negative')
+    def test_security_group_create_with_invalid_group_description(self):
+        """
+        Negative test:Security Group should not be created with description as
+        an empty string/with white spaces/chars more than 255
+        """
+        s_name = rand_name('securitygroup-')
+        #Create Security Group with empty string as description
+        try:
+            resp, _ = self.client.create_security_group(s_name, "")
+        except exceptions.BadRequest:
+            pass
+        else:
+            self.fail('Security Group should not be created '
+                      'with EMPTY Description')
+        #Create Security Group with white space in description
+        try:
+            resp, _ = self.client.create_security_group(s_name, " ")
+        except exceptions.BadRequest:
+            pass
+        else:
+            self.fail('Security Group should not be created '
+                      'with WHITE SPACE in Description')
+        #Create Security Group with group description longer than 255 chars
+        s_description = 'description-'.ljust(260, '0')
+        try:
+            resp, _ = self.client.create_security_group(s_name, s_description)
+        except exceptions.BadRequest:
+            pass
+        else:
+            self.fail('Security Group should not be created '
+                      'with more than 255 chars in Description')
+
+    @attr(type='negative')
+    def test_security_group_create_with_duplicate_name(self):
+        """
+        Negative test:Security Group with duplicate name should not
+        be created
+        """
+        try:
+            s_name = rand_name('securitygroup-')
+            s_description = rand_name('description-')
+            resp, security_group =\
+            self.client.create_security_group(s_name, s_description)
+            self.assertEqual(200, resp.status)
+            #Now try the Security Group with the same 'Name'
+            try:
+                resp, _ =\
+                self.client.create_security_group(s_name, s_description)
+            except exceptions.BadRequest:
+                pass
+            else:
+                self.fail('Security Group should not be created '
+                          'with duplicate Group Name')
+        finally:
+            #Delete the Security Group created in this method
+            resp, _ = self.client.delete_security_group(security_group['id'])
+            self.assertEqual(202, resp.status)
+
+    @attr(type='negative')
+    def test_delete_nonexistant_security_group(self):
+        """
+        Negative test:Deletion of a nonexistant Security Group should Fail
+        """
+        security_group_id = []
+        resp, body = self.client.list_security_groups()
+        for i in range(len(body)):
+            security_group_id.append(body[i]['id'])
+        #Creating Non Existant Security Group
+        while True:
+            non_exist_id = rand_name('999')
+            if non_exist_id not in security_group_id:
+                break
+        try:
+            resp, body = self.client.delete_security_group(non_exist_id)
+        except exceptions.NotFound:
+            pass
+        else:
+            self.fail('Should not be able to delete a nonexistant '
+                      'Security Group')