Mockowanie, co robie zle

Message: Moq.MockException : IHttpClientAdapter.SendAsync(Method: POST, RequestUri: 'https://here.someurl.nl/', Version: 1.1, Content: System.Net.Http.StringContent, Headers:
{
  Authorization: Basic XXXXXXXXXXXXXX
  Content-Type: application/json; charset=utf-8
}) invocation failed with mock behavior Strict.
All invocations on the mock must have a corresponding setup.

        private Mock<IHttpClientAdapter> mockHttpClientAdapter = new Mock<IHttpClientAdapter>(MockBehavior.Strict);

        [Fact]
        public async void AddDocumentToPackage_SendAsync_ShouldBeCalledWithExpectedValue()
        {
            // Arrange
            var documentForPackage = Builder<DocumentForPackage>.CreateNew().Build();
            var content = documentForPackage.JsonSerialize(jsonSerializerSettings);

            var httpRequestMessage = BuildHttpRequestMessage(content, HttpMethod.Post);

            mockHttpClientAdapter.Setup(x => x.SendAsync(httpRequestMessage));

            var validSignContext = new ValidSignContext(mockHttpClientAdapter.Object);

            // Act
            var result = await validSignContext.AddDocumentToPackage("test", documentForPackage);

            // Assert
            mockHttpClientAdapter.Verify(x => x.SendAsync(httpRequestMessage), Times.Once);
        }

        private HttpRequestMessage BuildHttpRequestMessage(string content, HttpMethod httpMethod)
        {
            var httpRequestMessage = new HttpRequestMessage();
            httpRequestMessage.Headers.Add("Authorization", "Basic XXXXXXXXXXXXXX==");
            httpRequestMessage.Content = new StringContent(content, Encoding.UTF8, "application/json");
            httpRequestMessage.Content.Headers.Add(@"Content-Length", content.Length.ToString());
            httpRequestMessage.RequestUri = new Uri("https://https://here.someurl.nl/");
            httpRequestMessage.Method = httpMethod;
            return httpRequestMessage;
        }

    public interface IHttpClientAdapter
    {
        Task<HttpResponseMessage> SendAsync(HttpRequestMessage request);
    }

        public async Task<DocumentForPackageResponse> AddDocumentToPackage(string packageId, DocumentForPackage documentForPackage)
        {
            var request = new HttpRequestMessage(HttpMethod.Post, new Uri(baseUrl + "packages/" + packageId + "/documents"));
            request.Headers.Add(authorizationHeaderName, authorizationHeaderValue);
            request.Content = new StringContent(documentForPackage.JsonSerialize(jsonSerializerSettings), Encoding.UTF8, "application/json");

            var response = await httpClient.SendAsync(request);
            return await response.Content.ReadAsAsync<DocumentForPackageResponse>();
        }

httpRequestMessage.Content.Headers.Add(@"Content-Length", content.Length.ToString());

mockHttpClientAdapter.Setup(x => x.SendAsync(httpRequestMessage)).ReturnsAsync(<<jakiś obiekt>>);

mockHttpClientAdapter.Setup(x => x.SendAsync(httpRequestMessage)).ReturnsAsync(new HttpResponseMessage{Content = "content"});

        [Fact]
        public async void AddDocumentToPackage_SendAsync_ShouldBeCalledWithExpectedValue()
        {
            // Arrange
            var documentForPackage = Builder<DocumentForPackage>.CreateNew().Build();
            var content = documentForPackage.JsonSerialize(jsonSerializerSettings);
            var dummyResponse = Builder<DocumentForPackageResponse>.CreateNew().Build();
            var packageId = "test";
            var uri = new Uri(baseUrl + "packages/" + packageId + "/documents");

            var httpRequestMessage = BuildHttpRequestMessageForPost(content, HttpMethod.Post, uri);

            var returnValue = Builder<HttpResponseMessage>.CreateNew()
                .With(x => x.Content = new StringContent(dummyResponse.JsonSerialize(), Encoding.UTF8, "application/json"))
                .Build();

            HttpRequestMessage callback = null;

            mockHttpClientAdapter.Setup(x => x.SendAsync(It.IsAny<HttpRequestMessage>())).ReturnsAsync(returnValue).Callback<HttpRequestMessage>(y => callback = y);

            var validSignContext = new ValidSignContext(mockHttpClientAdapter.Object);

            // Act
            var result = await validSignContext.AddDocumentToPackage("test", documentForPackage);

            // Assert
            mockHttpClientAdapter.Verify(x => x.SendAsync(It.IsAny<HttpRequestMessage>()), Times.Once);
            callback.Content.Should().BeEquivalentTo(stringContent);
            callback.RequestUri.Should().BeEquivalentTo(uri);
            callback.Headers.Should().BeEquivalentTo(httpRequestHeaders);
        }

    public interface IHttpClientAdapter
    {
        Task<string> SendAsync(string request);
    }

    class ValidSignContext
    {
        private readonly IHttpClientAdapter httpClient;

        public ValidSignContext(IHttpClientAdapter httpClient, string bleble)
        {
            this.httpClient = httpClient;
        }

        public async Task<string> AddDocumentToPackage(string packageId, string documentForPackage)
        {
            var request = $"{documentForPackage} Ble Ble Ble";

            var response = await httpClient.SendAsync(request);

            return "ble ble ble";
        }
    }

public class FakeHttpClientAdapter : IHttpClientAdapter
    {
        public string RecivedOjbect { get; set; }

        public async Task<string> SendAsync(string request)
        {
            RecivedOjbect = request;
            return await Task.Run(() => string.Empty);
        }
    }

    [TestFixture]
    public class Class1
    {
        [Test]
        public async Task AddDocumentToPackage_SendAsync_ShouldBeCalledWithExpectedValue()
        {
            var httpRequestMessage = "test";
            var clientAdapterMock = new FakeHttpClientAdapter();

            await AddDocumentToPackage(clientAdapterMock, httpRequestMessage);
            var expectedObject = BuildHttpRequestMessage();

            Assert.AreEqual(expectedObject, actual: clientAdapterMock.RecivedOjbect);
        }

        //
        //
        //

        private string BuildHttpRequestMessage()
        {
            var yoursLongBuild = "test Ble Ble Ble";
            return yoursLongBuild;
        }

        private Task<string> AddDocumentToPackage(IHttpClientAdapter mock, string httpRequestMessage) =>
            new ValidSignContext(mock, "stub").AddDocumentToPackage("stub", httpRequestMessage);
    }

public async Task<string> AddDocumentToPackage(string packageId, string documentForPackage)