Running MSpec tests from namespaces/classes selected in Unit Tests pad.

src/AddIns/Analysis/MachineSpecifications/MachineSpecifications.Tests/Src/MSpecTestFrameworkTests.cs

@@ -11,24 +11,21 @@ using System.Collections.Generic;
 using developwithpassion.specifications.rhinomocks;
 using ICSharpCode.SharpDevelop.Project;
 using Machine.Specifications;
+using ICSharpCode.UnitTesting;
+using ICSharpCode.SharpDevelop.Dom;
 
 namespace ICSharpCode.MachineSpecifications.Tests
 {
-	public abstract class MSpecTestFrameworkConcern : Observes<MSpecTestFramework> {
-		protected static void EstablishContext() {
-			
-		}
-		
-		protected static IProject testProject;
-		protected static IProject nonTestProject;
-	}
-	
 	[Subject(typeof(MSpecTestFramework))]
-	public class When_checking_if_is_a_test_project : MSpecTestFrameworkConcern {
+    public class When_checking_if_is_a_test_project : Observes<MSpecTestFramework>
-		static bool resultForTestProject;
+    {
+        static IProject testProject;
+        static IProject nonTestProject;
+        
+        static bool resultForTestProject;
 		static bool resultForNonTestProject;
 		
-		Establish ctx = EstablishContext;
+		Establish ctx;
 		
 		Because of = () => {
             resultForTestProject = sut.IsTestProject(testProject);
@@ -41,4 +38,34 @@ namespace ICSharpCode.MachineSpecifications.Tests
         It should_return_false_for_project_which_has_no_reference_to_test_framework = () =>
             resultForNonTestProject.ShouldBeFalse();
 	}
+
+    [Subject(typeof(MSpecTestFramework))]
+    public class When_checking_if_is_a_test_class : Observes<MSpecTestFramework>
+    {
+        static IClass classWithoutSpecificationMembers;
+        static IClass classWithSpecificationMembers;
+        static IClass classWithSpecificationMembersAndBehaviorAttribute;
+
+        static bool resultForClassWithBehaviorAttribute;
+        static bool resultForClassWithSpecifications;
+        static bool resultForClassWithoutSpecifications;
+
+        Establish ctx;
+
+        Because of = () =>
+        {
+            resultForClassWithoutSpecifications = sut.IsTestClass(classWithoutSpecificationMembers);
+            resultForClassWithSpecifications = sut.IsTestClass(classWithSpecificationMembers);
+            resultForClassWithBehaviorAttribute = sut.IsTestClass(classWithSpecificationMembersAndBehaviorAttribute);
+        };
+
+        It should_return_false_for_class_without_specification_members = () =>
+            resultForClassWithoutSpecifications.ShouldBeFalse();
+
+        It should_return_true_for_class_with_specification_members = () =>
+            resultForClassWithSpecifications.ShouldBeTrue();
+
+        It should_return_false_for_class_with_behavior_attribute = () =>
+            resultForClassWithBehaviorAttribute.ShouldBeFalse();
+    }
 }

src/AddIns/Analysis/MachineSpecifications/MachineSpecifications/src/MSpecApplication.cs

@@ -7,7 +7,10 @@
  * To change this template use Tools | Options | Coding | Edit Standard Headers.
  */
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using ICSharpCode.SharpDevelop;
+using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.UnitTesting;
 using System.IO;
 using ICSharpCode.Core;
@@ -53,11 +56,47 @@ namespace ICSharpCode.MachineSpecifications
             builder.Append(FileUtility.GetAbsolutePath(Environment.CurrentDirectory, Results));
             builder.Append("\" ");
 
+            var filterFileName = CreateFilterFile();
+            if (filterFileName != null)
+            {
+                builder.Append("-f \"");
+                builder.Append(FileUtility.GetAbsolutePath(Environment.CurrentDirectory, filterFileName));
+                builder.Append("\" ");
+            }
+
+            builder.Append("\"");
             builder.Append(project.OutputAssemblyFullPath);
+            builder.Append("\"");            
 
             return builder.ToString();
         }
 
+        string CreateFilterFile()
+        {
+        	var filter = new List<IClass>();
+        	if (tests.Class != null)
+        		filter.Add(tests.Class);
+            if (tests.NamespaceFilter != null)
+            {
+                var projectContent = ParserService.GetProjectContent(project);
+                foreach (var projectClass in projectContent.Classes)
+                    if (projectClass.FullyQualifiedName.StartsWith(tests.NamespaceFilter + "."))
+                        filter.Add(projectClass);
+            }
+                
+        	
+        	string path = null;
+        	if (filter.Count > 0) {
+        		path = Path.GetTempFileName();
+        		using (var stream = new FileStream(path, FileMode.Create, FileAccess.Write))
+    			using (var writer = new StreamWriter(stream))
+	        		foreach (var testClass in filter) {
+        			       	writer.WriteLine(testClass.FullyQualifiedName);
+	        		}
+        	}
+            return path;
+        }
+
         string ExecutableFileName {
             get {
                 var assemblyDirectory = Path.GetDirectoryName(new Uri(typeof(MSpecApplication).Assembly.CodeBase).LocalPath);

src/AddIns/Analysis/MachineSpecifications/MachineSpecifications/src/MSpecUnitTestMonitor.cs

@@ -65,7 +65,15 @@ namespace ICSharpCode.MachineSpecifications
         public void Read()
         {
             var document = new XmlDocument();
-            document.Load(FileName);
+            try
+            {
+                document.Load(FileName);
+            }
+            catch (XmlException e)
+            {
+                LoggingService.Warn("Error reading Machine.Specifications test results.", e);
+                return;
+            }
 
             var contextNodes = document.SelectNodes("MSpec/assembly/concern/context/specification");
             var results = contextNodes.Cast<XmlNode>().Select(BuildTestResultFrom).ToArray();

src/AddIns/Analysis/UnitTesting/Test/Frameworks/RegisteredTestFrameworksTestFixture.cs

@@ -231,4 +231,64 @@ namespace UnitTesting.Tests.Frameworks
 			Assert.IsFalse(testFrameworks.IsBuildNeededBeforeTestRunForProject(project));
 		}
 	}
+	
+	[TestFixture]
+    public class RegisteredTestFrameworksWithTwoFrameworksForTheSameProjectType
+    {
+        MockCSharpProject nunitTestProject;
+        MockTestFramework nunitTestFramework;
+        MockCSharpProject mspecTestProject;
+        MockTestFramework mspecTestFramework;
+        RegisteredTestFrameworks testFrameworks;
+
+        [SetUp]
+        public void Setup()
+        {
+			var factory = new MockTestFrameworkFactory();
+
+            Properties nunitProperties = new Properties();
+            nunitProperties["id"] = "nunit";
+            nunitProperties["class"] = "NUnitTestFramework";
+            nunitProperties["supportedProjects"] = ".csproj";
+            nunitTestFramework = new MockTestFramework();
+            factory.Add("NUnitTestFramework", nunitTestFramework);
+            
+            var mspecProperties = new Properties();
+			mspecProperties["id"] = "mspec";
+			mspecProperties["class"] = "MSpecTestFramework";
+			mspecProperties["supportedProjects"] = ".csproj";
+            mspecTestFramework = new MockTestFramework();
+            factory.Add("MSpecTestFramework", mspecTestFramework);
+			
+			TestFrameworkDescriptor mspecDescriptor = new TestFrameworkDescriptor(mspecProperties, factory);
+			TestFrameworkDescriptor nunitDescriptor = new TestFrameworkDescriptor(nunitProperties, factory);
+
+            var descriptors = new List<TestFrameworkDescriptor> { mspecDescriptor, nunitDescriptor };
+			
+			MockAddInTree addinTree = new MockAddInTree();
+            addinTree.AddItems("/SharpDevelop/UnitTesting/TestFrameworks", descriptors);
+			
+			testFrameworks = new RegisteredTestFrameworks(addinTree);
+
+            nunitTestProject = new MockCSharpProject();
+            nunitTestProject.FileName = @"d:\projects\nunitTestProject.csproj";
+            nunitTestFramework.AddTestProject(nunitTestProject);
+
+            mspecTestProject = new MockCSharpProject();
+            mspecTestProject.FileName = @"d:\projects\mspecTestProject.csproj";
+            mspecTestFramework.AddTestProject(mspecTestProject);
+        }
+
+        [Test]
+        public void ItShouldReturnMSpecTestFrameworkForMSpecTestProject()
+        {
+            Assert.AreSame(mspecTestFramework, testFrameworks.GetTestFrameworkForProject(mspecTestProject), "Expected mspec test framework.");
+        }
+
+        [Test]
+        public void ItShouldReturnNUnitTestFrameworkForNUnitTestProject()
+        {
+            Assert.AreSame(nunitTestFramework, testFrameworks.GetTestFrameworkForProject(nunitTestProject), "Expected nunit test framework.");
+        }
+    }
 }