public void NotesServiceMethodAddShareShouldAddAUserToTheNoteShares()
        {
            // Arrange
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var note = new Note { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.Note1RowKey };
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);
            var noteSharesCount = repository._noteShares.Count;

            // Act
            service.AddShare(note, NotesMemoryRepository.User2RowKey);

            // Assert
            Assert.IsTrue(repository._noteShares.Count == noteSharesCount + 1);
        }
        public void NotesServiceMethodCreateShouldCreateANote()
        {
            // Arrange
            var user = new User { PartitionKey = NotesMemoryRepository.IdentityProvider, RowKey = NotesMemoryRepository.User1RowKey };
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var note = new Note { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.Note1RowKey, Owner = user };
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);

            // Act
            service.Create(note);
            var result = service.Get(note.PartitionKey, note.RowKey);

            // Assert
            Assert.IsInstanceOfType(result, typeof(Note));
            Assert.IsNotNull(result);
        }
        public void NotesServiceMethodCopyNoteShouldCopyANote()
        {
            // Arrange
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var user = new User { PartitionKey = NotesMemoryRepository.IdentityProvider, RowKey = NotesMemoryRepository.User1RowKey };
            var note = new Note { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.Note1RowKey, Owner = user };
            var taskList = new TaskList { PartitionKey = NotesMemoryRepository.TaskList2PartitionKey, RowKey = repository.TaskList2RowKey };
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);

            // Act
            service.CopyNote(note, taskList);
            service.LoadNotes(taskList);

            // Assert
            //Assert.IsInstanceOfType(result, typeof(IQueryable<Note>));
            //Assert.IsTrue(result.Count() == 2);
        }
        public void NotesServiceMethodDeleteShouldDeleteANote()
        {
            // Arrange
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);
            var result = service.Get(NotesMemoryRepository.User1RowKey, repository.Note1RowKey);

            // Act
            service.Delete(result);
            result = service.Get(NotesMemoryRepository.User1RowKey, repository.Note1RowKey);

            // Assert
            Assert.IsNull(result);
        }
        public void NotesServiceMethodUpdateShouldUpdateANote()
        {
            // Arrange
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);
            var result = service.Get(NotesMemoryRepository.User1RowKey, repository.Note1RowKey);

            // Act
            result.Content = "Test content";
            service.Update(result);
            var updatedResult = service.Get(NotesMemoryRepository.User1RowKey, repository.Note1RowKey);

            // Assert
            Assert.IsTrue(updatedResult.Content == "Test content");
        }
        public void NotesServiceMethodNoteWithTitleExistsShouldReturnTrueForAnExistingTitle()
        {
            // Arrange
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var taskList = new TaskList { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.TaskList1RowKey };
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);

            // Act
            var result = service.NoteWithTitleExists("Test title", taskList);

            // Assert
            Assert.IsTrue(result);
        }
        public void NotesServiceMethodLoadShouldReturnAllNotes()
        {
            // Arrange
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);

            // Act
            var result = service.Load();

            // Assert
            Assert.IsInstanceOfType(result, typeof(IQueryable<Note>));
            Assert.IsTrue(result.Count() == 2);
        }
        public void NotesServiceMethodLoadNotesShouldLoadAllNotes()
        {
            // Arrange
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var taskList = new TaskList { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.TaskList1RowKey };
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);

            // Act
            service.LoadNotes(taskList);

            // Assert
            Assert.IsTrue(taskList.Notes.Count == 2);
        }
        public void NotesServiceMethodHasPermissionToEditShouldReturnTrueForAUserInTheShare()
        {
            // Arrange
            var user = new User { PartitionKey = NotesMemoryRepository.IdentityProvider, RowKey = NotesMemoryRepository.User1RowKey };
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var note = new Note { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.Note1RowKey, Owner = user };
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);

            // Act
            var result = service.HasPermissionToEdit(user, note);

            // Assert
            Assert.IsTrue(result);
        }
        public void NotesServiceMethodGetShouldReturnNullForANonExistingNote()
        {
            // Arrange
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);

            // Act
            var result = service.Get(NotesMemoryRepository.User3RowKey, repository.Note3RowKey);

            // Assert
            Assert.IsNull(result);
        }
        public void NotesServiceMethodGetShouldReturnANote()
        {
            // Arrange
            var unitOfWorkMock = new Mock<IUnitOfWork>();
            var taskListsRepositoryMock = new Mock<ITaskListsRepository>();
            var notesRepositoryMock = new Mock<INotesRepository>();
            var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object);
            var repository = new NotesMemoryRepository();
            var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService);

            // Act
            var result = service.Get(NotesMemoryRepository.User1RowKey, repository.Note1RowKey);

            // Assert
            Assert.IsInstanceOfType(result, typeof(Note));
            Assert.IsNotNull(result);
        }