public async Task RoomUpdateSuccessfully(int roomId)
{
//Arrange
var room = new Room()
{
RoomId = roomId,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1
};
// Act
var result = await RoomDAO.Create(roomContext, room);
// Assert
Assert.Equal((int)HttpStatusCode.OK, ((ObjectResult)result).StatusCode);
room.Subject = "testSubject2";
room.ClassName = "testName2";
result = RoomDAO.UpdateRoom(roomContext, room);
var resultRoom = RoomDAO.Get(roomContext, roomId);
Assert.Equal((int)HttpStatusCode.OK, ((ObjectResult)result).StatusCode);
Assert.Equal(resultRoom.RoomId, room.RoomId);
Assert.Equal(resultRoom.Subject, room.Subject);
Assert.Equal(resultRoom.ClassName, room.ClassName);
Assert.Equal(resultRoom.CreatorId, room.CreatorId);
Assert.Equal(resultRoom.SemesterId, room.SemesterId);
}
public async Task DeleteFail(int roomId1, int roomId2)
{
var room = new Room()
{
RoomId = roomId1,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1
};
var room2 = new Room()
{
RoomId = roomId2,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1
};
// Act
var result = await RoomDAO.Create(roomContext, room);
// Assert
Assert.Equal((int)HttpStatusCode.OK, ((ObjectResult)result).StatusCode);
result = await RoomDAO.Delete(roomContext, room2);
Assert.Equal((int)HttpStatusCode.InternalServerError, ((ObjectResult)result).StatusCode);
room = RoomDAO.Get(roomContext, roomId1);
Assert.NotNull(room);
}
public RoomServiceTest()
{
//setting up context
factory = new ConnectionFactory();
_context = factory.CreateRoomDbContextForInMemory();
_context.Database.EnsureDeleted();
_context.Database.EnsureCreated();
_context.SaveChanges();
var room = new Room()
{
RoomId = 1,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1
};
RoomDAO.Create(_context, room);
var chats = new List <RoomChat>();
chats.Add(new RoomChat()
{
Id = 1, RoomId = 1, UserId = "testUser", Date = DateTime.Now, Content = "testChat", Type = 1,
});
chats.Add(new RoomChat()
{
Id = 2, RoomId = 1, UserId = "testUser", Date = DateTime.Now, Content = "testChat", Type = 1,
});
chats.Add(new RoomChat()
{
Id = 3, RoomId = 1, UserId = "testUser", Date = DateTime.Now, Content = "testChat", Type = 1,
});
foreach (var chat in chats)
{
RoomChatDAO.Create(_context, chat);
}
var links = new List <RoomUserLink>();
links.Add(new RoomUserLink()
{
RoomId = 1, RoomUserId = 1, UserId = "testUser"
});
links.Add(new RoomUserLink()
{
RoomId = 1, RoomUserId = 2, UserId = "testUser1"
});
links.Add(new RoomUserLink()
{
RoomId = 1, RoomUserId = 3, UserId = "testUser2"
});
RoomUserLinkDAO.Create(_context, links);
_env = new Mock <IWebHostEnvironment>();
_env.Setup(f => f.ContentRootPath).Returns("");
}
public RoomChatDAOTest()
{
factory = new ConnectionFactory();
roomContext = factory.CreateRoomDbContextForInMemory();
roomContext.Database.EnsureDeleted();
roomContext.Database.EnsureCreated();
roomContext.SaveChanges();
var room = new Room()
{
RoomId = 1,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1
};
RoomDAO.Create(roomContext, room);
}
public async Task GetRoomByClassSubjectSemetser()
{
var result = await RoomDAO.Create(roomContext, new Room()
{
RoomId = 1,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1
});
Assert.Equal((int)HttpStatusCode.OK, ((ObjectResult)result).StatusCode);
result = await RoomDAO.Create(roomContext, new Room()
{
RoomId = 2,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 2
});
Assert.Equal((int)HttpStatusCode.OK, ((ObjectResult)result).StatusCode);
var room = RoomDAO.GetRoomByClassSubjectSemester(roomContext, "testName", "testSubject", 1);
Assert.NotNull(room);
Assert.Equal(1, room.RoomId);
Assert.Equal("testSubject", room.Subject);
Assert.Equal("testName", room.ClassName);
Assert.Equal("testUser", room.CreatorId);
Assert.Equal(1, room.SemesterId);
room = RoomDAO.GetRoomByClassSubjectSemester(roomContext, "testName", "testSubject", 2);
Assert.NotNull(room);
Assert.Equal(2, room.RoomId);
Assert.Equal("testSubject", room.Subject);
Assert.Equal("testName", room.ClassName);
Assert.Equal("testUser", room.CreatorId);
Assert.Equal(2, room.SemesterId);
}
public async Task GetGroupByRoom()
{
var result = await RoomDAO.Create(roomContext, new Room()
{
RoomId = 1,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1,
Group = true,
MainRoomId = 1,
});
Assert.Equal((int)HttpStatusCode.OK, ((ObjectResult)result).StatusCode);
var room = RoomDAO.GetGroupByRoom(roomContext, 1);
Assert.NotNull(room);
}
private void AddOperation()
{
switch (view.entity)
{
case Entity.Room:
Room room = view.RoomAddOrUpdateEnter();
roomDAO.Create(room);
break;
case Entity.Guest:
Guest guest = view.GuestAddOrUpdateEnter();
guestDAO.Create(guest);
break;
case Entity.Booking:
Booking booking = view.BookingAddOrUpdate();
bookingDAO.Create(booking);
break;
}
view.Success();
}
public static GroupResponse CreateGroup(RoomDBContext context, HttpRequest request)
{
var now = DateTime.Now;
Room room = new Room
{
Subject = request.Form["name"],
CreatorId = request.Form["teacherId"],
MainRoomId = Convert.ToInt32(request.Form["roomId"]),
Group = true,
StartDate = now,
EndDate = now
};
var result = RoomDAO.Create(context, room);
var group = RoomDAO.GetLastRoom(context);
var listUserIds = JsonConvert.DeserializeObject <List <string> >(request.Form["userIds"]);
var roomUserLinks = listUserIds.Select(userId => new RoomUserLink
{
RoomId = group.RoomId,
UserId = userId
}).ToList();
var existLink = context.RoomUserLink.Where(link => link.RoomId == group.RoomId).ToList();
if (existLink.Count != 0)
{
roomUserLinks = roomUserLinks.Where(link => !existLink.Any(x => x.UserId == link.UserId)).ToList();
}
result = RoomUserLinkDAO.Create(context, roomUserLinks);
return(new GroupResponse
{
GroupId = group.RoomId,
Name = group.Subject,
UserIds = RoomUserLinkDAO.GetRoomLink(context, group.RoomId).Select(item => item.UserId).ToList(),
StartTime = group.StartDate.ToUniversalTime(),
EndTime = group.EndDate.ToUniversalTime()
});
}
public async Task RoomCreateFail(int roomId)
{
var result = await RoomDAO.Create(roomContext, new Room()
{
RoomId = roomId,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1
});
result = await RoomDAO.Create(roomContext, new Room()
{
RoomId = roomId,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1
});
// Assert
Assert.Equal((int)HttpStatusCode.InternalServerError, ((ObjectResult)result).StatusCode);
}
public async Task DeleteSuccessfull(int roomId)
{
var room = new Room()
{
RoomId = roomId,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1
};
// Act
var result = await RoomDAO.Create(roomContext, room);
// Assert
Assert.Equal((int)HttpStatusCode.OK, ((ObjectResult)result).StatusCode);
result = await RoomDAO.Delete(roomContext, room);
Assert.Equal((int)HttpStatusCode.OK, ((ObjectResult)result).StatusCode);
room = RoomDAO.Get(roomContext, roomId);
Assert.Null(room);
}
public SemesterServiceTest()
{
factory = new ConnectionFactory();
userContext = factory.CreateUserDbContextForInMemory();
userContext.Database.EnsureDeleted();
userContext.Database.EnsureCreated();
userContext.SaveChanges();
roomContext = factory.CreateRoomDbContextForInMemory();
roomContext.Database.EnsureDeleted();
roomContext.Database.EnsureCreated();
roomContext.SaveChanges();
attendanceDAO = new Mock <AttendanceDAO>(userContext);
logDAO = new Mock <LogDAO>(userContext);
var iAttendanceDao = attendanceDAO.As <IAttendanceDAO>();
var iLogDAO = logDAO.As <ILogDAO>();
//mocking user manager
var users = new List <AppUser>
{
new AppUser
{
UserName = "******",
Email = "*****@*****.**"
},
new AppUser
{
UserName = "******",
Email = "*****@*****.**"
},
new AppUser
{
UserName = "******",
Email = "*****@*****.**"
},
new AppUser
{
UserName = "******",
Email = "*****@*****.**"
},
new AppUser
{
UserName = "******",
Email = "*****@*****.**"
},
}.AsQueryable();
var fakeUserManager = new Mock <FakeUserManager>();
fakeUserManager.Setup(x => x.Users).Returns(users.AsQueryable());
fakeUserManager.Setup(x => x.DeleteAsync(It.IsAny <AppUser>()))
.ReturnsAsync(IdentityResult.Success);
fakeUserManager.Setup(x => x.CreateAsync(It.IsAny <AppUser>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success);
fakeUserManager.Setup(x => x.UpdateAsync(It.IsAny <AppUser>()))
.ReturnsAsync(IdentityResult.Success);
var mockEnvironment = new Mock <IWebHostEnvironment>();
//...Setup the mock as needed
mockEnvironment
.Setup(m => m.EnvironmentName)
.Returns("Hosting:UnitTestEnvironment");
mockEnvironment.Setup(m => m.ContentRootPath).Returns("");
_SemetserService = new Mock <SemesterService>(fakeUserManager.Object, userContext, roomContext, mockEnvironment.Object, iAttendanceDao.Object, iLogDAO.Object);
var semester = new Semester()
{
Id = 1,
Name = "testSemester",
File = "TestFile.xsl",
LastUpdated = DateTime.Now
};
SemesterDAO.Create(roomContext, semester);
var room = new Room()
{
RoomId = 1,
Subject = "testSubject",
ClassName = "testName",
CreatorId = "testUser",
SemesterId = 1
};
RoomDAO.Create(roomContext, room);
var links = new List <RoomUserLink>();
links.Add(new RoomUserLink()
{
RoomId = 1, RoomUserId = 1, UserId = "testUser"
});
links.Add(new RoomUserLink()
{
RoomId = 1, RoomUserId = 2, UserId = "testUser2"
});
links.Add(new RoomUserLink()
{
RoomId = 1, RoomUserId = 3, UserId = "testUser1"
});
// Act
RoomUserLinkDAO.Create(roomContext, links);
var schedule = new Timetable()
{
Id = 1,
RoomId = 1,
Date = DateTime.Now.Date,
StartTime = TimeSpan.Parse("8:00"),
EndTime = TimeSpan.Parse("10:00"),
};
// Act
TimetableDAO.Create(roomContext, schedule);
}