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.