예제 #1
0
        public async Task Test_Add_Claim_Delete_All_Async()
        {
            var dao = Global.TenantDao;
            await dao.EstablishConnectionAsync();

            Guid userId = Guid.NewGuid();
            int  nCount = 10;

            for (int i = 0; i < nCount; ++i)
            {
                var guidId      = Guid.NewGuid().ToString();
                var claimHandle = new ClaimHandle()
                {
                    Type = "Type:" + guidId, UserId = userId, Value = "Value:" + guidId
                };
                await dao.CreateClaimAsync(claimHandle);
            }

            var result = await dao.FindClaimHandleByUserIdAsync(userId);

            Assert.IsNotNull(result);
            Assert.AreEqual(nCount, result.Count());

            await dao.DeleteClaimHandleByUserIdAsync(userId);

            result = await dao.FindClaimHandleByUserIdAsync(userId);

            Assert.IsNotNull(result);
            Assert.AreEqual(0, result.Count());
        }
예제 #2
0
        public async Task Test_Add_Claim_Delete_One_Async()
        {
            var dao = Global.TenantDao;
            await dao.EstablishConnectionAsync();

            Guid userId = Guid.NewGuid();

            var guidId      = Guid.NewGuid().ToString();
            var claimHandle = new ClaimHandle()
            {
                Type = "Type:" + guidId, UserId = userId, Value = "Value:" + guidId
            };
            await dao.CreateClaimAsync(claimHandle);


            var result = await dao.FindClaimHandleByUserIdAsync(userId);

            Assert.IsNotNull(result);
            var finalResult = result.ToList();

            Assert.AreEqual(1, finalResult.Count());

            var claimH = finalResult[0];

            Assert.IsTrue(ClaimHandleComparer.Comparer.Equals(claimHandle, claimH));

            await dao.DeleteClaimHandleByUserIdTypeAndValueAsync(userId, claimHandle.Type, claimHandle.Value);

            result = await dao.FindClaimHandleByUserIdAsync(userId);

            Assert.IsNotNull(result);
            Assert.AreEqual(0, result.Count());
        }
예제 #3
0
        public async Task Test_Add_Claims_Pager_Delete_All_Async()
        {
            var dao = Global.TenantDao;
            await dao.EstablishConnectionAsync();

            Guid userId = Guid.NewGuid();
            int  nCount = 1000;

            for (int i = 0; i < nCount; ++i)
            {
                var guidId      = Guid.NewGuid().ToString();
                var claimHandle = new ClaimHandle()
                {
                    Type = "Type:" + guidId, UserId = userId, Value = "Value:" + guidId
                };
                await dao.CreateClaimAsync(claimHandle);
            }
            byte[] pageState           = null;
            int    pageSize            = 99;
            IPage <ClaimHandle> result = await dao.PageClaimsAsync(userId, pageSize, pageState);

            pageState = result.PagingState;
            int nCounter = result.Count;

            while (pageState != null)
            {
                result = await dao.PageClaimsAsync(userId, pageSize, pageState);

                pageState = result.PagingState;
                nCounter += result.Count;
            }
            Assert.AreEqual(nCounter, nCount);


            await dao.DeleteClaimHandleByUserIdAsync(userId);

            var resultFind = await dao.FindClaimHandleByUserIdAsync(userId);

            Assert.IsNotNull(resultFind);
            Assert.AreEqual(0, resultFind.Count());
        }
예제 #4
0
        public async Task Test_Add_Full_User_Find_by_email_Delete_User_Async()
        {
            var dao = Global.TenantDao;
            await dao.EstablishConnectionAsync();

            var guidId        = Guid.NewGuid();
            var insertedUsers = new List <CassandraUser>();

            var role = new CassandraRole()
            {
                Name     = Guid.NewGuid().ToString(),
                IsGlobal = false,
            };
            await dao.CreateRoleAsync(role);

            var roleNameResult = await dao.FindRoleByNameAsync(role.Name);

            Assert.IsNotNull(roleNameResult);
            var foundRoleNameResult = roleNameResult.ToList();

            Assert.IsTrue(foundRoleNameResult.Any());
            Assert.AreEqual(role.Name, foundRoleNameResult[0].Name);

            int nCount = 1;

            for (int i = 0; i < nCount; ++i)
            {
                string userName = Guid.NewGuid().ToString();
                var    user     = new CassandraUser()
                {
                    Email    = userName,
                    UserName = userName
                };
                insertedUsers.Add(user);
                await dao.UpsertUserAsync(user);


                var providerLoginHandle = new ProviderLoginHandle()
                {
                    LoginProvider = Guid.NewGuid().ToString(),
                    ProviderKey   = Guid.NewGuid().ToString(),
                    UserId        = user.Id
                };
                await dao.UpsertLoginsAsync(providerLoginHandle);

                var claimHandle = new ClaimHandle()
                {
                    Type   = "Type:" + guidId,
                    UserId = user.Id,
                    Value  = "Value:" + guidId
                };
                await dao.CreateClaimAsync(claimHandle);

                await dao.AddToRoleAsync(user.Id, role.Name);
            }


            foreach (var testUser in insertedUsers)
            {
                testUser.TenantId = dao.TenantId;
                var foundUserResult = await dao.FindUserByEmailAsync(testUser.Email);

                Assert.IsNotNull(foundUserResult);
                var foundUserList = foundUserResult.ToList();
                Assert.IsTrue(foundUserList.Any());
                Assert.AreEqual(foundUserList.Count, 1);
                var foundUser = foundUserList[0];
                Assert.IsTrue(CassandraUserComparer.ShallowComparer.Equals(foundUser, testUser));

                var roleResult = await dao.FindRoleNamesByUserIdAsync(testUser.Id);

                Assert.IsNotNull(roleResult);
                var roleResultList = roleResult.ToList();
                Assert.AreEqual(1, roleResultList.Count());
                var foundRole = roleResultList[0];
                Assert.AreEqual(foundRole, role.Name);

                var claimResult = await dao.FindClaimHandleByUserIdAsync(testUser.Id);

                Assert.IsNotNull(claimResult);
                var claimResultList = claimResult.ToList();
                Assert.AreEqual(1, claimResultList.Count());
                var foundClaim = claimResultList[0];

                var claimHandle = new ClaimHandle()
                {
                    Type   = "Type:" + guidId,
                    UserId = testUser.Id,
                    Value  = "Value:" + guidId
                };
                Assert.IsTrue(ClaimHandleComparer.Comparer.Equals(foundClaim, claimHandle));
            }

            foreach (var testUser in insertedUsers)
            {
                await dao.DeleteUserAsync(testUser);

                var foundUserResult = await dao.FindUserByEmailAsync(testUser.Email);

                Assert.IsNotNull(foundUserResult);
                var foundUserList = foundUserResult.ToList();
                Assert.IsFalse(foundUserList.Any());
                Assert.AreEqual(foundUserList.Count, 0);

                var roleResult = await dao.FindRoleNamesByUserIdAsync(testUser.Id);

                Assert.IsNotNull(roleResult);
                var roleResultList = roleResult.ToList();
                Assert.IsFalse(roleResultList.Any());

                var claimResult = await dao.FindClaimHandleByUserIdAsync(testUser.Id);

                Assert.IsNotNull(claimResult);
                var claimResultList = claimResult.ToList();
                Assert.IsFalse(claimResultList.Any());
            }
            await dao.DeleteRoleAsync(role);

            roleNameResult = await dao.FindRoleByNameAsync(role.Name);

            Assert.IsNotNull(roleNameResult);
            foundRoleNameResult = roleNameResult.ToList();
            Assert.IsFalse(foundRoleNameResult.Any());
        }
        public async Task Test_add_many_users_page_delete()
        {
            var dao = Global.TenantDao;
            await dao.EstablishConnectionAsync();

            var guidId        = Guid.NewGuid();
            var insertedUsers = new List <CassandraUser>();

            var role = new CassandraRole()
            {
                Name     = Guid.NewGuid().ToString(),
                IsGlobal = false,
            };


            var roleStore = Global.TanantCassandraRoleStore;
            var userStore = Global.TanantCassandraUserStore;

            await roleStore.CreateAsync(role);

            int nCount = 100;

            for (int i = 0; i < nCount; ++i)
            {
                string userName = Guid.NewGuid().ToString();
                var    user     = new CassandraUser()
                {
                    Email    = userName,
                    UserName = userName
                };
                insertedUsers.Add(user);
                await userStore.CreateAsync(user);

                var providerLoginHandle = new ProviderLoginHandle()
                {
                    LoginProvider = Guid.NewGuid().ToString(),
                    ProviderKey   = Guid.NewGuid().ToString(),
                    UserId        = user.Id
                };
                await
                userStore.AddLoginAsync(user,
                                        new UserLoginInfo(providerLoginHandle.LoginProvider, providerLoginHandle.ProviderKey));


                var claimHandle = new ClaimHandle()
                {
                    Type   = "Type:" + guidId,
                    UserId = user.Id,
                    Value  = "Value:" + guidId
                };
                await userStore.AddClaimAsync(user, new Claim(claimHandle.Type, claimHandle.Value));

                await userStore.AddToRoleAsync(user, role.Name);
            }

            byte[] pageState = null;
            int    pageSize  = 9;
            var    result    = await userStore.PageUsersAsync(pageSize, pageState);

            pageState = result.PagingState;
            int nCounter = result.Count;

            while (pageState != null)
            {
                result = await userStore.PageUsersAsync(pageSize, pageState);

                pageState = result.PagingState;
                nCounter += result.Count;
            }
            Assert.AreEqual(nCounter, nCount);


            foreach (var testUser in insertedUsers)
            {
                await dao.DeleteUserAsync(testUser);

                var foundUserResult = await dao.FindUserByEmailAsync(testUser.Email);

                Assert.IsNotNull(foundUserResult);
                var foundUserList = foundUserResult.ToList();
                Assert.IsFalse(foundUserList.Any());
                Assert.AreEqual(foundUserList.Count, 0);

                var roleResult = await dao.FindRoleNamesByUserIdAsync(testUser.Id);

                Assert.IsNotNull(roleResult);
                var roleResultList = roleResult.ToList();
                Assert.IsFalse(roleResultList.Any());

                var claimResult = await dao.FindClaimHandleByUserIdAsync(testUser.Id);

                Assert.IsNotNull(claimResult);
                var claimResultList = claimResult.ToList();
                Assert.IsFalse(claimResultList.Any());
            }
            await roleStore.DeleteAsync(role);

            var findDeletedRole = await roleStore.FindByNameAsync(role.Name);

            Assert.IsNull(findDeletedRole);
        }