コード例 #1
0
        public async Task DeleteCompany_WithNonExistentUser_ReturnsFalse()
        {
            var testId = Guid.NewGuid().ToString();

            var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
                                                 .UseInMemoryDatabase(Guid.NewGuid().ToString())
                                                 .Options);

            var personalDataService = new PersonalDataService(new EfRepository <Company>(context),
                                                              new EfRepository <ContactMessage>(context),
                                                              new EfRepository <Job>(context),
                                                              new EfRepository <JobSeeker>(context),
                                                              new EfRepository <JobCandidate>(context),
                                                              new EfRepository <User>(context),
                                                              new EfRepository <Resume>(context));

            var result = await personalDataService.DeleteCompany(testId);

            Assert.False(result);
        }
コード例 #2
0
        public async Task DeleteCompany_WithExistingCompany_WorksCorrectly()
        {
            var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
                                                 .UseInMemoryDatabase(Guid.NewGuid().ToString())
                                                 .Options);

            var testUsers = new List <User>
            {
                new User
                {
                    UserName        = "******",
                    Email           = "*****@*****.**",
                    ContactMessages = new List <ContactMessage>()
                    {
                        new ContactMessage()
                        {
                            Subject = "SubjectTest",
                            Message = "MessageTest"
                        }
                    }
                },
                new User
                {
                    UserName = "******",
                    Email    = "*****@*****.**",
                }
            };

            var model = new Company()
            {
                CompanyName = "CompanyTestName",
                User        = testUsers[0],
                Jobs        = new List <Job>()
                {
                    new Job()
                    {
                        Title       = "Test Job Title",
                        Location    = "Test Location",
                        Description = "Random description",
                        EndDate     = DateTime.UtcNow.AddDays(1),
                        Category    = new Category()
                        {
                            CategoryType = "NewCategory"
                        },
                        JobType = new JobType()
                        {
                            Type = "NewType"
                        },
                        JobCandidates = new List <JobCandidate>()
                        {
                            new JobCandidate()
                            {
                                JobSeeker = new JobSeeker()
                                {
                                    FirstName = "TestFirstName",
                                    LastName  = "TestLastName",
                                    User      = testUsers[1]
                                }
                            }
                        }
                    },
                    new Job()
                    {
                        Title       = "Test Job Title1",
                        Location    = "Test Location1",
                        Description = "Random description1",
                        EndDate     = DateTime.UtcNow.AddDays(1),
                        Category    = new Category()
                        {
                            CategoryType = "NewCategory1"
                        },
                        JobType = new JobType()
                        {
                            Type = "NewType1"
                        },
                        JobCandidates = new List <JobCandidate>()
                        {
                            new JobCandidate()
                            {
                                JobSeeker = new JobSeeker()
                                {
                                    FirstName = "TestFirstName1",
                                    LastName  = "TestLastName1",
                                    User      = testUsers[1]
                                }
                            }
                        }
                    }
                }
            };

            await context.AddAsync(model);

            context.SaveChanges();

            var personalDataService = new PersonalDataService(new EfRepository <Company>(context),
                                                              new EfRepository <ContactMessage>(context),
                                                              new EfRepository <Job>(context),
                                                              new EfRepository <JobSeeker>(context),
                                                              new EfRepository <JobCandidate>(context),
                                                              new EfRepository <User>(context),
                                                              new EfRepository <Resume>(context));

            var result = await personalDataService.DeleteCompany(testUsers[0].Id);

            Assert.True(result);

            var companiesCount = await context.Companies.CountAsync();

            Assert.Equal(0, companiesCount);

            var jobsCount = await context.Jobs.CountAsync();

            Assert.Equal(0, jobsCount);

            var contactMessagesCount = await context.ContactMessages.CountAsync();

            Assert.Equal(0, contactMessagesCount);

            var usersCount = await context.Users.CountAsync();

            Assert.Equal(1, usersCount);
        }