public void AddIsMethodResultTest() { var dic = new Dictionary <JsonSchema, SchemaImplementationDetails>(); var schema = new JsonSchema(); var service = new MockService(); service.Schemas.Add("TestSchema", new MockSchema() { SchemaDetails = schema }); var method = new MockMethod() { ResponseType = "TestSchema" }; // Test parameter validation: Assert.Throws <ArgumentNullException>( () => ImplementationDetailsGenerator.AddIsMethodResult(null, service, method)); Assert.Throws <ArgumentNullException>( () => ImplementationDetailsGenerator.AddIsMethodResult(dic, null, method)); Assert.Throws <ArgumentNullException>( () => ImplementationDetailsGenerator.AddIsMethodResult(dic, service, (IMethod)null)); // Test single add: ImplementationDetailsGenerator.AddIsMethodResult(dic, service, method); Assert.AreEqual(dic.Count, 1); var implDetails = dic[schema]; Assert.IsTrue(implDetails.IsMethodResult); }
public void WriteTestsWritesDirectoriesForReferencedProjectsToSysPathCommandLineArguments() { MockCSharpProject referencedProject = new MockCSharpProject(); referencedProject.FileName = @"c:\projects\pyproject\pyproject.pyproj"; MockCSharpProject unitTestProject = new MockCSharpProject(); ProjectReferenceProjectItem projectRef = new ProjectReferenceProjectItem(unitTestProject, referencedProject); projectRef.FileName = @"c:\projects\pyproject\pyproject.pyproj"; ProjectService.AddProjectItem(unitTestProject, projectRef); MockMethod method = MockMethod.CreateMockMethodWithoutAnyAttributes(); method.FullyQualifiedName = "MyNamespace.MyTests.MyTestMethod"; SelectedTests tests = new SelectedTests(unitTestProject, null, null, method); responseFile.WriteTests(tests); string expectedText = "/p:\"c:\\projects\\pyproject\"\r\n" + "MyNamespace.MyTests.MyTestMethod\r\n"; Assert.AreEqual(expectedText, responseFileText.ToString()); }
public MockFoozzing <T> Build() { return(new MockFoozzing <T> { _voidVoid = _voidVoid, _responseTaskVoid = _responseTaskVoid, _paramType = _paramType, _paramGeneric = _paramGeneric, _paramTypeResponseTask = _paramTypeResponseTask, _paramTuple = _paramTuple, _paramTypeGeneric = _paramTypeGeneric, _responseGeneric = _responseGeneric, _responseType = _responseType, _responseTaskGeneric = _responseTaskGeneric, _responseTaskType = _responseTaskType, _paramTypeResponseTaskType = _paramTypeResponseTaskType, _paramTupleResponseType = _paramTupleResponseType, _funcTaskGeneric = _funcTaskGeneric, _funcTaskGenericResponseTaskGeneric = _funcTaskGenericResponseTaskGeneric, _sameNameDifParamsInt = _sameNameDifParamsInt, _sameNameDifParamsDouble = _sameNameDifParamsDouble, _actionGenericResponseActionGeneric = _actionGenericResponseActionGeneric, _actionTypeResponseActionType = _actionTypeResponseActionType, , });
public void SetUp() { MockProjectContent projectContent = new MockProjectContent(); // Create the base test class. MockClass baseClass = new MockClass(projectContent, "ICSharpCode.SharpDevelop.Tests.ReflectionOrCecilLayerTests"); MockMethod baseMethod = new MockMethod(baseClass, "InheritanceTests"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseClass.Methods.Add(baseMethod); // Add a second method that does not have a Test attribute. baseMethod = new MockMethod(baseClass, "NonTestMethod"); baseClass.Methods.Add(baseMethod); // Create the derived test class. c = new MockClass(projectContent, "ICSharpCode.SharpDevelop.Tests.CecilLayerTests"); c.SetDotNetName(c.FullyQualifiedName); c.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(c); // Set derived class's base class. c.AddBaseClass(baseClass); // Create TestClass. MockTestFrameworksWithNUnitFrameworkSupport testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); testClass = new TestClass(c, testFrameworks); }
public void Init() { resultChangedCalled = false; IProject project = new MockCSharpProject(); project.Name = "TestProject"; ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project); nunitFrameworkReferenceItem.Include = "NUnit.Framework"; ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem); projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; MockClass mockClass = new MockClass("RootNamespace.Tests.MyTestFixture"); mockClass.Namespace = "RootNamespace.Tests"; mockClass.ProjectContent = projectContent; mockClass.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(mockClass); // Add a method to the test class MockMethod mockMethod = new MockMethod("TestMethod"); mockMethod.DeclaringType = mockClass; mockMethod.Attributes.Add(new MockAttribute("Test")); mockClass.Methods.Add(mockMethod); testProject = new TestProject(project, projectContent); testClass = testProject.TestClasses[0]; testMethod = testClass.TestMethods[0]; }
public void Init() { testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); // Add a test class. MockProjectContent projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; MockClass c = new MockClass(projectContent, "RootNamespace.MyTestFixture"); c.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(c); // Add first method. MockMethod method = new MockMethod(c, "MyTest"); method.Attributes.Add(new MockAttribute("Test")); c.Methods.Add(method); // Add duplicate method. c.Methods.Add(method); // Add a base class that has duplicate methods. MockClass baseClass = new MockClass(projectContent, "RootNamespace.MyTestFixtureBase"); baseClass.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(baseClass); c.AddBaseClass(baseClass); baseClass.Methods.Add(method); baseClass.Methods.Add(method); // Create test class. testClass = new TestClass(c, testFrameworks); }
public void DeclaringTypeReturnsExpectedClassWhenMethodCreated() { MockClass declaringType = new MockClass(); MockMethod method = new MockMethod(declaringType); Assert.AreEqual(declaringType, method.DeclaringType); }
public void NameReturnsExpectedMethodNameWhenMethodCreated() { MockClass declaringType = new MockClass(); MockMethod method = new MockMethod(declaringType, "MyMethod"); Assert.AreEqual("MyMethod", method.Name); }
public void CreateProcessInfoReturnsCommandLineWithDirectoriesForReferencedProjects() { MockCSharpProject referencedProject = new MockCSharpProject(); referencedProject.FileName = @"c:\projects\rbproject\rbproject.rbproj"; MockCSharpProject unitTestProject = new MockCSharpProject(); ProjectReferenceProjectItem projectRef = new ProjectReferenceProjectItem(unitTestProject, referencedProject); projectRef.FileName = @"c:\projects\rbproject\pyproject.rbproj"; ProjectService.AddProjectItem(unitTestProject, projectRef); MockMethod method = MockMethod.CreateMockMethodWithoutAnyAttributes(); method.CompilationUnit.FileName = @"d:\mytest.rb"; FileProjectItem fileItem = new FileProjectItem(unitTestProject, ItemType.Compile); fileItem.FileName = @"d:\mytest.rb"; ProjectService.AddProjectItem(unitTestProject, fileItem); SelectedTests tests = RubySelectedTestsHelper.CreateSelectedTests(unitTestProject); ProcessStartInfo processStartInfo = GetProcessStartInfoFromTestRunnerApp(tests); string expectedCommandLine = "--disable-gems " + "\"-Ic:\\rubybinding\\TestRunner\" " + "\"-Ic:\\projects\\rbproject\" " + "\"c:\\rubybinding\\TestRunner\\sdtest.rb\" " + "-- " + "\"results.txt\" " + "\"temp.tmp\""; Assert.AreEqual(expectedCommandLine, processStartInfo.Arguments); }
public void IsTestMethodCallRecorded() { MockMethod method = MockMethod.CreateMockMethodWithoutAnyAttributes(); testFramework.IsTestMember(method); Assert.AreEqual(method, testFramework.IsTestMemberParameterUsed); }
public void SetUp() { MockProjectContent projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; // Create the top base test class. MockClass baseBaseClass = new MockClass(projectContent, "ICSharpCode.SharpDevelop.Tests.BaseBaseTestFixture"); MockMethod baseMethod = new MockMethod(baseBaseClass, "BaseBaseTest"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseBaseClass.Methods.Add(baseMethod); // Create the next level test class. MockClass baseClass = new MockClass(projectContent, "ICSharpCode.SharpDevelop.Tests.BaseTestFixture"); baseMethod = new MockMethod(baseClass, "BaseTest"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseClass.Methods.Add(baseMethod); // Create the derived test class. c = new MockClass(projectContent, "ICSharpCode.SharpDevelop.Tests.MainTestFixture"); c.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(c); // Set the base class for each class in the hierarchy. c.AddBaseClass(baseClass); baseClass.AddBaseClass(baseBaseClass); // Create TestClass. testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); testClass = new TestClass(c, testFrameworks); }
public void SetUp() { MockProjectContent projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; // Create the base test class. MockClass baseClass = new MockClass("RootNamespace.TestFixtureBase"); baseClass.Attributes.Add(new MockAttribute("TestFixture")); baseClass.ProjectContent = projectContent; MockMethod baseMethod = new MockMethod("BaseMethod"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseMethod.DeclaringType = baseClass; baseClass.Methods.Add(baseMethod); // Create the derived test class. c = new MockClass("RootNamespace.MyTestFixture"); c.Attributes.Add(new MockAttribute("TestFixture")); c.ProjectContent = projectContent; MockMethod method = new MockMethod("DerivedMethod"); method.DeclaringType = c; method.Attributes.Add(new MockAttribute("Test")); c.Methods.Add(method); projectContent.Classes.Add(c); // Set derived class's base class. c.BaseClass = baseClass; // Create TestClass. testClass = new TestClass(c); }
public void IsTestMethodReturnsTrueWhenMethodHasFullyQualifiedNUnitTestAttribute() { MockAttribute testAttribute = new MockAttribute("MbUnit.Framework.TestAttribute"); MockMethod mockMethod = MockMethod.CreateMockMethodWithAttribute(testAttribute); Assert.IsTrue(testFramework.IsTestMethod(mockMethod)); }
public void Init() { base.InitBase(); project = new MockCSharpProject(); MockBuildProjectBeforeTestRun buildProject = new MockBuildProjectBeforeTestRun(); context.MockBuildProjectFactory.AddBuildProjectBeforeTestRun(buildProject); methodToTest = MockMethod.CreateMockMethodWithoutAnyAttributes(); methodToTest.FullyQualifiedName = "MyTests.MyTestClass.MyTestMethod"; classToTest = methodToTest.DeclaringType as MockClass; classToTest.SetDotNetName("MyTests.MyTestClass"); treeView = new MockTestTreeView(); treeView.SelectedProject = project; treeView.SelectedMember = methodToTest; runTestCommand.Owner = treeView; runTestCommand.Run(); buildProject.FireBuildCompleteEvent(); context.MockUnitTestWorkbench.MakeSafeThreadAsyncMethodCallsWithArguments = true; context.MockBuildOptions.ShowErrorListAfterBuild = false; TestResult result = new TestResult("MyTests.MyTestClass.MyTestMethod"); result.ResultType = TestResultType.Failure; context.MockTestResultsMonitor.FireTestFinishedEvent(result); runTestCommand.CallTestsCompleted(); }
public void Init() { project = new MockCSharpProject(); c = new MockClass(); method = new MockMethod(c); selectedTests = new SelectedTests(project, namespaceFilter, c, method); }
void CreateTestMethod() { project = new MockCSharpProject(); MockClass c = new MockClass("MyNamespace.MyTestClass"); methodToTest = new MockMethod(c, "MyTestMethod"); }
public void IsValidReturnsFalseForMethodWithoutAnyAttributes() { MockMethod method = MockMethod.CreateMockMethodWithoutAnyAttributes(); MockMemberNode memberNode = new MockMemberNode(method); Assert.IsFalse(testableCondition.IsValid(memberNode, null)); }
public void NewMethodAdded() { TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode; TestClass testClass = projectNode.TestProject.TestClasses["RootNamespace.Tests.MyTestFixture"]; MockMethod method = new MockMethod(testClass.Class, "NewMethod"); method.Attributes.Add(new MockAttribute("Test")); testClass.TestMembers.Add(new TestMember(method)); ExtTreeNode newMethodNode = null; foreach (ExtTreeNode node in testFixtureNode.Nodes) { if (node.Text == "NewMethod") { newMethodNode = node; break; } } Assert.AreEqual(2, testFixtureNode.Nodes.Count); Assert.IsNotNull(newMethodNode); Assert.IsInstanceOf(typeof(TestMemberTreeNode), newMethodNode); }
public void HasAttribute_MethodWithDifferentAttribute_ReturnsTrue() { var subject = new MockMethod(); var actual = subject.HasAttribute <DisplayAttribute>("MethodWithAlias"); Assert.IsFalse(actual); }
public void HasAttribute_MethodWithoutAttribute_ReturnsFalse() { var subject = new MockMethod(); var actual = subject.HasAttribute <AliasAttribute>("MethodWithoutAlias"); Assert.IsFalse(actual); }
public void GetMemberFromMemberNode() { MockMethod mockMethod = MockMethod.CreateMockMethodWithoutAnyAttributes(); MockMemberNode memberNode = new MockMemberNode(mockMethod); Assert.IsTrue(Object.ReferenceEquals(mockMethod, TestableCondition.GetMember(memberNode))); }
public void IsTestMethodReturnsFalseForMethodThatDoesNotStartWithTest() { MockClass c = MockClass.CreateMockClassWithoutAnyAttributes(); MockMethod method = new MockMethod(c, "RunThis"); Assert.IsFalse(testFramework.IsTestMethod(method)); }
public void GetAttribute_MethodWithoutRequestedAttribute_ReturnsNull() { var subject = new MockMethod(); var actual = subject.GetAttribute <AliasAttribute>("MethodWithoutAlias"); Assert.IsNull(actual); }
public void Init() { IProject project = new MockCSharpProject(); project.Name = "TestProject"; ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project); nunitFrameworkReferenceItem.Include = "NUnit.Framework"; ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem); MockProjectContent projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; mockClass = new MockClass(projectContent, "RootNamespace.Tests.MyTestFixture"); mockClass.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(mockClass); // Add a method to the test class MockMethod mockMethod = new MockMethod(mockClass, "TestMethod1"); mockMethod.Attributes.Add(new MockAttribute("Test")); mockClass.Methods.Add(mockMethod); mockMethod = new MockMethod(mockClass, "TestMethod2"); mockMethod.Attributes.Add(new MockAttribute("Test")); mockClass.Methods.Add(mockMethod); testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); testProject = new TestProject(project, projectContent, testFrameworks); testClass = testProject.TestClasses[0]; testMethod1 = testClass.TestMembers[0]; testMethod2 = testClass.TestMembers[1]; }
public void GetAttribute_MethodWithAttribute_ReturnsAttribute() { var subject = new MockMethod(); var actual = subject.GetAttribute <AliasAttribute>("MethodWithAlias"); Assert.IsNotNull(actual); }
public void GetAttribute_MethodWithDifferentAttribute_ReturnsNull() { var subject = new MockMethod(); var actual = subject.GetAttribute <DisplayAttribute>("MethodWithAlias"); Assert.IsNull(actual); }
public void DecorateClassTest() { var method = new MockMethod() { Name = "Method", Parameters = new Dictionary <string, IParameter>() }; method.Parameters.Add("Param", new MockParameter() { Name = "Param" }); method.Parameters.Add("Param2", new MockParameter() { Name = "Param2" }); var resource = new MockResource(); resource.Methods.Add("Method", method); var resourceDecl = new CodeTypeDeclaration(); var requestDecl = new CodeTypeDeclaration(); // Confirm that the decorator adds the two parameters as properties with a backing field each. var decorator = new ParameterPropertyDecorator(); decorator.DecorateClass(resource, method, requestDecl, resourceDecl); Assert.AreEqual(4, requestDecl.Members.Count); // 2 properties + 2 field. Assert.AreEqual(0, resourceDecl.Members.Count); }
public void CreateConstructorTest() { var parameter = new MockParameter() { Name = "Param", IsRequired = true }; var method = new MockMethod() { Name = "Method", Parameters = new Dictionary <string, IParameter>() }; method.Parameters.Add("Param", parameter); var resource = new MockResource(); resource.Methods.Add("Method", method); var resourceDecl = new CodeTypeDeclaration(); var typeProvider = new DefaultObjectTypeProvider("Schema"); // Confirm that the "service" parameter is added. var decorator = new RequestConstructorDecorator(typeProvider); CodeConstructor constructor = decorator.CreateRequiredConstructor(resourceDecl, method, false); Assert.AreEqual(2, constructor.Parameters.Count); Assert.AreEqual("service", constructor.Parameters[0].Name); Assert.AreEqual(1, constructor.BaseConstructorArgs.Count); }
public void AddBodyParameterTest() { var method = new MockMethod() { Name = "Method", Parameters = new Dictionary <string, IParameter>() }; var typeProvider = new DefaultObjectTypeProvider("Schema"); // Confirm that no body parameter is added. var decorator = new RequestConstructorDecorator(typeProvider); CodeConstructor constructor = new CodeConstructor(); method.HasBody = false; decorator.AddBodyParameter(constructor, method); Assert.AreEqual(0, constructor.Parameters.Count); Assert.AreEqual(0, constructor.Statements.Count); // Confirm that a required body parameter is added. method.RequestType = "MySchema"; method.HasBody = true; constructor = new CodeConstructor(); decorator.AddBodyParameter(constructor, method); Assert.AreEqual(1, constructor.Parameters.Count); Assert.AreEqual("body", constructor.Parameters[0].Name); Assert.AreEqual("Schema.MySchema", constructor.Parameters[0].Type.BaseType); Assert.AreEqual(1, constructor.Statements.Count); }
public void SetUp() { MockProjectContent projectContent = new MockProjectContent(); // Create the base test class. MockClass baseClass = new MockClass(projectContent, "RootNamespace.TestFixtureBase"); baseClass.Attributes.Add(new MockAttribute("TestFixture")); MockMethod baseMethod = new MockMethod(baseClass, "BaseMethod"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseClass.Methods.Add(baseMethod); // Create the derived test class. c = new MockClass(projectContent, "RootNamespace.MyTestFixture"); c.Attributes.Add(new MockAttribute("TestFixture")); MockMethod method = new MockMethod(c, "DerivedMethod"); method.Attributes.Add(new MockAttribute("Test")); c.Methods.Add(method); projectContent.Classes.Add(c); // Set derived class's base class. c.AddBaseClass(baseClass); // Create TestClass. testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); testClass = new TestClass(c, testFrameworks); }
public void Init() { firstAttribute = new MockAttribute("first"); mockMethod = MockMethod.CreateMockMethodWithAttribute(firstAttribute); }
public void Init() { mockMethod = MockMethod.CreateMockMethodWithoutAnyAttributes(); }