क्या एमवीसी 4 में यूनिट परीक्षण बंडल कॉन्फिग करना संभव है?

Question

जहाँ तक मैं कह सकता हूं, जवाब नहीं है। जो मुद्दा मैं देख रहा हूं Include(params string[]) विधि System.Web.Optimization.Bundle कक्षा में आता है। आंतरिक रूप से यह आह्वान System.Web.Optimization.IncludeDirectory(string, string, bool), जो बारी में इस कोड का उपयोग करता है:

DirectoryInfo directoryInfo = new DirectoryInfo(
    HttpContext.Current.Server.MapPath(directoryVirtualPath)); 

हालांकि यह एक इकाई परीक्षण के दौरान HttpContext.Current स्थापित करने के लिए संभव है, मैं समझ नहीं कैसे अपने .Server.MapPath(string directoryVirtualPath) वापसी एक गैर-शून्य स्ट्रिंग बनाने के लिए। चूंकि DirectoryInfo(string) कन्स्ट्रक्टर एक अपवाद फेंकने के बाद अपवाद फेंकता है, इसलिए ऐसा परीक्षण हमेशा असफल हो जाएगा।

इसके लिए .NET टीम की सिफारिश क्या है? क्या हमें एकीकरण परीक्षण या उपयोगकर्ता स्वीकृति परीक्षण के हिस्से के रूप में यूनिट परीक्षण बंडल कॉन्फ़िगरेशन करना है?

Answer 1

मैं, आप के लिए कुछ अच्छी खबर है RTM के लिए हम और अधिक इकाई परीक्षण सक्षम करने के लिए BundleTable पर एक नया स्थिर संपत्ति कहा:

public static Func<string, string> MapPathMethod; 

संपादित एक परीक्षण आभासी पथ प्रदाता के साथ अपडेट किया गया:

तो आप इस तरह कुछ कर सकते हैं:

public class TestVirtualPathProvider : VirtualPathProvider { 

    private string NormalizeVirtualPath(string virtualPath, bool isDirectory = false) { 
     if (!virtualPath.StartsWith("~")) { 
      virtualPath = "~" + virtualPath; 
     } 
     virtualPath = virtualPath.Replace('\\', '/'); 
     // Normalize directories to always have an ending "/" 
     if (isDirectory && !virtualPath.EndsWith("/")) { 
      return virtualPath + "/"; 
     } 
     return virtualPath; 
    } 

    // Files on disk (virtualPath -> file) 
    private Dictionary<string, VirtualFile> _fileMap = new Dictionary<string, VirtualFile>(); 
    private Dictionary<string, VirtualFile> FileMap { 
     get { return _fileMap; } 
    } 

    public void AddFile(VirtualFile file) { 
     FileMap[NormalizeVirtualPath(file.VirtualPath)] = file; 
    } 

    private Dictionary<string, VirtualDirectory> _directoryMap = new Dictionary<string, VirtualDirectory>(); 
    private Dictionary<string, VirtualDirectory> DirectoryMap { 
     get { return _directoryMap; } 
    } 

    public void AddDirectory(VirtualDirectory dir) { 
     DirectoryMap[NormalizeVirtualPath(dir.VirtualPath, isDirectory: true)] = dir; 
    } 

    public override bool FileExists(string virtualPath) { 
     return FileMap.ContainsKey(NormalizeVirtualPath(virtualPath)); 
    } 

    public override bool DirectoryExists(string virtualDir) { 
     return DirectoryMap.ContainsKey(NormalizeVirtualPath(virtualDir, isDirectory: true)); 
    } 

    public override VirtualFile GetFile(string virtualPath) { 
     return FileMap[NormalizeVirtualPath(virtualPath)]; 
    } 

    public override VirtualDirectory GetDirectory(string virtualDir) { 
     return DirectoryMap[NormalizeVirtualPath(virtualDir, isDirectory: true)]; 
    } 

    internal class TestVirtualFile : VirtualFile { 
     public TestVirtualFile(string virtualPath, string contents) 
      : base(virtualPath) { 
      Contents = contents; 
     } 

     public string Contents { get; set; } 

     public override Stream Open() { 
      return new MemoryStream(UTF8Encoding.Default.GetBytes(Contents)); 
     } 
    } 

    internal class TestVirtualDirectory : VirtualDirectory { 
     public TestVirtualDirectory(string virtualPath) 
      : base(virtualPath) { 
     } 

     public List<VirtualFile> _directoryFiles = new List<VirtualFile>(); 
     public List<VirtualFile> DirectoryFiles { 
      get { 
       return _directoryFiles; 
      } 
     } 

     public List<VirtualDirectory> _subDirs = new List<VirtualDirectory>(); 
     public List<VirtualDirectory> SubDirectories { 
      get { 
       return _subDirs; 
      } 
     } 

     public override IEnumerable Files { 
      get { 
       return DirectoryFiles; 
      } 
     } 

     public override IEnumerable Children { 
      get { throw new NotImplementedException(); } 
     } 

     public override IEnumerable Directories { 
      get { 
       return SubDirectories; 
      } 
     } 
    } 

और फिर इसका उपयोग करके यूनिट परीक्षण लिखें:

[TestMethod] 
    public void StyleBundleCustomVPPIncludeVersionSelectsTest() { 
     //Setup the vpp to contain the files/directories 
     TestVirtualPathProvider vpp = new TestVirtualPathProvider(); 
     var directory = new TestVirtualPathProvider.TestVirtualDirectory("/dir/"); 
     directory.DirectoryFiles.Add(new TestVirtualPathProvider.TestVirtualFile("/dir/style1.0.css", "correct")); 
     directory.DirectoryFiles.Add(new TestVirtualPathProvider.TestVirtualFile("/dir/style.css", "wrong")); 
     vpp.AddDirectory(directory); 

     // Setup the bundle 
     ScriptBundle bundle = new ScriptBundle("~/bundles/test"); 
     bundle.Items.VirtualPathProvider = vpp; 
     bundle.Include("~/dir/style{version}.css"); 

     // Verify the bundle repsonse 
     BundleContext context = SetupContext(bundle, vpp); 
     BundleResponse response = bundle.GetBundleResponse(context); 
     Assert.AreEqual(@"correct", response.Content); 
    } 

Answer 2

नेट 4.5 चीजों में थोड़ा बदलाव आया है। इन परिवर्तनों को समायोजित करने के लिए अपडेट किए गए अनुमोदित उत्तर का एक कार्य संस्करण यहां दिया गया है (मैं ऑटोफैक का उपयोग कर रहा हूं)। "GetBundleResponse" के बजाय "जेनरेटबंडल रिस्पॉन्स" पर ध्यान दें:

[Fact] 
    public void StyleBundleIncludesVersion() 
    { 
     //Setup the vpp to contain the files/directories 
     var vpp = new TestVirtualPathProvider(); 
     var directory = new TestVirtualPathProvider.TestVirtualDirectory("/dir/"); 
     directory.DirectoryFiles.Add(new TestVirtualPathProvider.TestVirtualFile("/dir/style1.0.css", "correct")); 
     directory.DirectoryFiles.Add(new TestVirtualPathProvider.TestVirtualFile("/dir/style.css", "wrong")); 
     vpp.AddDirectory(directory); 

     // Setup the bundle 
     var bundleCollection = new BundleCollection(); 
     var bundle = new ScriptBundle("~/bundles/test"); 
     BundleTable.VirtualPathProvider = vpp; 
     bundle.Include("~/dir/style{version}.css"); 
     bundleCollection.Add(bundle); 
     var mockHttpContext = new Mock<HttpContextBase>(); 

     // Verify the bundle repsonse 
     var context = new BundleContext(mockHttpContext.Object, bundleCollection, vpp.ToString()); 
     var response = bundle.GenerateBundleResponse(context); 
     Assert.Equal(@"correct", response.Content); 
    }