使用Entity Framework 6对基本服务进行单元测试

Question

I have a base service class that my services usually inherit from, that looks like this

public abstract class BaseService<TEntity> 
    where TEntity : class, IBaseEntity
{
    protected DataContext _context;

    protected BaseService(DataContext context)
    {
        _context = context;
    }

    public virtual async Task<ICollection<TEntity>> GetAllAsync()
    {
        return await _context.Set<TEntity>().ToListAsync();
    }

    public virtual Task<TEntity> GetAsync(long id)
    {
        return _context.Set<TEntity>().FindAsync(id);
    }

    public virtual Task<int> AddAsync(TEntity t)
    {
        if (_context.Entry(t).State == EntityState.Detached)
        {
            _context.Set<TEntity>().Add(t);
        }

        _context.Entry(t).State = EntityState.Added;

        return _context.SaveChangesAsync();
    }

    public virtual Task<int> AddAllAsync(ICollection<TEntity> all)
    {
        foreach (var item in all)
        {
            if (_context.Entry(item).State == EntityState.Detached)
            {
                _context.Set<TEntity>().Add(item);
            }

            _context.Entry(item).State = EntityState.Added;
        }

        return _context.SaveChangesAsync();
    }

    public virtual Task<int> UpdateAsync(TEntity updated)
    {
        _context.Entry(updated).State = EntityState.Modified;

        return _context.SaveChangesAsync();
    }

    public virtual Task<int> DeleteAsync(long key)
    {
        return DeleteAsync(key, true);
    }

    public virtual async Task<int> DeleteAsync(long key, bool useFlag)
    {
        TEntity entity = await GetAsync(key);
        return await DeleteAsync(entity, useFlag);
    }

    public virtual Task<int> DeleteAsync(TEntity t)
    {
        return DeleteAsync(t, true);
    }

    public virtual Task<int> DeleteAsync(TEntity t, bool useFlag)
    {
        // check if the object uses IAuditableEntity
        IAuditableEntity auditable = t as IAuditableEntity;

        if (useFlag && auditable != null)
        {
            // flag item as deleted
            auditable.IsDeleted = true;

            return UpdateAsync(t);
        }
        else
        {
            _context.Entry(t).State = EntityState.Deleted;

            return _context.SaveChangesAsync();
        }
    }

}

Now if i need to override a method in a class that inherits from it, i can do that.

My question is should these methods be tested in each unit test for each class that inherits from the BaseService class, or should i only unit test the methods that i override and have a unit test for the baseservice? Only thing with this is, that the baseService is abstract, so in order to test it i would need to create a class that inherits from it, in order to test it.

I am new to unit testing, so sorry if this is has an obvious answer.

Answer 1

Yup

In general you do indeed want to test each descendant against the contract of the base. After all any overridden method could incorporate code that invalidates/contradicts/... the base behavior expected by clients of this class hierarchy. And you don't want that to happen, so you need the early alarm system of unit tests for each of the base service's descendants.

This is something which is also known as "contract testing".

One of the ways to achieve it is to create a(n abstract) unit test class to verify the behavior of the base class and then derive (concrete) unit test classes for each of its descendants. All those concrete unit test classes should have to do is to set up the instance under test - that is an instance of the descendant class. Inheritance should then take care of running the test methods defined in the base's unit test class against the descendant instance.

If the base class is abstract you can still write your unit test class against this base class. By marking this unit test class abstract as well, you ensure that the test runner won't instantiate it to run its test. It would only "discover and run" the concrete test classes that are derived from it to test the base's descendants.