public void ShouldStartChatWithUser()
{
var profile = new Profile
{
Id = Guid.NewGuid(),
Login = "******",
Avatar = Guid.NewGuid(),
Password = "******",
Name = "odmin",
Surname = "odmin"
};
const string chatName = "UserChat";
var profileRepository = new ProfilesRepository(Constants.Constants.ConnectionString);
var result = profileRepository.CreateProfile(profile);
_tempUsers.Add(result.Id);
var chatRepository = new ChatsRepository(Constants.Constants.ConnectionString, profileRepository);
var chatBefore = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat = chatRepository.CreateChat(chatBefore);
_chats.Add(chat.ChatId);
var userChats = profileRepository.GetProfileChats(profile.Id);
Assert.AreEqual(chatName, chat.ChatName);
Assert.AreEqual(profile.Id, chat.ChatMembers.Single());
var chats = userChats as IList <Chat> ?? userChats.ToList();
Assert.AreEqual(chat.ChatId, chats.Single().ChatId);
Assert.AreEqual(chat.ChatName, chats.Single().ChatName);
}
private void fillGrid()
{
ChatsRepository cr = new ChatsRepository();
gvChats.DataSource = cr.InboxAdmin(adminid);
gvChats.DataBind();
}
public void ShouldStartChatWithUser()
{
//arrange
var user = new User
{
Name = "testUser",
Avatar = Encoding.UTF8.GetBytes("ava"),
Password = "******"
};
const string chatName = "чатик";
//act
var usersRepository = new UsersRepository(ConnectionString);
var result = usersRepository.Create(user);
_tempUsers.Add(result.Id);
var chatRepository = new ChatsRepository(ConnectionString, usersRepository);
var chat = chatRepository.Create(new[] { user.Id }, chatName);
var userChats = chatRepository.GetUserChats(user.Id);
//asserts
Assert.AreEqual(chatName, chat.Name);
Assert.AreEqual(user.Id, chat.Members.Single().Id);
Assert.AreEqual(chat.Id, userChats.Single().Id);
Assert.AreEqual(chat.Name, userChats.Single().Name);
}
protected override void Seed(MainDataBase dataBase)
{
_usersRepository = new UsersRepository(dataBase);
_chatsRepository = new ChatsRepository(dataBase);
_chatUserRepository = new ChatUserRepository(dataBase);
_messagesRepository = new MessagesRepository(dataBase);
}
public void ShouldGetChat()
{
var profile = new Profile
{
Id = Guid.NewGuid(),
Login = "******",
Avatar = Guid.NewGuid(),
Password = "******",
Name = "odmin",
Surname = "odmin"
};
const string chatName = "GetChat";
var usersRepository = new ProfilesRepository(Constants.Constants.ConnectionString);
var result = usersRepository.CreateProfile(profile);
_tempUsers.Add(result.Id);
var chatRepository = new ChatsRepository(Constants.Constants.ConnectionString, usersRepository);
var chatBefore = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat = chatRepository.CreateChat(chatBefore);
_chats.Add(chat.ChatId);
var resultChatById = chatRepository.GetChat(chat.ChatId);
Assert.AreEqual(chat.ChatName, resultChatById.ChatName);
}
public void ShouldDeleteMessage()
{
var profile = new Profile
{
Id = Guid.NewGuid(),
Login = "******",
Avatar = Guid.NewGuid(),
Password = "******",
Name = "odmin",
Surname = "odmin"
};
const string chatName = "SendChat";
var usersRepository = new ProfilesRepository(Constants.Constants.ConnectionString);
var result = usersRepository.CreateProfile(profile);
_tempUsers.Add(result.Id);
var chatRepository = new ChatsRepository(Constants.Constants.ConnectionString, usersRepository);
var chatBefore = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat = chatRepository.CreateChat(chatBefore);
_chats.Add(chat.ChatId);
var messageRepository = new MessagesRepository(Constants.Constants.ConnectionString);
var message = new Message
{
MessageId = Guid.NewGuid(),
ProfileId = profile.Id,
ChatId = chat.ChatId,
MessageText = "Hello, world!",
Date = DateTime.Now,
TimeToDestroy = 0,
Attachment = Guid.Empty
};
_messages.Add(message.MessageId);
messageRepository.CreateMessage(message);
messageRepository.DeleteMessage(message.MessageId);
try
{
messageRepository.GetMessage(message.MessageId);
}
catch (Exception)
{
return;
}
}
public async Task <WrapperSimpleTypesDTO> CrearChat(Chats chatParaCrearOwner)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
ChatsRepository chatsRepo = new ChatsRepository(context);
// Verifico si ya existe mi chat principal, si existe lo reactivo, si no lo creo
bool existeChatOwner = await chatsRepo.VerificarSiYaExisteChat(chatParaCrearOwner);
if (existeChatOwner)
{
chatParaCrearOwner = await chatsRepo.ReactivarChat(chatParaCrearOwner);
}
else
{
chatParaCrearOwner.EstadoChat = EstadosChat.Activo;
chatParaCrearOwner.Creacion = DateTime.Now;
chatsRepo.CrearChat(chatParaCrearOwner);
}
Chats chatNoOwner = new Chats
{
CodigoPersonaOwner = chatParaCrearOwner.CodigoPersonaNoOwner,
CodigoPersonaNoOwner = chatParaCrearOwner.CodigoPersonaOwner
};
// Verifico si ya existe mi chat secundario de la persona a que le voy a enviar, si existe no hago nada, si no lo creo
// Lo dejo en estado inactivo para que crear el chat principal no le cree un chat a la persona secundaria
// Solo cuando un mensaje es mandado es que ambos son reactivados
bool existeChatNoOwner = await chatsRepo.VerificarSiYaExisteChat(chatNoOwner);
if (!existeChatNoOwner)
{
chatNoOwner.EstadoChat = EstadosChat.PendienteParaBorrarMensajes;
chatNoOwner.Creacion = DateTime.Now;
chatsRepo.CrearChat(chatNoOwner);
}
WrapperSimpleTypesDTO wrapperCrearChat = new WrapperSimpleTypesDTO();
wrapperCrearChat.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearChat.NumeroRegistrosAfectados > 0 || chatParaCrearOwner.Consecutivo > 0)
{
wrapperCrearChat.Exitoso = true;
wrapperCrearChat.ConsecutivoCreado = chatParaCrearOwner.Consecutivo;
if (chatNoOwner.Consecutivo > 0)
{
wrapperCrearChat.ConsecutivoChatRecibe = chatNoOwner.Consecutivo;
}
else
{
wrapperCrearChat.ConsecutivoChatRecibe = await chatsRepo.BuscarConsecutivoChat(chatNoOwner);
}
}
return(wrapperCrearChat);
}
}
public void ShouldChangeChatPicture()
{
//arrange
var user = new User
{
Name = "testCharUser",
Picture = new byte[] { }
};
var login = "******";
var password = "******";
var title = "chatTitle";
var pic = new byte[] { };
var newPic = new byte[] { };
//act
var userRepository = new UsersRepository(ConnectionString);
var resultUser1 = userRepository.Create(user, login, password);
var resultUser2 = userRepository.Create(user, login + "1", password);
var userIds = new List <Guid> {
resultUser1.Id, resultUser2.Id
};
_tempUsers.AddRange(userIds);
var chatRepository = new ChatsRepository(ConnectionString);
var resultChat = chatRepository.Create(title, userIds, pic);
_tempChats.Add(resultChat.Id);
chatRepository.ChangePicture(resultChat.Id, newPic);
resultChat = chatRepository.Get(resultChat.Id);
//asserts
Assert.AreEqual(newPic, resultChat.Picture);
}
public Chat()
{
_messagesRepository = new List <Message>();
_id = Guid.NewGuid();
_chatsRepository = new ChatsRepository();
_chatsRepository.AddNewChatToRepository(this);
}
public void ShouldGetMessage()
{
//arrange
var usersRepository = new UsersRepository(_connectionString);
var chatsRepository = new ChatsRepository(_connectionString, usersRepository);
var messagesRepository = new MessagesRepository(_connectionString, usersRepository, chatsRepository);
var createdMessage = messagesRepository.CreateMessage(_message);
_tmpMessages.Add(createdMessage.Id);
//act
var gottenMessage = messagesRepository.GetMessage(createdMessage.Id);
//assert
Assert.AreEqual(createdMessage.Text, gottenMessage.Text);
Assert.AreEqual(createdMessage.IsSelfDestructing, gottenMessage.IsSelfDestructing);
Assert.AreEqual(createdMessage.Date.ToString(CultureInfo.InvariantCulture), gottenMessage.Date.ToString(CultureInfo.InvariantCulture));
if (createdMessage.Attachments.ElementAt(0).Length ==
gottenMessage.Attachments.ElementAt(0).Length)
{
Assert.IsTrue(createdMessage.Attachments.ElementAt(0).
SequenceEqual(gottenMessage.Attachments.ElementAt(0)));
Assert.IsTrue(createdMessage.Attachments.ElementAt(1).
SequenceEqual(gottenMessage.Attachments.ElementAt(1)));
}
else
{
Assert.IsTrue(createdMessage.Attachments.ElementAt(0).
SequenceEqual(gottenMessage.Attachments.ElementAt(1)));
Assert.IsTrue(createdMessage.Attachments.ElementAt(1).
SequenceEqual(gottenMessage.Attachments.ElementAt(0)));
}
}
public void ShouldGetChat()
{
//arrange
var user = new User
{
Name = "testCharUser",
Picture = new byte[] { }
};
var login = "******";
var password = "******";
var title = "chatTitle";
var pic = new byte[] {};
//act
var userRepository = new UsersRepository(ConnectionString);
var resultUser1 = userRepository.Create(user, login, password);
var resultUser2 = userRepository.Create(user, login + "1", password);
var userIds = new List <Guid> {
resultUser1.Id, resultUser2.Id
};
_tempUsers.AddRange(userIds);
var chatRepository = new ChatsRepository(ConnectionString);
var tempChat = chatRepository.Create(title, userIds, pic);
var resultChat = chatRepository.Get(tempChat.Id);
_tempChats.Add(resultChat.Id);
//asserts
Assert.AreEqual(resultChat.Title, title);
Assert.AreEqual(resultChat.Members.Count(), 2);
Assert.AreEqual(resultChat.Members.Any(u => u.Id == resultUser1.Id), true);
Assert.AreEqual(resultChat.Members.Any(u => u.Id == resultUser2.Id), true);
}
public async Task <List <ChatsMensajes> > ListarChatsMensajes(ChatsMensajes chatMensajeParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
ChatsRepository chatsRepo = new ChatsRepository(context);
if (chatMensajeParaListar.FechaFiltroBase != DateTime.MinValue)
{
chatMensajeParaListar.FechaFiltroBase = helper.ConvertDateTimeFromAnotherTimeZone(chatMensajeParaListar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, chatMensajeParaListar.FechaFiltroBase);
}
List <ChatsMensajes> listaMensajes = await chatsRepo.ListarChatsMensajes(chatMensajeParaListar);
if (listaMensajes != null && listaMensajes.Count > 0)
{
foreach (var mensaje in listaMensajes)
{
mensaje.FechaMensaje = helper.ConvertDateTimeFromAnotherTimeZone(chatMensajeParaListar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, mensaje.FechaMensaje);
}
}
return(listaMensajes);
}
}
public void ShouldGetChatMembers()
{
_tempUsers1.Clear();
var user1 = new User
{
Name = Guid.NewGuid().ToString(),
Password = "******"
};
var user2 = new User
{
Name = Guid.NewGuid().ToString(),
Password = "******"
};
UsersRepository userRepository = new UsersRepository(_connectionString);
user1 = userRepository.Create(user1);
user2 = userRepository.Create(user2);
_tempUsers1.Add(user1);
_tempUsers1.Add(user2);
ChatsRepository chatRepository = new ChatsRepository(_connectionString, userRepository);
var resultCreate = chatRepository.Create(new[] { user1.Id, user2.Id }, "NewChat");
List <User> resultUsers = chatRepository.GetChatMembers(resultCreate.Id).ToList();
Assert.AreEqual(_tempUsers1.OrderBy(u => u.Id).First().Id, resultCreate.Members.OrderBy(u => u.Id).First().Id);
}
public void Clean()
{
var usersRepository = new UsersRepository(_connectionString);
var chatsRepository = new ChatsRepository(_connectionString, usersRepository);
var messagesRepository = new MessagesRepository(_connectionString, usersRepository, chatsRepository);
foreach (var cm in _tempChatIdMemberIds)
{
chatsRepository.DeleteMember(cm.ChatId, cm.MemberId);
}
foreach (var messageId in _tmpMessages)
{
messagesRepository.DeleteMessage(messageId);
}
foreach (var chatId in _tmpChats)
{
chatsRepository.DeleteChat(chatId);
}
foreach (var userId in _tmpUsers)
{
usersRepository.DeleteUser(userId);
}
}
public void ShouldSendAndDeleteMessage()
{
//arrange
var user = new User
{
Name = "testCharUser",
Picture = new byte[] {}
};
var login = "******";
var password = "******";
var title = "chatTitle";
var pic = new byte[] {};
string msg = "TestText of msg";
//act
var userRepository = new UsersRepository(ConnectionString);
var resultUser = userRepository.Create(user, login, password);
var userIds = new List <Guid> {
resultUser.Id
};
_tempUsers.AddRange(userIds);
var chatRepository = new ChatsRepository(ConnectionString);
var resultChat = chatRepository.Create(title, userIds, pic);
_tempChats.Add(resultChat.Id);
var messageRepository = new MessagesRepository(ConnectionString);
var resultMsg = messageRepository.Send(msg, resultUser.Id, resultChat.Id);
messageRepository.Delete(resultMsg.Id);
//asserts
Assert.AreEqual(false, messageRepository.MessageExists(resultMsg.Id));
Assert.AreEqual(false, chatRepository.GetChatMessages(resultChat.Id).Any(m => m.Id == resultMsg.Id));
}
public void ShouldGetChatsOfUser()
{
//arrange
var user = new User
{
Name = "testUser",
Picture = new byte[] {}
};
var login = "******";
var password = "******";
//act
var userRepository = new UsersRepository(ConnectionString);
var resultUser = userRepository.Create(user, login, password);
_tempUsers.Add(resultUser.Id);
var chatRepository = new ChatsRepository(ConnectionString);
var chatResult = chatRepository.Create("chatTitle", new List <Guid>()
{
resultUser.Id
});
_tempChats.Add(chatResult.Id);
var chats = userRepository.GetUserChats(resultUser.Id);
//asserts
Assert.AreEqual(chats.Count(), 1);
}
public void ShouldCreateAndDeleteChat()
{
//arrange
var user = new User
{
Name = "testCharUser",
Picture = new byte[] { }
};
var login = "******";
var password = "******";
var title = "chatTitle";
//act
var userRepository = new UsersRepository(ConnectionString);
var resultUser1 = userRepository.Create(user, login, password);
var resultUser2 = userRepository.Create(user, login + "1", password);
var userIds = new List <Guid> {
resultUser1.Id, resultUser2.Id
};
_tempUsers.AddRange(userIds);
var chatRepository = new ChatsRepository(ConnectionString);
var resultChat = chatRepository.Create(title, userIds);
chatRepository.Delete(resultChat.Id);
//asserts
Assert.AreEqual(chatRepository.ChatExists(resultChat.Id), false);
}
public async Task <Tuple <WrapperSimpleTypesDTO, TimeLineNotificaciones> > EliminarContacto(Contactos contactoParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
ChatsRepository chatsRepo = new ChatsRepository(context);
Contactos contactoFiltro = new Contactos
{
Consecutivo = contactoParaEliminar.Consecutivo
};
chatsRepo.EliminarContacto(contactoFiltro);
Tuple <Contactos, int?> tupleBusqueda = await chatsRepo.BuscarConsecutivoContactoContrario(contactoParaEliminar);
Contactos contactoOwner = tupleBusqueda.Item1;
int? consecutivoContrarioBuscado = tupleBusqueda.Item2;
if (!consecutivoContrarioBuscado.HasValue)
{
throw new InvalidOperationException("No existe el contacto contrario de esta persona!.");
}
Contactos contactoParaBorrar = new Contactos
{
Consecutivo = consecutivoContrarioBuscado.Value
};
chatsRepo.EliminarContacto(contactoParaBorrar);
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacion = new Notificaciones
{
CodigoTipoNotificacion = (int)TipoNotificacionEnum.PersonaEliminada,
CodigoPersonaOrigenAccion = contactoOwner.CodigoPersonaOwner,
CodigoPersonaDestinoAccion = contactoOwner.CodigoPersonaContacto,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
WrapperSimpleTypesDTO wrapperEliminarContacto = new WrapperSimpleTypesDTO();
TimeLineNotificaciones timeLineNotificacion = null;
wrapperEliminarContacto.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarContacto.NumeroRegistrosAfectados > 0)
{
wrapperEliminarContacto.Exitoso = true;
if (notificacion.Consecutivo > 0)
{
timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacion));
}
}
return(Tuple.Create(wrapperEliminarContacto, timeLineNotificacion));
}
}
protected void btnSearch_ServerClick(object sender, EventArgs e)
{
int id = Session["employeeid"].ToString().ToInt();
ChatsRepository cr = new ChatsRepository();
gvChats.DataSource = cr.Search(id, tbxSearch.Value);
gvChats.DataBind();
}
private void fillGV()
{
int id = Session["employeeid"].ToString().ToInt();
ChatsRepository cr = new ChatsRepository();
gvChats.DataSource = cr.Inbox(id);
gvChats.DataBind();
}
private void fillGV()
{//Session["userid"].ToString().ToInt();
int id = 5;
ChatsRepository cr = new ChatsRepository();
gvChats.DataSource = cr.Inbox(id);
gvChats.DataBind();
}
public ChatsManager(Model context, IMapper mapper,
UserManager <ApplicationUser> userManager,
IOptions <ApplicationSettings> appSettings)
{
_mapper = mapper;
_repository = new ChatsRepository(context);
_userManager = userManager;
_appUsersManager = new ApplicationUsersManager(context, mapper, userManager, appSettings);
}
public async Task <Contactos> BuscarContacto(Contactos contactoParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
ChatsRepository chatsRepo = new ChatsRepository(context);
Contactos contactoBuscado = await chatsRepo.BuscarContacto(contactoParaBuscar);
return(contactoBuscado);
}
}
public async Task <List <ContactosDTO> > ListarContactos(Contactos contactoParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
ChatsRepository chatsRepo = new ChatsRepository(context);
List <ContactosDTO> listaContactos = await chatsRepo.ListarContactos(contactoParaListar);
return(listaContactos);
}
}
public async Task <Contactos> VerificarSiLaPersonaEstaAgregadaContactos(Contactos contactoParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
ChatsRepository chatsRepo = new ChatsRepository(context);
Contactos contactoBuscado = await chatsRepo.VerificarSiLaPersonaEstaAgregadaContactos(contactoParaBuscar);
return(contactoBuscado);
}
}
public void WhenDeletingAbsenteeUserToChat_DeleteParticipantFromChat_ShouldThrowException()
{
ChatsRepository chatsRepository = new ChatsRepository();
Guid id = Guid.NewGuid();
Channel channel = new Channel(id, "title");
Guid absenteeId = new Guid();
var chatId = channel.GetId();
chatsRepository.DeleteUserFromChat(chatId, absenteeId);
}
public async Task <ChatsDTO> BuscarChat(Chats chatParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
ChatsRepository chatsRepo = new ChatsRepository(context);
ChatsDTO chatBuscado = await chatsRepo.BuscarChat(chatParaBuscar);
return(chatBuscado);
}
}
public void IfCalling_AddMessageToChat_PassWrongChatId_FindChatById_ShouldThrowException()
{
ChatsRepository chatsRepository = new ChatsRepository();
Guid id = Guid.NewGuid();
Channel channel = new Channel(id, "title");
var wrongId = Guid.NewGuid();
var message = new Message("message", id);
chatsRepository.AddMessageToChat(wrongId, message);
}
public void WhenAddingAlreadyParticipatingUserToChat_AddParticipantToChat_ShouldThrowException()
{
ChatsRepository chatsRepository = new ChatsRepository();
Guid id = Guid.NewGuid();
Channel channel = new Channel(id, "title");
var chatId = channel.GetId();
Account user = new Account("user", "password");
chatsRepository.AddUserToChat(chatId, user.Id);
chatsRepository.AddUserToChat(chatId, user.Id);
}
public void Verify_Get_ByKey_Should_ReturnTheCorrectChat()
{
// Arrange
Mock <IDbSet <Chat> > mockSetChats;
var mockContext = ChatsMockingSetup.DoMockingSetupForContext(true, out mockSetChats);
var repository = new ChatsRepository(mockContext.Object);
// Act
var chats = repository.Get("KING-STEPHEN");
// Assert
Assert.Equal("/TEST/KING-STEPHEN", chats.ApiDetailUrl);
}
public void Verify_Add_Should_AddTheEntityToTheContext()
{
// Arrange
Mock<IDbSet<Chat>> mockSetChats;
var mockContext = ChatsMockingSetup.DoMockingSetupForContext(false, out mockSetChats);
var repository = new ChatsRepository(mockContext.Object);
var chats = new Chat { Active = true, CustomKey = "SALVATORE-RAA", };
// Act
repository.Add(chats);
// Assert
mockSetChats.Verify(x => x.Add(chats), Times.Once);
}
public void Verify_Deactivate_Should_SetTheActivePropertyToFalseOnTheEntity()
{
// Arrange
Mock<IDbSet<Chat>> mockSetChats;
var mockContext = ChatsMockingSetup.DoMockingSetupForContext(true, out mockSetChats);
var repository = new ChatsRepository(mockContext.Object);
var chats = repository.Get(1);
// Act
repository.Deactivate(chats);
// Assert
Assert.Equal(false, chats.Active);
}
public void Verify_List_Should_ReturnAListOfChatsWithData()
{
// Arrange
Mock<IDbSet<Chat>> mockSetChats;
var mockContext = ChatsMockingSetup.DoMockingSetupForContext(true, out mockSetChats);
var repository = new ChatsRepository(mockContext.Object);
// Act
var chats = repository.List.ToArray();
// Assert
Assert.Equal(2, chats.Length);
Assert.Equal(1, chats[0].Id);
Assert.Equal("/TEST/KING-STEPHEN", chats[0].ApiDetailUrl);
Assert.Equal(2, chats[1].Id);
Assert.Equal("/TEST/NIVEN-LARRY", chats[1].ApiDetailUrl);
}
public void Verify_Remove_Should_RemoveTheEntityFromTheContext()
{
// Arrange
Mock<IDbSet<Chat>> mockSetChats;
var mockContext = ChatsMockingSetup.DoMockingSetupForContext(true, out mockSetChats);
var repository = new ChatsRepository(mockContext.Object);
var chats = repository.Get(1);
// Act
repository.Remove(chats);
// Assert
mockSetChats.Verify(x => x.Remove((Chat)chats), Times.Once);
}
public void Verify_Search_WithModifiedSince_Should_ReturnAListOfChatsWithDataMatchingSearchParameters()
{
// Arrange
Mock<IDbSet<Chat>> mockSetChats;
var mockContext = ChatsMockingSetup.DoMockingSetupForContext(true, out mockSetChats, true);
var repository = new ChatsRepository(mockContext.Object);
var createDate = new System.DateTime(2015, 05, 28, 10, 45, 00).AddDays(1).AddMinutes(-1);
//var searchModel = new Mock<IChatSearchModel>();
//searchModel.Setup(m => m.ModifiedSince).Returns(() => createDate);
var searchModel = new ChatSearchModel { ModifiedSince = createDate };
// Act
var chats = repository.Search(searchModel/*.Object*/).ToArray();
// Assert
Assert.Equal(1, chats.Length);
Assert.Equal(2, chats[0].Id);
Assert.Equal("/TEST/NIVEN-LARRY", chats[0].ApiDetailUrl);
// Stephen King was filtered out because he was created before the modified since date
}
public void Verify_Search_WithPaging_Should_ReturnAListOfChatsWithDataMatchingSearchParameters()
{
// Arrange
Mock<IDbSet<Chat>> mockSetChats;
var mockContext = ChatsMockingSetup.DoMockingSetupForContext(true, out mockSetChats);
var repository = new ChatsRepository(mockContext.Object);
var searchModel = new ChatSearchModel { Paging = new Paging { Skip = 1, Take = 1 } };
// Act
var chats = repository.Search(searchModel/*.Object*/).ToArray();
// Assert
Assert.Equal(1, chats.Length);
Assert.Equal(2, chats[0].Id);
Assert.Equal("/TEST/NIVEN-LARRY", chats[0].ApiDetailUrl);
// Stephen King was filtered out because he was Skipped
}
public void Verify_Search_WithSelectStatement_Should_ReturnAListOfDynamicObjects()
{
// Arrange
Mock<IDbSet<Chat>> mockSetChats;
var mockContext = ChatsMockingSetup.DoMockingSetupForContext(true, out mockSetChats, true);
var repository = new ChatsRepository(mockContext.Object);
var searchModel = new Mock<IChatSearchModel>();
// Act
var chats = repository.Search(searchModel.Object, i => new { i.Id, MyApiDetailUrl = i.ApiDetailUrl }).ToArray();
// Assert
Assert.Equal(1, chats.Length);
Assert.Equal(2, chats[0].Id);
Assert.Equal("/TEST/NIVEN-LARRY", chats[0].MyApiDetailUrl);
// Stephen King was filtered out because he was Inactive
}
public void Verify_Update_Should_SetTheEntityStateToModified()
{
// Arrange
Mock<IDbSet<Chat>> mockSetChats;
var mockContext = ChatsMockingSetup.DoMockingSetupForContext(true, out mockSetChats);
var repository = new ChatsRepository(mockContext.Object);
var chats = repository.Get(1);
chats.ApiDetailUrl = "/TEST";
// Act
repository.Update(chats);
// Assert
mockContext.Verify(x => x.SetModified(It.IsAny<object>()), Times.Once);
}
public void Verify_Get_ByID_Should_ReturnTheCorrectChat()
{
// Arrange
Mock<IDbSet<Chat>> mockSetChats;
var mockContext = ChatsMockingSetup.DoMockingSetupForContext(true, out mockSetChats);
var repository = new ChatsRepository(mockContext.Object);
// Act
var chats = repository.Get(1);
// Assert
Assert.Equal("/TEST/KING-STEPHEN", chats.ApiDetailUrl);
}
