Do I unit test the correct thing Thats my method to test:

   public LessonplannerRequest GetWeeklyLessonplanner(int schoolyearId)  
        {            
            Schoolyear schoolyear = _unitOfWork.SchoolyearRepository.GetById(schoolyearId);
            DayOfWeek firstDayOfWeek = schoolyear.FirstDayOfWeek;

            DateTime currentDate = DateTime.Now.Date;
            DateTime startDateOfWeek = _dateService.GetFirstDateOfWeek(currentDate, firstDayOfWeek);
            DateTime endDateOfWeek = _dateService.GetLastDateOfWeek(currentDate, firstDayOfWeek);

            var periods = _unitOfWork.PeriodRepository.GetWeeklyPeriods(schoolyearId, startDateOfWeek, endDateOfWeek );
            var weeks = _dateService.GetAllWeekStartingDays(startDateOfWeek, endDateOfWeek, firstDayOfWeek);
            var request = new LessonplannerRequest
            {
                 Periods = periods,
                 Weeks = weeks,
            };

            return request;
        }


Thats my unit test:

 // Arrange
            Mock&lt;IUnitOfWork&gt; unitOfWorkMock = new Mock&lt;IUnitOfWork&gt;();
            Mock&lt;IDateService&gt; dateServiceMock = new Mock&lt;IDateService&gt;();
            Mock&lt;TLPContext&gt; contextMock = new Mock&lt;TLPContext&gt;();
            Mock&lt;IGenericRepository&lt;Schoolyear&gt;&gt; schoolyearRepositoryMock = new Mock&lt;IGenericRepository&lt;Schoolyear&gt;&gt;();
            Mock&lt;ILessonplannerRepository&gt; lessonplannerRepoMock = new Mock&lt;ILessonplannerRepository&gt;();

            int schoolyearId = 1;
            DateTime start = new DateTime(2010, 1, 1);
            DateTime end = new DateTime(2010, 1, 2);

            unitOfWorkMock.Setup(s =&gt; s.SchoolyearRepository).Returns(schoolyearRepositoryMock.Object);
            unitOfWorkMock.Setup(s =&gt; s.PeriodRepository).Returns(lessonplannerRepoMock.Object);
            dateServiceMock.Setup(s =&gt; s.GetFirstDateOfWeek(DateTime.Now.Date, DayOfWeek.Sunday)).Returns(start);
            dateServiceMock.Setup(s =&gt; s.GetLastDateOfWeek(DateTime.Now.Date, DayOfWeek.Sunday)).Returns(end);
            schoolyearRepositoryMock.Setup(s =&gt; s.GetById(schoolyearId)).Returns(new Schoolyear() { FirstDayOfWeek = DayOfWeek.Sunday });

            ILessonplannerService service = new LessonplannerService(unitOfWorkMock.Object, dateServiceMock.Object);            

            // Act
            LessonplannerRequest request = service.GetWeeklyLessonplanner(schoolyearId);

            // Assert         
            dateServiceMock.Verify(d =&gt; d.GetFirstDateOfWeek(DateTime.Now.Date, DayOfWeek.Sunday));
            dateServiceMock.Verify(d =&gt; d.GetLastDateOfWeek(DateTime.Now.Date, DayOfWeek.Sunday));
            lessonplannerRepoMock.Verify(d =&gt; d.GetWeeklyPeriods(schoolyearId, start, end));

            Assert.That(request.Periods, Is.Empty);
            Assert.That(request.Weeks, Is.Empty); 


In my method to test all calls to a repository or dateService are already unit tested itself thus I am mocking them not to have an integration test...

I ask myself wether my assertion for empty lists make sense. And If not what would you test. Actually in this method everything is already tested just the creation of the LessonplannerRequest is not tested...
Almost everything is perfect. Some notes:


Do use var to avoid repeating in cases like Mock&lt;IUnitOfWork&gt; unitOfWorkMock = new Mock&lt;IUnitOfWork&gt;()
Move mocks initialisation and wiring up to SetUp method to avoid copy-pasting in different test methods, and leave only actual setups that provide test data in test method
It's hard to unit test the code that uses DateTime.Now. For example your test may fail when running near midnight (since you call DateTime.Now several times, and subsequent calls may return the next day). I would suggest to add the UtcNow property to your IDateService and always use it instead of DateTime.Now (I prefer to force using UTC time since it forces you to think about time zones). Then, most likely you won't need methods like GetFirstDateOfWeek in IDateService (if they depend on inputs only), they could be just extension methods to DateTime.
You don't need to verify that GetFirstDateOfWeek and GetLastDateOfWeek were called, just make sure that result matches expected value. The reason is because the call to those methods does not guarantee that returned values were used correctly. And when all tests pass without those calls - it only shows that you should add more tests to verify that returned values were used properly


As a result you'll have something like this:

[Test]
public void WhenWeekStartOnSunday...ShouldReturnSomething
{
    const int schoolyearId = 1;
    var currentDate = new DateTime(2010, 1, 1).ToUniversalTime();
    var periods = new [] {...}; //specify test periods here

    //Arrange
    _schoolyearRepositoryMock.Setup(s =&gt; s.GetById(schoolyearId)).Returns(new Schoolyear() { FirstDayOfWeek = DayOfWeek.Sunday });       
    _dateServiceMock.Setup(s =&gt; s.UtcNow).Returns(currentDate);
    _lessonplannerRepoMock.Setup(lp =&gt; lp.GetWeeklyPeriods(schoolyearId, new DateTime(2010, 1, 1), 
            new DateTime(2010, 1, 5))) //specify the dates expected according to "currentDate" value.
        .Returns(periods);

    var service = new LessonplannerService(_unitOfWorkMock.Object, _dateServiceMock.Object);            

    // Act
    LessonplannerRequest request = service.GetWeeklyLessonplanner(schoolyearId);

    // Assert         
    Assert.That(request.Periods, Is.SameAs(periods));
    Assert.That(request.Weeks, Is.Empty); //verify here expected list of weeks according to logic of the method
}