CoContra.cs

public abstract class MyBaseClass { }

public class DerivedClass : MyBaseClass { }

public class SubjectClass
{
    private readonly IGenericFoo foo;

    public SubjectClass(IGenericFoo foo)
    {
        this.foo = foo;
    }

    public object GetObjectFromType(object input)
    {
        return this.GetType().GetMethod("GetObjectFrom").MakeGenericMethod(input.GetType()).Invoke(this, new[] { input });
    }

    public object GetObjectFrom<T>(T input)
    {
        return this.foo.GetObjectFrom<T>();
    }
}

public interface IGenericFoo
{
    object GetObjectFrom<T>();
}

public class Test : WithSubject<SubjectClass>
{
    static MyBaseClass input;
    static object o;

    Establish context = () => input = new DerivedClass();

    Because of = () => o = Subject.GetObjectFromType(input);

    It should_have_called_with_derived = () => The<IGenericFoo>().WasToldTo(f => f.GetObjectFrom<DerivedClass>());

    It should_not_have_called_with_base = () => The<IGenericFoo>().WasNotToldTo(f => f.GetObjectFrom<MyBaseClass>());
}