mirror of https://github.com/dapr/dotnet-sdk.git
483 lines
20 KiB
C#
483 lines
20 KiB
C#
// ------------------------------------------------------------------------
|
|
// Copyright 2021 The Dapr Authors
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
// ------------------------------------------------------------------------
|
|
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
|
|
namespace Dapr.AspNetCore.Test
|
|
{
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Threading.Tasks;
|
|
using Shouldly;
|
|
using Microsoft.AspNetCore.Builder;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Xunit;
|
|
|
|
public class CloudEventsMiddlewareTest
|
|
{
|
|
[Theory]
|
|
[InlineData("text/plain")]
|
|
[InlineData("application/json")] // "binary" format
|
|
[InlineData("application/cloudevents")] // no format
|
|
[InlineData("application/cloudevents+xml")] // wrong format
|
|
[InlineData("application/cloudevents-batch+json")] // we don't support batch
|
|
public async Task InvokeAsync_IgnoresOtherContentTypes(string contentType)
|
|
{
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents();
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe(contentType);
|
|
ReadBody(httpContext.Request.Body).ShouldBe("Hello, world!");
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext
|
|
{
|
|
Request = { ContentType = contentType, Body = MakeBody("Hello, world!") }
|
|
};
|
|
|
|
await pipeline.Invoke(context);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(null, null)] // assumes application/json + utf8
|
|
[InlineData("application/json", null)] // assumes utf8
|
|
[InlineData("application/json", "utf-8")]
|
|
[InlineData("application/json", "UTF-8")]
|
|
[InlineData("application/person+json", "UTF-16")] // arbitrary content type and charset
|
|
public async Task InvokeAsync_ReplacesBodyJson(string dataContentType, string charSet)
|
|
{
|
|
var encoding = charSet == null ? null : Encoding.GetEncoding(charSet);
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents();
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe(dataContentType ?? "application/json");
|
|
ReadBody(httpContext.Request.Body).ShouldBe("{\"name\":\"jimmy\"}");
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext { Request =
|
|
{
|
|
ContentType =
|
|
charSet == null
|
|
? "application/cloudevents+json"
|
|
: $"application/cloudevents+json;charset={charSet}",
|
|
Body = dataContentType == null ?
|
|
MakeBody("{ \"data\": { \"name\":\"jimmy\" } }", encoding) :
|
|
MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"data\": {{ \"name\":\"jimmy\" }} }}", encoding)
|
|
}
|
|
};
|
|
|
|
await pipeline.Invoke(context);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(null, null)] // assumes application/json + utf8
|
|
[InlineData("application/json", null)] // assumes utf8
|
|
[InlineData("application/json", "utf-8")]
|
|
[InlineData("application/json", "UTF-8")]
|
|
[InlineData("application/person+json", "UTF-16")] // arbitrary content type and charset
|
|
public async Task InvokeAsync_ReplacesPascalCasedBodyJson(string dataContentType, string charSet)
|
|
{
|
|
var encoding = charSet == null ? null : Encoding.GetEncoding(charSet);
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents();
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe(dataContentType ?? "application/json");
|
|
ReadBody(httpContext.Request.Body).ShouldBe("{\"name\":\"jimmy\"}");
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext { Request =
|
|
{
|
|
ContentType =
|
|
charSet == null
|
|
? "application/cloudevents+json"
|
|
: $"application/cloudevents+json;charset={charSet}",
|
|
Body = dataContentType == null ?
|
|
MakeBody("{ \"Data\": { \"name\":\"jimmy\" } }", encoding) :
|
|
MakeBody($"{{ \"DataContentType\": \"{dataContentType}\", \"Data\": {{ \"name\":\"jimmy\" }} }}", encoding)
|
|
}
|
|
};
|
|
|
|
await pipeline.Invoke(context);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(null, null)] // assumes application/json + utf8
|
|
[InlineData("application/json", null)] // assumes utf8
|
|
[InlineData("application/json", "utf-8")]
|
|
[InlineData("application/json", "UTF-8")]
|
|
[InlineData("application/person+json", "UTF-16")] // arbitrary content type and charset
|
|
public async Task InvokeAsync_ForwardsJsonPropertiesAsHeaders(string dataContentType, string charSet)
|
|
{
|
|
var encoding = charSet == null ? null : Encoding.GetEncoding(charSet);
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents(new CloudEventsMiddlewareOptions
|
|
{
|
|
ForwardCloudEventPropertiesAsHeaders = true
|
|
});
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe(dataContentType ?? "application/json");
|
|
ReadBody(httpContext.Request.Body).ShouldBe("{\"name\":\"jimmy\"}");
|
|
|
|
httpContext.Request.Headers.ShouldContainKey("Cloudevent.type");
|
|
httpContext.Request.Headers["Cloudevent.type"].ToString().ShouldBe("Test.Type");
|
|
httpContext.Request.Headers.ShouldContainKey("Cloudevent.subject");
|
|
httpContext.Request.Headers["Cloudevent.subject"].ToString().ShouldBe("Test.Subject");
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext { Request =
|
|
{
|
|
ContentType =
|
|
charSet == null
|
|
? "application/cloudevents+json"
|
|
: $"application/cloudevents+json;charset={charSet}",
|
|
Body = dataContentType == null ?
|
|
MakeBody("{ \"type\": \"Test.Type\", \"subject\": \"Test.Subject\", \"data\": { \"name\":\"jimmy\" } }", encoding) :
|
|
MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"type\":\"Test.Type\", \"subject\": \"Test.Subject\", \"data\": {{ \"name\":\"jimmy\" }} }}", encoding)
|
|
}
|
|
};
|
|
|
|
await pipeline.Invoke(context);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(null, null)] // assumes application/json + utf8
|
|
[InlineData("application/json", null)] // assumes utf8
|
|
[InlineData("application/json", "utf-8")]
|
|
[InlineData("application/json", "UTF-8")]
|
|
[InlineData("application/person+json", "UTF-16")] // arbitrary content type and charset
|
|
public async Task InvokeAsync_ForwardsIncludedJsonPropertiesAsHeaders(string dataContentType, string charSet)
|
|
{
|
|
var encoding = charSet == null ? null : Encoding.GetEncoding(charSet);
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents(new CloudEventsMiddlewareOptions
|
|
{
|
|
ForwardCloudEventPropertiesAsHeaders = true,
|
|
IncludedCloudEventPropertiesAsHeaders = new []{"type"}
|
|
});
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe(dataContentType ?? "application/json");
|
|
ReadBody(httpContext.Request.Body).ShouldBe("{\"name\":\"jimmy\"}");
|
|
|
|
httpContext.Request.Headers.ShouldContainKey("Cloudevent.type");
|
|
httpContext.Request.Headers["Cloudevent.type"].ToString().ShouldBe("Test.Type");
|
|
httpContext.Request.Headers.ShouldNotContainKey("Cloudevent.subject");
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext { Request =
|
|
{
|
|
ContentType =
|
|
charSet == null
|
|
? "application/cloudevents+json"
|
|
: $"application/cloudevents+json;charset={charSet}",
|
|
Body = dataContentType == null ?
|
|
MakeBody("{ \"type\": \"Test.Type\", \"subject\": \"Test.Subject\", \"data\": { \"name\":\"jimmy\" } }", encoding) :
|
|
MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"type\":\"Test.Type\", \"subject\": \"Test.Subject\", \"data\": {{ \"name\":\"jimmy\" }} }}", encoding)
|
|
}
|
|
};
|
|
|
|
await pipeline.Invoke(context);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(null, null)] // assumes application/json + utf8
|
|
[InlineData("application/json", null)] // assumes utf8
|
|
[InlineData("application/json", "utf-8")]
|
|
[InlineData("application/json", "UTF-8")]
|
|
[InlineData("application/person+json", "UTF-16")] // arbitrary content type and charset
|
|
public async Task InvokeAsync_DoesNotForwardExcludedJsonPropertiesAsHeaders(string dataContentType, string charSet)
|
|
{
|
|
var encoding = charSet == null ? null : Encoding.GetEncoding(charSet);
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents(new CloudEventsMiddlewareOptions
|
|
{
|
|
ForwardCloudEventPropertiesAsHeaders = true,
|
|
ExcludedCloudEventPropertiesFromHeaders = new []{"type"}
|
|
});
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe(dataContentType ?? "application/json");
|
|
ReadBody(httpContext.Request.Body).ShouldBe("{\"name\":\"jimmy\"}");
|
|
|
|
httpContext.Request.Headers.ShouldNotContainKey("Cloudevent.type");
|
|
httpContext.Request.Headers.ShouldContainKey("Cloudevent.subject");
|
|
httpContext.Request.Headers["Cloudevent.subject"].ToString().ShouldBe("Test.Subject");
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext { Request =
|
|
{
|
|
ContentType =
|
|
charSet == null
|
|
? "application/cloudevents+json"
|
|
: $"application/cloudevents+json;charset={charSet}",
|
|
Body = dataContentType == null ?
|
|
MakeBody("{ \"type\": \"Test.Type\", \"subject\": \"Test.Subject\", \"data\": { \"name\":\"jimmy\" } }", encoding) :
|
|
MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"type\":\"Test.Type\", \"subject\": \"Test.Subject\", \"data\": {{ \"name\":\"jimmy\" }} }}", encoding)
|
|
}
|
|
};
|
|
|
|
await pipeline.Invoke(context);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task InvokeAsync_ReplacesBodyNonJsonData()
|
|
{
|
|
// Our logic is based on the content-type, not the content.
|
|
// Since this is for text-plain content, we're going to encode it as a JSON string
|
|
// and store it in the data attribute - the middleware should JSON-decode it.
|
|
const string input = "{ \"message\": \"hello, world\"}";
|
|
var expected = input;
|
|
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents();
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe("text/plain");
|
|
ReadBody(httpContext.Request.Body).ShouldBe(expected);
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext { Request =
|
|
{
|
|
ContentType = "application/cloudevents+json",
|
|
Body = MakeBody($"{{ \"datacontenttype\": \"text/plain\", \"data\": {JsonSerializer.Serialize(input)} }}")
|
|
}
|
|
};
|
|
|
|
await pipeline.Invoke(context);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task InvokeAsync_ReplacesBodyNonJsonData_ExceptWhenSuppressed()
|
|
{
|
|
// Our logic is based on the content-type, not the content. This test tests the old bad behavior.
|
|
const string input = "{ \"message\": \"hello, world\"}";
|
|
var expected = JsonSerializer.Serialize(input);
|
|
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents(new CloudEventsMiddlewareOptions() { SuppressJsonDecodingOfTextPayloads = true, });
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe("text/plain");
|
|
ReadBody(httpContext.Request.Body).ShouldBe(expected);
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext { Request =
|
|
{
|
|
ContentType = "application/cloudevents+json",
|
|
Body = MakeBody($"{{ \"datacontenttype\": \"text/plain\", \"data\": {JsonSerializer.Serialize(input)} }}")
|
|
}
|
|
};
|
|
|
|
await pipeline.Invoke(context);
|
|
}
|
|
|
|
// This is a special case. S.T.Json will always output utf8, so we have to reinterpret the charset
|
|
// of the datacontenttype.
|
|
[Fact]
|
|
public async Task InvokeAsync_ReplacesBodyJson_NormalizesPayloadCharset()
|
|
{
|
|
const string dataContentType = "application/person+json;charset=UTF-16";
|
|
const string charSet = "UTF-16";
|
|
var encoding = Encoding.GetEncoding(charSet);
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents();
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe("application/person+json");
|
|
ReadBody(httpContext.Request.Body).ShouldBe("{\"name\":\"jimmy\"}");
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext { Request =
|
|
{
|
|
ContentType = $"application/cloudevents+json;charset={charSet}", Body = MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"data\": {{ \"name\":\"jimmy\" }} }}", encoding)
|
|
}
|
|
};
|
|
|
|
await pipeline.Invoke(context);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task InvokeAsync_ReadsBinaryData()
|
|
{
|
|
const string dataContentType = "application/octet-stream";
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents();
|
|
var data = new byte[] { 1, 2, 3 };
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe(dataContentType);
|
|
var bytes = new byte[httpContext.Request.Body.Length];
|
|
#if NET9_0
|
|
httpContext.Request.Body.ReadExactly(bytes, 0, bytes.Length);
|
|
#else
|
|
httpContext.Request.Body.Read(bytes, 0, bytes.Length);
|
|
#endif
|
|
bytes.ShouldBe(data);
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext { Request = { ContentType = "application/cloudevents+json" } };
|
|
var base64Str = System.Convert.ToBase64String(data);
|
|
|
|
context.Request.Body =
|
|
MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"data_base64\": \"{base64Str}\"}}");
|
|
|
|
await pipeline.Invoke(context);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task InvokeAsync_DataAndData64Set_ReturnsBadRequest()
|
|
{
|
|
const string dataContentType = "application/octet-stream";
|
|
var serviceCollection = new ServiceCollection();
|
|
var provider = serviceCollection.BuildServiceProvider();
|
|
|
|
var app = new ApplicationBuilder(provider);
|
|
app.UseCloudEvents();
|
|
const string data = "{\"id\": \"1\"}";
|
|
|
|
// Do verification in the scope of the middleware
|
|
app.Run(httpContext =>
|
|
{
|
|
httpContext.Request.ContentType.ShouldBe("application/json");
|
|
var body = ReadBody(httpContext.Request.Body);
|
|
body.ShouldBe(data);
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
var pipeline = app.Build();
|
|
|
|
var context = new DefaultHttpContext { Request = { ContentType = "application/cloudevents+json" } };
|
|
var bytes = Encoding.UTF8.GetBytes(data);
|
|
var base64Str = System.Convert.ToBase64String(bytes);
|
|
context.Request.Body =
|
|
MakeBody($"{{ \"datacontenttype\": \"{dataContentType}\", \"data_base64\": \"{base64Str}\", \"data\": {data} }}");
|
|
|
|
await pipeline.Invoke(context);
|
|
context.Response.StatusCode.ShouldBe((int)HttpStatusCode.BadRequest);
|
|
}
|
|
|
|
private static Stream MakeBody(string text, Encoding encoding = null)
|
|
{
|
|
encoding ??= Encoding.UTF8;
|
|
|
|
var stream = new MemoryStream();
|
|
var bytes = encoding.GetBytes(text);
|
|
stream.Write(bytes);
|
|
stream.Seek(0L, SeekOrigin.Begin);
|
|
return stream;
|
|
}
|
|
|
|
private static string ReadBody(Stream stream, Encoding encoding = null)
|
|
{
|
|
encoding ??= Encoding.UTF8;
|
|
|
|
var bytes = new byte[stream.Length];
|
|
#if NET9_0
|
|
stream.ReadExactly(bytes, 0, bytes.Length);
|
|
#else
|
|
stream.Read(bytes, 0, bytes.Length);
|
|
#endif
|
|
var str = encoding.GetString(bytes);
|
|
return str;
|
|
}
|
|
}
|
|
}
|