Add unit test for IDepdendenciesFolder

--HG--
branch : dev
rename : src/Orchard.Tests/Environment/Configuration/AppDataFolderTests.cs => src/Orchard.Tests/FileSystems/AppData/AppDataFolderTests.cs

src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs

@@ -11,6 +11,7 @@ using Orchard.Indexing;
 using Orchard.Core.Indexing.Lucene;
 using Orchard.Services;
 using Orchard.Tests.Environment.Configuration;
+using Orchard.Tests.FileSystems.AppData;
 
 namespace Orchard.Tests.Indexing {
     public class DefaultIndexProviderTests {

src/Orchard.Core.Tests/Indexing/DefaultSearchBuilderTests.cs

@@ -11,6 +11,7 @@ using Orchard.Indexing;
 using Orchard.Core.Indexing.Lucene;
 using Orchard.Services;
 using Orchard.Tests.Environment.Configuration;
+using Orchard.Tests.FileSystems.AppData;
 
 namespace Orchard.Tests.Indexing {
     public class DefaultSearchBuilderTests {

src/Orchard.Tests/Environment/Blueprint/DefaultShellDescriptorCacheTests.cs

@@ -9,6 +9,7 @@ using Orchard.FileSystems.AppData;
 using Orchard.FileSystems.VirtualPath;
 using Orchard.Services;
 using Orchard.Tests.Environment.Configuration;
+using Orchard.Tests.FileSystems.AppData;
 
 namespace Orchard.Tests.Environment.Blueprint {
     [TestFixture]

src/Orchard.Tests/Environment/Configuration/DefaultTenantManagerTests.cs

@@ -7,6 +7,7 @@ using Orchard.Environment.Configuration;
 using Orchard.FileSystems.AppData;
 using Orchard.FileSystems.VirtualPath;
 using Orchard.Services;
+using Orchard.Tests.FileSystems.AppData;
 
 namespace Orchard.Tests.Environment.Configuration {
     [TestFixture]

src/Orchard.Tests/Environment/DefaultOrchardHostTests.cs

@@ -25,6 +25,7 @@ using Orchard.Mvc.ModelBinders;
 using Orchard.Mvc.Routes;
 using Orchard.Tests.Environment.Configuration;
 using Orchard.Tests.Environment.TestDependencies;
+using Orchard.Tests.FileSystems.AppData;
 using Orchard.Tests.Stubs;
 using Orchard.Tests.Utility;
 

src/Orchard.Tests/Environment/Extensions/ExtensionLoaderCoordinatorTests.cs

@@ -0,0 +1,361 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Autofac;
+using NUnit.Framework;
+using Orchard.Environment.Extensions;
+using Orchard.Environment.Extensions.Folders;
+using Orchard.Environment.Extensions.Loaders;
+using Orchard.Environment.Extensions.Models;
+using Orchard.Tests.Extensions.ExtensionTypes;
+
+namespace Orchard.Tests.Environment.Extensions {
+    [TestFixture]
+    public class ExtensionLoaderCoordinatorTests {
+        private IContainer _container;
+        private IExtensionManager _manager;
+        private IExtensionLoaderCoordinator _loader;
+        private StubFolders _folders;
+
+        [SetUp]
+        public void Init() {
+            var builder = new ContainerBuilder();
+            _folders = new StubFolders();
+            builder.RegisterInstance(_folders).As<IExtensionFolders>();
+            builder.RegisterType<ExtensionManager>().As<IExtensionManager>();
+            _container = builder.Build();
+            _manager = _container.Resolve<IExtensionManager>();
+        }
+
+        public class StubFolders : IExtensionFolders {
+            public StubFolders() {
+                Manifests = new Dictionary<string, string>();
+            }
+
+            public IDictionary<string, string> Manifests { get; set; }
+
+            public IEnumerable<ExtensionDescriptor> AvailableExtensions() {
+                foreach (var e in Manifests) {
+                    string name = e.Key;
+                    var parseResult = ExtensionFolders.ParseManifest(Manifests[name]);
+                    yield return ExtensionFolders.GetDescriptorForExtension("~/", name, "Module", parseResult);
+                }
+            }
+        }
+
+        public class StubLoaders : ExtensionLoaderBase {
+            #region Implementation of IExtensionLoader
+
+            public override int Order {
+                get { return 1; }
+            }
+
+            public override ExtensionProbeEntry Probe(ExtensionDescriptor descriptor) {
+                return new ExtensionProbeEntry { Descriptor = descriptor, Loader = this };
+            }
+
+            public override ExtensionEntry Load(ExtensionDescriptor descriptor) {
+                return new ExtensionEntry { Descriptor = descriptor, ExportedTypes = new[] { typeof(Alpha), typeof(Beta), typeof(Phi) } };
+            }
+
+            #endregion
+        }
+
+
+        [Test]
+        public void AvailableExtensionsShouldFollowCatalogLocations() {
+            _folders.Manifests.Add("foo", "name: Foo");
+            _folders.Manifests.Add("bar", "name: Bar");
+            _folders.Manifests.Add("frap", "name: Frap");
+            _folders.Manifests.Add("quad", "name: Quad");
+
+            var available = _manager.AvailableExtensions();
+
+            Assert.That(available.Count(), Is.EqualTo(4));
+            Assert.That(available, Has.Some.Property("Name").EqualTo("foo"));
+        }
+
+        [Test]
+        public void ExtensionDescriptorsShouldHaveNameAndVersion() {
+
+            _folders.Manifests.Add("Sample", @"
+name: Sample Extension
+version: 2.x
+");
+
+            var descriptor = _manager.AvailableExtensions().Single();
+            Assert.That(descriptor.Name, Is.EqualTo("Sample"));
+            Assert.That(descriptor.DisplayName, Is.EqualTo("Sample Extension"));
+            Assert.That(descriptor.Version, Is.EqualTo("2.x"));
+        }
+
+        [Test]
+        public void ExtensionDescriptorsShouldBeParsedForMinimalModuleTxt() {
+
+            _folders.Manifests.Add("SuperWiki", @"
+name: SuperWiki
+version: 1.0.3
+orchardversion: 1
+features:
+  SuperWiki: 
+    Description: My super wiki module for Orchard.
+");
+
+            var descriptor = _manager.AvailableExtensions().Single();
+            Assert.That(descriptor.Name, Is.EqualTo("SuperWiki"));
+            Assert.That(descriptor.Version, Is.EqualTo("1.0.3"));
+            Assert.That(descriptor.OrchardVersion, Is.EqualTo("1"));
+            Assert.That(descriptor.Features.Count(), Is.EqualTo(1));
+            Assert.That(descriptor.Features.First().Name, Is.EqualTo("SuperWiki"));
+            Assert.That(descriptor.Features.First().Extension.Name, Is.EqualTo("SuperWiki"));
+            Assert.That(descriptor.Features.First().Description, Is.EqualTo("My super wiki module for Orchard."));
+        }
+
+        [Test]
+        public void ExtensionDescriptorsShouldBeParsedForCompleteModuleTxt() {
+
+            _folders.Manifests.Add("MyCompany.AnotherWiki", @"
+name: AnotherWiki
+author: Coder Notaprogrammer
+website: http://anotherwiki.codeplex.com
+version: 1.2.3
+orchardversion: 1
+features:
+  AnotherWiki: 
+    Description: My super wiki module for Orchard.
+    Dependencies: Versioning, Search
+    Category: Content types
+  AnotherWiki Editor:
+    Description: A rich editor for wiki contents.
+    Dependencies: TinyMCE, AnotherWiki
+    Category: Input methods
+  AnotherWiki DistributionList:
+    Description: Sends e-mail alerts when wiki contents gets published.
+    Dependencies: AnotherWiki, Email Subscriptions
+    Category: Email
+  AnotherWiki Captcha:
+    Description: Kills spam. Or makes it zombie-like.
+    Dependencies: AnotherWiki, reCaptcha
+    Category: Spam
+");
+
+            var descriptor = _manager.AvailableExtensions().Single();
+            Assert.That(descriptor.Name, Is.EqualTo("MyCompany.AnotherWiki"));
+            Assert.That(descriptor.DisplayName, Is.EqualTo("AnotherWiki"));
+            Assert.That(descriptor.Author, Is.EqualTo("Coder Notaprogrammer"));
+            Assert.That(descriptor.WebSite, Is.EqualTo("http://anotherwiki.codeplex.com"));
+            Assert.That(descriptor.Version, Is.EqualTo("1.2.3"));
+            Assert.That(descriptor.OrchardVersion, Is.EqualTo("1"));
+            Assert.That(descriptor.Features.Count(), Is.EqualTo(5));
+            foreach (var featureDescriptor in descriptor.Features) {
+                switch (featureDescriptor.Name) {
+                    case "AnotherWiki":
+                        Assert.That(featureDescriptor.Extension, Is.SameAs(descriptor));
+                        Assert.That(featureDescriptor.Description, Is.EqualTo("My super wiki module for Orchard."));
+                        Assert.That(featureDescriptor.Category, Is.EqualTo("Content types"));
+                        Assert.That(featureDescriptor.Dependencies.Count(), Is.EqualTo(2));
+                        Assert.That(featureDescriptor.Dependencies.Contains("Versioning"));
+                        Assert.That(featureDescriptor.Dependencies.Contains("Search"));
+                        break;
+                    case "AnotherWiki Editor":
+                        Assert.That(featureDescriptor.Extension, Is.SameAs(descriptor));
+                        Assert.That(featureDescriptor.Description, Is.EqualTo("A rich editor for wiki contents."));
+                        Assert.That(featureDescriptor.Category, Is.EqualTo("Input methods"));
+                        Assert.That(featureDescriptor.Dependencies.Count(), Is.EqualTo(2));
+                        Assert.That(featureDescriptor.Dependencies.Contains("TinyMCE"));
+                        Assert.That(featureDescriptor.Dependencies.Contains("AnotherWiki"));
+                        break;
+                    case "AnotherWiki DistributionList":
+                        Assert.That(featureDescriptor.Extension, Is.SameAs(descriptor));
+                        Assert.That(featureDescriptor.Description, Is.EqualTo("Sends e-mail alerts when wiki contents gets published."));
+                        Assert.That(featureDescriptor.Category, Is.EqualTo("Email"));
+                        Assert.That(featureDescriptor.Dependencies.Count(), Is.EqualTo(2));
+                        Assert.That(featureDescriptor.Dependencies.Contains("AnotherWiki"));
+                        Assert.That(featureDescriptor.Dependencies.Contains("Email Subscriptions"));
+                        break;
+                    case "AnotherWiki Captcha":
+                        Assert.That(featureDescriptor.Extension, Is.SameAs(descriptor));
+                        Assert.That(featureDescriptor.Description, Is.EqualTo("Kills spam. Or makes it zombie-like."));
+                        Assert.That(featureDescriptor.Category, Is.EqualTo("Spam"));
+                        Assert.That(featureDescriptor.Dependencies.Count(), Is.EqualTo(2));
+                        Assert.That(featureDescriptor.Dependencies.Contains("AnotherWiki"));
+                        Assert.That(featureDescriptor.Dependencies.Contains("reCaptcha"));
+                        break;
+                    // default feature.
+                    case "MyCompany.AnotherWiki":
+                        Assert.That(featureDescriptor.Extension, Is.SameAs(descriptor));
+                        break;
+                    default:
+                        Assert.Fail("Features not parsed correctly");
+                        break;
+                }
+            }
+        }
+
+        [Test]
+        public void ExtensionManagerShouldLoadFeatures() {
+            var extensionLoader = new StubLoaders();
+            var extensionFolder = new StubFolders();
+
+            extensionFolder.Manifests.Add("TestModule", @"
+name: TestModule
+version: 1.0.3
+orchardversion: 1
+features:
+  TestModule: 
+    Description: My test module for Orchard.
+  TestFeature:
+    Description: Contains the Phi type.
+");
+
+            IExtensionManager extensionManager = new ExtensionManager(new[] { extensionFolder }, new[] { extensionLoader });
+            var testFeature = extensionManager.AvailableExtensions()
+                .SelectMany(x => x.Features);
+
+            var features = extensionManager.LoadFeatures(testFeature);
+            var types = features.SelectMany(x => x.ExportedTypes);
+
+            Assert.That(types.Count(), Is.Not.EqualTo(0));
+        }
+
+        [Test]
+        public void ExtensionManagerFeaturesContainNonAbstractClasses() {
+            var extensionLoader = new StubLoaders();
+            var extensionFolder = new StubFolders();
+
+            extensionFolder.Manifests.Add("TestModule", @"
+name: TestModule
+version: 1.0.3
+orchardversion: 1
+features:
+  TestModule: 
+    Description: My test module for Orchard.
+  TestFeature:
+    Description: Contains the Phi type.
+");
+
+            IExtensionManager extensionManager = new ExtensionManager(new[] { extensionFolder }, new[] { extensionLoader });
+            var testFeature = extensionManager.AvailableExtensions()
+                .SelectMany(x => x.Features);
+
+            var features = extensionManager.LoadFeatures(testFeature);
+            var types = features.SelectMany(x => x.ExportedTypes);
+
+            foreach (var type in types) {
+                Assert.That(type.IsClass);
+                Assert.That(!type.IsAbstract);
+            }
+        }
+
+        [Test]
+        public void ExtensionManagerShouldThrowIfFeatureDoesNotExist() {
+            var featureDescriptor = new FeatureDescriptor { Name = "NoSuchFeature" };
+            Assert.Throws<ArgumentException>(() => _manager.LoadFeatures(new[] { featureDescriptor }));
+        }
+
+        [Test]
+        public void ExtensionManagerTestFeatureAttribute() {
+            var extensionLoader = new StubLoaders();
+            var extensionFolder = new StubFolders();
+
+            extensionFolder.Manifests.Add("TestModule", @"
+name: TestModule
+version: 1.0.3
+orchardversion: 1
+features:
+  TestModule: 
+    Description: My test module for Orchard.
+  TestFeature:
+    Description: Contains the Phi type.
+");
+
+            IExtensionManager extensionManager = new ExtensionManager(new[] { extensionFolder }, new[] { extensionLoader });
+            var testFeature = extensionManager.AvailableExtensions()
+                .SelectMany(x => x.Features)
+                .Single(x => x.Name == "TestFeature");
+
+            foreach (var feature in extensionManager.LoadFeatures(new[] { testFeature })) {
+                foreach (var type in feature.ExportedTypes) {
+                    foreach (OrchardFeatureAttribute featureAttribute in type.GetCustomAttributes(typeof(OrchardFeatureAttribute), false)) {
+                        Assert.That(featureAttribute.FeatureName, Is.EqualTo("TestFeature"));
+                    }
+                }
+            }
+        }
+
+        [Test]
+        public void ExtensionManagerLoadFeatureReturnsTypesFromSpecificFeaturesWithFeatureAttribute() {
+            var extensionLoader = new StubLoaders();
+            var extensionFolder = new StubFolders();
+
+            extensionFolder.Manifests.Add("TestModule", @"
+name: TestModule
+version: 1.0.3
+orchardversion: 1
+features:
+  TestModule: 
+    Description: My test module for Orchard.
+  TestFeature:
+    Description: Contains the Phi type.
+");
+
+            IExtensionManager extensionManager = new ExtensionManager(new[] { extensionFolder }, new[] { extensionLoader });
+            var testFeature = extensionManager.AvailableExtensions()
+                .SelectMany(x => x.Features)
+                .Single(x => x.Name == "TestFeature");
+
+            foreach (var feature in extensionManager.LoadFeatures(new[] { testFeature })) {
+                foreach (var type in feature.ExportedTypes) {
+                    Assert.That(type == typeof(Phi));
+                }
+            }
+        }
+
+        [Test]
+        public void ExtensionManagerLoadFeatureDoesNotReturnTypesFromNonMatchingFeatures() {
+            var extensionLoader = new StubLoaders();
+            var extensionFolder = new StubFolders();
+
+            extensionFolder.Manifests.Add("TestModule", @"
+name: TestModule
+version: 1.0.3
+orchardversion: 1
+features:
+  TestModule: 
+    Description: My test module for Orchard.
+  TestFeature:
+    Description: Contains the Phi type.
+");
+
+            IExtensionManager extensionManager = new ExtensionManager(new[] { extensionFolder }, new[] { extensionLoader });
+            var testModule = extensionManager.AvailableExtensions()
+                .SelectMany(x => x.Features)
+                .Single(x => x.Name == "TestModule");
+
+            foreach (var feature in extensionManager.LoadFeatures(new[] { testModule })) {
+                foreach (var type in feature.ExportedTypes) {
+                    Assert.That(type != typeof(Phi));
+                    Assert.That((type == typeof(Alpha) || (type == typeof(Beta))));
+                }
+            }
+        }
+
+        [Test]
+        public void ModuleNameIsIntroducedAsFeatureImplicitly() {
+            var extensionLoader = new StubLoaders();
+            var extensionFolder = new StubFolders();
+
+            extensionFolder.Manifests.Add("Minimalistic", @"
+name: Minimalistic
+version: 1.0.3
+orchardversion: 1
+");
+
+            IExtensionManager extensionManager = new ExtensionManager(new[] { extensionFolder }, new[] { extensionLoader });
+            var minimalisticModule = extensionManager.AvailableExtensions().Single(x => x.Name == "Minimalistic");
+
+            Assert.That(minimalisticModule.Features.Count(), Is.EqualTo(1));
+            Assert.That(minimalisticModule.Features.Single().Name, Is.EqualTo("Minimalistic"));
+        }
+    }
+}

src/Orchard.Tests/Environment/Extensions/ExtensionManagerTests.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Linq;
 using Autofac;
 using NUnit.Framework;
-using Orchard.Caching;
 using Orchard.Environment.Extensions;
 using Orchard.Environment.Extensions.Folders;
 using Orchard.Environment.Extensions.Loaders;

src/Orchard.Tests/FileSystems/AppData/AppDataFolderTests.cs

@@ -2,10 +2,9 @@
 using System.Linq;
 using NUnit.Framework;
 using Orchard.FileSystems.AppData;
-using Orchard.FileSystems.VirtualPath;
-using Orchard.Services;
+using Orchard.Tests.Stubs;
 
-namespace Orchard.Tests.Environment.Configuration {
+namespace Orchard.Tests.FileSystems.AppData {
     [TestFixture]
     public class AppDataFolderTests {
         private string _tempFolder;
@@ -18,7 +17,8 @@ namespace Orchard.Tests.Environment.Configuration {
 
         public static IAppDataFolder CreateAppDataFolder(string tempFolder) {
             var folderRoot = new StubAppDataFolderRoot {RootPath = "~/App_Data", RootFolder = tempFolder};
-            return new AppDataFolder(folderRoot, new DefaultVirtualPathMonitor(new Clock()));
+            var monitor = new StubVirtualPathMonitor();
+            return new AppDataFolder(folderRoot, monitor);
         }
 
         [SetUp]

src/Orchard.Tests/FileSystems/Dependencies/DependenciesFolderTests.cs

@@ -0,0 +1,49 @@
+using System.IO;
+using NUnit.Framework;
+using Orchard.FileSystems.AppData;
+using Orchard.FileSystems.Dependencies;
+using Orchard.Tests.FileSystems.AppData;
+
+namespace Orchard.Tests.FileSystems.Dependencies {
+    [TestFixture]
+    public class DependenciesFolderTests {
+        private string _tempFolder;
+        private IAppDataFolder _appDataFolder;
+        private IDependenciesFolder _dependenciesFolder;
+
+        [SetUp]
+        public void Init() {
+            _tempFolder = Path.GetTempFileName();
+            File.Delete(_tempFolder);
+
+            _appDataFolder = AppDataFolderTests.CreateAppDataFolder(_tempFolder);
+            _dependenciesFolder = new DefaultDependenciesFolder(new Stubs.StubCacheManager(), _appDataFolder);
+        }
+
+        [TearDown]
+        public void Term() {
+            Directory.Delete(_tempFolder, true);
+        }
+
+        [Test]
+        public void LoadDescriptorsShouldReturnEmptyList() {
+            Directory.Delete(_tempFolder, true);
+            var e = _dependenciesFolder.LoadDescriptors();
+            Assert.That(e, Is.Empty);
+        }
+
+        [Test]
+        public void StoreDescriptors() {
+            Directory.Delete(_tempFolder, true);
+            var d = new DependencyDescriptor {
+                LoaderName = "test",
+                Name = "name",
+                VirtualPath = "~/bin"
+            };
+            
+            _dependenciesFolder.StoreDescriptors(new [] { d });
+            var e = _dependenciesFolder.LoadDescriptors();
+            Assert.That(e, Has.Count.EqualTo(1));
+        }
+    }
+}

src/Orchard.Tests/Orchard.Framework.Tests.csproj

@@ -185,10 +185,11 @@
     <Compile Include="Data\StubLocator.cs" />
     <Compile Include="Environment\AutofacUtil\AutofacTests.cs" />
     <Compile Include="Environment\AutofacUtil\DynamicProxy2\DynamicProxyTests.cs" />
+    <Compile Include="Environment\Extensions\ExtensionLoaderCoordinatorTests.cs" />
     <Compile Include="Environment\State\DefaultProcessingEngineTests.cs" />
     <Compile Include="Environment\RunningShellTableTests.cs" />
     <Compile Include="Environment\Utility\Build.cs" />
-    <Compile Include="Environment\Configuration\AppDataFolderTests.cs" />
+    <Compile Include="FileSystems\AppData\AppDataFolderTests.cs" />
     <Compile Include="Environment\Configuration\DefaultTenantManagerTests.cs" />
     <Compile Include="Environment\DefaultCompositionStrategyTests.cs" />
     <Compile Include="Environment\DefaultOrchardHostTests.cs" />
@@ -196,9 +197,11 @@
     <Compile Include="Environment\OrchardStarterTests.cs" />
     <Compile Include="Environment\ShellBuilders\DefaultShellContainerFactoryTests.cs" />
     <Compile Include="Environment\ShellBuilders\DefaultShellContextFactoryTests.cs" />
+    <Compile Include="FileSystems\Dependencies\DependenciesFolderTests.cs" />
     <Compile Include="Localization\CultureManagerTests.cs" />
     <Compile Include="Mvc\Routes\ShellRouteTests.cs" />
     <Compile Include="Mvc\Routes\UrlPrefixTests.cs" />
+    <Compile Include="Stubs\StubVirtualPathMonitor.cs" />
     <Compile Include="Stubs\StubCacheManager.cs" />
     <Compile Include="Stubs\StubWebSiteFolder.cs" />
     <Compile Include="Utility\ContainerExtensions.cs" />
@@ -270,6 +273,7 @@
       <Install>true</Install>
     </BootstrapperPackage>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

src/Orchard.Tests/Stubs/StubVirtualPathMonitor.cs

@@ -0,0 +1,18 @@
+using System;
+using Orchard.Caching;
+using Orchard.FileSystems.VirtualPath;
+
+namespace Orchard.Tests.Stubs {
+    public class StubVirtualPathMonitor : IVirtualPathMonitor {
+        public class Token : IVolatileToken {
+            public bool IsCurrent { get; set; }
+        }
+        public IVolatileToken WhenPathChanges(string virtualPath) {
+            return new Token();
+        }
+
+        public void WhenPathChanges(string virtualPath, Action action) {
+            return;
+        }
+    }
+}