public void ScriptAssetsListNotContainAssetsWithInvalidTypes()
{
// Arrange
var jqueryJsAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "jquery-1.6.2.js"),
_virtualFileSystemWrapper);
var testCoffeeAsset = new Asset(
UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestCoffeeScript.coffee"),
_virtualFileSystemWrapper);
var assets = new List <IAsset>
{
jqueryJsAsset,
testCoffeeAsset
};
Exception currentException = null;
var scriptAssetTypesValidator = new ScriptAssetTypesValidator();
// Act
try
{
scriptAssetTypesValidator.Validate(assets);
}
catch (Exception ex)
{
currentException = ex;
}
// Assert
Assert.IsNotType <InvalidAssetTypesException>(currentException);
}
public void StyleAssetsListNotContainAssetsWithInvalidTypes()
{
// Arrange
var siteCssAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Site.css"),
_virtualFileSystemWrapper);
var testLessAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "TestLess.less"),
_virtualFileSystemWrapper);
var assets = new List <IAsset>
{
siteCssAsset,
testLessAsset
};
Exception currentException = null;
var styleAssetTypesValidator = new StyleAssetTypesValidator();
// Act
try
{
styleAssetTypesValidator.Validate(assets);
}
catch (Exception ex)
{
currentException = ex;
}
// Assert
Assert.IsNotType <InvalidAssetTypesException>(currentException);
}
public void DuplicateScriptAssetsRemovedIsCorrect()
{
// Arrange
var virtualFileSystemWrapper = (new Mock <IVirtualFileSystemWrapper>()).Object;
var jqueryMinAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-1.6.2.min.js"), virtualFileSystemWrapper);
var jqueryAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-1.6.2.js"), virtualFileSystemWrapper);
var ajaxLoginAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"AjaxLogin.js"), virtualFileSystemWrapper);
var microsoftAjaxDebugAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"MicrosoftAjax.debug.js"), virtualFileSystemWrapper);
var microsoftAjaxAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"MicrosoftAjax.js"), virtualFileSystemWrapper);
var modernizrAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"modernizr-2.0.6-development-only.js"), virtualFileSystemWrapper);
var ajaxLoginDuplicateAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"ajaxlogin.js"), virtualFileSystemWrapper);
var testCoffeeAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"coffee/TestCoffeeScript.coffee"), virtualFileSystemWrapper);
var testTsAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"ts/TestTypeScript.ts"), virtualFileSystemWrapper);
var duplicateTestCoffeeAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"coffee/TestCoffeescript.coffee"), virtualFileSystemWrapper);
IList <IAsset> assets = new List <IAsset>
{
jqueryMinAsset,
jqueryAsset,
ajaxLoginAsset,
microsoftAjaxDebugAsset,
microsoftAjaxAsset,
modernizrAsset,
ajaxLoginDuplicateAsset,
testCoffeeAsset,
testTsAsset,
duplicateTestCoffeeAsset
};
var scriptDuplicateFilter = new ScriptDuplicateAssetsFilter();
// Act
IList <IAsset> processedAssets = scriptDuplicateFilter.Transform(assets);
// Assert
Assert.Equal(6, processedAssets.Count);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-1.6.2.min.js"), processedAssets[0].VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"AjaxLogin.js"), processedAssets[1].VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"MicrosoftAjax.debug.js"), processedAssets[2].VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"modernizr-2.0.6-development-only.js"), processedAssets[3].VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"coffee/TestCoffeeScript.coffee"), processedAssets[4].VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"ts/TestTypeScript.ts"), processedAssets[5].VirtualPath);
}
public void ReplacementOfFileExtensionsInDebugModeAndUsageOfPreMinifiedFilesAllowedIsCorrect()
{
// Arrange
IList <IAsset> assets = GetTestAssets();
var cssFileExtensionsFilter = new CssFileExtensionsFilter(_virtualFileSystemWrapper)
{
IsDebugMode = true,
UsePreMinifiedFiles = true
};
// Act
IList <IAsset> processedAssets = cssFileExtensionsFilter.Transform(assets);
IAsset siteAsset = processedAssets[0];
IAsset jqueryUiAccordionAsset = processedAssets[1];
IAsset testCssComponentsPathsAsset = processedAssets[2];
// Assert
Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Site.css"), siteAsset.VirtualPath);
Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
@"themes\base\jquery.ui.accordion.min.css"), jqueryUiAccordionAsset.VirtualPath);
Assert.NotEqual(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
@"themes\base\jquery.ui.accordion.css"), jqueryUiAccordionAsset.VirtualPath);
Assert.Equal(UrlHelpers.Combine(ALTERNATIVE_STYLES_DIRECTORY_VIRTUAL_PATH,
@"css\TestCssComponentsPaths.css"), testCssComponentsPathsAsset.VirtualPath);
Assert.False(siteAsset.Minified);
Assert.True(jqueryUiAccordionAsset.Minified);
Assert.False(testCssComponentsPathsAsset.Minified);
}
public void DuplicateStyleAssetsRemovedIsCorrect()
{
// Arrange
var siteAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"Site.css"), _virtualFileSystemWrapper);
var jqueryUiAccordionMinAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"themes/base/jquery.ui.accordion.min.css"), _virtualFileSystemWrapper);
var testCssComponentsPathsAsset = new Asset(UrlHelpers.Combine(ALTERNATIVE_STYLES_DIRECTORY_VIRTUAL_PATH,
"css/TestCssComponentsPaths.css"), _virtualFileSystemWrapper);
var testCssComponentsPathsMinAsset = new Asset(UrlHelpers.Combine(
ALTERNATIVE_STYLES_DIRECTORY_VIRTUAL_PATH,
"css/TestCssComponentsPaths.min.css"), _virtualFileSystemWrapper);
var siteDuplicateAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"site.css"), _virtualFileSystemWrapper);
var testLessAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"less/TestLess.less"), _virtualFileSystemWrapper);
var testSassAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"sass/TestSass.sass"), _virtualFileSystemWrapper);
var testScssAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"scss/TestScss.scss"), _virtualFileSystemWrapper);
var duplicateTestLessAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"LESS/TestLess.less"), _virtualFileSystemWrapper);
IList <IAsset> assets = new List <IAsset>
{
siteAsset,
jqueryUiAccordionMinAsset,
testCssComponentsPathsAsset,
testCssComponentsPathsMinAsset,
siteDuplicateAsset,
testLessAsset,
testSassAsset,
testScssAsset,
duplicateTestLessAsset
};
var styleDuplicateFilter = new StyleDuplicateAssetsFilter();
// Act
IList <IAsset> processedAssets = styleDuplicateFilter.Transform(assets);
// Assert
Assert.Equal(6, processedAssets.Count);
Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"Site.css"), processedAssets[0].VirtualPath);
Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"themes/base/jquery.ui.accordion.min.css"), processedAssets[1].VirtualPath);
Assert.Equal(UrlHelpers.Combine(ALTERNATIVE_STYLES_DIRECTORY_VIRTUAL_PATH,
"css/TestCssComponentsPaths.css"), processedAssets[2].VirtualPath);
Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"less/TestLess.less"), processedAssets[3].VirtualPath);
Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"sass/TestSass.sass"), processedAssets[4].VirtualPath);
Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"scss/TestScss.scss"), processedAssets[5].VirtualPath);
}
public void UnneededScriptAssetsRemovedIsCorrect()
{
// Arrange
var virtualFileSystemWrapper = (new Mock <IVirtualFileSystemWrapper>()).Object;
var ajaxLoginAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"AjaxLogin.js"), virtualFileSystemWrapper);
var jqueryMinAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-1.6.2.min.js"), virtualFileSystemWrapper);
var jqueryVsDocAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-1.6.2-vsdoc.js"), virtualFileSystemWrapper);
var jqueryValidateVsDocMinAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery.validate-vsdoc.min.js"), virtualFileSystemWrapper);
var microsoftAjaxDebugAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"MicrosoftAjax.debug.js"), virtualFileSystemWrapper);
var telerikAllMinAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"telerik.all.min.js"), virtualFileSystemWrapper);
var knockoutAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"knockout-2.0.0.js"), virtualFileSystemWrapper);
var modernizrAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"modernizr-2.0.6-development-only.js"), virtualFileSystemWrapper);
var referencesAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"_references.js"), virtualFileSystemWrapper);
var assets = new List <IAsset>
{
ajaxLoginAsset,
jqueryMinAsset,
jqueryVsDocAsset,
jqueryValidateVsDocMinAsset,
microsoftAjaxDebugAsset,
telerikAllMinAsset,
knockoutAsset,
modernizrAsset,
referencesAsset
};
var scriptUnnecessaryAssetsFilter = new ScriptUnnecessaryAssetsFilter(
new[] { "*-vsdoc.js", "*.all.js", "_references.js" });
// Act
IList <IAsset> processedAssets = scriptUnnecessaryAssetsFilter.Transform(assets).ToList();
// Assert
Assert.Equal(5, processedAssets.Count);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "AjaxLogin.js"),
processedAssets[0].VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "jquery-1.6.2.min.js"),
processedAssets[1].VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "MicrosoftAjax.debug.js"),
processedAssets[2].VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "knockout-2.0.0.js"),
processedAssets[3].VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"modernizr-2.0.6-development-only.js"), processedAssets[4].VirtualPath);
}
/// <summary>
/// Transforms a relative path to absolute
/// </summary>
/// <param name="basePath">The base path</param>
/// <param name="relativePath">The relative path</param>
public string ResolveRelativePath(string basePath, string relativePath)
{
if (basePath == null)
{
throw new ArgumentNullException(
nameof(basePath),
string.Format(Strings.Common_ArgumentIsNull, nameof(basePath))
);
}
if (relativePath == null)
{
throw new ArgumentNullException(
nameof(relativePath),
string.Format(Strings.Common_ArgumentIsNull, nameof(relativePath))
);
}
// Convert backslashes to forward slashes
string processedBasePath = UrlHelpers.ProcessBackSlashes(basePath);
string processedRelativePath = UrlHelpers.ProcessBackSlashes(relativePath);
// Trying to convert paths to absolute paths
string absoluteRelativePath;
if (TryConvertToAbsolutePath(processedRelativePath, out absoluteRelativePath))
{
return(UrlHelpers.Normalize(absoluteRelativePath));
}
string absoluteBasePath;
if (TryConvertToAbsolutePath(processedBasePath, out absoluteBasePath))
{
processedBasePath = absoluteBasePath;
}
if (string.IsNullOrWhiteSpace(processedBasePath))
{
return(UrlHelpers.Normalize(processedRelativePath));
}
if (string.IsNullOrWhiteSpace(processedRelativePath))
{
return(UrlHelpers.Normalize(processedBasePath));
}
string baseDirectoryName = UrlHelpers.GetDirectoryName(processedBasePath);
string absolutePath = UrlHelpers.Combine(baseDirectoryName, processedRelativePath);
return(absolutePath);
}
public void UrlCalculationIsCorrect()
{
// Arrange
var siteCssAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Site.css"),
_virtualFileSystemWrapper);
var jqueryAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "jquery-1.6.2.js"),
_virtualFileSystemWrapper);
// Act
string siteCssAssetUrl = siteCssAsset.Url;
string jqueryAssetUrl = jqueryAsset.Url;
// Assert
Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_URL, "Site.css"), siteCssAssetUrl);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_URL, "jquery-1.6.2.js"), jqueryAssetUrl);
}
private IList <IAsset> GetTestAssets()
{
var siteAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Site.css"),
_virtualFileSystemWrapper);
var jqueryUiAccordionAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
@"themes\base\jquery.ui.accordion.min.css"), _virtualFileSystemWrapper);
var testCssComponentsPathsAsset = new Asset(UrlHelpers.Combine(ALTERNATIVE_STYLES_DIRECTORY_VIRTUAL_PATH,
@"css\TestCssComponentsPaths.css"), _virtualFileSystemWrapper);
var testAssets = new List <IAsset>
{
siteAsset,
jqueryUiAccordionAsset,
testCssComponentsPathsAsset
};
return(testAssets);
}
public void UnneededStyleAssetsRemovedIsCorrect()
{
// Arrange
var virtualFileSystemWrapper = (new Mock <IVirtualFileSystemWrapper>()).Object;
var siteAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, @"Site.css"),
virtualFileSystemWrapper);
var jqueryUiAccordionAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
@"themes\base\jquery.ui.accordion.css"), virtualFileSystemWrapper);
var jqueryUiAllAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
@"themes\base\jquery.ui.all.css"), virtualFileSystemWrapper);
var testCssComponentsPathsAsset = new Asset(UrlHelpers.Combine(ALTERNATIVE_STYLES_DIRECTORY_VIRTUAL_PATH,
@"css\TestCssComponentsPaths.css"), virtualFileSystemWrapper);
var jqueryUiBaseMinAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
@"themes\base\jquery.ui.base.min.css"), virtualFileSystemWrapper);
var assets = new List <IAsset>
{
siteAsset,
jqueryUiAccordionAsset,
jqueryUiAllAsset,
testCssComponentsPathsAsset,
jqueryUiBaseMinAsset
};
var styleUnnecessaryAssetsFilter = new StyleUnnecessaryAssetsFilter(
new[] { "*.all.css", "jquery.ui.base.css" });
// Act
IList <IAsset> processedAssets = styleUnnecessaryAssetsFilter.Transform(assets).ToList();
// Assert
Assert.Equal(3, processedAssets.Count);
Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, @"Site.css"),
processedAssets[0].VirtualPath);
Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
@"themes\base\jquery.ui.accordion.css"), processedAssets[1].VirtualPath);
Assert.Equal(UrlHelpers.Combine(ALTERNATIVE_STYLES_DIRECTORY_VIRTUAL_PATH,
@"css\TestCssComponentsPaths.css"), processedAssets[2].VirtualPath);
}
public void ReplacementOfFileExtensionsInReleaseModeAndUsageOfPreMinifiedFilesDisallowedIsCorrect()
{
// Arrange
IList <IAsset> assets = GetTestAssets();
var jsFileExtensionsFilter = new JsFileExtensionsFilter(_jsFilesWithMicrosoftStyleExtensions,
_virtualFileSystemWrapper)
{
IsDebugMode = false,
UsePreMinifiedFiles = false
};
// Act
IList <IAsset> processedAssets = jsFileExtensionsFilter.Transform(assets);
IAsset jqueryAsset = processedAssets[0];
IAsset jqueryUiAsset = processedAssets[1];
IAsset microsoftAjaxAsset = processedAssets[2];
IAsset knockoutAsset = processedAssets[3];
IAsset modernizrAsset = processedAssets[4];
// Assert
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "jquery-1.6.2.js"),
jqueryAsset.VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "jquery-ui-1.8.11.js"),
jqueryUiAsset.VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "MicrosoftAjax.debug.js"),
microsoftAjaxAsset.VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "knockout-2.1.0beta.debug.js"),
knockoutAsset.VirtualPath);
Assert.Equal(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"modernizr-2.0.6-development-only.js"), modernizrAsset.VirtualPath);
Assert.NotEqual(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"modernizr-2.0.6-development-only.min.js"), modernizrAsset.VirtualPath);
Assert.False(jqueryAsset.Minified);
Assert.False(jqueryUiAsset.Minified);
Assert.False(microsoftAjaxAsset.Minified);
Assert.False(knockoutAsset.Minified);
Assert.False(modernizrAsset.Minified);
}
public CssFileExtensionsFilterTests()
{
var virtualFileSystemMock = new Mock <IVirtualFileSystemWrapper>();
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Site.css")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Site.min.css")))
.Returns(false)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
@"themes\base\jquery.ui.accordion.css")))
.Returns(false)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
@"themes\base\jquery.ui.accordion.min.css")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(ALTERNATIVE_STYLES_DIRECTORY_VIRTUAL_PATH,
@"css\TestCssComponentsPaths.css")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(ALTERNATIVE_STYLES_DIRECTORY_VIRTUAL_PATH,
@"css\TestCssComponentsPaths.min.css")))
.Returns(true)
;
_virtualFileSystemWrapper = virtualFileSystemMock.Object;
}
private IList <IAsset> GetTestAssets()
{
var jqueryAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-1.6.2.js"), _virtualFileSystemWrapper);
var jqueryUiAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-ui-1.8.11.min.js"), _virtualFileSystemWrapper);
var microsoftAjaxAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"MicrosoftAjax.debug.js"), _virtualFileSystemWrapper);
var knockoutAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"knockout-2.1.0beta.js"), _virtualFileSystemWrapper);
var modernizrAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"modernizr-2.0.6-development-only.js"), _virtualFileSystemWrapper);
var testAssets = new List <IAsset>
{
jqueryAsset,
jqueryUiAsset,
microsoftAjaxAsset,
knockoutAsset,
modernizrAsset
};
return(testAssets);
}
public void FillingOfDependenciesIsCorrect()
{
// Arrange
var virtualFileSystemMock = new Mock <IVirtualFileSystemWrapper>();
string testLessLessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "TestLess.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(testLessLessAssetVirtualPath))
.Returns(testLessLessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(testLessLessAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(testLessLessAssetVirtualPath))
.Returns(@"@import (once) ""Mixins.less"";
@import (reference) ""Variables.less"";
@import (css) url(""data:text/css;base64,Ym9keSB7IGJhY2tncm91bmQtY29sb3I6IGxpbWUgIWltcG9ydGFudDsgfQ=="");
.translators #less
{
float: left;
.visible();
padding: 0.2em 0.5em 0.2em 0.5em;
background-color: @bg-color;
color: @caption-color;
font-weight: bold;
border: 1px solid @bg-color;
.border-radius(5px);
}
.icon-monitor
{
display: inline;
background-image: url(""@{icons-path}monitor.png"");
}
@import (once) ""TestLessImport.less"";")
;
string mixinsLessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Mixins.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(mixinsLessAssetVirtualPath))
.Returns(mixinsLessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(mixinsLessAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(mixinsLessAssetVirtualPath))
.Returns(@"// Border Radius
.border-radius(@radius) {
-webkit-border-radius: @radius;
-moz-border-radius: @radius;
border-radius: @radius;
}
// Visible
.visible
{
display: block;
}")
;
string variablesLessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Variables.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(variablesLessAssetVirtualPath))
.Returns(variablesLessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(variablesLessAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(variablesLessAssetVirtualPath))
.Returns(@"@bg-color: #7AC0DA;
@caption-color: #FFFFFF;
@stylesheets-path: ""/Content/"";
@icons-path: ""/Content/images/icons/"";")
;
string testLessImportLessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"TestLessImport.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(testLessImportLessAssetVirtualPath))
.Returns(testLessImportLessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(testLessImportLessAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(testLessImportLessAssetVirtualPath))
.Returns(@"@alt-bg-color: #143352;
.translators #less
{
background-color: @alt-bg-color;
}
.icon-headphone
{
display: inline;
background-image: data-uri('@{icons-path}headphone.gif');
}
.icon-google-plus
{
display: inline;
background-image: data-uri('google-plus.svg');
}
@import (multiple) url( ""TestLessImport.Sub1.less"" );
.singleline-comment { content: ""//"" } .triple-slash-directive { content: '///' } @import '@{stylesheets-path}TestLessImport.Sub2';
/*@import 'TestLessImport.Sub3.less';
@import 'TestLessImport.Sub4.less';*/
// @import ""TestLessImport.Sub5.less"";
// Obsolete import //@import ""TestLessImport.Sub6.less"";
.icon-bean { background-image: url(http://taritsyn.files.wordpress.com/2013/08/bean.png); } //@import ""TestLessImport.Sub7.less"";
// @import ""TestLessImport.Sub8.less""; @import ""TestLessImport.Sub9.less"";
")
;
string headphoneGifAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "images/icons/headphone.gif");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(headphoneGifAssetVirtualPath))
.Returns(headphoneGifAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(headphoneGifAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileBinaryContent(headphoneGifAssetVirtualPath))
.Returns(new byte[0])
;
string googlePlusSvgAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "google-plus.svg");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(googlePlusSvgAssetVirtualPath))
.Returns(googlePlusSvgAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(googlePlusSvgAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(googlePlusSvgAssetVirtualPath))
.Returns(string.Empty)
;
string testLessImportSub1LessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"TestLessImport.Sub1.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(testLessImportSub1LessAssetVirtualPath))
.Returns(testLessImportSub1LessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(testLessImportSub1LessAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(testLessImportSub1LessAssetVirtualPath))
.Returns(@"@import (css) url(http://fonts.googleapis.com/css?family=Limelight&subset=latin,latin-ext);
@border-color: #143352;
.translators #less
{
border-color: @border-color;
}
.icon-network
{
display: inline;
background-image: data-uri('image/png;base64', ""@network.png"");
}
@import url(""TagIcon.css"");")
;
string networkPngAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "@network.png");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(networkPngAssetVirtualPath))
.Returns(networkPngAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(networkPngAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileBinaryContent(networkPngAssetVirtualPath))
.Returns(new byte[0])
;
string tagIconCssAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "TagIcon.css");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(tagIconCssAssetVirtualPath))
.Returns(tagIconCssAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(tagIconCssAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(tagIconCssAssetVirtualPath))
.Returns(@".icon-tag
{
display: inline;
background-image: url(tag.png) !important;
}")
;
string testLessImportSub2LessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"TestLessImport.Sub2.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(testLessImportSub2LessAssetVirtualPath))
.Returns(testLessImportSub2LessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(testLessImportSub2LessAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(testLessImportSub2LessAssetVirtualPath))
.Returns(@"@import (css) 'http://fonts.googleapis.com/css?family=Limelight&subset=latin,latin-ext';
@import (css) ""UsbFlashDriveIcon.css"";
@import (less) ""ValidationIcon.css"";
@import (inline) ""MicroformatsIcon.css"";
@import (inline, css) 'NodeIcon.less';
@import (css) ""OpenIdIcon.less"";
@import (optional) ""PrinterIcon.less"";
@import (optional) ""NonExistentIcon.less"";
@import ""~/Content/XfnIcon.less"";
@import ""~/Content/YahooIcon.css"";")
;
string usbFlashDriveIconCssAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"UsbFlashDriveIcon.css");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(usbFlashDriveIconCssAssetVirtualPath))
.Returns(usbFlashDriveIconCssAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(usbFlashDriveIconCssAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(usbFlashDriveIconCssAssetVirtualPath))
.Returns(@".icon-usb-flash-drive
{
display: inline;
background-image: ""usb-flash-drive.png"" !important;
}")
;
string validationIconCssAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"ValidationIcon.css");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(validationIconCssAssetVirtualPath))
.Returns(validationIconCssAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(validationIconCssAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(validationIconCssAssetVirtualPath))
.Returns(@".icon-validation
{
display: inline;
background-image: url('validation.png') !important;
}")
;
string microformatsIconCssAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"MicroformatsIcon.css");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(microformatsIconCssAssetVirtualPath))
.Returns(microformatsIconCssAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(microformatsIconCssAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(microformatsIconCssAssetVirtualPath))
.Returns(@".icon-microformats
{
display: inline;
background-image: url(microformats.png) !important;
}")
;
string nodeIconLessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"NodeIcon.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(nodeIconLessAssetVirtualPath))
.Returns(nodeIconLessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(nodeIconLessAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(nodeIconLessAssetVirtualPath))
.Returns(@".icon-node
{
display: inline;
background-image: url(node.png) !important;
}")
;
string openIdIconLessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"OpenIdIcon.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(openIdIconLessAssetVirtualPath))
.Returns(openIdIconLessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(openIdIconLessAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(openIdIconLessAssetVirtualPath))
.Returns(@".icon-openid
{
display: inline;
background-image: url(openid.png) !important;
}")
;
string printerIconLessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"PrinterIcon.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(printerIconLessAssetVirtualPath))
.Returns(printerIconLessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(printerIconLessAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(printerIconLessAssetVirtualPath))
.Returns(@".icon-printer
{
display: inline;
background-image: url(printer.png) !important;
}")
;
string nonExistentIconLessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"NonExistentIcon.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(nonExistentIconLessAssetVirtualPath))
.Returns(nonExistentIconLessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(nonExistentIconLessAssetVirtualPath))
.Returns(false)
;
string xfnIconLessAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"XfnIcon.less");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath("~" + xfnIconLessAssetVirtualPath))
.Returns(xfnIconLessAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(xfnIconLessAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(xfnIconLessAssetVirtualPath))
.Returns(@".icon-xfn
{
display: inline;
background-image: url(""~/Content/xfn.png"");
}")
;
string xfnPngAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"xfn.png");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath("~" + xfnPngAssetVirtualPath))
.Returns(xfnPngAssetVirtualPath)
;
string yahooIconCssAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH,
"YahooIcon.css");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath("~" + yahooIconCssAssetVirtualPath))
.Returns(yahooIconCssAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(yahooIconCssAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(yahooIconCssAssetVirtualPath))
.Returns(@".icon-yahoo
{
display: inline;
background-image: url(""/Content/yahoo.ico"") !important;
}")
;
Func <IJsEngine> createJsEngineInstance =
() => JsEngineSwitcher.Instance.CreateDefaultEngine();
IVirtualFileSystemWrapper virtualFileSystemWrapper = virtualFileSystemMock.Object;
var lessConfig = new LessSettings();
var lessTranslator = new LessTranslator(createJsEngineInstance,
virtualFileSystemWrapper, lessConfig);
IAsset asset = new Asset(testLessLessAssetVirtualPath, virtualFileSystemWrapper);
// Act
asset = lessTranslator.Translate(asset);
IList <string> dependencies = asset.VirtualPathDependencies;
// Assert
Assert.Equal(14, dependencies.Count);
Assert.Equal(mixinsLessAssetVirtualPath, dependencies[0]);
Assert.Equal(variablesLessAssetVirtualPath, dependencies[1]);
Assert.Equal(testLessImportLessAssetVirtualPath, dependencies[2]);
Assert.Equal(testLessImportSub1LessAssetVirtualPath, dependencies[3]);
Assert.Equal(testLessImportSub2LessAssetVirtualPath, dependencies[4]);
Assert.Equal(validationIconCssAssetVirtualPath, dependencies[5]);
Assert.Equal(microformatsIconCssAssetVirtualPath, dependencies[6]);
Assert.Equal(nodeIconLessAssetVirtualPath, dependencies[7]);
Assert.Equal(printerIconLessAssetVirtualPath, dependencies[8]);
Assert.Equal(nonExistentIconLessAssetVirtualPath, dependencies[9]);
Assert.Equal(xfnIconLessAssetVirtualPath, dependencies[10]);
Assert.Equal(headphoneGifAssetVirtualPath, dependencies[11]);
Assert.Equal(googlePlusSvgAssetVirtualPath, dependencies[12]);
Assert.Equal(networkPngAssetVirtualPath, dependencies[13]);
}
public void ScriptAssetsListContainAssetsWithInvalidTypes()
{
// Arrange
var siteCssAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Site.css"),
_virtualFileSystemWrapper);
var jqueryJsAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "jquery-1.6.2.js"),
_virtualFileSystemWrapper);
var testLessAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "TestLess.less"),
_virtualFileSystemWrapper);
var testCoffeeAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestCoffeeScript.coffee"),
_virtualFileSystemWrapper);
var testLitCoffeeAsset = new Asset(
UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestLiterateCoffeeScript.litcoffee"),
_virtualFileSystemWrapper);
var testCoffeeMdAsset = new Asset(
UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestCoffeeScriptMarkdown.coffee.md"),
_virtualFileSystemWrapper);
var testPlainTextAsset = new Asset(UrlHelpers.Combine(APPLICATION_ROOT_VIRTUAL_PATH, "TestPlainText.txt"),
_virtualFileSystemWrapper);
var assets = new List <IAsset>
{
siteCssAsset,
jqueryJsAsset,
testLessAsset,
testCoffeeAsset,
testLitCoffeeAsset,
testCoffeeMdAsset,
testPlainTextAsset
};
Exception currentException = null;
var scriptAssetTypesValidator = new ScriptAssetTypesValidator();
// Act
try
{
scriptAssetTypesValidator.Validate(assets);
}
catch (Exception ex)
{
currentException = ex;
}
var invalidAssetsVirtualPaths = new string[0];
var invalidAssetTypesException = (InvalidAssetTypesException)currentException;
if (invalidAssetTypesException != null)
{
invalidAssetsVirtualPaths = invalidAssetTypesException.InvalidAssetsVirtualPaths;
}
// Assert
Assert.IsType <InvalidAssetTypesException>(currentException);
Assert.Equal(3, invalidAssetsVirtualPaths.Length);
Assert.Contains(siteCssAsset.VirtualPath, invalidAssetsVirtualPaths);
Assert.Contains(testLessAsset.VirtualPath, invalidAssetsVirtualPaths);
Assert.Contains(testPlainTextAsset.VirtualPath, invalidAssetsVirtualPaths);
}
public string ToAbsolutePath(string virtualPath)
{
return(UrlHelpers.Combine(_applicationRootUrl, virtualPath.TrimStart('~').TrimStart('/')));
}
public JsFileExtensionsFilterTests()
{
var virtualFileSystemMock = new Mock <IVirtualFileSystemWrapper>();
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-1.6.2.debug.js")))
.Returns(false)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-1.6.2.js")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-1.6.2.min.js")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-ui-1.8.11.debug.js")))
.Returns(false)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-ui-1.8.11.js")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery-ui-1.8.11.min.js")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"MicrosoftAjax.debug.js")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"MicrosoftAjax.js")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"MicrosoftAjax.min.js")))
.Returns(false)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"knockout-2.1.0beta.debug.js")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"knockout-2.1.0beta.js")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"knockout-2.1.0beta.min.js")))
.Returns(false)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"modernizr-2.0.6-development-only.debug.js")))
.Returns(false)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"modernizr-2.0.6-development-only.js")))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"modernizr-2.0.6-development-only.min.js")))
.Returns(false)
;
_virtualFileSystemWrapper = virtualFileSystemMock.Object;
}
public void FillingOfDependenciesIsCorrect()
{
// Arrange
var virtualFileSystemMock = new Mock <IVirtualFileSystemWrapper>();
string testCssAssetVirtualPath = UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Test.css");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(testCssAssetVirtualPath))
.Returns(testCssAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(testCssAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(testCssAssetVirtualPath))
.Returns(@":fullscreen a
{
display: flex
}")
;
const string customStatisticsFileVirtualPath = "~/App_Data/BundleTransformer/stats.json";
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(customStatisticsFileVirtualPath))
.Returns(customStatisticsFileVirtualPath.Replace("~/", "/"))
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(customStatisticsFileVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(customStatisticsFileVirtualPath))
.Returns(@"{
""name"": ""All data of website"",
""id"": ""90598522|undefined"",
""type"": ""custom"",
""source"": ""google_analytics"",
""dataByBrowser"": {},
""meta"": {
""start_date"": ""2015-12-20"",
""end_date"": ""2016-01-19""
},
""uid"": ""custom.90598522|undefined""
}")
;
Func <IJsEngine> createJsEngineInstance =
() => JsEngineSwitcher.Instance.CreateDefaultEngine();
IVirtualFileSystemWrapper virtualFileSystemWrapper = virtualFileSystemMock.Object;
var autoprefixerConfig = new AutoprefixerSettings
{
Stats = customStatisticsFileVirtualPath
};
var autoprefixCssPostProcessor = new AutoprefixCssPostProcessor(createJsEngineInstance,
virtualFileSystemWrapper, autoprefixerConfig);
IAsset asset = new Asset(testCssAssetVirtualPath, virtualFileSystemWrapper);
// Act
asset = autoprefixCssPostProcessor.PostProcess(asset);
IList <string> dependencies = asset.VirtualPathDependencies;
// Assert
Assert.Equal(1, dependencies.Count);
Assert.Equal("/App_Data/BundleTransformer/stats.json", dependencies[0]);
}
public void FillingOfDependenciesIsCorrect()
{
// Arrange
var virtualFileSystemMock = new Mock <IVirtualFileSystemWrapper>();
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath("~/"))
.Returns("/")
;
string testTypeScriptTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"TestTypeScript.ts");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(testTypeScriptTsAssetVirtualPath))
.Returns(testTypeScriptTsAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(testTypeScriptTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(testTypeScriptTsAssetVirtualPath))
.Returns(@"/// <reference path=""ColoredTranslatorBadge.ts"" />
module TranslatorBadges {
var TS_BADGE_TEXT: string = ""TypeScript"";
var TS_BADGE_COLOR: string = ""#0074C1"";
export function createTsTranslatorBadge() {
var tsBadge: IColoredTranslatorBadge = new ColoredTranslatorBadge(""ts"");
tsBadge.setText(TS_BADGE_TEXT);
tsBadge.setTextColor(TS_BADGE_COLOR);
tsBadge.setBorderColor(TS_BADGE_COLOR);
tsBadge.show();
}
}
TranslatorBadges.createTsTranslatorBadge();")
;
string jqueryTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery.d.ts");
virtualFileSystemMock
.Setup(fs => fs.FileExists(jqueryTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(jqueryTsAssetVirtualPath))
.Returns(Utils.GetResourceAsString("BundleTransformer.Tests.Resources.jquery.d.ts", GetType().Assembly))
;
string iTranslatorBadgeTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"ITranslatorBadge.d.ts");
virtualFileSystemMock
.Setup(fs => fs.FileExists(iTranslatorBadgeTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(iTranslatorBadgeTsAssetVirtualPath))
.Returns(@"interface ITranslatorBadge {
getText(): string;
setText(text: string): void;
show(): void;
hide(): void;
isVisible(): boolean;
}")
;
string translatorBadgeTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"TranslatorBadge.ts");
virtualFileSystemMock
.Setup(fs => fs.FileExists(translatorBadgeTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(translatorBadgeTsAssetVirtualPath))
.Returns(@"/// <reference path=""jquery.d.ts"" />
/// <reference path=""ITranslatorBadge.d.ts"" />
module TranslatorBadges {
export class TranslatorBadge implements ITranslatorBadge {
$badgeElem: JQuery;
$linkElem: JQuery;
constructor (public elementId: string) {
this.$badgeElem = jQuery(""#"" + elementId);
this.$linkElem = this.$badgeElem.find(""A:first"");
}
public getText(): string {
return this.$linkElem.text();
}
public setText(text: string): void {
this.$linkElem.text(text);
}
public show(): void {
this.$badgeElem.show(0);
}
public hide(): void {
this.$badgeElem.hide(0);
}
public isVisible() : boolean {
return this.$badgeElem.is("":visible"");
}
}
}")
;
string iColoredTranslatorBadgeTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"IColoredTranslatorBadge.d.ts");
virtualFileSystemMock
.Setup(fs => fs.FileExists(iColoredTranslatorBadgeTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(iColoredTranslatorBadgeTsAssetVirtualPath))
.Returns(@"/// <reference path=""ITranslatorBadge.d.ts"" />
interface IColoredTranslatorBadge extends ITranslatorBadge {
getTextColor(): string;
setTextColor(color: string): void;
getBorderColor(): string;
setBorderColor(color: string): void;
}")
;
string coloredTranslatorBadgeTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"ColoredTranslatorBadge.ts");
virtualFileSystemMock
.Setup(fs => fs.FileExists(coloredTranslatorBadgeTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(coloredTranslatorBadgeTsAssetVirtualPath))
.Returns(@"/// <reference path=""jquery.d.ts"" />
/// <reference path=""./IColoredTranslatorBadge.d.ts"" />
/// <reference path=""TranslatorBadge.ts"" />
module TranslatorBadges {
export class ColoredTranslatorBadge
extends TranslatorBadge
{
public getTextColor(): string {
return this.$linkElem.css(""color"");
}
public setTextColor(color: string): void {
this.$linkElem.css(""color"", color);
}
public getBorderColor(): string {
return this.$badgeElem.css(""border-color"");
}
public setBorderColor(color: string): void {
this.$badgeElem.css(""border-color"", color);
}
}
}")
;
Func <IJsEngine> createJsEngineInstance =
() => JsEngineSwitcher.Current.CreateDefaultEngine();
IVirtualFileSystemWrapper virtualFileSystemWrapper = virtualFileSystemMock.Object;
var tsConfig = new TypeScriptSettings();
var tsTranslator = new TypeScriptTranslator(createJsEngineInstance, virtualFileSystemWrapper,
tsConfig);
IAsset asset = new Asset(testTypeScriptTsAssetVirtualPath, virtualFileSystemWrapper);
// Act
asset = tsTranslator.Translate(asset);
IList <string> dependencies = asset.VirtualPathDependencies;
// Assert
Assert.Equal(5, dependencies.Count);
Assert.Equal(coloredTranslatorBadgeTsAssetVirtualPath, dependencies[0]);
Assert.Equal(jqueryTsAssetVirtualPath, dependencies[1]);
Assert.Equal(iColoredTranslatorBadgeTsAssetVirtualPath, dependencies[2]);
Assert.Equal(iTranslatorBadgeTsAssetVirtualPath, dependencies[3]);
Assert.Equal(translatorBadgeTsAssetVirtualPath, dependencies[4]);
}
public void DeterminationOfAssetTypeIsCorrect()
{
// Arrange
// Act
var siteCssAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Site.css"),
_virtualFileSystemWrapper);
var jqueryJsAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "jquery-1.6.2.js"),
_virtualFileSystemWrapper);
var testLessAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "TestLess.less"),
_virtualFileSystemWrapper);
var testSassAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "TestSass.sass"),
_virtualFileSystemWrapper);
var testScssAsset = new Asset(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "TestScss.scss"),
_virtualFileSystemWrapper);
var testCoffeeAsset = new Asset(
UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestCoffeeScript.coffee"),
_virtualFileSystemWrapper);
var testLitCoffeeAsset = new Asset(
UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestLiterateCoffeeScript.litcoffee"),
_virtualFileSystemWrapper);
var testCoffeeMdAsset = new Asset(
UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestCoffeeScriptMarkdown.coffee.md"),
_virtualFileSystemWrapper);
var testTsAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestTypeScript.ts"),
_virtualFileSystemWrapper);
var testHandlebarsAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestHandlebars.handlebars"),
_virtualFileSystemWrapper);
var testShortHandlebarsAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestShortHandlebars.hbs"),
_virtualFileSystemWrapper);
var testPlainTextAsset = new Asset(UrlHelpers.Combine(APPLICATION_ROOT_VIRTUAL_PATH, "TestPlainText.txt"),
_virtualFileSystemWrapper);
// Assert
Assert.Equal(CoreAssetTypeCodes.Css, siteCssAsset.AssetTypeCode);
Assert.Equal(CoreAssetTypeCodes.JavaScript, jqueryJsAsset.AssetTypeCode);
Assert.Equal(LessAssetTypeCodes.Less, testLessAsset.AssetTypeCode);
Assert.Equal(SassAndScssAssetTypeCodes.Sass, testSassAsset.AssetTypeCode);
Assert.Equal(SassAndScssAssetTypeCodes.Scss, testScssAsset.AssetTypeCode);
Assert.Equal(CoffeeScriptAssetTypeCodes.CoffeeScript, testCoffeeAsset.AssetTypeCode);
Assert.Equal(CoffeeScriptAssetTypeCodes.LiterateCoffeeScript, testLitCoffeeAsset.AssetTypeCode);
Assert.Equal(CoffeeScriptAssetTypeCodes.LiterateCoffeeScript, testCoffeeMdAsset.AssetTypeCode);
Assert.Equal(TypeScriptAssetTypeCodes.TypeScript, testTsAsset.AssetTypeCode);
Assert.Equal(HandlebarsAssetTypeCodes.Handlebars, testHandlebarsAsset.AssetTypeCode);
Assert.Equal(HandlebarsAssetTypeCodes.Handlebars, testShortHandlebarsAsset.AssetTypeCode);
Assert.Equal(CoreAssetTypeCodes.Unknown, testPlainTextAsset.AssetTypeCode);
Assert.True(siteCssAsset.IsStylesheet);
Assert.False(siteCssAsset.IsScript);
Assert.False(jqueryJsAsset.IsStylesheet);
Assert.True(jqueryJsAsset.IsScript);
Assert.True(testLessAsset.IsStylesheet);
Assert.False(testLessAsset.IsScript);
Assert.True(testSassAsset.IsStylesheet);
Assert.False(testSassAsset.IsScript);
Assert.True(testScssAsset.IsStylesheet);
Assert.False(testScssAsset.IsScript);
Assert.False(testCoffeeAsset.IsStylesheet);
Assert.True(testCoffeeAsset.IsScript);
Assert.False(testLitCoffeeAsset.IsStylesheet);
Assert.True(testLitCoffeeAsset.IsScript);
Assert.False(testCoffeeMdAsset.IsStylesheet);
Assert.True(testCoffeeMdAsset.IsScript);
Assert.False(testTsAsset.IsStylesheet);
Assert.True(testTsAsset.IsScript);
Assert.False(testHandlebarsAsset.IsStylesheet);
Assert.True(testHandlebarsAsset.IsScript);
Assert.False(testShortHandlebarsAsset.IsStylesheet);
Assert.True(testShortHandlebarsAsset.IsScript);
Assert.False(testPlainTextAsset.IsStylesheet);
Assert.False(testPlainTextAsset.IsScript);
}
