Develop Reference

Any way to run one test inside another, and be able to see if child test passes?

I want to know if it's possible to somehow call one functional test inside another, and have the parent functional test be able to see if the child tests passes or not ? ... Please note that the parent and child tests are in different projects and although I can reference the child test's project in my project's CSPROJ file for read access, I cannot modify anything in the child test's project.
Something like this is what I'm after:
[TestClass]
public class ParentTests
{
[TestMethod]
public void Test_Parent()
{
var childTestPassed = RunAnotherTest(Test_Child);
if(childTestRunResult == true)
{
// do something
} else
{
// do something
}
}
}
... where Test_Child is the name of the child test method I want to run within my parent test.
I know very clearly that this is not the recommended testing methodology to use as tests need to be stateless, independent, modular with consistent results, however I have a very tricky scenario which requires me to do what I've stated above - there's no way around it. As I said, I do not have control over the child functional test source code, so if the above isn't possible then I'll have to copy paste the entire code of the child test, into my parent test, which I don't want to do as it's quite big and involves importing several classes, interfaces, etc., and I don't have working knowledge of that code.
In case if you still want to know why I'm asking this, please put a comment and I can answer.

Well, i have no idea, why do you need things like this, but any Assert Method throws an AssertFailedException.
So your code should look like this:
[TestClass]
public class ChildTests
{
[TestMethod]
public void Test_Child()
{
Assert.Fail ("Child test failed.");
}
}
and the parent tests:
[TestClass]
public class ParentTests
{
[TestMethod]
public void Test_Parent()
{
ChildTests childTests = new ChildTests();
try
{
childTests.Test_Child();
// child test succeded
}
catch (AssertFailedException ex)
{
// child test failed
}
}
}

Prevent NUnit tests to run depending on environment

I'm struggle with this one quite a long time now. Some background: I created my automated test framework using Selenium. With one project being pure NUnit tests and second one that does all the work for the tests. Now, in test project I keep the directories to all environments I run my tests against. So far many of my tests were read-only and didn't bother much about if tests did not run on environment that they supposed to. This has changed as I started to run some 'write' tests.
I need to prevent this 'Write' tests to run on any other environment then localhost. So far I tried to use method attributes and getting test method names on run time and do work then but this is not quite efficient. Can you guys point me a good solution? Thanks!

I would tag the tests to exclude with a particular category name then define a SetUp function which will stop the tests from running if they are tagged with that name and if you are on a particular environment such as Production. Place the SetUp function in a BaseClass and have all your test fixtures inherit it. The SetUp function will run before every test and prevent it from running if it needs to.
Something like this:
public class BaseSetup
{
protected const string CategoryToExclude = "Write";
[SetUp]
public void Init()
{
string env = ConfigurationManager.GetEnvironment();
if ( env == Constants.Environments.PROD && (TestContext.CurrentContext.Test.Properties["Categories"].Contains(CategoryToExclude)))
{
Assert.Inconclusive(String.Format("Cannot run this test on environment: {0}", env));
}
}
}
[TestFixture]
public class UnitTests : BaseSetup
{
[Test]
[Category(CategoryToExclude)]
public void TestMethod1()
{
Console.WriteLine("TestMethod1");
}
[Test]
public void TestMethod2()
{
Console.WriteLine("TestMethod2");
}
}
Hope this helps!

NUnit have category attribute.
You can group tests by categories and run only wanted categories.

Impossible to run test with TestCaseData generated from RhinoMocks stub

I am working with C# in Visual Studio 2015 Community, with NUnit3 and Rhino Mocks and attempting to write a test for a component of my system (it is NOT a unit test).
I have encountered a problem when trying to use a generated stub as the argument to a TestCaseData that is provided to a TestCaseSource. I get the following errors in the output window:
Test adapter sent back a result for an unknown test case. Ignoring result for 'MyTest(Castle.Proxies.IMyInterfaceProxy4c6c716794ef48818f41fd5012345ead)'.
Test adapter sent back a result for an unknown test case. Ignoring result for 'MyTest(Castle.Proxies.IMyInterfaceProxy4c6c716794ef48818f41fd5012345ead)'.
The test name appears in the VS2015 integrated test-runner when I rebuild the test project, but as soon I try to run it it becomes greyed out.
Here there is some sample code based on my test code:
using NUnit.Framework;
using Rhino.Mocks;
using System.Collections;
namespace FenixLib.Core.Tests
{
public interface IMyInterface
{
int Property { get; }
}
[TestFixture]
class TestMocks
{
[Test, TestCaseSource( "TestCases" )]
public void MyTest(IMyInterface what)
{
// Do stuff
}
public static IEnumerable TestCases()
{
yield return new TestCaseData ( CreateFake ( 2 ) );
yield return new TestCaseData ( CreateFake ( 4 ) );
}
public static IMyInterface CreateFake ( int something )
{
var fake = MockRepository.GenerateStub<IMyInterface> ();
fake.Stub ( x => x.Property ).Return ( something );
return fake;
}
}
}
I have been able to overcome the problem if I create a decorator class that wraps the generated stub:
public class Decorator : IMyInterface
{
IMyInterface decorated;
public Decorator ( IMyInterface decorated )
{
this.decorated = decorated;
}
public int Property
{
get
{
return decorated.Property;
}
}
}
And change the prior return fake; by return new Decorator ( fake );. Everything works fine then.
However this is a bit of a pain in my real scenario because my interface does not only have a single property as in this example but is more complex (and yes I know that VS2015 can generate the code for implementing through the decorated field, but that's not the point). Besides, it feels pointless to use RinhoMocks if I am going to end up creating an implementation of the interface I am wishing to not fully implement for my test purposes.
Anyway, what annoys me is that I do not understand why it does not work and therefore I ask:
Can anyone help me to understand why the code without the decorator did not work?

At discovery time, TestExplorer creates a process and asks our adapter to find tests. Your TestCaseSource method runs and generates the cases. It has a name generated by Moq.
Much later in the lifetime of the program, your test is executed by Visual studio, which creates a different process and asks the adapter to run the tests. Since we are running in a new process, the adapter has to discover (that is generate) the cases all over. Most likely, Moq generates them with a different name. The originally created cases are never run and NUnit runs these new cases, which, from the point of view of TestExplorer, were never discovered in the first place.
I haven't seen this symptom before, but we have a similar problem with random arguments being regenerated at execution time. It's essentially a problem with the architecture and could only be resolved if the Adapter could somehow keep the originally loaded test assembly around to be found by the execution process.

Why are nUnit tests just getting ignored when using TestCaseSource?

I am having a lot of difficulty getting the nUnit TestCaseSource attribute to work correctly in nUnit 2.6.4.14350.
When running the unit tests through VS2010, it just says the tests are being ignored, without any additional information as to why. The Create test just appears greyed out on the test results viewer.
In my case the class being tested is the TestCaseSource itself. This is what I've got:
public class TestClass
{
static TestClass()
{
PopulateIds();
}
public IEnumerable<object> CreateTestCases
{
get
{
return _ids.Select(id => new TestCaseData(id).SetName("createTest_" + id));
}
}
private static string[] _ids;
private static void PopulateIds()
{
_ids = new string[] { "id123", // ... }
}
[TestFixtureSetUp]
public void Init()
{
// this completes successfully
}
[Test, TestCaseSource("CreateTestCases")]
public void Create(string Id)
{
// breakpoint here is never hit as test is ignored
}
}
Clues:
CreateBondTestCases getter is getting hit. (before [TestFixtureSetUp] is called).
[TestCaseSource(typeof(TestClass), ...)] doesn't change anything.
public TestClass() doesn't change anything.
public IEnumberable<TestCaseSource> CreateTestCases or public IEnumberable CreateTestCases doesn't change anything.
[TestCaseSource(typeof(TestClass), "asdfasdf")] results in Failed: System.Reflection.TargetParameterCountException : Parameter count mismatch.
I saw this question but still can't get it to work. I have also tried to get it to work as in this answer, with the same results. I guess I must be doing something pretty stupid here but I am too infuriated to see what it is. Please can somebody enlighten me?

It's likely that your issue is being caused by your test runner not supporting the TestCaseSource attribute, particularly if it is being reported as Create. NUnit renames tests that use TestCaseSource, to combine the argument names into the name of the test. For your test, it should be reported as createTest_id123 (the name of the test + the value of the parameters).
Check your assembly using the NUnit GUI to see if the tests work as expected when run from there. If they do, then this will confirm that your TestRunner is the issue. With VS2012+, you can use the NUnit Test Adapter, installed via Nuget to run your tests. Other addins like Resharper (depending on the version) should support the attribute, but I'm not sure what versions will work with VS2010.

ClassCleanup in MSTest is static, but the build server uses nunit to run the unit tests. How can i adjust?

MSTest has a [ClassCleanup()] attribute, which needs to be static as far as I can tell. I like to run through after my unit tests have run,and clean up my database. This all works great, however when I go to our build server and use our Nant build script, it seems like the unit tests are run with NUnit. NUnit doesn't seem to like the cleanup method to be static. It therefore ignores my tests in that class. What can I do to remedy this? I prefer to not use [TestCleanUp()] as that is run after each test. Does anyone have any suggestions? I know [TestCleanup()] aids in decoupling, but I really prefer the [ClassCleanup()] in this situation. Here is some example code.
////Use ClassCleanup to run code after all tests have run
[ClassCleanup()]
public static void MyFacadeTestCleanup()
{
UpdateCleanup();
}
private static void UpdateCleanup()
{
DbCommand dbCommand;
Database db;
try
{
db = DatabaseFactory.CreateDatabase(TestConstants.DB_NAME);
int rowsAffected;
dbCommand = db.GetSqlStringCommand("DELETE FROM tblA WHERE biID=#biID");
db.AddInParameter(dbCommand, "biID", DbType.Int64, biToDelete);
rowsAffected = db.ExecuteNonQuery(dbCommand);
Debug.WriteLineIf(rowsAffected == TestConstants.ONE_ROW, string.Format("biId '{0}' was successfully deleted.", biToDelete));
} catch (SqlException ex) {
} finally {
dbCommand = null;
db = null;
biDelete = 0;
}
}
Thanks for any pointers and yes i realize I'm not catching anything. I need to get passed this hurdle first.
Cheers,
~ck in San Diego

Your build server is ignoring your tests because MSTest uses a different set of attributes to specify tests to what NUnit uses. This is more likely the issue you're having, if it's not seeing any of your tests.
For example: MSTest uses [TestClass] and [TestMethod] to specify a test fixtures and tests, while NUnit uses [TestFixture] and [Test].
Also, NUnit's equivalent to [ClassCleanup] is [TestFixtureTearDown], and it isn't static.
Bear in mind that if your tests absolutely have to run on MSTest and NUnit, you can decorate the tests with attributes for both frameworks and it will work (to a certain degree, anyway). However, to get ClassCleanup behaviour with both, you'd need something like this:
[ClassCleanup]
public static void MSTestClassCleanup()
{
CommonCleanup();
}
[TestFixtureTearDown]
public void NUnitTearDown()
{
CommonCleanup();
}
public static void CommonCleanup()
{
// Actually clean up here
}