private static string GenerateFragment(BlockingCollection <string> fragments)
{
var generatedFragment = EarlMiniProvider.GenerateFragment();
fragments.Add(generatedFragment);
return(generatedFragment);
}
private static string GenerateFragment(IList <string> fragments)
{
var generatedFragment = EarlMiniProvider.GenerateFragment();
fragments.Add(generatedFragment);
return(generatedFragment);
}
public IHttpActionResult Expand(string miniUrl)
{
try
{
if (!Uri.IsWellFormedUriString(miniUrl, UriKind.Absolute))
{
return(BadRequest("The parameter miniUrl's format is invalid"));
}
var miniUri = new Uri(miniUrl);
if (string.IsNullOrWhiteSpace(miniUri.AbsolutePath.Substring(1)))
{
return(BadRequest("The parameter miniUrl's format is invalid"));
}
string originalUrl = EarlMiniProvider.ExpandUrl(miniUri);
if (!string.IsNullOrWhiteSpace(originalUrl))
{
return(Ok(new
{
orginalUrl = originalUrl
}));
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return(InternalServerError( ));
}
return(NotFound());
}
public IHttpActionResult Minify([FromBody] JToken jsonBody)
{
var url = jsonBody.Value <string>("url");
try
{
if (string.IsNullOrWhiteSpace(url))
{
return(BadRequest("The parameter url is empty"));
}
var originalUri = new Uri(url);
string miniUrl = EarlMiniProvider.MinifyUrl(originalUri);
if (!string.IsNullOrWhiteSpace(miniUrl))
{
return(Ok(new
{
miniUrl
}));
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return(InternalServerError( ));
}
return(InternalServerError());
}
public void Can_Minify_Url(string originalUrl)
{
string miniUrl = EarlMiniProvider.MinifyUrl(originalUrl);
Assert.IsNotNullOrEmpty(miniUrl);
Assert.IsTrue(miniUrl.Length == ExpectedLenthOfUnsecureMiniUrl);
}
public void Can_InitializeDefaultConfiguration()
{
EarlMiniProvider.InitializeDefaultConfiguration();
Assert.AreEqual("EarlMini", EarlMiniProvider.ConnectionStringName);
Assert.AreEqual("[dbo].[EarlMini]", EarlMiniProvider.TableName);
Assert.AreEqual("url.mini", EarlMiniProvider.HostName);
}
public void Can_GetLastSegmentFromUrl_WithoutAbsolutePath(string url)
{
var uri = new Uri(url);
string lastSegment = EarlMiniProvider.GetLastSegmentFromUrl(uri);
Assert.AreEqual(string.Empty, lastSegment);
}
public void Can_InitializeCustomConfiguration_ConnectionString_TableName()
{
const string connectionStringName = "TestConnStringName";
const string tableName = "TestTableName";
EarlMiniProvider.InitializeConfiguration(connectionStringName, tableName);
Assert.AreEqual(connectionStringName, EarlMiniProvider.ConnectionStringName);
Assert.AreEqual(tableName, EarlMiniProvider.TableName);
}
public void Can_GetLastSegmentFromUrl_WithtAbsolutePath(string url)
{
var uri = new Uri(url);
string lastSegment = EarlMiniProvider.GetLastSegmentFromUrl(uri);
Assert.IsNotNullOrEmpty(lastSegment);
Assert.IsTrue(!lastSegment.EndsWith("/"));
Assert.IsTrue(!lastSegment.Contains("/"));
Assert.AreEqual(lastSegment, "abcd1234");
}
public void Can_Expand_MiniUrl(string miniUrl)
{
const string expectedOriginalUrl = "https://www.google.com";
//Arrange
_repositoryMock.Setup(x => x.GetOriginalUrl("abcd1234"))
.Returns(expectedOriginalUrl);
EarlMiniProvider.InitializeTestingConfiguration(_repositoryMock.Object);
//Act
string originalUrl = EarlMiniProvider.ExpandUrl(miniUrl);
//Assert
Assert.IsNotNullOrEmpty(miniUrl);
Assert.AreEqual(expectedOriginalUrl, originalUrl);
}
public IHttpActionResult Index(string url)
{
string miniUrl = Request.RequestUri.AbsoluteUri;
if (string.IsNullOrWhiteSpace(miniUrl))
{
return(NotFound());
}
string originalUrl = EarlMiniProvider.ExpandUrl(miniUrl);
if (string.IsNullOrWhiteSpace(miniUrl))
{
return(NotFound());
}
return(Redirect(originalUrl));
}
public void Should_RetriveAlreadyExistingMiniUrl_WhenGivenAPreviouslyTriedUrl()
{
const string expectedAlreadyExistingUrl = "http://url.mini/abcd1234";
//Arrange
_repositoryMock.Setup(x => x.GetMiniUrl(It.IsAny <string>()))
.Returns(expectedAlreadyExistingUrl);
EarlMiniProvider.InitializeTestingConfiguration(_repositoryMock.Object);
//Act
string miniUrl = EarlMiniProvider.MinifyUrl("https://www.sometestingurl.com");
//Assert
Assert.AreEqual(expectedAlreadyExistingUrl, miniUrl);
_repositoryMock.Verify(x => x.SaveMiniUrl(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Never);
_repositoryMock.Verify(x => x.GetSqlBinaryCheckSum(It.IsAny <string>()), Times.Never);
}
public void Can_MinifyUrl_UsingSecureTemplate(string url)
{
//Arrange
_repositoryMock.Setup(x => x.GetSqlBinaryCheckSum(It.IsAny <string>()))
.Returns(-123456);
_repositoryMock.Setup(x => x.GetMiniUrl(It.IsAny <string>()))
.Returns(string.Empty);
_repositoryMock.Setup(x => x.SaveMiniUrl(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(true);
EarlMiniProvider.InitializeTestingConfiguration(_repositoryMock.Object);
//Act
string miniUrl = EarlMiniProvider.MinifyUrl(url, true);
//Assert
Assert.IsNotNullOrEmpty(miniUrl);
Assert.IsTrue(miniUrl.Length == ExpectedLenthOfSecureMiniUrl);
}
public void Should_TryConfiguredMaxTries_AtMost_WhenGeneratingUniqueFragment()
{
//Arrange
_repositoryMock.Setup(x => x.GetSqlBinaryCheckSum(It.IsAny <string>()))
.Returns(-123456);
_repositoryMock.Setup(x => x.GetMiniUrl(It.IsAny <string>()))
.Returns(string.Empty);
_repositoryMock.Setup(x => x.SaveMiniUrl(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(false);
EarlMiniProvider.InitializeTestingConfiguration(_repositoryMock.Object);
//Act
string miniUrl = EarlMiniProvider.MinifyUrl("https://www.google.com");
//Assert
Assert.IsNullOrEmpty(miniUrl);
_repositoryMock.Verify(x => x.GetMiniUrl(It.IsAny <string>()), Times.Exactly(EarlMiniProvider.MaxNumberOfTriesToGenerateUniqueFragment));
}
public void When_ExpandingUrl_GivenAnEmptyMiniUrl_ThrowsException(string miniUrl)
{
EarlMiniProvider.MinifyUrl(string.Empty);
}
public void When_MinifyingUrl_GivenAnEmptyUrl_ThrowsException(string url)
{
EarlMiniProvider.MinifyUrl(string.Empty);
}
