public void SetUp()
{
this.mocks = new MockRepository();
this.handler = this.mocks.StrictMock <IBuildHandler>();
this.properties = new BuildDataDictionary();
this.testObject = new BuilderSerializer();
}
/// <summary>
/// Initializes a new instance of the <see cref="MemberBuildContextBase"/> class.
/// </summary>
/// <param name="codeNamespace">The code namespace.</param>
/// <param name="testClassDeclaration">The test class declaration.( early testObject ).</param>
/// <param name="typeMember">The current type to create a test method for.</param>
/// <param name="buildData">The additional build data lookup.</param>
/// <param name="setUpTearDownContext">Contains data specific to SetUp and TearDown test-methods.</param>
/// <param name="baseKey">The base string of the <see cref="TestKey"/>. Is amended by the
/// <paramref name="codeNamespace"/> identifier, normalized and fixed by a <see cref="KeynameFixer"/>.</param>
protected MemberBuildContextBase(
CodeNamespace codeNamespace,
CodeTypeDeclaration testClassDeclaration,
CodeTypeMember typeMember,
BuildDataDictionary buildData,
ISetupAndTearDownContext setUpTearDownContext,
string baseKey)
{
Guard.NotNull(() => codeNamespace, codeNamespace);
Guard.NotNull(() => testClassDeclaration, testClassDeclaration);
Guard.NotNull(() => typeMember, typeMember);
Guard.NotNull(() => buildData, buildData);
Guard.NotNull(() => setUpTearDownContext, setUpTearDownContext);
Guard.NotNullOrEmpty(() => baseKey, baseKey);
this.CodeNamespace = codeNamespace;
this.TestClassDeclaration = testClassDeclaration;
this.TypeMember = typeMember;
this.BuildData = buildData;
this.SetUpTearDownContext = setUpTearDownContext;
this.PreBuildResult = new MemberBuildResult();
this.BuildResult = new MemberBuildResult();
//this.TestKey = GetTestKey(codeNamespace, testClassDeclaration, typeMember);
var fixer = new KeynameFixer(codeNamespace, testClassDeclaration, typeMember);
var fixedName = fixer.Fix(typeMember.Name);
this.TestKey = baseKey + "." + fixedName;
}
public void SetUp()
{
buildData = new BuildDataDictionary();
this.typeDeclarations = new CodeTypeDeclarationCollection();
this.testClassDeclaration = new System.CodeDom.CodeTypeDeclaration();
typeDeclarations.Add(this.testClassDeclaration);
this.namespaceDetector = new NStub.CSharp.NamespaceDetector(typeDeclarations);
this.testObject = new CodeTypeSetup(this.namespaceDetector, buildData, this.testClassDeclaration);
}
public void ConstructTest()
{
this.testObject = new BuildDataDictionary();
// unit test for Empty list. Always has the 'General' category.
Assert.AreEqual(1, testObject.Count);
Assert.IsNotEmpty(testObject);
var lookup = testObject["General"];
Assert.IsNotNull(lookup);
}
public void SetUp()
{
this.mocks = new MockRepository();
buildData = new BuildDataDictionary();
codeNamespace = new CodeNamespace();
testClassDeclaration = new CodeTypeDeclaration();
setUpMethod = new CodeMemberMethod();
tearDownMethod = new CodeMemberMethod();
creator = this.mocks.StrictMock <ITestObjectComposer>();
this.testObject = this.mocks.StrictMock <SetupAndTearDownContextBase>(buildData, codeNamespace,
testClassDeclaration, setUpMethod, tearDownMethod, creator);
}
public void ConstructWithParametersCodeNamespaceTestClassDeclarationTypeMemberBuildDataSetUpTearDownContextTest(
)
{
// TODO: Implement unit test for ConstructWithParametersCodeNamespaceTestClassDeclarationTypeMemberBuildDataSetUpTearDownContext
this.codeNamespace = new CodeNamespace();
this.testClassDeclaration = new CodeTypeDeclaration();
this.typeMember = new CodeTypeMember();
this.buildData = new BuildDataDictionary();
this.testObject = new MemberBuildContext(
this.codeNamespace,
this.testClassDeclaration,
this.typeMember,
this.buildData,
this.setUpTearDownContext, TheKey);
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpTestProjectBuilder"/> class.
/// </summary>
/// <param name="sbs">The system wide build system.</param>
/// <param name="buildData">The build data properties.</param>
/// <param name="projectGenerator">The project generator.</param>
/// <param name="createGeneratorCallback">The callback to create new code
/// generators per test class <see cref="CodeNamespace"/>.</param>
/// <param name="logger">The logging method.</param>
public CSharpTestProjectBuilder(
IBuildSystem sbs,
IBuildDataDictionary buildData,
IProjectGenerator projectGenerator,
Func <IBuildSystem, IBuildDataDictionary, ICodeGeneratorParameters, CodeNamespace, ICodeGenerator> createGeneratorCallback,
Action <string> logger)
: base(sbs, projectGenerator, OldOnCreateCodeGenerator, logger)
{
Guard.NotNull(() => buildData, buildData);
Guard.NotNull(() => createGeneratorCallback, createGeneratorCallback);
this.createGeneratorCallback = createGeneratorCallback;
// properties = SetUpBuildProperties();
this.properties = SetUpBuildProperties(buildData);
}
public void SetUp()
{
this.testObject = new BuildDataDictionary();
this.item1 = new EmptyMultiBuildParameters()
{
Enabled = true
};
this.item2 = new EmptyMultiBuildParameters()
{
Id = new Guid("2764B5BE-6E56-4694-B1A1-5C105420CB7F")
};
this.item3 = new EmptyMultiBuildParameters()
{
Enabled = true, Id = new Guid("0AE4E28A-9B78-43bf-ABD2-9F7CB5F3833B")
};
}
/// <summary>
/// Initializes a new instance of the <see cref="SetupAndTearDownContext"/> class.
/// </summary>
/// <param name="buildData">The build data dictionary.</param>
/// <param name="codeNamespace">The code namespace of the test.</param>
/// <param name="testClassDeclaration">The test class declaration.( early testObject ).</param>
/// <param name="setUpMethod">A reference to the test setup method.</param>
/// <param name="tearDownMethod">The tear down method.</param>
/// <param name="creator">The test object member field generator of the test SetUp method.</param>
public SetupAndTearDownContext(
BuildDataDictionary buildData,
CodeNamespace codeNamespace,
CodeTypeDeclaration testClassDeclaration,
CodeMemberMethod setUpMethod,
CodeMemberMethod tearDownMethod,
ITestObjectComposer creator)
: base(
buildData,
codeNamespace,
testClassDeclaration,
setUpMethod,
tearDownMethod,
creator)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="MemberBuildContext"/> class.
/// </summary>
/// <param name="codeNamespace">The code namespace of the test.</param>
/// <param name="testClassDeclaration">The test class declaration.( early testObject ).</param>
/// <param name="typeMember">The current type to create a test method for.</param>
/// <param name="buildData">The additional build data lookup.</param>
/// <param name="setUpTearDownContext">Contains data specific to SetUp and TearDown test-methods.</param>
/// <param name="baseKey">The base string of the <see cref="MemberBuildContextBase.TestKey"/>. Is amended by the
/// <paramref name="codeNamespace"/> identifier, normalized and fixed by a <see cref="KeynameFixer"/>.</param>
public MemberBuildContext(
CodeNamespace codeNamespace,
CodeTypeDeclaration testClassDeclaration,
CodeTypeMember typeMember,
BuildDataDictionary buildData,
ISetupAndTearDownContext setUpTearDownContext,
string baseKey)
: base(
codeNamespace,
testClassDeclaration,
typeMember,
buildData,
setUpTearDownContext,
baseKey)
{
}
public void SetUp()
{
this.codeNamespace = new CodeNamespace();
this.testClassDeclaration = new CodeTypeDeclaration();
this.typeMember = new CodeTypeMember();
// MethodInfo methodInfo = this.GetType().GetMethod("SetUp");
// typeMember.UserData[NStubConstants.TestMemberMethodInfoKey] = methodInfo;
this.buildData = new BuildDataDictionary();
this.mocks = new MockRepository();
this.setUpTearDownContext = this.mocks.StrictMock <ISetupAndTearDownContext>();
this.testObject = new MemberBuildContext(
this.codeNamespace,
this.testClassDeclaration,
this.typeMember,
this.buildData,
this.setUpTearDownContext, TheKey);
}
/// <summary>
/// SetUp the default build properties.
/// </summary>
/// <param name="buildData">The incoming build data.</param>
/// <returns>A new <see cref="BuildDataDictionary"/>, merged with the input <paramref name="buildData"/>.</returns>
private static BuildDataDictionary SetUpBuildProperties(IBuildDataDictionary buildData)
{
var props = new BuildDataDictionary();
// ReadOnlyCollection
foreach (var category in buildData.Data())
{
foreach (var item in category.Value)
{
props.AddDataItem(category.Key, item.Key, item.Value);
}
// props.AddDataItem(item.Key, item,);
}
props.AddDataItem("DasGuuuut", new EmptyBuildParameters());
props.AddDataItem("EinTest", new StringConstantBuildParameter("Der Parameter!"));
// Todo: !!!
return(props);
}
/// <summary>
/// Initializes a new instance of the <see cref="SetupAndTearDownContextBase"/> class.
/// </summary>
/// <param name="buildData">The build data dictionary.</param>
/// <param name="codeNamespace">The code namespace.</param>
/// <param name="testClassDeclaration">The test class declaration.( early testObject ).</param>
/// <param name="setUpMethod">A reference to the test setup method.</param>
/// <param name="tearDownMethod">The tear down method.</param>
/// <param name="creator">The test object member field generator of the test SetUp method.</param>
protected SetupAndTearDownContextBase(
BuildDataDictionary buildData,
CodeNamespace codeNamespace,
CodeTypeDeclaration testClassDeclaration,
CodeMemberMethod setUpMethod,
CodeMemberMethod tearDownMethod,
ITestObjectComposer creator)
{
Guard.NotNull(() => buildData, buildData);
Guard.NotNull(() => codeNamespace, codeNamespace);
Guard.NotNull(() => testClassDeclaration, testClassDeclaration);
Guard.NotNull(() => setUpMethod, setUpMethod);
Guard.NotNull(() => tearDownMethod, tearDownMethod);
Guard.NotNull(() => creator, creator);
this.BuildData = buildData;
this.CodeNamespace = codeNamespace;
this.TestClassDeclaration = testClassDeclaration;
this.SetUpMethod = setUpMethod;
this.TearDownMethod = tearDownMethod;
this.TestObjectCreator = creator;
}
public void PropertyIsDirtyNormalBehavior()
{
// Test read access of 'IsDirty' Property.
var expected = false;
var actual = testObject.IsDirty;
Assert.AreEqual(expected, actual);
testObject.AddDataItem("Moo", "Key", item1);
expected = true;
actual = testObject.IsDirty;
Assert.AreEqual(expected, actual);
this.testObject = new BuildDataDictionary();
testObject.AddDataItem("YesInGeneral", item2);
actual = testObject.IsDirty;
Assert.AreEqual(expected, actual);
this.testObject = new BuildDataDictionary();
testObject.AddDataItem("NotInGeneral", "My-Key", item3);
actual = testObject.IsDirty;
Assert.AreEqual(expected, actual);
testObject.Save();
expected = false;
actual = testObject.IsDirty;
Assert.AreEqual(expected, actual);
// replacing the existing from above should not affect the dirty flag.
testObject.AddDataItem("NotInGeneral", "My-Key", item3, true);
actual = testObject.IsDirty;
Assert.AreEqual(expected, actual);
testObject.AddDataItem("NotInGeneral", "My-OtherKey", item3, true);
expected = true;
actual = testObject.IsDirty;
Assert.AreEqual(expected, actual);
}
public void TearDown()
{
this.testObject = null;
}
/// <summary>
/// Initializes a new instance of the <see cref="GeneratorConfig"/> class.
/// </summary>
/// <param name="buildData">The build data property store.</param>
public GeneratorConfig(BuildDataDictionary buildData)
{
Guard.NotNull(() => buildData, buildData);
this.properties = buildData;
this.InitializeComponent();
}
/// <summary>
/// Initializes a new instance of the <see cref="GeneratorConfig"/> class.
/// </summary>
public GeneratorConfig()
{
this.properties = new BuildDataDictionary();
this.InitializeComponent();
}
private void SetupInstance()
{
BuildProperties = new BuildDataDictionary();
Memberfactory = MemberBuilderFactory.Default;
}
public void TearDown()
{
this.testObject = null;
this.properties = null;
}
