Add additional unit tests

These tests are to cover existing class functionality before
modifications of app agnostic parameters and changes in Oslo Log.

Change-Id: I0b041746865e4da5d2c73ce6093f96bd48760e24

2 files changed, 107 insertions, 1 deletions

diff --git a/oslo_context/context.py b/oslo_context/context.py
index 9dd4001..1c43ee5 100644
--- a/oslo_context/context.py
+++ b/oslo_context/context.py
@@ -155,7 +155,7 @@ def get_context_from_function_and_args(function, args, kwargs):
 
 def is_user_context(context):
     """Indicates if the request context is a normal user."""
-    if not context:
+    if not context or not isinstance(context, RequestContext):
         return False
     if context.is_admin:
         return False
diff --git a/oslo_context/tests/test_context.py b/oslo_context/tests/test_context.py
index 531d762..45ead84 100644
--- a/oslo_context/tests/test_context.py
+++ b/oslo_context/tests/test_context.py
@@ -54,15 +54,27 @@ class ContextTest(test_base.BaseTestCase):
         ctx1 = context.RequestContext(overwrite=True)
         context.get_admin_context()
         self.assertIs(context.get_current(), ctx1)
+        self.assertFalse(ctx1.is_admin)
 
     def test_store_current(self):
         # By default a new context is stored.
         ctx = context.RequestContext()
         self.assertIs(context.get_current(), ctx)
 
+    def test_no_context(self):
+        self.assertIsNone(context.get_current())
+
     def test_admin_context_show_deleted_flag_default(self):
         ctx = context.get_admin_context()
+        self.assertIsInstance(ctx, context.RequestContext)
+        self.assertTrue(ctx.is_admin)
         self.assertFalse(ctx.show_deleted)
+        self.assertIsNone(ctx.tenant)
+
+    def test_admin_context_show_deleted_flag_set(self):
+        ctx = context.get_admin_context(show_deleted=True)
+        self.assertTrue(ctx.is_admin)
+        self.assertTrue(ctx.show_deleted)
 
     def test_from_dict(self):
         dct = {
@@ -98,6 +110,7 @@ class ContextTest(test_base.BaseTestCase):
         self.assertFalse(context.is_user_context(ctx))
         ctx = context.RequestContext(is_admin=False)
         self.assertTrue(context.is_user_context(ctx))
+        self.assertFalse(context.is_user_context("non context object"))
 
     def test_from_environ_variables(self):
         auth_token = uuid.uuid4().hex
@@ -119,3 +132,96 @@ class ContextTest(test_base.BaseTestCase):
         self.assertEqual(project_id, ctx.tenant)
         self.assertEqual(user_domain_id, ctx.user_domain)
         self.assertEqual(project_domain_id, ctx.project_domain)
+
+    def test_from_function_and_args(self):
+        ctx = context.RequestContext(user="user1")
+        arg = []
+        kw = dict(c=ctx, s="s")
+        fn = context.get_context_from_function_and_args
+        ctx1 = context.get_context_from_function_and_args(fn, arg, kw)
+        self.assertIs(ctx1, ctx)
+
+    def test_not_in_from_function_and_args(self):
+        arg = []
+        kw = dict()
+        fn = context.get_context_from_function_and_args
+        ctx1 = context.get_context_from_function_and_args(fn, arg, kw)
+        self.assertIsNone(ctx1)
+
+    def test_values(self):
+        auth_token = "token1"
+        user = "user1"
+        tenant = "tenant1"
+        domain = "domain1"
+        user_domain = "user_domain1"
+        project_domain = "project_domain1"
+        is_admin = True
+        read_only = True
+        show_deleted = True
+        request_id = "id1"
+        resource_uuid = "uuid1"
+
+        ctx = context.RequestContext(auth_token=auth_token,
+                                     user=user,
+                                     tenant=tenant,
+                                     domain=domain,
+                                     user_domain=user_domain,
+                                     project_domain=project_domain,
+                                     is_admin=is_admin,
+                                     read_only=read_only,
+                                     show_deleted=show_deleted,
+                                     request_id=request_id,
+                                     resource_uuid=resource_uuid)
+        self.assertEqual(auth_token, ctx.auth_token)
+        self.assertEqual(user, ctx.user)
+        self.assertEqual(tenant, ctx.tenant)
+        self.assertEqual(domain, ctx.domain)
+        self.assertEqual(user_domain, ctx.user_domain)
+        self.assertEqual(project_domain, ctx.project_domain)
+        self.assertEqual(is_admin, ctx.is_admin)
+        self.assertEqual(read_only, ctx.read_only)
+        self.assertEqual(show_deleted, ctx.show_deleted)
+        self.assertEqual(request_id, ctx.request_id)
+        self.assertEqual(resource_uuid, ctx.resource_uuid)
+
+        d = ctx.to_dict()
+        self.assertIn('auth_token', d)
+        self.assertIn('user', d)
+        self.assertIn('tenant', d)
+        self.assertIn('domain', d)
+        self.assertIn('user_domain', d)
+        self.assertIn('project_domain', d)
+        self.assertIn('is_admin', d)
+        self.assertIn('read_only', d)
+        self.assertIn('show_deleted', d)
+        self.assertIn('request_id', d)
+        self.assertIn('resource_uuid', d)
+        self.assertIn('user_identity', d)
+
+        self.assertEqual(auth_token, d['auth_token'])
+        self.assertEqual(tenant, d['tenant'])
+        self.assertEqual(domain, d['domain'])
+        self.assertEqual(user_domain, d['user_domain'])
+        self.assertEqual(project_domain, d['project_domain'])
+        self.assertEqual(is_admin, d['is_admin'])
+        self.assertEqual(read_only, d['read_only'])
+        self.assertEqual(show_deleted, d['show_deleted'])
+        self.assertEqual(request_id, d['request_id'])
+        self.assertEqual(resource_uuid, d['resource_uuid'])
+        user_identity = "%s %s %s %s %s" % (user, tenant, domain,
+                                            user_domain, project_domain)
+        self.assertEqual(user_identity, d['user_identity'])
+
+    def test_dict_empty_user_identity(self):
+        ctx = context.RequestContext()
+        d = ctx.to_dict()
+        self.assertEqual("- - - - -", d['user_identity'])
+
+    def test_generate_request_id(self):
+        id = context.generate_request_id()
+        self.assertEqual("req-", id[:4])
+
+    def test_generate_request_id_unique(self):
+        id1 = context.generate_request_id()
+        id2 = context.generate_request_id()
+        self.assertNotEqual(id1, id2)