public async Task InsertKwet_InvalidJWT_ThrowsException()
{
var userGuid = Guid.NewGuid();
var timeStamp = DateTime.Now;
const string jwt = "";
var newkwet = new NewKwetModel()
{
Id = userGuid.ToString(),
Message = "This is my placed Kwet",
UserName = "******"
};
var returnKwet = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
_jwtIdClaimReaderHelper.Setup(x => x.getUserIdFromToken(jwt))
.Returns(userGuid);
_kwetService.Setup(x => x.InsertKwet(It.IsAny <NewKwetModel>(), jwt))
.Throws <JwtInvalidException>();
var result = await _kwetController.Insert(newkwet, jwt) as ObjectResult;
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task GetKwet_GetSuccess_ReturnKwetList()
{
var userGuid = Guid.NewGuid();
var timeStamp = DateTime.Now;
var kwet1 = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
var kwet2 = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my other placed Kwet",
TimeStamp = timeStamp.AddHours(1),
Likes = new List <Likes>()
};
var kwets = new List <Kwet>();
kwets.Add(kwet1);
kwets.Add(kwet2);
_kwetService.Setup(x => x.Get()).ReturnsAsync(kwets);
var result = await _kwetController.Get() as ObjectResult;
Assert.IsType <OkObjectResult>(result);
Assert.Equal(kwets, ((List <Kwet>)result.Value));
}
public async Task CreateNewKwet_PlaceSuccess_ReturnsPlacedKwet()
{
var userGuid = Guid.NewGuid();
var timeStamp = DateTime.Now;
var kwet1 = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
var kwet2 = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my other placed Kwet",
TimeStamp = timeStamp.AddHours(1),
Likes = new List <Likes>()
};
var result1 = await _kwetRepository.Create(kwet1);
var result2 = await _kwetRepository.Create(kwet2);
Assert.NotNull(result1);
Assert.NotNull(result2);
Assert.NotEqual(result1.TimeStamp, result2.TimeStamp);
Assert.Equal(kwet1.Likes, result2.Likes);
Assert.Equal(kwet2.UserId, result2.UserId);
}
public async Task InsertKwet_ValidKwet_ReturnsKwet()
{
var userGuid = Guid.NewGuid();
var timeStamp = DateTime.Now;
const string jwt = "";
var newkwet = new NewKwetModel()
{
Id = userGuid.ToString(),
Message = "This is my placed Kwet",
UserName = "******"
};
var returnKwet = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
_jwtIdClaimReaderHelper.Setup(x => x.getUserIdFromToken(jwt)).Returns(userGuid);
_kwetService.Setup(x => x.InsertKwet(It.IsAny <NewKwetModel>(), jwt)).ReturnsAsync(returnKwet);
var result = await _kwetController.Insert(newkwet, jwt) as ObjectResult;
Assert.IsType <OkObjectResult>(result);
Assert.Equal(returnKwet.KwetId, ((Kwet)result.Value).KwetId);
}
public async Task LikeKwet_UpdateSuccess_ReturnsLikedKwet()
{
var userGuid = Guid.NewGuid();
var likeUser = Guid.NewGuid();
var timeStamp = DateTime.Now;
var kwet1 = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
var like = new Likes()
{
Name = "LikeUser",
userId = likeUser
};
var kwetWithLikes = kwet1;
kwetWithLikes.Likes.Add(like);
await _kwetRepository.Create(kwet1);
var result = await _kwetRepository.Update(kwetWithLikes);
Assert.Single(result.Likes);
Assert.Equal(result.Likes[0].Name, like.Name);
Assert.Equal(result.Likes[0].userId, like.userId);
}
public async Task UnlikeKwet_UnLikeSuccess_ReturnsUnlikedKwet()
{
var userGuid = Guid.NewGuid();
var likeUser = Guid.NewGuid();
var timeStamp = DateTime.Now;
var kwet1 = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
var like = new Likes()
{
Name = "LikeUser",
userId = likeUser
};
kwet1.Likes.Add(like);
var kwetWithoutLikes = await _kwetRepository.Create(kwet1);
kwetWithoutLikes.Likes.Remove(like);
var result = await _kwetRepository.Update(kwetWithoutLikes);
Assert.Empty(result.Likes);
}
public async Task GetKwetsById_GetSuccess_ReturnsKwetList()
{
var userGuid = Guid.NewGuid();
var timeStamp = DateTime.Now;
var kwet1 = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
var kwet2 = new Kwet()
{
KwetId = new Guid(),
UserId = new Guid(),
UserName = "******",
Message = "This is my other placed Kwet",
TimeStamp = timeStamp.AddHours(1),
Likes = new List <Likes>()
};
await _kwetRepository.Create(kwet1);
await _kwetRepository.Create(kwet2);
var result = await _kwetRepository.GetByUserId(userGuid);
Assert.Single(result);
}
public async Task InsertKwets_InvalidJWT_ThrowsException()
{
var userGuid = Guid.NewGuid();
var timeStamp = DateTime.Now;
const string jwt = "";
var newkwet = new NewKwetModel()
{
Id = userGuid.ToString(),
Message = "This is my placed Kwet",
UserName = "******"
};
var returnKwet = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
_repository.Setup(x => x.Create(It.IsAny <Kwet>())).ReturnsAsync(returnKwet);
_jwtIdClaimReaderHelper.Setup(x => x.getUserIdFromToken(jwt)).Returns(Guid.Empty);
var result = await Assert.ThrowsAsync <JwtInvalidException>(() =>
_kwetService.InsertKwet(newkwet, jwt));
Assert.IsType <JwtInvalidException>(result);
}
public async Task InsertKwets_ValidKwet_ReturnsPlacedKwet()
{
var userGuid = Guid.NewGuid();
var timeStamp = DateTime.Now;
const string jwt = "";
var newkwet = new NewKwetModel()
{
Id = userGuid.ToString(),
Message = "This is my placed Kwet",
UserName = "******"
};
var returnKwet = new Kwet()
{
KwetId = new Guid(),
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
_repository.Setup(x => x.Create(It.IsAny <Kwet>())).ReturnsAsync(returnKwet);
_jwtIdClaimReaderHelper.Setup(x => x.getUserIdFromToken(jwt)).Returns(userGuid);
var result = await _kwetService.InsertKwet(newkwet, jwt);
Assert.Equal(returnKwet.Message, result.Message);
Assert.Equal(returnKwet.KwetId, result.KwetId);
}
public async Task <Kwet> InsertKwet(NewKwetModel kwet, string token)
{
if (Guid.Parse(kwet.Id) != _jwtIdClaimReaderHelper.getUserIdFromToken(token))
{
throw new JwtInvalidException();
}
var newKwet = new Kwet
{
KwetId = new Guid(),
UserId = Guid.Parse(kwet.Id),
UserName = kwet.UserName,
Message = kwet.Message,
TimeStamp = DateTime.Now,
Likes = new List <Likes>()
};
return(await _repository.Create(newKwet));
}
public async Task LikeKwet_SuccessfullLike_ReturnsKwetWithLikes()
{
var userGuid = Guid.NewGuid();
var kwetGuid = Guid.NewGuid();
var timeStamp = DateTime.Now;
var likedKwet = new Kwet()
{
KwetId = kwetGuid,
UserId = userGuid,
UserName = "******",
Message = "This is my placed Kwet",
TimeStamp = timeStamp,
Likes = new List <Likes>()
};
var likemodel = new LikeModel()
{
Id = userGuid,
KwetId = kwetGuid,
UserName = "******"
};
var returnKwet = likedKwet;
returnKwet.Likes.Add(new Likes()
{
userId = likemodel.Id, Name = likemodel.UserName
});
_repository.Setup(x => x.Get(likemodel.KwetId)).ReturnsAsync(likedKwet);
_repository.Setup(x => x.Update(It.IsAny <Kwet>())).ReturnsAsync(returnKwet);
var result = await _kwetService.LikeKwet(likemodel);
Assert.NotEmpty(result.Likes);
Assert.Equal(returnKwet.Likes, result.Likes);
Assert.Equal(likemodel.KwetId, result.KwetId);
}
public async Task <Kwet> Update(Kwet likedKwet)
{
await _kwets.ReplaceOneAsync(kwet => kwet.KwetId == likedKwet.KwetId, likedKwet);
return(likedKwet);
}
public async Task <Kwet> Create(Kwet kwet)
{
await _kwets.InsertOneAsync(kwet);
return(kwet);
}
