Unit testing passing arguments to base constructor

Question

I have the following code:

        using System;
        using NUnit.Framework;
        using Rhino.Mocks;

        public class A
        {
        }

        public class B
        {
        }

        public interface IStatementExecutor
        {
            void Exec(string statement);
        }

        public abstract class Foo<T>
        {
            private readonly IStatementExecutor _statementExecutor;
            private readonly string _targetSegment;

            protected Foo(IStatementExecutor statementExecutor, string targetSegment)
            {
                _statementExecutor = statementExecutor;
                _targetSegment = targetSegment;
            }

            public void Update(T item)
            {
                _statementExecutor.Exec("sp_" + _targetSegment + "Update");
            }
        }

        public class Bar : Foo<A>
        {
            public Bar(IStatementExecutor statementExecutor)
                : base(statementExecutor, "ATable")
            {
            }
        }

        public class Baz : Foo<B>
        {
            public Baz(IStatementExecutor statementExecutor)
                : base(statementExecutor, "BTable")
            {
            }
        }

        [TestFixture]
        public class Foo_Tests
        {
            [Test]
            public void Update_CallsStatementExecutorWithTableName()
            {
                const string tableName = "TestTable";
                var mockStatementExecutor = MockRepository.GenerateMock<IStatementExecutor>();
                mockStatementExecutor.Expect(m => m.Exec("sp_" + tableName + "Update"));
                var sut = MockRepository.GeneratePartialMock<Foo<A>>(mockStatementExecutor, tableName);
                var testModel = new A();


                sut.Update(testModel);

                mockStatementExecutor.AssertWasCalled(m => m.Exec("sp_" + tableName + "Update"));
            }
        }

I already have unit tests for the base class Foo<T>. Since the base class is already covered, I don't want to write identical tests for the derived classes Bar and Baz.

The only thing I really care about in the derived classes is that the correct string target is passed to the base class.

I'm struggling on how to unit test this without breaking encapsulation of the derived classes or writing redundant unit tests.

So, the question is, how do I test that the correct value gets passed to the base class from the derived classes for the target parameter?

(If your answer is "use composition...", please back it up with a code sample modified from above.

Thanks!

Answer 1

Think I'be more likely to test through the other methods on Bar and Baz, as you'd expect something bad to happen if you'd put ZTable in there instead of BTable

You could add a method to Foo that would return what ever had been passed to it

and then after creating the descendant call it and validate against the expected value.

Or you could do something like

public class Bar : Foo<A>     
{         
  private static String _tableName = "ATable";
  public String  TableName {get {return _tableName;}}
  public Bar() : base(_tableName)         
  {         
  }     
} 

Then you could test testBar.TableName

Another Option would be T was a struct or a class with a TableName property, then you wouldn't need Bar and Baz descendants, just for this.

Answer 2

Your Foo and Bar unit test methods could call helper methods that contain the common testing code.

Answer 3

You can do this in many ways. One way you could use a mocking framework like TypeMock to effectively mock the based class and thus get more information from TypeMock about internal variables.

It't not apparently clear from your post, though, why it's important that the base class be used in a specific why by the bar class. This isn't clear because you have no way of testing it. i.e. there's no external behaviour that you can monitor to guarantee Bar is using Foo in the expected way. You could redirect console output then monitor that output to do the verification. But, I don't think that's really what you're looking for.

You should provide an more testable example; something that doesn't just output text, something that had real behaviour that you can observe by a test.