public void BuildWithAssignmentsSkipsAssignmentsWithOneAssignment() { var assignments = new[] { new AssignmentInfoCollection() }; var memberField = new CodeMemberField(typeof(int), "myField"); var assignStatement = new CodeAssignStatement(); var ctorAssignment = new ConstructorAssignment("theParameter", assignStatement, memberField, typeof(string)); assignments[0].AddAssignment(ctorAssignment); //assignments[0].UsedConstructor = var tobuilder = this.mocks.StrictMock <ITestObjectComposer>(); Expect.Call(tobuilder.Assignments).Return(assignments); var stcontext = this.mocks.StrictMock <ISetupAndTearDownCreationContext>(); Expect.Call(stcontext.TestObjectCreator).Return(tobuilder); Expect.Call(this.context.SetUpTearDownContext).Return(stcontext);//.Repeat.Any(); mocks.ReplayAll(); var expected = true; var actual = testObject.Build(this.context); Assert.AreEqual(expected, actual); mocks.VerifyAll(); }
public void PropertyItemIndexNormalBehavior() { // Test read access of 'Indexer' Property. var expected = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); testObject.AddAssignment(expected); var actual = testObject["ParameterName"]; Assert.AreEqual(expected, actual); }
public void PropertyItemIndexWithNotPresentKey() { // Test read access of 'Indexer' Property with a key that is not present. var actual = testObject["NotPresent"]; Assert.IsNull(actual); var item = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); testObject.AddAssignment(item); actual = testObject["AnotherNotPresent"]; Assert.IsNull(actual); }
public void AddAssignmentWithSameKeyShouldThrow() { var item = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); testObject.AddAssignment(item); Assert.AreEqual(1, testObject.Count); Assert.Throws <ArgumentException>(() => testObject.AddAssignment(item)); Assert.AreEqual(1, testObject.Count); var item2 = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); Assert.Throws <ArgumentException>(() => testObject.AddAssignment(item2)); Assert.AreEqual(1, testObject.Count); }
private void CreateMocker( CodeTypeDeclaration testClassDeclaration, CodeMemberMethod setUpMethod, CodeMemberField mockRepositoryMemberField, List <CodeAssignStatement> mockAssignments, Type paraType, string paraName, ConstructorAssignment data) { if (data != null && data.MemberFieldName != data.ParameterName) { } // reuse already present field assignments. var mockMemberField = testClassDeclaration .Members.OfType <CodeMemberField>() .Where(e => e.Name == paraName) .FirstOrDefault(); var mockMemberFieldCreated = false; if (mockMemberField == null) { mockMemberField = AddTestMemberField( testClassDeclaration, paraType.FullName, paraName); mockMemberFieldCreated = true; } var mockAssignment = this.AddMockObject(mockRepositoryMemberField, paraType.FullName, paraName); if (mockMemberFieldCreated) { // none found, add a new assignment. setUpMethod.Statements.Add(mockAssignment); } else { if (data != null) { data.AssignStatement.Right = mockAssignment.Right; } } mockAssignments.Add(mockAssignment); }
public void AddAssignmentTest() { var expected = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); testObject.AddAssignment(expected); Assert.AreEqual(1, testObject.Count); var actual = testObject["ParameterName"]; Assert.AreEqual(expected, actual); var expected2 = new ConstructorAssignment("OtherParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); testObject.AddAssignment(expected2); actual = testObject["OtherParameterName"]; Assert.AreEqual(2, testObject.Count); Assert.AreEqual(expected2, actual); actual = testObject["ParameterName"]; Assert.AreEqual(expected, actual); }
/*/// <summary> * /// Compose additional items of the test setup method. * /// </summary> * /// <param name="setUpMethod">The test setup method.</param> * /// <param name="testObjectMemberField">The member field of the object under test.</param> * /// <param name="testObjectName">The name of the object under test.</param> * /// <returns> * /// The initialization expression of the object under test. * /// Is <c>null</c>, when none is created. * /// </returns> * protected override CodeObjectCreateExpression ComposeTestSetupMethod( * CodeMemberMethod setUpMethod, * CodeMemberField testObjectMemberField, * string testObjectName) * { * //var invokeExpression = new CodeMethodInvokeExpression( * // new CodeTypeReferenceExpression("Assert"), * // "AreEqual", * //new CodePrimitiveExpression("expected") * // new CodeFieldReferenceExpression(testObjectMemberField, "bla") * // , new CodeVariableReferenceExpression("actual")); * var fieldRef1 = * new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), testObjectMemberField.Name); * * var testObjectMemberFieldCreate = new CodeObjectCreateExpression(testObjectName, new CodeExpression[] { }); * var as1 = new CodeAssignStatement(fieldRef1, testObjectMemberFieldCreate); * * // Creates a statement using a code expression. * // var expressionStatement = new CodeExpressionStatement(fieldRef1); * setUpMethod.Statements.Add(as1); * return testObjectMemberFieldCreate; * }*/ /// <summary> /// Compose additional items of the test setup method. /// </summary> /// <param name="context">The setup context.</param> /// <param name="testObjectMemberField">The member field of the object under test.</param> /// <param name="testObjectName">The name of the object under test.</param> /// <returns> /// The list of assigned mock objects. /// </returns> protected virtual IEnumerable <CodeAssignStatement> ComposeTestSetupMockery( ISetupAndTearDownCreationContext context, CodeMemberField testObjectMemberField, string testObjectName) { CodeTypeDeclaration testClassDeclaration = context.TestClassDeclaration; CodeMemberMethod setUpMethod = context.SetUpMethod; // Todo: only the Type is necs, the CodeTypeDeclaration is too much knowledge. var testObjectClassType = (Type)testClassDeclaration.UserData[NStubConstants.UserDataClassTypeKey]; Type[] parameters = { /*typeof(int)*/ }; // Get the constructor that takes an integer as a parameter. var flags = BindingFlags.Instance; var noPrivate = true; switch (Configuration.MethodGeneratorLevelOfDetail) { case MemberVisibility.Public: flags |= BindingFlags.Public; break; case MemberVisibility.Internal: flags |= BindingFlags.Public | BindingFlags.NonPublic; break; case MemberVisibility.Private: flags |= BindingFlags.Public | BindingFlags.NonPublic; noPrivate = false; break; default: break; } var ctor = testObjectClassType.GetConstructor(flags, Type.DefaultBinder, parameters, null); if (ctor == null) { // outputBlock.Text += // "There is no public constructor of MyClass that takes an integer as a parameter.\n"; } // else // { // outputBlock.Text += // "The public constructor of MyClass that takes an integer as a parameter is:\n"; // outputBlock.Text += ctor.ToString() + "\n"; // } var testObjectConstructors = testObjectClassType.GetConstructors(flags); bool hasInterfaceInCtorParameters = false; var ctorParameterTypes = new List <ParameterInfo>(); foreach (var constructor in testObjectConstructors) { if (noPrivate && constructor.IsPrivate) { continue; } var ctorParameters = constructor.GetParameters(); foreach (var para in ctorParameters) { if (para.ParameterType.IsInterface /*&& !para.ParameterType.IsGenericType*/) { hasInterfaceInCtorParameters = true; ctorParameterTypes.Add(para); } } } if (!hasInterfaceInCtorParameters) { return(new CodeAssignStatement[0]); } var testObjectInitializerPosition = setUpMethod.Statements.Count - 1; var mockRepositoryMemberField = this.AddMockRepository( testClassDeclaration, setUpMethod, "mocks"); var mockAssignments = new List <CodeAssignStatement>(); foreach (var paraInfo in ctorParameterTypes) { IBuilderData data; ConstructorAssignment ctorassignment = null; if (paraInfo.ParameterType.IsGenericType) { var genericTypeDefinition = paraInfo.ParameterType.GetGenericTypeDefinition(); if (typeof(IEnumerable <>).IsAssignableFrom(genericTypeDefinition)) { // try to find the testobjcomposer assigned sub items for IEnumerable<T>'s. BuildProperties.TryGetValue( "CreateAssignments." + testObjectClassType.FullName + "." + paraInfo.Name, paraInfo.Name + "Item", out data); if (data != null) { ctorassignment = data.GetData() as ConstructorAssignment; } if (testObjectClassType.Name == "DefaultMemberBuilderFactory") { } if (ctorassignment != null) { this.CreateMocker( testClassDeclaration, setUpMethod, mockRepositoryMemberField, mockAssignments, ctorassignment.MemberType, paraInfo.Name, ctorassignment); } continue; } } BuildProperties.TryGetValue( "Assignments." + testObjectClassType.FullName, paraInfo.Name, out data); if (data != null) { ctorassignment = data.GetData() as ConstructorAssignment; } this.CreateMocker( testClassDeclaration, setUpMethod, mockRepositoryMemberField, mockAssignments, paraInfo.ParameterType, paraInfo.Name, ctorassignment); } // reorder the testObject initializer to the bottom of the SetUp method. // var removedTypedec = setUpMethod.Statements[testObjectInitializerPosition]; // setUpMethod.Statements.RemoveAt(testObjectInitializerPosition); // setUpMethod.Statements.Add(removedTypedec); return(mockAssignments); }
public void BuildWithAssignmentsNoMatchingParameters() { var method = new CodeMemberMethod(); var assCol1 = new AssignmentInfoCollection(); var assCol2 = new AssignmentInfoCollection(); var assignments = new[] { assCol1, assCol2 }; var memberField = new CodeMemberField(typeof(int), "myField"); var assignStatement = new CodeAssignStatement(); var ctorAssignment = new ConstructorAssignment("theParameter", assignStatement, memberField, typeof(string)); assignments[0].AddAssignment(ctorAssignment); var helpctors = typeof(ConstructorBuilderHelpType).GetConstructors(); assignments[0].UsedConstructor = helpctors[0]; assignments[1].UsedConstructor = helpctors[0]; var tobuilder = this.mocks.StrictMock <ITestObjectComposer>(); Expect.Call(tobuilder.Assignments).Return(assignments); var stcontext = this.mocks.StrictMock <ISetupAndTearDownCreationContext>(); Expect.Call(stcontext.TestObjectCreator).Return(tobuilder); Expect.Call(this.context.SetUpTearDownContext).Return(stcontext);//.Repeat.Any(); Expect.Call(this.context.TestObjectType).Return(typeof(int)).Repeat.AtLeastOnce(); var ctdecl = new CodeTypeDeclaration("TheTestClass"); Expect.Call(this.context.TestClassDeclaration).Return(ctdecl).Repeat.AtLeastOnce(); var buildResult = new MemberBuildResult(); Expect.Call(this.context.BuildResult).Return(buildResult).Repeat.AtLeastOnce(); Expect.Call(delegate { tobuilder.AssignExtra(ctdecl, method, null, assCol1); }) //.Constraints(Is.Equal(ctdecl), Is.Equal(method), Is.Anything(), Is.Equal(assCol1) .Constraints(Is.Equal(ctdecl), Is.Anything(), Is.Anything(), Is.Equal(assCol1)) .Do((Action <CodeTypeDeclaration, CodeMemberMethod, CodeObjectCreateExpression, AssignmentInfoCollection>) delegate(CodeTypeDeclaration testClassDeclaration, CodeMemberMethod testMethod, CodeObjectCreateExpression testObjectConstructor, AssignmentInfoCollection ctorAssignments) { var a = testClassDeclaration; var b = testMethod; Assert.IsInstanceOfType <CustomConstructorCodeMemberMethod>(testMethod); Assert.AreEqual("ConstructWithParametersTheIntParameterTest", testMethod.Name); var c = testObjectConstructor; Assert.IsEmpty(testObjectConstructor.Parameters); Assert.AreEqual("Int32", testObjectConstructor.CreateType.BaseType); var d = ctorAssignment; var e = ctorAssignment; }); Expect.Call(delegate { tobuilder.AssignExtra(ctdecl, method, null, assCol1); }) //.Constraints(Is.Equal(ctdecl), Is.Equal(method), Is.Anything(), Is.Equal(assCol1) .Constraints(Is.Equal(ctdecl), Is.Anything(), Is.Anything(), Is.Equal(assCol2) ); mocks.ReplayAll(); var expected = true; var actual = testObject.Build(this.context); Assert.AreEqual(expected, actual); // there should be two methods (constructor testers) added. Assert.Count(2, buildResult.ClassMethodsToAdd); var bresList = buildResult.ClassMethodsToAdd.ToList(); Assert.IsInstanceOfType <CustomConstructorCodeMemberMethod>(bresList[0]); Assert.IsInstanceOfType <CustomConstructorCodeMemberMethod>(bresList[1]); mocks.VerifyAll(); }
public void BuildWithAssignmentsSkipsAssignmentsWithOneAssignment() { var assignments = new[] { new AssignmentInfoCollection()}; var memberField = new CodeMemberField(typeof(int), "myField"); var assignStatement = new CodeAssignStatement(); var ctorAssignment = new ConstructorAssignment("theParameter", assignStatement, memberField, typeof(string)); assignments[0].AddAssignment(ctorAssignment); //assignments[0].UsedConstructor = var tobuilder = this.mocks.StrictMock<ITestObjectComposer>(); Expect.Call(tobuilder.Assignments).Return(assignments); var stcontext = this.mocks.StrictMock<ISetupAndTearDownCreationContext>(); Expect.Call(stcontext.TestObjectCreator).Return(tobuilder); Expect.Call(this.context.SetUpTearDownContext).Return(stcontext);//.Repeat.Any(); mocks.ReplayAll(); var expected = true; var actual = testObject.Build(this.context); Assert.AreEqual(expected, actual); mocks.VerifyAll(); }
public void BuildWithAssignmentsNoMatchingParameters() { var method = new CodeMemberMethod(); var assCol1 = new AssignmentInfoCollection(); var assCol2 = new AssignmentInfoCollection(); var assignments = new[] { assCol1, assCol2 }; var memberField = new CodeMemberField(typeof(int), "myField"); var assignStatement = new CodeAssignStatement(); var ctorAssignment = new ConstructorAssignment("theParameter", assignStatement, memberField, typeof(string)); assignments[0].AddAssignment(ctorAssignment); var helpctors = typeof(ConstructorBuilderHelpType).GetConstructors(); assignments[0].UsedConstructor = helpctors[0]; assignments[1].UsedConstructor = helpctors[0]; var tobuilder = this.mocks.StrictMock<ITestObjectComposer>(); Expect.Call(tobuilder.Assignments).Return(assignments); var stcontext = this.mocks.StrictMock<ISetupAndTearDownCreationContext>(); Expect.Call(stcontext.TestObjectCreator).Return(tobuilder); Expect.Call(this.context.SetUpTearDownContext).Return(stcontext);//.Repeat.Any(); Expect.Call(this.context.TestObjectType).Return(typeof(int)).Repeat.AtLeastOnce(); var ctdecl = new CodeTypeDeclaration("TheTestClass"); Expect.Call(this.context.TestClassDeclaration).Return(ctdecl).Repeat.AtLeastOnce(); var buildResult = new MemberBuildResult(); Expect.Call(this.context.BuildResult).Return(buildResult).Repeat.AtLeastOnce(); Expect.Call(delegate { tobuilder.AssignExtra(ctdecl, method, null, assCol1); }) //.Constraints(Is.Equal(ctdecl), Is.Equal(method), Is.Anything(), Is.Equal(assCol1) .Constraints(Is.Equal(ctdecl), Is.Anything(), Is.Anything(), Is.Equal(assCol1)) .Do((Action<CodeTypeDeclaration,CodeMemberMethod,CodeObjectCreateExpression ,AssignmentInfoCollection>) delegate(CodeTypeDeclaration testClassDeclaration, CodeMemberMethod testMethod, CodeObjectCreateExpression testObjectConstructor, AssignmentInfoCollection ctorAssignments) { var a = testClassDeclaration; var b = testMethod; Assert.IsInstanceOfType<CustomConstructorCodeMemberMethod>(testMethod); Assert.AreEqual("ConstructWithParametersTheIntParameterTest", testMethod.Name); var c = testObjectConstructor; Assert.IsEmpty(testObjectConstructor.Parameters); Assert.AreEqual("Int32", testObjectConstructor.CreateType.BaseType); var d = ctorAssignment; var e = ctorAssignment; }); Expect.Call(delegate { tobuilder.AssignExtra(ctdecl, method, null, assCol1); }) //.Constraints(Is.Equal(ctdecl), Is.Equal(method), Is.Anything(), Is.Equal(assCol1) .Constraints(Is.Equal(ctdecl), Is.Anything(), Is.Anything(), Is.Equal(assCol2) ); mocks.ReplayAll(); var expected = true; var actual = testObject.Build(this.context); Assert.AreEqual(expected, actual); // there should be two methods (constructor testers) added. Assert.Count(2, buildResult.ClassMethodsToAdd); var bresList = buildResult.ClassMethodsToAdd.ToList(); Assert.IsInstanceOfType<CustomConstructorCodeMemberMethod>(bresList[0]); Assert.IsInstanceOfType<CustomConstructorCodeMemberMethod>(bresList[1]); mocks.VerifyAll(); }