public async void ShouldReturnNotFound()
{
// Arrange
var url = new UrlDto
{
Id = 2,
AccessCount = 1,
ActualUrl = "https://google.com",
ShortenedUrl = "GH65ff"
};
var urlDto = new UrlDto
{
Id = 8,
AccessCount = 1,
ActualUrl = "https://google.com",
ShortenedUrl = "GH65ff"
};
UrlServiceMock.Setup(x => x.UpdateUrl(url)).ReturnsAsync(url);
// Act
var result = await UrlControllerToTest.Put(urlDto);
// Assert
Assert.IsType <NotFoundResult>(result);
}
public async void ShouldReturnOkResult()
{
// Arrange
var url = new UrlCreate
{
ActualUrl = "https://google.com"
};
var urlDto = new UrlDto
{
Id = 1,
ActualUrl = "https://google.com",
ShortenedUrl = "fGwY73",
AccessCount = 0
};
UrlServiceMock.Setup(x => x.AddUrl(url)).ReturnsAsync(urlDto);
// Act
var result = await UrlControllerToTest.Post(url);
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(urlDto, okResult.Value);
}
public async Task <UrlDto> UpdateUrl(UrlDto url)
{
if (url == null)
{
throw new Exception("Not found");
}
var currentUrl = await _context.Urls.Where(u => u.Id == url.Id).FirstOrDefaultAsync();
if (currentUrl == null)
{
throw new Exception("Not found");
}
currentUrl.ShortenedUrl = url.ShortenedUrl;
currentUrl.ActualUrl = url.ActualUrl;
currentUrl.FriendlyName = url.FriendlyName;
// An update should potentially clear down the access count? Left as is for now
await _context.SaveChangesAsync();
return(new UrlDto
{
Id = url.Id,
ActualUrl = url.ActualUrl,
ShortenedUrl = url.ShortenedUrl,
AccessCount = currentUrl.AccessCount
});
}
public async Task <UrlDto> GetUrl(string shortened)
{
// Return the individual url specified.
var url = await _context.Urls.Where(u => u.ShortenedUrl == shortened).FirstOrDefaultAsync();
if (url == null)
{
throw new Exception("Not found");
}
// We should also update the access count here, as we can presume this is someone being redirected
url.AccessCount += 1;
_context.Urls.Update(url);
await _context.SaveChangesAsync();
UrlDto finalUrl = new UrlDto
{
Id = url.Id,
ActualUrl = url.ActualUrl,
FriendlyName = url.FriendlyName,
ShortenedUrl = url.ShortenedUrl,
AccessCount = url.AccessCount
};
return(finalUrl);
}
public async Task Should_Add_Url()
{
// Arrange
var urlCreateDto = new UrlCreateBodyDto
{
Href = "http://www.landesblasorchester.de",
AnchorText = "Landesblasorchester Baden-Württemberg"
};
var expectedDto = new UrlDto()
{
Href = urlCreateDto.Href,
AnchorText = urlCreateDto.AnchorText,
CreatedBy = _staff.DisplayName,
CreatedAt = FakeDateTime.UtcNow
};
// Act
HttpResponseMessage responseMessage = await _authenticatedServer
.CreateClient()
.AuthenticateWith(_staff)
.PostAsync(ApiEndpoints.ProjectsController.AddUrl(ProjectDtoData.HoorayForHollywood.Id), BuildStringContent(urlCreateDto));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.Created);
UrlDto result = await DeserializeResponseMessageAsync <UrlDto>(responseMessage);
result.Should().BeEquivalentTo(expectedDto, opt => opt.Excluding(r => r.Id));
result.Id.Should().NotBeEmpty();
responseMessage.Headers.Location.AbsolutePath.Should().Be($"/{ApiEndpoints.UrlsController.Get(result.Id)}");
}
public void GetLongUrlFor_ValidCode()
{
// Arrange
var urlDto = new UrlDto
{
LongUrl = _fixture.Create <string>(),
ShortUrl = _fixture.Create <string>()
};
var mockedDal = new MockedDal(
isShortCodeStored: true,
getOriginalFor: urlDto.LongUrl);
var service = new UrlService(mockedDal.GetObject);
// Act
var response = service.GetLongUrlFor(urlDto.ShortUrl);
// Assert
response
.Should()
.BeEquivalentTo(
urlDto,
"because the same long URL is returned by the program when using its code");
}
public void GetShortUrlFor_UrlNotStored()
{
// Arrange
var urlDto = new UrlDto
{
LongUrl = $"http://{_fixture.Create<string>()}",
ShortUrl = string.Empty
};
var mockedDal = new MockedDal(
isUrlStored: false,
getShortenedUrlFor: urlDto.ShortUrl);
var service = new UrlService(mockedDal.GetObject);
// Act
service.GetShortUrlFor(urlDto.LongUrl);
// Assert
mockedDal.GetMock
.Verify(_ =>
_.GetShortenedFor(It.IsAny <string>()),
Times.Never);
mockedDal.GetMock
.Verify(_ =>
_.IsUrlStored(It.IsAny <string>()),
Times.Once);
mockedDal.GetMock
.Verify(_ =>
_.StoreShortened(It.IsAny <string>(), It.IsAny <string>()),
Times.Once);
}
public async Task <IHttpActionResult> Post(UrlDto url)
{
try
{
Regex urlchk = new Regex(@"((file|gopher|news|nntp|telnet|http|ftp|https|ftps|sftp)://)+(([a-zA-Z0-9\._-]+\.[a-zA-Z]{2,15})|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(/[a-zA-Z0-9\&%_\./-~-]*)?", RegexOptions.Singleline | RegexOptions.IgnoreCase);
if (urlchk.Match(url.Url).Length <= 0)
{
return(this.BadRequest("Invalid URL"));
}
if (string.IsNullOrEmpty(url.Url))
{
return(NotFound());
}
var shortUrl = this._utilityManager.ConvertToShortUrl(url.Url);
var model = await this._repository.Add(new UrlModel(shortUrl, url.Url));
var cached = this._cacheManager.GetCached <UrlModel>(model.ShortUrl);
if (cached == null)
{
this._cacheManager.TryAddToCache <UrlModel>(model.ShortUrl, model);
}
return(this.Ok(model.ToWellFormattedObject()));
}
catch (Exception ex)
{
return(this.InternalServerError(ex));
}
}
public async Task <ActionResult <UrlDto> > GetUrlInfo([FromQuery] int count = 10)
{
var ret = new UrlDto
{
PercentWithUrl = await _info.GetPercentWithUrl(),
PercentWithUrlOfImage = await _info.GetPercentWithUrlOfPhoto(),
TopDomainsOfUrls = await _info.GetTopDomain(count)
};
return(Ok(ret));
}
public bool UpdateAvatar(int userId, UrlDto dto)
{
var userFromDb = db.Users.FirstOrDefault(x => x.Id == userId && !x.DelFlag);
if (userFromDb == null)
{
return(false);
}
userFromDb.Avatar = dto.Url;
db.SaveChanges();
return(true);
}
public async Task Should_Get_By_Id()
{
// Arrange
UrlDto expectedUrl = UrlDtoData.ArpaWebsite;
HttpClient client = _authenticatedServer.CreateClient().AuthenticateWith(_staff);
// Act
HttpResponseMessage responseMessage = await client
.GetAsync(ApiEndpoints.UrlsController.Get(expectedUrl.Id));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.OK);
UrlDto result = await DeserializeResponseMessageAsync <UrlDto>(responseMessage);
result.Should().BeEquivalentTo(expectedUrl);
}
public async void ShouldUpdate()
{
// Arrange
UrlDto newUrl = new UrlDto
{
Id = 2,
ActualUrl = "https://www.bbc.co.uk/news",
ShortenedUrl = "FG5tYi"
};
// Act
var result = await UrlServiceToTest.UpdateUrl(newUrl);
// Assert
Assert.True(result.Id == newUrl.Id);
Assert.True(result.ActualUrl == newUrl.ActualUrl);
}
public IActionResult Create([FromBody] UrlDto urlDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var url = new Url()
{
Description = urlDto.Description, Redirect = urlDto.Redirect
};
_context.Urls.Add(url);
_context.SaveChanges();
return(Ok(url));
}
public async Task Should_Modify()
{
// Arrange
UrlDto urlToModify = UrlDtoData.GoogleDe;
var modifyDto = new UrlModifyBodyDto
{
Href = "http://google.de/modified",
AnchorText = "modified anchor",
};
HttpClient client = _authenticatedServer.CreateClient().AuthenticateWith(_staff);
// Act
HttpResponseMessage responseMessage = await client
.PutAsync(ApiEndpoints.UrlsController.Put(urlToModify.Id), BuildStringContent(modifyDto));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.NoContent);
}
public async Task Should_Remove_Role()
{
// Arrange
UrlDto expectedDto = UrlDtoData.ArpaWebsite;
expectedDto.Roles.Clear();
// Act
HttpResponseMessage responseMessage = await _authenticatedServer
.CreateClient()
.AuthenticateWith(_staff)
.DeleteAsync(ApiEndpoints.UrlsController.RemoveRole(
UrlSeedData.ArpaWebsite.Id,
RoleSeedData.Staff.Id));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.NoContent);
}
public async Task <IActionResult> Put(UrlDto url)
{
try
{
var result = await _urlService.UpdateUrl(url);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
catch (Exception ex)
{
_logger.LogError(ex, "Error in Put", new Object[] { url });
throw;
}
}
public async Task Should_Delete()
{
// Arrange
UrlDto urlToDelete = ProjectDtoData.HoorayForHollywood.Urls[0];
HttpClient client = _authenticatedServer.CreateClient().AuthenticateWith(_staff);
// Act: delete url from projects list of urls
HttpResponseMessage responseMessage = await client
.DeleteAsync(ApiEndpoints.UrlsController.Delete(urlToDelete.Id));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.NoContent);
HttpResponseMessage getResponseMessage = await client
.GetAsync(ApiEndpoints.UrlsController.Get(urlToDelete.Id));
getResponseMessage.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public async Task Should_Add_Role()
{
// Arrange
UrlDto expectedDto = UrlDtoData.ArpaWebsite;
expectedDto.Roles.Add(RoleDtoData.Performer);
HttpClient client = _authenticatedServer.CreateClient().AuthenticateWith(_staff);
HttpResponseMessage responseMessage = await client
.PostAsync(ApiEndpoints.UrlsController.AddRole(expectedDto.Id, RoleDtoData.Performer.Id), null);
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.OK);
UrlDto result = await DeserializeResponseMessageAsync <UrlDto>(responseMessage);
result.Should().BeEquivalentTo(expectedDto);
}
public async void ShouldReturnOkWithResults()
{
// Arrange
var url = new UrlDto
{
Id = 2,
AccessCount = 1,
ActualUrl = "https://google.com",
ShortenedUrl = "GH65ff"
};
UrlServiceMock.Setup(x => x.GetUrl("GH65ff")).ReturnsAsync(url);
// Act
var result = await UrlControllerToTest.Get("GH65ff");
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(url, okResult.Value);
}
public void GetShortUrlFor_UrlAlreadyStored()
{
// Arrange
var urlDto = new UrlDto
{
LongUrl = $"http://{_fixture.Create<string>()}",
ShortUrl = _fixture.Create <string>()
};
var mockedDal = new MockedDal(
isUrlStored: true,
getShortenedUrlFor: urlDto.ShortUrl);
var service = new UrlService(mockedDal.GetObject);
// Act
var response = service.GetShortUrlFor(urlDto.LongUrl);
// Assert
response
.Should()
.BeEquivalentTo(
urlDto,
"because the fetched values should match the original ones");
mockedDal.GetMock
.Verify(_ =>
_.GetShortenedFor(It.IsAny <string>()),
Times.Once);
mockedDal.GetMock
.Verify(_ =>
_.IsUrlStored(It.IsAny <string>()),
Times.Once);
mockedDal.GetMock
.Verify(_ =>
_.StoreShortened(It.IsAny <string>(), It.IsAny <string>()),
Times.Never);
}
public IHttpActionResult UpdateAvatar(int userId, [FromBody] UrlDto dto)
{
if (dto == null)
{
return(BadRequest("Invalid or missing avatar url"));
}
var token = Request.Headers.GetValues("Authorization").First();
if (!ValidatePermission(token, userId))
{
return(Unauthorized());
}
var result = _userService.UpdateAvatar(userId, dto);
if (result == false)
{
return(BadRequest("Fail to update"));
}
return(Ok("Avatar is update"));
}
public UrlDto Execute()
{
var url = new UrlDto();
return(url);
}
public static Url Build(UrlDto dto)
{
return(new Url(dto.Link, dto.ShortLink, dto.LinkCode));
}
public async Task <ActionResult <UrlDto> > AddUrl(UrlCreateDto urlCreateDto)
{
UrlDto createdUrl = await _urlService.CreateAsync(urlCreateDto);
return(CreatedAtAction(nameof(UrlsController.GetById), "Urls", new { id = createdUrl.Id }, createdUrl));
}
