C# UserRepository.CreateUser方法代码示例

        public void Delete_ShouldDelete()
        {
            //arange
            PlaceRepository placeRep = new PlaceRepository(Properties.Resources.ConnectionString);
            MeetingRepository meetRep = new MeetingRepository(Properties.Resources.ConnectionString);
            UserRepository userRep = new UserRepository(Properties.Resources.ConnectionString);
            InvitationRepository inviteRep = new InvitationRepository(Properties.Resources.ConnectionString);
            Meeting meeting = TestDataHelper.GenerateMeeting();

            //act
            userRep.CreateUser(meeting.Owner);
            placeRep.CreatePlace(meeting.Place);
            meetRep.CreateMeeting(meeting);
            foreach (User user in meeting.InvitedPeople.Values)
            {
                userRep.CreateUser(user);
                inviteRep.Create(CreateInvitation(meeting, user));
            }

            Meeting resultMeeting = meetRep.GetMeeting(meeting.Id);
            if (resultMeeting != null) TestDataHelper.PrintMeetingInfo(resultMeeting);
            else Console.WriteLine("Meeting not exist");

            meetRep.DeleteMeeting(resultMeeting);
            resultMeeting = meetRep.GetMeeting(meeting.Id);

            //assert
            if (resultMeeting != null) TestDataHelper.PrintMeetingInfo(resultMeeting);
            else Console.WriteLine("Meeting deleted");
            Assert.IsNull(resultMeeting);
        }

        public void CreateInvitation_ShouldCreate()
        {
            //arange
            PlaceRepository placeRep = new PlaceRepository(Properties.Resources.ConnectionString);
            MeetingRepository meetRep = new MeetingRepository(Properties.Resources.ConnectionString);
            UserRepository userRep = new UserRepository(Properties.Resources.ConnectionString);
            InvitationRepository inviteRep = new InvitationRepository(Properties.Resources.ConnectionString);
            Meeting meeting = TestDataHelper.GenerateMeeting();

            //act
            userRep.CreateUser(meeting.Owner);
            placeRep.CreatePlace(meeting.Place);
            meetRep.CreateMeeting(meeting);

            foreach (User user in meeting.InvitedPeople.Values)
            {
                userRep.CreateUser(user);
                inviteRep.Create(CreateInvitation(meeting, user));
            }

            Meeting resultMeeting = meetRep.GetMeeting(meeting.Id);

            //assert
            TestDataHelper.PrintMeetingInfo(meeting);
            TestDataHelper.PrintMeetingInfo(resultMeeting);
            Assert.IsTrue(TestDataHelper.CompareInvitedUsersLists
                (meeting.InvitedPeople.Values, resultMeeting.InvitedPeople.Values));
        }

        public void ShouldReturnUserById()
        {
            const string accountName = "super_user";
            var repo = new UserRepository();
            repo.CreateUser("user_name1", "password", "name1", "address", "phone");
            repo.CreateUser(accountName, "password", "name2", "address", "phone");

            var bankUser = repo.GetUserById(1);

            Assert.AreEqual(accountName,bankUser.AccountName);
        }

 public ActionResult IndexPost(string username)
 {
     var userRepository = new UserRepository();
     var userID = userRepository.CreateUser(username);
     Session.Add("UserID", userID);
     return RedirectToAction("Trivia", "Trivia");
 }

        public void Delete_ShouldDeleteUser()
        {
            //arrange
            var userRepository = new UserRepository(Properties.Resources.ConnectionString);
            User user = TestDataHelper.GenerateUser();

            //act
            userRepository.CreateUser(user);
            User userBeforeDelete = userRepository.GetUser(user.Id);
            if (userBeforeDelete == null)
            {
                Console.WriteLine("User not exist!");
            }
            else
            {
                Console.WriteLine("User exist.");
            }
            userRepository.DeleteUser(user.Id);

            //assert
            User userAfterDelete = userRepository.GetUser(user.Id);

            if (userAfterDelete == null)
            {
                Console.WriteLine("User deleted.");
            }
            else
            {
                Console.WriteLine("User not deleted!");
            }

            Assert.IsTrue(!(userBeforeDelete == null) & (userAfterDelete == null));
        }

        public void ShouldReturnNullWhenUserDoesntExists()
        {
            var repo = new UserRepository();
            repo.CreateUser("some_name", "password", "name", "address", "phone");

            var user = repo.GetUserByName("other_name");

            Assert.IsNull(user);
        }

        public void ShouldCreateNewUserAndReturnHisId()
        {
            var repo = new UserRepository();
            int userId = repo.CreateUser("user_name", "password", "name", "address", "phone");
            var user = repo.GetUserById(userId);

            Assert.IsNotNull(user);
            Assert.AreEqual("user_name",user.AccountName);
        }

        public void ShouldReturnUserByAccountName()
        {
            const string accountName = "user_name";
            var repo = new UserRepository();
            repo.CreateUser(accountName, "password", "name", "address", "phone");

            var user = repo.GetUserByName(accountName);

            Assert.IsNotNull(user);
            Assert.AreEqual(accountName,user.AccountName);
        }

        public void Get_ByEmail_ShouldReturnUser()
        {
            //arrange
            var userRepository = new UserRepository(Properties.Resources.ConnectionString);
            User user = TestDataHelper.GenerateUser();

            //act
            userRepository.CreateUser(user);
            var resultUser = userRepository.GetUser(user.Email);

            //asserts
            TestDataHelper.PrintUserInfo(resultUser);
            Assert.IsTrue(TestDataHelper.CompareUsers(user, resultUser));
        }

        public void DeleteInvitation_ShouldDelete()
        {
            //arange
            PlaceRepository placeRep = new PlaceRepository(Properties.Resources.ConnectionString);
            MeetingRepository meetRep = new MeetingRepository(Properties.Resources.ConnectionString);
            UserRepository userRep = new UserRepository(Properties.Resources.ConnectionString);
            InvitationRepository inviteRep = new InvitationRepository(Properties.Resources.ConnectionString);

            Meeting meeting = TestDataHelper.GenerateMeeting();
            User invitedUser = TestDataHelper.GenerateUser();

            meeting.InvitedPeople.Clear();

            //act
            userRep.CreateUser(meeting.Owner);
            placeRep.CreatePlace(meeting.Place);
            meetRep.CreateMeeting(meeting);

            userRep.CreateUser(invitedUser);
            inviteRep.Create(CreateInvitation(meeting, invitedUser));

            Meeting resultMeeting = meetRep.GetMeeting(meeting.Id);

            bool inviteResult = resultMeeting.InvitedPeople.Count == 1;
            TestDataHelper.PrintMeetingInfo(resultMeeting);

            inviteRep.Delete(CreateInvitation(resultMeeting, invitedUser));

            resultMeeting = meetRep.GetMeeting(meeting.Id);

            bool deleteResult = resultMeeting.InvitedPeople.Count == 0;

            //assert
            TestDataHelper.PrintMeetingInfo(resultMeeting);
            Assert.IsTrue(inviteResult & deleteResult);
        }

        public void Create_ShouldCreateUser()
        {
            //arrange
            var userRepository = new UserRepository(Properties.Resources.ConnectionString);
            User user = TestDataHelper.GenerateUser();
            user.FirstName = "TestUser";

            //act
            userRepository.CreateUser(user);

            //asserts
            var resultUser = userRepository.GetUser(user.Id);
            TestDataHelper.PrintUserInfo(resultUser);
            Assert.IsTrue(TestDataHelper.CompareUsers(user, resultUser));
        }

        public void Create_ShouldCreate()
        {
            //arange
            PlaceRepository placeRep = new PlaceRepository(Properties.Resources.ConnectionString);
            MeetingRepository meetRep = new MeetingRepository(Properties.Resources.ConnectionString);
            UserRepository userRep = new UserRepository(Properties.Resources.ConnectionString);
            Meeting meeting = TestDataHelper.GenerateMeeting();

            //act
            userRep.CreateUser(meeting.Owner);
            placeRep.CreatePlace(meeting.Place);
            meetRep.CreateMeeting(meeting);
            Meeting resultMeeting = meetRep.GetMeeting(meeting.Id);

            //assert
            TestDataHelper.PrintMeetingInfo(meeting);
            TestDataHelper.PrintMeetingInfo(resultMeeting);
            Assert.IsTrue(TestDataHelper.CompareMeetings(meeting, resultMeeting));
        }

 public void ShouldThrowExceptionWhenDuplicateAccountName()
 {
     var repo = new UserRepository();
     repo.CreateUser("some_name", "password", "name", "address", "phone");
     repo.CreateUser("some_name", "123", "Mark", "address", "phone");
 }

        public void Update_ShouldUpdate()
        {
            //arange
            PlaceRepository placeRep = new PlaceRepository(Properties.Resources.ConnectionString);
            MeetingRepository meetRep = new MeetingRepository(Properties.Resources.ConnectionString);
            UserRepository userRep = new UserRepository(Properties.Resources.ConnectionString);
            Meeting firstMeeting = TestDataHelper.GenerateMeeting();
            Meeting secondMeeting = TestDataHelper.GenerateMeeting();
            secondMeeting.Id = firstMeeting.Id;
            secondMeeting.Owner = firstMeeting.Owner;
            secondMeeting.Place = firstMeeting.Place;
            secondMeeting.Title = "secondMeeting";
            secondMeeting.Description = "second descr";

            //act
            placeRep.CreatePlace(firstMeeting.Place);
            userRep.CreateUser(firstMeeting.Owner);
            meetRep.CreateMeeting(firstMeeting);

            meetRep.UpdateMeetingInfo(secondMeeting);
            Meeting resultMeeting = meetRep.GetMeeting(firstMeeting.Id);

            //assert
            TestDataHelper.PrintMeetingInfo(firstMeeting);
            TestDataHelper.PrintMeetingInfo(secondMeeting);
            TestDataHelper.PrintMeetingInfo(resultMeeting);
            Assert.IsTrue(TestDataHelper.CompareMeetings(secondMeeting, resultMeeting));
        }

        public void GetAllMeetingsCreatedByUser_ShouldReturnMeetings()
        {
            //arange
            PlaceRepository placeRep = new PlaceRepository(Properties.Resources.ConnectionString);
            MeetingRepository meetRep = new MeetingRepository(Properties.Resources.ConnectionString);
            UserRepository userRep = new UserRepository(Properties.Resources.ConnectionString);
            User user = TestDataHelper.GenerateUser();
            List<Meeting> meetingList = new List<Meeting>();

            for (int i = 0; i == 5; i++)
            {
                Meeting meeting = TestDataHelper.GenerateMeeting();
                meeting.Owner = user;
                meetingList.Add(meeting);
            }

            //act
            userRep.CreateUser(user);
            foreach(Meeting meeting in meetingList)
            {
                placeRep.CreatePlace(meeting.Place);
                meetRep.CreateMeeting(meeting);
            }
            List<Meeting> resultMeetingList = meetRep.GetAllMeetingsCreatedByUser(user.Id);

            //assert
            Assert.IsTrue(TestDataHelper.CompareMeetingsLists(meetingList, resultMeetingList));
        }