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();
}
