public void Constructor_SutIsCmdlet()
        {
            // When
            var sut = new SetPostCommand();

            // Then
            Assert.IsAssignableFrom<Cmdlet>(sut);
        }
        public void Invoke_DoesNotReturnNull()
        {
            // Given
            var sut = new SetPostCommand();

            // When
            var result = sut.Invoke();

            // Then
            Assert.NotNull(result);
        }
        public void Invoke_WithExceptionAndInnerException_ThrowsInnerException(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            int postId,
            string message,
            InvalidOperationException innerException)
        {
            // Given
            var exception = new Exception(message, innerException);
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            repository.Setup(s => s.Find(It.IsAny<Expression<Func<Post, bool>>>())).Throws(exception);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.Id = postId;

            // Then
            Assert.Throws(innerException.GetType(), () => sut.Invoke<Post>().Any());
        }
        public void Invoke_WithNullInputObjectAndId_DoesNotThrow(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            Post post)
        {
            // Given
            var posts = new[] { post };
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            repository.Setup(s => s.Find(It.IsAny<Expression<Func<Post, bool>>>())).Returns(posts);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.InputObject = null;
            sut.Id = post.Id;

            // Then
            Assert.DoesNotThrow(() => sut.Invoke<Post>().Any());
        }
        public void Invoke_WithInputObject_SavesInputObject(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            Post post)
        {
            // Given
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.InputObject = post;
            sut.Invoke<Post>().Any();

            // Then
            repository.Verify(m => m.Save(post));
        }
        public void Invoke_WithInputObject_ReturnsInputObject(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            Post post)
        {
            // Given
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.InputObject = post;
            var result = sut.Invoke<Post>().SingleOrDefault();

            // Then
            Assert.NotNull(result);
        }
        public void Invoke_WithInputObjectAndTitle_SavesInputObjectWithNewTitle(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            Post post,
            string title)
        {
            // Given
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.InputObject = post;
            sut.Title = title;
            sut.Invoke<Post>().Any();

            // Then
            repository.Verify(m => m.Save(It.Is<Post>(
                p => p.Id == post.Id && p.Title == title)));
        }
        public void Invoke_WithInputObjectAndNullContent_SavesInputObjectWithNotNullContent(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            Post post)
        {
            // Given
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.InputObject = post;
            sut.Content = null;
            sut.Invoke<Post>().Any();

            // Then
            repository.Verify(m => m.Save(It.Is<Post>(
                p => p.Id == post.Id && p.MarkdownContent != null)));
        }
        public void Invoke_WithId_SavesPostWithSameId(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            Post post)
        {
            // Given
            var posts = new[] { post };
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            repository.Setup(s => s.Find(It.IsAny<Expression<Func<Post, bool>>>())).Returns(posts);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.Id = post.Id;
            sut.Invoke<Post>().Any();

            // Then
            repository.Verify(m => m.Save(post));
        }
        public void Invoke_WithId_ReturnsPostWithSameId(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            Post post)
        {
            // Given
            var posts = new[] { post };
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            repository.Setup(s => s.Find(It.IsAny<Expression<Func<Post, bool>>>())).Returns(posts);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.Id = post.Id;
            var result = sut.Invoke<Post>().SingleOrDefault();

            // Then
            Assert.Equal(post.Id, result.Id);
        }
        public void Invoke_WithIdThatDoesNotExist_ThrowsArgumentException(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            int postId)
        {
            // Given
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.Id = postId;

            // Then
            Assert.Throws<ArgumentException>(() => sut.Invoke<Post>().Any());
        }
        public void Invoke_WithIdAndSingleTag_SavesPostWithSameIdAndTag(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            Post post,
            string tag)
        {
            // Given
            var posts = new[] { post };
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            repository.Setup(s => s.Find(It.IsAny<Expression<Func<Post, bool>>>())).Returns(posts);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.Id = post.Id;
            sut.Tags = new[] { tag };
            sut.Invoke<Post>().Any();

            // Then
            repository.Verify(m => m.Save(It.Is<Post>(
                p => p.Id == post.Id &&
                     p.Tags.Select(t => t.Name).FirstOrDefault() == tag)));
        }