コード例 #1
0
        public async Task Save_ProfilePictureUrl_InDb_WhenValidValuesPassed()
        {
            var options = TestUtils.GetOptions(nameof(Save_ProfilePictureUrl_InDb_WhenValidValuesPassed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var arrangeContext = new CMContext(options))
            {
                //1
                arrangeContext.Users.Add(
                    new AppUser
                {
                    Id       = "1",
                    UserName = "******",
                    Email    = "*****@*****.**",
                });

                await arrangeContext.SaveChangesAsync();
            }
            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                await sut.SetProfilePictureURL("1", "image");

                Assert.AreEqual("image", assertContext.Users.First(x => x.Id == "1").ImageURL);
            }
        }
コード例 #2
0
        public async Task SetDateDeleted_OfAppUser_ToDateTimeNow_WhenValidValuesPassed()
        {
            var options = TestUtils.GetOptions(nameof(SetDateDeleted_OfAppUser_ToDateTimeNow_WhenValidValuesPassed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var user = new AppUser
                {
                    Id       = "1",
                    UserName = "******",
                    ImageURL = "user1Img",
                    Email    = "user1@mail",
                };
                assertContext.Users.Add(user);
                await assertContext.SaveChangesAsync();

                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                Assert.AreEqual(null, assertContext.Users.First().DateDeleted);

                await sut.Delete("1");

                Assert.AreNotEqual(null, assertContext.Users.First().DateDeleted);
                Assert.AreEqual(1, assertContext.Users.Count());
            }
        }
コード例 #3
0
            public async Task Return_AppUserDTOWithCorrectAttributes_WhenValidIdPassed()
            {
                var options = TestUtils.GetOptions(nameof(Return_AppUserDTOWithCorrectAttributes_WhenValidIdPassed));

                var userStoreMocked   = new Mock <IUserStore <AppUser> >();
                var userManagerMocked =
                    new Mock <UserManager <AppUser> >
                        (userStoreMocked.Object, null, null, null, null, null, null, null, null);

                using (var arrangeContext = new CMContext(options))
                {
                    arrangeContext.Roles.Add(new AppRole {
                        Id = "1", Name = "Manager", NormalizedName = "MANAGER"
                    });

                    //1
                    arrangeContext.Users.Add(
                        new AppUser
                    {
                        Id       = "1",
                        UserName = "******",
                        Email    = "*****@*****.**"
                    });

                    //2
                    arrangeContext.Users.Add(
                        new AppUser
                    {
                        Id       = "2",
                        UserName = "******",
                        Email    = "*****@*****.**"
                    });

                    //3
                    var user = new AppUser
                    {
                        Id       = "3",
                        UserName = "******",
                        Email    = "*****@*****.**",
                    };
                    arrangeContext.Users.Add(user);
                    await arrangeContext.SaveChangesAsync();

                    IList <string> roles = new List <string> {
                        "Manager"
                    };
                    userManagerMocked.Setup(x => x.GetRolesAsync(user))
                    .ReturnsAsync(roles);

                    var sut = new AppUserServices(arrangeContext, userManagerMocked.Object);

                    var result = await sut.GetUserDToByID("3");

                    Assert.AreEqual("user3", result.Username);
                    Assert.AreEqual("*****@*****.**", result.Email);
                    Assert.AreEqual("3", result.Id);
                    Assert.AreEqual("Manager", result.Role);
                    Assert.IsInstanceOfType(result, typeof(AppUserDTO));
                }
            }
コード例 #4
0
        public async Task Throw_CorrectMagicExeption_WhenIdPassed_IsOfDeletedAppUser()
        {
            var options = TestUtils.GetOptions(nameof(Throw_CorrectMagicExeption_WhenIdPassed_IsOfDeletedAppUser));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var arrangeContext = new CMContext(options))
            {
                //1
                arrangeContext.Users.Add(
                    new AppUser
                {
                    Id          = "1",
                    UserName    = "******",
                    Email       = "*****@*****.**",
                    DateDeleted = DateTime.Now
                });

                await arrangeContext.SaveChangesAsync();
            }


            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await Assert.ThrowsExceptionAsync <MagicException>(
                    async() => await sut.SetProfilePictureURL("1", "url"));

                Assert.AreEqual("AppUser cannot be null!", result.Message);
            }
        }
コード例 #5
0
        public async Task ThrowMagicExeption_IfAppUser_DoesnotExist()
        {
            var options = TestUtils.GetOptions(nameof(ThrowMagicExeption_IfAppUser_DoesnotExist));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var role = new AppRole {
                    Id = "1", Name = "Administrator", NormalizedName = "ADMINISTRATOR"
                };

                assertContext.Roles.Add(role);
                assertContext.UserRoles.Add(
                    new IdentityUserRole <string>
                {
                    RoleId = "1",
                    UserId = "1"
                });
                await assertContext.SaveChangesAsync();

                var sut = new AppUserServices(assertContext, userManagerMocked.Object);
                var ex  = await Assert.ThrowsExceptionAsync <MagicException>
                              (async() => await sut.GetAdmin());
            }
        }
コード例 #6
0
        public async Task Return_RoleAsString_WhenValidAppUserPassed()
        {
            var options = TestUtils.GetOptions(nameof(Return_RoleAsString_WhenValidAppUserPassed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var managerRole = new AppRole {
                    Id = "1", Name = "Manager", NormalizedName = "MANAGER"
                };
                var adminRole = new AppRole {
                    Id = "2", Name = "Admin", NormalizedName = "ADMIN"
                };
                assertContext.Roles.Add(managerRole);
                assertContext.Roles.Add(adminRole);
                var manager = new AppUser
                {
                    Id       = "1",
                    UserName = "******",
                    ImageURL = "user1Img",
                    Email    = "user1@mail",
                };
                var admin = new AppUser
                {
                    Id       = "2",
                    UserName = "******",
                    ImageURL = "user2Img",
                    Email    = "user2@mail",
                };
                assertContext.Users.Add(manager);
                assertContext.Users.Add(admin);
                await assertContext.SaveChangesAsync();

                var roles = new List <string> {
                    "Manager"
                };
                var roles2 = new List <string> {
                    "Admin"
                };
                userManagerMocked.Setup(x => x.GetRolesAsync(manager))
                .ReturnsAsync(roles);
                userManagerMocked.Setup(y => y.GetRolesAsync(admin))
                .ReturnsAsync(roles2);

                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await sut.GetRole(manager);

                Assert.AreEqual("Manager", result);
                var result2 = await sut.GetRole(admin);

                Assert.AreEqual("Admin", result2);
                Assert.IsInstanceOfType(result, typeof(String));
            }
        }
コード例 #7
0
        public async Task Return_AppUserImageUrl_WhenValidValuePassed()
        {
            var options = TestUtils.GetOptions(nameof(Return_AppUserImageUrl_WhenValidValuePassed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var arrangeContext = new CMContext(options))
            {
                //1
                arrangeContext.Users.Add(
                    new AppUser
                {
                    Id       = "1",
                    UserName = "******",
                    Email    = "*****@*****.**",
                    ImageURL = "myImage"
                });

                //2
                arrangeContext.Users.Add(
                    new AppUser
                {
                    Id       = "2",
                    UserName = "******",
                    Email    = "*****@*****.**",
                    ImageURL = "user2Img"
                });

                //3
                var user = new AppUser
                {
                    Id       = "3",
                    UserName = "******",
                    Email    = "*****@*****.**",
                    ImageURL = "targetImg"
                };
                arrangeContext.Users.Add(user);

                await arrangeContext.SaveChangesAsync();
            }
            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await sut.GetProfilePictureURL("3");

                Assert.AreEqual("targetImg", result);
                Assert.IsInstanceOfType(result, typeof(String));
            }
        }
コード例 #8
0
        public async Task Throw_MagicCorrectExeption_WhenNullValueId_Passed()
        {
            var options = TestUtils.GetOptions(nameof(Throw_MagicCorrectExeption_WhenNullValueId_Passed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var arrangeContext = new CMContext(options))
            {
                //1
                arrangeContext.Users.Add(
                    new AppUser
                {
                    Id       = "1",
                    UserName = "******",
                    Email    = "*****@*****.**",
                    ImageURL = "myImage"
                });

                //2
                arrangeContext.Users.Add(
                    new AppUser
                {
                    Id       = "2",
                    UserName = "******",
                    Email    = "*****@*****.**",
                    ImageURL = "user2Img"
                });

                //3
                var user = new AppUser
                {
                    Id       = "3",
                    UserName = "******",
                    Email    = "*****@*****.**",
                    ImageURL = "targetImg"
                };
                arrangeContext.Users.Add(user);

                await arrangeContext.SaveChangesAsync();
            }
            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await Assert.ThrowsExceptionAsync <MagicException>(
                    async() => await sut.GetProfilePictureURL(null));

                Assert.AreEqual("ID cannot be null!", result.Message);
            }
        }
コード例 #9
0
        public async Task MakeInstance_OfTypeAppUserService_IfValidValuesPassed()
        {
            var options = TestUtils.GetOptions(nameof(MakeInstance_OfTypeAppUserService_IfValidValuesPassed));

            var userStoreMocked = new Mock<IUserStore<AppUser>>();
            var userManagerMocked = 
                new Mock<UserManager<AppUser>>
                (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            var userService = new AppUserServices(new CMContext(options), userManagerMocked.Object);

            Assert.IsInstanceOfType(userService, typeof(AppUserServices));
        }
コード例 #10
0
        public async Task ThrowMagicExeption_IfNullValueId_Passed()
        {
            var options = TestUtils.GetOptions(nameof(ThrowMagicExeption_IfNullValueId_Passed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);
                var ex  = await Assert.ThrowsExceptionAsync <MagicException>
                              (async() => await sut.Delete(null));
            }
        }
コード例 #11
0
        public async Task ThrowMagicExeption_IfAppRole_DoesnotExist()
        {
            var options = TestUtils.GetOptions(nameof(ThrowMagicExeption_IfAppRole_DoesnotExist));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);
                var ex  = await Assert.ThrowsExceptionAsync <MagicException>
                              (async() => await sut.GetAdmin());
            }
        }
コード例 #12
0
        public async Task ThrowMagicExeption_IfAppUser_WichDoesntExist_Passed()
        {
            var options = TestUtils.GetOptions(nameof(ThrowMagicExeption_IfAppUser_WichDoesntExist_Passed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);
                var ex  = await Assert.ThrowsExceptionAsync <MagicException>
                              (async() => await sut.ConvertToManager("dasdad"));
            }
        }
コード例 #13
0
        public async Task Return_RoleName_NoRole_IfUserHasNoRole()
        {
            var options = TestUtils.GetOptions(nameof(Return_RoleName_NoRole_IfUserHasNoRole));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var managerRole = new AppRole {
                    Id = "1", Name = "Manager", NormalizedName = "MANAGER"
                };
                var adminRole = new AppRole {
                    Id = "2", Name = "Admin", NormalizedName = "ADMIN"
                };
                assertContext.Roles.Add(managerRole);
                assertContext.Roles.Add(adminRole);
                var user = new AppUser
                {
                    Id       = "1",
                    UserName = "******",
                    ImageURL = "user1Img",
                    Email    = "user1@mail",
                };

                assertContext.Users.Add(user);
                await assertContext.SaveChangesAsync();

                var roles = new List <string> {
                };
                userManagerMocked.Setup(x => x.GetRolesAsync(user))
                .ReturnsAsync(roles);

                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await sut.GetAllUsers();

                Assert.AreEqual(1, result.Count);
                Assert.AreEqual("No role", result.First().Role);
                Assert.AreEqual("user1", result.First().Username);
                Assert.AreEqual("user1@mail", result.First().Email);
                Assert.AreEqual("user1Img", result.First().ImageURL);
                Assert.IsInstanceOfType(result, typeof(ICollection <AppUserDTO>));
            }
        }
コード例 #14
0
        public async Task Throw_MagicExeption_IfNullValue_AppUserOccurs()
        {
            var options = TestUtils.GetOptions(nameof(Throw_CorrectMagicExeption_IfNullValue_AppUserOccurs));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await Assert.ThrowsExceptionAsync <MagicException>
                                 (async() => await sut.GetUserByUsernameAsync("13333"));
            }
        }
コード例 #15
0
        public async Task Throw_MagicExeption_WhenAppUserWithThisId_DoesNotExist()
        {
            var options = TestUtils.GetOptions(nameof(Throw_MagicExeption_WhenAppUserWithThisId_DoesNotExist));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await Assert.ThrowsExceptionAsync <MagicException>(
                    async() => await sut.SetProfilePictureURL("asdadad", "url"));
            }
        }
コード例 #16
0
        public async Task ChangeUserRole_toManager_WhenValidIdPassed()
        {
            var options = TestUtils.GetOptions(nameof(ChangeUserRole_toManager_WhenValidIdPassed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var managerRole = new AppRole {
                    Id = "1", Name = "Manager", NormalizedName = "MANAGER"
                };
                assertContext.Roles.Add(managerRole);

                var member = new AppUser
                {
                    Id       = "1",
                    UserName = "******",
                    ImageURL = "user1Img",
                    Email    = "user1@mail",
                };

                assertContext.Users.Add(member);
                await assertContext.SaveChangesAsync();

                var roles = new List <string> {
                    "Member", "bloger"
                };

                userManagerMocked.Setup(x => x.GetRolesAsync(member))
                .ReturnsAsync(roles);
                userManagerMocked.Setup(x => x.RemoveFromRolesAsync(member, roles));
                userManagerMocked.Setup(x => x.AddToRoleAsync(member, "Manager"));

                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                await sut.ConvertToManager("1");

                userManagerMocked.Verify(x => x.GetRolesAsync(member), Times.Once);
                userManagerMocked.Verify(x => x.RemoveFromRolesAsync(member, roles), Times.Once);
                userManagerMocked.Verify(x => x.AddToRoleAsync(member, "Manager"), Times.Once);
            }
        }
コード例 #17
0
        public async Task ThrowCorrectMagicExeption_IfNullId_Passed()
        {
            var options = TestUtils.GetOptions(nameof(ThrowCorrectMagicExeption_IfNullId_Passed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);
                var ex  = await Assert.ThrowsExceptionAsync <MagicException>
                              (async() => await sut.ConvertToManager(null));

                Assert.AreEqual("ID cannot be null!", ex.Message);
            }
        }
コード例 #18
0
        public async Task ThrowCorrectMagicExeption_IfUserWithIdPassed_DoesnotExist()
        {
            var options = TestUtils.GetOptions(nameof(ThrowCorrectMagicExeption_IfUserWithIdPassed_DoesnotExist));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);
                var ex  = await Assert.ThrowsExceptionAsync <MagicException>
                              (async() => await sut.Delete("dasda"));

                Assert.AreEqual("AppUser cannot be null!", ex.Message);
            }
        }
コード例 #19
0
        public async Task Return_AppUser_WithRoleAdministrator_WhenEverythingIsOk()
        {
            var options = TestUtils.GetOptions(nameof(Return_AppUser_WithRoleAdministrator_WhenEverythingIsOk));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var member = new AppUser {
                    Id = "2", UserName = "******"
                };
                var manager = new AppUser {
                    Id = "1", UserName = "******"
                };
                var admin = new AppUser {
                    Id = "3", UserName = "******"
                };
                assertContext.Users.Add(admin);
                assertContext.Users.Add(member);
                assertContext.Users.Add(manager);
                var role = new AppRole {
                    Id = "1", Name = "Administrator", NormalizedName = "ADMINISTRATOR"
                };

                assertContext.Roles.Add(role);
                assertContext.UserRoles.Add(
                    new IdentityUserRole <string>
                {
                    RoleId = "1",
                    UserId = "3"
                });
                await assertContext.SaveChangesAsync();

                var sut    = new AppUserServices(assertContext, userManagerMocked.Object);
                var result = await sut.GetAdmin();

                Assert.AreEqual("3", result.Id);
                Assert.AreEqual("Admin", result.UserName);
                Assert.IsInstanceOfType(result, typeof(AppUser));
            }
        }
コード例 #20
0
        public async Task Throw_CorrectMagicExeption_WhenNullAppUserId_Passed()
        {
            var options = TestUtils.GetOptions(nameof(Throw_CorrectMagicExeption_WhenNullAppUserId_Passed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await Assert.ThrowsExceptionAsync <MagicException>(
                    async() => await sut.SetProfilePictureURL(null, "url"));

                Assert.AreEqual("ID cannot be null!", result.Message);
            }
        }
コード例 #21
0
        public async Task Throw_CorrectMagicExeption_IfNullValue_UserNamePassed()
        {
            var options = TestUtils.GetOptions(nameof(Throw_CorrectMagicExeption_IfNullValue_UserNamePassed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await Assert.ThrowsExceptionAsync <MagicException>
                                 (async() => await sut.GetUserByUsernameAsync(null));

                Assert.AreEqual("UserName cannot be null!", result.Message);
            }
        }
コード例 #22
0
        public async Task Return_UserNameAsString_WhenValidValues_Passed()
        {
            var options = TestUtils.GetOptions(nameof(Return_UserNameAsString_WhenValidValues_Passed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var arrangeContext = new CMContext(options))
            {
                //1
                arrangeContext.Users.Add(new AppUser {
                    Id = "1", UserName = "******"
                });

                //2
                arrangeContext.Users.Add(new AppUser {
                    Id = "2", UserName = "******"
                });

                //3
                arrangeContext.Users.Add(new AppUser {
                    Id = "3", UserName = "******"
                });

                await arrangeContext.SaveChangesAsync();
            }
            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await sut.GetUsernameById("2");

                Assert.AreEqual("user2", result);
                Assert.IsInstanceOfType(result, typeof(String));
                var result2 = await sut.GetUsernameById("3");

                Assert.AreEqual("user3", result2);
            }
        }
コード例 #23
0
        public async Task Return_AppUserWithSameUsername_IfThereIsOne()
        {
            var options = TestUtils.GetOptions(nameof(Return_AppUserWithSameUsername_IfThereIsOne));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var arrangeContext = new CMContext(options))
            {
                //1
                arrangeContext.Users.Add(new AppUser {
                    Id = "1", UserName = "******"
                });

                //2
                arrangeContext.Users.Add(new AppUser {
                    Id = "2", UserName = "******"
                });

                //3
                arrangeContext.Users.Add(new AppUser {
                    Id = "3", UserName = "******", Email = "*****@*****.**"
                });

                await arrangeContext.SaveChangesAsync();
            }
            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await sut.GetUserByUsernameAsync("user3");

                Assert.AreEqual("user3", result.UserName);
                Assert.AreEqual("3", result.Id);
                Assert.AreEqual("*****@*****.**", result.Email);
                Assert.IsInstanceOfType(result, typeof(AppUser));
            }
        }
コード例 #24
0
        public async Task Throw_CorrectMagicExeption_IfUserWithSuchId_DoesNotExist()
        {
            var options = TestUtils.GetOptions(nameof(Throw_CorrectMagicExeption_IfUserWithSuchId_DoesNotExist));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var arrangeContext = new CMContext(options))
            {
                //1
                arrangeContext.Users.Add(new AppUser {
                    Id = "1", UserName = "******"
                });

                //2
                arrangeContext.Users.Add(new AppUser {
                    Id = "2", UserName = "******"
                });

                //3
                arrangeContext.Users.Add(new AppUser {
                    Id = "3", UserName = "******"
                });

                await arrangeContext.SaveChangesAsync();
            }
            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await Assert.ThrowsExceptionAsync <MagicException>
                                 (async() => await sut.GetUsernameById("a3331s"));

                Assert.AreEqual("AppUser cannot be null!", result.Message);
            }
        }
コード例 #25
0
        public async Task Return_AnnonymousAsUserName_IfNullIdPassed()
        {
            var options = TestUtils.GetOptions(nameof(Return_AnnonymousAsUserName_IfNullIdPassed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var arrangeContext = new CMContext(options))
            {
                //1
                arrangeContext.Users.Add(new AppUser {
                    Id = "1", UserName = "******"
                });

                //2
                arrangeContext.Users.Add(new AppUser {
                    Id = "2", UserName = "******"
                });

                //3
                arrangeContext.Users.Add(new AppUser {
                    Id = "3", UserName = "******"
                });

                await arrangeContext.SaveChangesAsync();
            }
            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = await sut.GetUsernameById(null);

                Assert.AreEqual("annonymous", result);
            }
        }
コード例 #26
0
        public async Task Throw_MagicExeption_NullValueIdPassed()
        {
            var options = TestUtils.GetOptions(nameof(Throw_MagicExeption_NullValueIdPassed));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var arrangeContext = new CMContext(options))
            {
                //1
                arrangeContext.Users.Add(new AppUser {
                    Id = "1", UserName = "******"
                });

                //2
                arrangeContext.Users.Add(new AppUser {
                    Id = "2", UserName = "******"
                });

                //3
                arrangeContext.Users.Add(new AppUser {
                    Id = "3", UserName = "******"
                });

                await arrangeContext.SaveChangesAsync();
            }
            using (var assertContext = new CMContext(options))
            {
                var sut = new AppUserServices(assertContext, userManagerMocked.Object);

                var result = Assert.ThrowsExceptionAsync <MagicException>
                                 (async() => await sut.GetUserByID(null));
            }
        }
コード例 #27
0
        public async Task ThrowCorrectMagicExeption_IfUserRoleConnection_DoesnotExist()
        {
            var options = TestUtils.GetOptions(nameof(ThrowMagicExeption_IfUserRoleConnection_DoesnotExist));

            var userStoreMocked   = new Mock <IUserStore <AppUser> >();
            var userManagerMocked =
                new Mock <UserManager <AppUser> >
                    (userStoreMocked.Object, null, null, null, null, null, null, null, null);

            using (var assertContext = new CMContext(options))
            {
                var role = new AppRole {
                    Name = "Administrator", NormalizedName = "ADMINISTRATOR"
                };
                assertContext.Roles.Add(role);
                await assertContext.SaveChangesAsync();

                var sut = new AppUserServices(assertContext, userManagerMocked.Object);
                var ex  = await Assert.ThrowsExceptionAsync <MagicException>
                              (async() => await sut.GetAdmin());

                Assert.AreEqual("UserRole cannot be null!", ex.Message);
            }
        }