public async Task If_CalledWithIds_Then_FilteredTeacherModelsReturned()
        {
            // Arrange
            var reconstructionFactory = Substitute.For <IStorageUserReconstructionFactory>();
            var wrongTeacher          = new Teacher
            {
                FirstName    = "name 2",
                LastName     = "surname 2",
                Email        = "*****@*****.**",
                UserName     = "******",
                DepartmentId = 1,
                Id           = "teacherId 2"
            };
            await _storage.AddAsync(wrongTeacher);

            await _storage.SaveChangesAsync();

            var teacherModel =
                new Modules.UsersService.Repository.Models.Teacher("*****@*****.**",
                                                                   "name 1",
                                                                   "surname 1",
                                                                   1,
                                                                   "teacherId 1");

            reconstructionFactory.Create(_storageTeacher)
            .Returns(teacherModel);
            var repository = new UsersRepository(_storage, reconstructionFactory);

            // Act
            var result = await repository.GetTeachers(1, new[] { "teacherId 1" });

            // Assert
            result.First().Should().Be(teacherModel);
        }
        public async Task If_CalledWithIdsAndSomeNotFound_Then_ExceptionIsThrown()
        {
            // Arrange
            var teacherModel =
                new Modules.UsersService.Repository.Models.Teacher("*****@*****.**",
                                                                   "name 1",
                                                                   "surname 1",
                                                                   1,
                                                                   "teacherId 1");
            var repository = new UsersRepository(_storage, Substitute.For <IStorageUserReconstructionFactory>());

            // Act
            Func <Task> act = async() => await repository.GetTeachers(1, new[] { "teacherId 1", "teacherId 2" });

            // Assert
            await act.Should().ThrowExactlyAsync <UsersNotFoundException>();
        }
        public void If_CalledWithTeacherInstance_Then_TeacherModelReturned()
        {
            // Arrange
            var storageTeacher = new Teacher
            {
                Id           = "id",
                Email        = "*****@*****.**",
                FirstName    = "name",
                LastName     = "surname",
                DepartmentId = 1
            };
            var expected = new Modules.UsersService.Repository.Models.Teacher("*****@*****.**", "name", "surname", 1, "id");
            var factory  = new StorageUserReconstructionFactory();

            // Act
            var result = factory.Create(storageTeacher);

            // Assert
            result.Should().BeEquivalentTo(expected);
        }
        public async Task Then_ReconstructionFactoryCalled()
        {
            // Arrange
            var reconstructionFactory = Substitute.For <IStorageUserReconstructionFactory>();
            var teacherModel          =
                new Modules.UsersService.Repository.Models.Teacher("*****@*****.**",
                                                                   "name 1",
                                                                   "surname 1",
                                                                   1,
                                                                   "teacherId 1");

            reconstructionFactory.Create(_storageTeacher)
            .Returns(teacherModel);
            var repository = new UsersRepository(_storage, reconstructionFactory);

            // Act
            await repository.GetTeachers(1);

            // Assert
            reconstructionFactory.Received().Create(_storageTeacher);
        }