C# Mocking a bit complex Object

I have a Mocking related question please.

There is the following interface with it's class representation

public interface ICourses
{
    public ICourse CurrentCourse { get; }
    public IEnumerable<ICourse> PreviousCourses { get; }
}

Where the ICourse is the following:

public interface ICourse
{
    public int Id { get; set; }
    public string CourseName { get; set; }
    public int DurationInMinutes { get; set; }
}

The class of the ICourses is:

public class Courses: ICourses
{
private readonly IEnumerable<ICourse> _courses;
private readonly int _selectedIdAsCurrent;

public Courses(IEnumerable<ICourse> courses,
    int selectedAsCurrent)
{
    _courses = courses;
    _selectedIdAsCurrent = selectedIdAsCurrent;
    
    public Courses(int selectedIdAsCurrent, IEnumerable<ICourse> courses) 
    {
        _courses = courses;
        _selectedIdAsCurrent = selectedIdAsCurrent;
    }
    public ICourse CurrentCourse
    {
        get { return _courses.FirstOrDefault(p => p.Id == _selectedIdAsCurrent); }
    }

    public IEnumerable<ICourse > PreviousCourses 
    {
        get { return _courses.Where(p => p.Id != _selectedIdAsCurrent); }
    }
}

}

My question is, how to mocking Mock<ICourses> ?
I tried the following:

public Mock<ICourses> CreateCoursesMock(List<ICourse> coursesData)
{
    var coursesMock = new Mock<ICourses>();

    var coursesMockList = new List<Mock<ICourse>>();
    foreach (var course in coursesData)
    {
        var courseMock = CreateCourseMock(course);
        coursesMockList.Add(courseMock);
    }
    coursesMock Setup(p => p.PreviousCourses).Returns(???);
}

First of all, do you need to mock it? While there is some benefit to test components individually, there is also some benefit at testing components together. This is especially true if you only have one implementation of ICourses, you might even consider removing the interface and view the class as a data transfer object, or as a part of the module you are testing.

You should test against the interface of some module, but a 'module' can be much larger than a single class. And the interface might very well include complex types. Using interfaces for every single type will likely just result in code that is more difficult to read and understand.

Second, do you need to use a mocking framework? While mocking frameworks certainly can be useful in some cases, I do not view them as a panacea for all types of mocking. In some cases it is more useful to just write a simple implementation of your interface. If you have problems setting up your mock, will you be able to read what it does in a year? will your colleges? Or will you switch mocking framework and need to rewrite all your mocking code?

If you are using Moq you need to convert your list to a list of ICourse, by using the .Object property

var coursesMockList = new List<ICourse>();
foreach (var course in coursesData)
{
   var courseMock = CreateCourseMock(course);
   coursesMockList.Add(courseMock.Object);
}
coursesMock.Setup(p => p.PreviousCourses).Returns(coursesMockList);

Let's go step by step: first, let's mock a single ICourse, e.g. (let's extract a method for it)

private static Mock<ICourse> MockedCourse(int id, string name, int duration) {
  Mock<ICourse> mockedCourse = new Mock<ICourse>();

  // That's how "get" can be mocked
  mockedCourse
    .SetupGet(item => item.Id)
    .Returns(id);

  // That's how "set" can be mocked;
  // let's not allow id changing
  mockedCourse
    .SetupSet(item => item.Id = It.IsAny<int>())
    .Callback<int>(value => throw new InvalidOperationException("Don't change my ID!"));

  mockedCourse
    .SetupGet(item => item.CourseName)
    .Returns(name);

  mockedCourse
    .SetupGet(item => item.DurationInMinutes)
    .Returns(duration);

  return mockedCourse;
}

Now we are ready for ICourses:

// A mocked courses
Mock<ICourses> mockedCourses = new Mock<ICourses>();

// uses Math as a current course
// note ".Object" - we want mocked object, not mock itself
mockedCourses
  .SetupGet(item => item.CurrentCourse)
  .Returns(MockedCourse(123, "Math", 60).Object);

// And requires Arithmetic and Geometry as previous courses
mockedCourses
  .SetupGet(item => item.PreviousCourses)
  .Returns(new ICourse[] {
     MockedCourse(700, "Arithmetic", 90).Object,
     MockedCourse(700, "Geometry", 90).Object,
   });

// Mocked interface ready to be used in the test
ICourses courses = mockedCourses.Object;
...