public async void GetProtocol_Valid_IsProtocol_Test()
        {
            //Arrange
            const int idToRead = 0;
            _repositoryMock.Setup(r => r.Read(idToRead)).Returns(Task.FromResult(_storedStudy));
            var studyAdapter = new StudyAdapter(_repositoryMock.Object);

            //Act
            var returnedProtocol = await studyAdapter.Read(idToRead);

            //Assert
            Assert.IsInstanceOfType(returnedProtocol, typeof(Protocol));
        }
        public void CreateStudy_Success_Test()
        {
            //Arrange 
            const int expectedReturnId = 0;
            _repositoryMock.Setup(r => r.Create(_storedStudy)).Returns(Task.FromResult(expectedReturnId));
            var studyAdapter = new StudyAdapter(_repositoryMock.Object);

            //Act
            var actualId = studyAdapter.Read(_storedStudy.Id).Id;

            //Assert
            Assert.IsTrue(expectedReturnId == actualId);
        }
        public async void GetStudy_Valid_NotNull_Test()
        {
            //Arrange
            const int idToRead = 0;
            _repositoryMock.Setup(r => r.Read(idToRead)).Returns(Task.FromResult(_storedStudy));
            var studyAdapter = new StudyAdapter(_repositoryMock.Object);

            //Act
            var returnedStudy = await studyAdapter.Read(idToRead);

            //Assert
            Assert.IsNotNull(returnedStudy);
        }
        public async void GetProtocol_Valid_CorrectProtocolInfo_Test()
        {
            //Arrange
            const int idToRead = 0;
            _repositoryMock.Setup(r => r.Read(idToRead)).Returns(Task.FromResult(_storedStudy));
            var adapter = new StudyAdapter(_repositoryMock.Object);

            //Act
            var actualStudy = await adapter.Read(idToRead);

            //Assert 
            Assert.IsTrue(_study.Id == actualStudy.Id);
            Assert.IsTrue(_study.Name == actualStudy.Name);
            CollectionAssert.AreEqual(_study.UserIds.ToList(), actualStudy.UserIds.ToList());
            //Assert.IsTrue(_study.UserIds == actualStudy.UserIds);
            //Assert.IsTrue(_study.Phases == actualStudy.Phases);
        }
        [ExpectedException(typeof(NullReferenceException))] // Assert 
        public async void DeleteStudy_Fail_StudyDoesNotExist_Test()
        {
            //Arrange
            var repositoryMock = new Mock<IRepository<StoredStudy>>();
            const int toDeleteId = 0;
            repositoryMock.Setup(r => r.DeleteIfExists(toDeleteId)).Returns(Task.FromResult(false));
            var adapter = new StudyAdapter(repositoryMock.Object);

            //Act
            await adapter.DeleteIfExists(toDeleteId);
        }
        public async void DeleteStudy_Success_Test()
        {
            //Arrange
            var repositoryMock = new Mock<IRepository<StoredStudy>>();
            const int toDeleteId = 0;
            repositoryMock.Setup(r => r.DeleteIfExists(toDeleteId)).Returns(Task.FromResult(true));
            var adapter = new StudyAdapter(repositoryMock.Object);

            //Act
            var result = await adapter.DeleteIfExists(toDeleteId);

            //Assert
            Assert.IsTrue(result);
        }
        public void GetAllStudies_Valid_ReturnsCorrectStudies_Test()
        {
            // TODO add property values 
            //Arrange
            var study1 = new StoredStudy { };
            var study2 = new StoredStudy { };
            var study3 = new StoredStudy { };
            var studyList = new List<StoredStudy> { study1, study2, study3 }.AsQueryable();

            _repositoryMock.Setup(r => r.Read()).Returns(studyList);
            var adapter = new StudyAdapter(_repositoryMock.Object);

            //Act
            var result = adapter.Read();
            var actualStudies = result.ToList();

            //Assert
            var counter = 0;
            foreach (var actualStudy in studyList.AsEnumerable())
            {
                var returnedStudy = actualStudies[counter];
                // Todo add property asserts 
                Assert.IsTrue(returnedStudy.Name == actualStudy.Name);
                counter++;
            }

        }
        public void GetAllStudies_Valid_ReturnsCorrectNumberOfStudies_Test()
        {
            //Arrange
            var study1 = new StoredStudy(); { };
            var study2 = new StoredStudy(); { };
            var study3 = new StoredStudy(); { };
            var studyList = new List<StoredStudy> { study1, study2, study3 }.AsQueryable();

            _repositoryMock.Setup(r => r.Read()).Returns(studyList);
            var adapter = new StudyAdapter(_repositoryMock.Object);
            const int expectedCount = 3;

            //Act
            var result = adapter.Read();
            var actualCount = result.ToList().Count;

            //Assert
            Assert.IsTrue(expectedCount == actualCount);
        }
        public async void GetStudy_Invalid_NoExistingStudy_Test()
        {
            //Arrange
            const int idToRead = 0;
            _repositoryMock.Setup(r => r.Read(idToRead));
            var adapter = new StudyAdapter(_repositoryMock.Object);

            //Act
            var returnedStudy = await adapter.Read(idToRead);

            //Assert
            Assert.IsNull(returnedStudy);
        }