public void GetUpdatedAt_ReturnsTheDateWhenPresent()
{
JObject sut = JObject.Parse("{\"updatedAt\":\"2021-03-16T12:32:05.000+00:00\"}");
DateTimeOffset expected = DateTimeOffset.Parse("2021-03-16T12:32:05.000+00:00");
Assert.Equal(expected.ToUniversalTime(), ServiceSerializer.GetUpdatedAt(sut)?.ToUniversalTime());
}
public DelegateHttpContent(string mediaType, object content, ServiceSerializer serializer)
{
Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
m_content = content;
m_serializer = serializer;
}
public FakeConformanceApiService(ServiceSerializer serializer, RequiredResponseDto?requiredResponse = null, WidgetDto?widgetResponse = null)
: base(ServiceDelegators.NotImplemented)
{
m_serializer = serializer;
m_requiredResponse = requiredResponse ?? CreateRequiredResponse();
m_widgetResponse = widgetResponse ?? CreateWidget();
}
/// <summary>
/// Gets the conditional headers for the request to the remote service.
/// </summary>
/// <param name="instance">The instance being sent.</param>
/// <returns>The conditional headers, or <c>null</c> if there are no conditional headers.</returns>
protected static Dictionary <string, string> GetConditionalHeaders(JObject instance)
{
string version = ServiceSerializer.GetVersion(instance);
return(string.IsNullOrEmpty(version) ? null : new Dictionary <string, string> {
[ServiceHeaders.IfMatch] = version.ToETagValue()
});
}
protected static void AssertJsonDocumentMatches(EFMovie entity, JToken actual)
{
var serializer = new ServiceSerializer();
var expected = (JObject)serializer.Serialize(entity);
Assert.IsAssignableFrom <JObject>(actual);
Assert.Equal(expected, (JObject)actual);
}
public void SetIdToDefault_JObject_Works()
{
JObject sut = JObject.Parse("{\"id\":\"1234\"}");
var serializer = new ServiceSerializer();
serializer.SetIdToDefault(sut);
Assert.Null(sut.Value <string>("id"));
}
/// <summary>
/// Inserts the instance in the remote table.
/// </summary>
/// <param name="instance">The instance to insert.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
/// <returns>A task that returns when the operation is complete.</returns>
public async Task InsertItemAsync(T instance, CancellationToken cancellationToken = default)
{
Arguments.IsNotNull(instance, nameof(instance));
JObject value = ServiceClient.Serializer.Serialize(instance) as JObject;
value = ServiceSerializer.RemoveSystemProperties(value, out _);
JToken insertedValue = await TransformHttpExceptionAsync(() => InsertItemAsync(value, cancellationToken)).ConfigureAwait(false);
ServiceClient.Serializer.Deserialize(insertedValue, instance);
}
/// <summary>
/// Inserts the instance in the remote table.
/// </summary>
/// <param name="instance">The instance to insert.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
/// <returns>A task that returns when the operation is complete.</returns>
public async Task InsertItemAsync(T instance, CancellationToken cancellationToken = default)
{
Arguments.IsNotNull(instance, nameof(instance));
var value = Serializer.Serialize(instance) as JObject;
value = ServiceSerializer.RemoveSystemProperties(value, out _);
JObject inserted = await InsertItemAsync(value, cancellationToken).ConfigureAwait(false);
Serializer.Deserialize(inserted, instance);
}
/// <summary>
/// Executes the operation on the offline store.
/// </summary>
/// <param name="store">The offline store.</param>
/// <param name="item">The item to use for the store operation.</param>
/// <returns>A task that completes when the store operation is completed.</returns>
public override async Task ExecuteOperationOnOfflineStoreAsync(IOfflineStore store, JObject item, CancellationToken cancellationToken = default)
{
var itemId = ServiceSerializer.GetId(item);
var originalItem = await store.GetItemAsync(TableName, itemId, cancellationToken).ConfigureAwait(false);
if (originalItem == null)
{
throw new OfflineStoreException($"Item with ID '{itemId}' does not exist in the offline store.");
}
await store.UpsertAsync(TableName, new[] { item }, false, cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Deletes an item from the remote table.
/// </summary>
/// <param name="instance">The instance to delete from the table.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
/// <returns>A task that returns the response when complete.</returns>
public Task <JToken> DeleteItemAsync(JObject instance, CancellationToken cancellationToken = default)
{
string id = ServiceSerializer.GetId(instance);
ServiceRequest request = new()
{
Method = HttpMethod.Delete,
UriPathAndQuery = CreateUriPath(TableName, id),
EnsureResponseContent = false,
RequestHeaders = GetConditionalHeaders(instance)
};
return(SendRequestAsync(request, cancellationToken));
}
/// <summary>
/// Inserts an item into the remote table.
/// </summary>
/// <param name="instance">The instance to insert into the table.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
/// <returns>A task that returns the inserted data when complete.</returns>
public Task <JToken> InsertItemAsync(JObject instance, CancellationToken cancellationToken = default)
{
_ = ServiceSerializer.GetId(instance, allowDefault: true);
ServiceRequest request = new()
{
Method = HttpMethod.Post,
UriPathAndQuery = CreateUriPath(TableName),
EnsureResponseContent = true,
Content = instance.ToString(Formatting.None)
};
return(SendRequestAsync(request, cancellationToken));
}
/// <summary>
/// Replaces an item into the remote table.
/// </summary>
/// <param name="instance">The instance to replace into the table.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
/// <returns>A task that returns the replaced data when complete.</returns>
public Task <JToken> ReplaceItemAsync(JObject instance, CancellationToken cancellationToken = default)
{
string id = ServiceSerializer.GetId(instance);
ServiceRequest request = new()
{
Method = HttpMethod.Put,
UriPathAndQuery = CreateUriPath(TableName, id),
EnsureResponseContent = true,
Content = instance.ToString(Formatting.None),
RequestHeaders = GetConditionalHeaders(instance)
};
return(SendRequestAsync(request, cancellationToken));
}
public ConformanceTests(ServiceSerializer serializer)
: base(serializer)
{
m_tests = CreateTestProvider(JsonSerializer);
m_contentSerializer = HttpContentSerializer.Create(Serializer);
var service = new ConformanceApiService(new ConformanceApiServiceSettings {
Tests = m_tests, JsonSerializer = JsonSerializer
});
var settings = new ServiceHttpHandlerSettings {
ContentSerializer = m_contentSerializer
};
var handler = new ConformanceApiHttpHandler(service, settings)
{
InnerHandler = new NotFoundHttpHandler()
};
m_httpClient = new HttpClient(handler)
{
BaseAddress = new Uri("http://example.com/")
};
}
protected ServiceSerializerTestsBase(ServiceSerializer serializer)
{
Serializer = serializer;
}
public ServiceDtoTests(ServiceSerializer serializer)
: base(serializer)
{
}
public ServiceSerializer_Tests()
{
serializer = new();
}
public StandardHttpContentSerializer(ServiceSerializer serializer)
{
m_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
public void GetUpdatedAt_ReturnsNullWhenMissing()
{
JObject sut = JObject.Parse("{\"id\":\"1234\"}");
Assert.Null(ServiceSerializer.GetUpdatedAt(sut));
}
/// <summary> /// Creates a standard HTTP content serializer. /// </summary> public static HttpContentSerializer Create(ServiceSerializer serviceSerializer) => new StandardHttpContentSerializer(serviceSerializer);
public void GetId_NoId_Throws()
{
JObject sut = JObject.Parse("{}");
Assert.Throws <ArgumentException>(() => ServiceSerializer.GetId(sut));
}
public void GetId_IgnoreCase_Throws()
{
JObject sut = JObject.Parse("{\"iD\":\"1234\"}");
Assert.Throws <ArgumentException>(() => ServiceSerializer.GetId(sut, ignoreCase: false));
}
public void GetId_IgnoreCase_ReturnsId()
{
JObject sut = JObject.Parse("{\"Id\":\"1234\"}");
Assert.Equal("1234", ServiceSerializer.GetId(sut, ignoreCase: true));
}
public void GetId_ReturnsId()
{
JObject sut = JObject.Parse("{\"id\":\"1234\"}");
Assert.Equal("1234", ServiceSerializer.GetId(sut));
}
public DtoValidationTests(ServiceSerializer serializer)
: base(serializer)
{
}
public ServiceDataUtilityTests(ServiceSerializer serializer)
: base(serializer)
{
}
public void IsDeleted_ReturnsCorrectlyWhenPresent(string value, bool expected)
{
JObject sut = JObject.Parse($"{{\"deleted\":{value}}}");
Assert.Equal(expected, ServiceSerializer.IsDeleted(sut));
}
public async Task <int> RunAsync(IReadOnlyList <string> args)
{
const string defaultUrl = "http://localhost:4117/";
var argsReader = new ArgsReader(args);
if (argsReader.ReadFlag("?|h|help"))
{
throw new ArgsReaderException("");
}
var serializerName = argsReader.ReadOption("serializer")?.ToLowerInvariant();
ServiceSerializer serializer = serializerName switch
{
null or "systemtextjson" => SystemTextJsonServiceSerializer.Instance,
"newtonsoftjson" or "obsoletejson" => NewtonsoftJsonServiceSerializer.Instance,
_ => throw new ArgsReaderException("Unsupported serializer."),
};
var contentSerializer = HttpContentSerializer.Create(serializer);
#pragma warning disable CS0618 // Type or member is obsolete
if (serializerName is "obsoletejson")
{
contentSerializer = new JsonHttpContentSerializer(new JsonHttpContentSerializerSettings {
ForceAsyncIO = true
});
}
#pragma warning restore CS0618 // Type or member is obsolete
var jsonSerializer = serializer as JsonServiceSerializer ?? NewtonsoftJsonServiceSerializer.Instance;
var tests = ConformanceTestsInfo.FromJson(m_testsJson, jsonSerializer).Tests !;
var command = argsReader.ReadArgument();
if (command == "host")
{
var url = argsReader.ReadOption("url") ?? defaultUrl;
argsReader.VerifyComplete();
var service = new ConformanceApiService(
new ConformanceApiServiceSettings
{
Tests = tests,
JsonSerializer = jsonSerializer,
});
await new WebHostBuilder()
.UseKestrel(options => options.AllowSynchronousIO = serializerName is "newtonsoftjson")
.UseUrls(url)
.Configure(app => app.Run(httpContext => HostAsync(httpContext, service, contentSerializer)))
.Build()
.RunAsync();
return(0);
}
if (command == "test")
{
var baseUri = new Uri(argsReader.ReadOption("url") ?? defaultUrl);
var testNames = argsReader.ReadArguments();
argsReader.VerifyComplete();
var api = new HttpClientConformanceApi(
new HttpClientServiceSettings
{
BaseUri = baseUri,
ContentSerializer = contentSerializer,
});
var tester = new ConformanceApiTester(
new ConformanceApiTesterSettings
{
Tests = tests,
Api = api,
HttpClient = new HttpClient {
BaseAddress = baseUri
},
JsonSerializer = jsonSerializer,
});
var results = new List <ConformanceTestResult>();
if (testNames.Count == 0)
{
results.AddRange((await tester.RunAllTestsAsync()).Results);
}
else
{
foreach (var testName in testNames)
{
var testInfo = tests.SingleOrDefault(x => x.Test == testName);
if (testInfo == null)
{
Console.WriteLine($"Test not found: {testName}");
return(-1);
}
results.Add(await tester.RunTestAsync(testInfo));
}
}
var failureCount = 0;
foreach (var result in results.Where(x => x.Status == ConformanceTestStatus.Fail))
{
Console.WriteLine($"{result.TestName} fail: {result.Message}");
failureCount++;
}
Console.WriteLine($"{results.Count} tests: {results.Count - failureCount} passed, {failureCount} failed.");
return(failureCount == 0 ? 0 : 1);
}
if (command == "fsd")
{
var outputPath = argsReader.ReadOption("output");
var shouldVerify = argsReader.ReadFlag("verify");
argsReader.VerifyComplete();
return(WriteText(path: outputPath, contents: m_fsdText, shouldVerify: shouldVerify));
}
if (command == "json")
{
var outputPath = argsReader.ReadOption("output");
var shouldVerify = argsReader.ReadFlag("verify");
argsReader.VerifyComplete();
return(WriteText(path: outputPath, contents: m_testsJson, shouldVerify: shouldVerify));
}
if (command != null)
{
throw new ArgsReaderException($"Invalid command: {command}");
}
throw new ArgsReaderException("Missing command.");
}
protected ServiceSerializerTestsBase(ServiceSerializer serializer)
{
Serializer = serializer;
JsonSerializer = serializer as JsonServiceSerializer ?? NewtonsoftJsonServiceSerializer.Instance;
}
public void GetId_NoId_AllowDefault_Ok()
{
JObject sut = JObject.Parse("{}");
Assert.Null(ServiceSerializer.GetId(sut, allowDefault: true));
}
public void IsDeleted_ReturnsFalseWhenMissing()
{
JObject sut = JObject.Parse("{\"id\":\"1234\"}");
Assert.False(ServiceSerializer.IsDeleted(sut));
}
