public void TestRemovalResolution()
{
Assert.AreEqual(typeof(DummySerializer), Client.Serializer.Resolve <AnotherTestObject>(DataDirection.In).GetType());
SerializerResolver.Unregister <AnotherTestObject>();
Assert.AreEqual(typeof(ApiJsonSerializer), Client.Serializer.Resolve <AnotherTestObject>(DataDirection.In).GetType());
}
public void SerializerFor_EmptyRecordIndexNode_Returns_Specific_Serializer()
{
var serializer = new SerializerResolver()
.SerializerFor <Node <EmptyRecordIndexKey> >();
Assert.AreEqual(typeof(EmptyRecordIndexNodeSerializer), serializer.GetType());
}
public DatabaseOperations(
SPMiddlewareOptions sPMiddlewareOptions,
SwaggerFromSPOptions options,
SqlHelper sqlHelper,
ILogger <DatabaseOperations> logger,
DbConnection dbConnection,
ParameterProvider parametersProvider,
SerializerResolver serializerResolver,
NamingMappingHandler namingMappingHandler,
CodeConvention codeConvention,
ConfigProvider configProvider,
IWebHostEnvironment hostingEnvironment)
{
this.codeConvention = codeConvention;
this.hostingEnvironment = hostingEnvironment;
this.sPMiddlewareOptions = sPMiddlewareOptions;
this.options = options;
this.sqlHelper = sqlHelper;
this.logger = logger;
this.serializerResolver = serializerResolver;
this.dbConnection = dbConnection;
this.parametersProvider = parametersProvider;
this.namingMappingHandler = namingMappingHandler;
entities = configProvider.Entities;
}
public void Setup()
{
// testobject will use xml
SerializerResolver.Register <TestObject, ApiXmlSerializer>();
// anothertestobject will use the dummyserializer
SerializerResolver.Register <AnotherTestObject, DummySerializer>();
}
/// <summary>
/// Initialises a new <see cref="ApiClient"/> using a user-set <see cref="ApiSerializer"/>
/// </summary>
public ApiClient(ApiSerializer serializer)
{
Headers = new HeaderCollection(this);
Serializer = new SerializerResolver(serializer);
_lock = new AsyncReaderWriterLock();
RequestClientReset(true);
}
static ApiClient()
{
// register generic xml document type
SerializerResolver.Register <XmlDocument, ApiXmlSerializer>();
// register stream resolver types (inwards only)
SerializerResolver.Register <Stream, InternalStreamSerializer>(DataDirection.In);
SerializerResolver.Register <FileStream, InternalStreamSerializer>(DataDirection.In);
SerializerResolver.Register <MemoryStream, InternalStreamSerializer>(DataDirection.In);
}
public GenericSPMiddleware(
ILogger <GenericSPMiddleware> logger,
SerializerResolver serializerResolver,
SPMiddlewareOptions sPMiddlewareOptions,
DbConnection dbConnection,
IEnumerable <Filter.IRequestInterceptor> requestInterceptors,
IEnumerable <Filter.RequestLogger> requestLoggers,
CommandPreparation commandPreparation)
{
this.logger = logger;
this.serializerResolver = serializerResolver;
this.sPMiddlewareOptions = sPMiddlewareOptions;
this.dbConnection = dbConnection;
this.requestInterceptors = requestInterceptors;
this.commandPreparation = commandPreparation;
this.requestLoggers = requestLoggers;
}
private HttpContent GetContent(SerializerResolver serializer)
{
switch (BodyType)
{
case BodyType.Encoded:
return(new FormUrlEncodedContent(ParameterUtils.GetParameter <FormParameter>(this, RequestCulture)));
case BodyType.Serialized:
return(serializer.Resolve(GetType(), DataDirection.Out).Serialize(this));
case BodyType.SerializedProperty:
var body = serializer.Resolve(GetType(), DataDirection.Out).Serialize(ParameterUtils.GetSingleParameterObject <RequestBody>(this));
return(body);
case BodyType.Custom:
return(BodyContent);
default:
//todo custom exception - there should have been a datatype specified
throw new ArgumentOutOfRangeException();
}
}
public void Cleanup()
{
SerializerResolver.Unregister <TestObject>();
SerializerResolver.Unregister <AnotherTestObject>();
}
public void SerializerForBtreeNodeValueWithAddress_Returns_FormatterSerializer()
{
var serializer = new SerializerResolver().SerializerFor <Node <ValueWithAddressIndexKey <String> > >();
Assert.AreEqual(typeof(BTreeNodeBinaryFormatterSerializer <ValueWithAddressIndexKey <String> >), serializer.GetType());
}
public void SerializerForBtreeNodeInt64_Returns_FormatterSerializer()
{
var serializer = new SerializerResolver().SerializerFor <Node <Int64> >();
Assert.AreEqual(typeof(BTreeNodeBinaryFormatterSerializer <Int64>), serializer.GetType());
}
public void SerializerFor_CollectionFileRoot_Returns_Specific_Serializer()
{
var serializer = new SerializerResolver().SerializerFor <CollectionFileRoot>();
Assert.AreEqual(typeof(CollectionFileRootSerializer), serializer.GetType());
}
public void SerializerForTransasctionJournal_Returns_Specific_Serializer()
{
var serializer = new SerializerResolver().SerializerFor <TransactionJournal>();
Assert.AreEqual(typeof(TransactionJournalSerializer), serializer.GetType());
}
public void SerializerFor_IndexMetaRecord_Returns_Correct_Serializer()
{
var serializer = new SerializerResolver().SerializerFor <IndexMetaRecord>();
Assert.AreEqual(typeof(IndexMetaRecordSerializer), serializer.GetType());
}
public void SerializerFor_Object_Returns_BSONSerializer()
{
var serializer = new SerializerResolver().SerializerFor <object>();
Assert.AreEqual(typeof(BsonSerializer <object>), serializer.GetType());
}
public void SerializerForBtreeNodeCustomType_Returns_Bson_Serializer()
{
var serializer = new SerializerResolver().SerializerFor <Node <CustomIndexKey> >();
Assert.AreEqual(typeof(BTreeNodeBsonSerializer <CustomIndexKey>), serializer.GetType());
}
/// <summary> /// Registers the <see cref="ApiHtmlSerializer"/> to resolve <see cref="HtmlDocument"/> objects /// </summary> public static void RegisterDefaults() => SerializerResolver.Register <HtmlDocument, ApiHtmlSerializer>();
/// <summary>
/// Create a <see cref="HttpResponseMessage"/> for this <see cref="ApiRequest"/>, which can then be modified manually or overriden by <see cref="ApiClient.SetupRequest"/>
/// </summary>
/// <remarks>
/// This validates the <see cref="Path"/> and <see cref="RequireAuth"/> properties, throwing a <see cref="ClientValidationException"/> if it's unsatisfied with the constraints
/// </remarks>
public HttpRequestMessage Build(SerializerResolver serializer)
{
if (!Path.StartsWith("http") && !Path.StartsWith("//"))
{
throw new HttpRequestException("The request path is invalid (it must start with http or https)");
}
var request = new HttpRequestMessage
{
RequestUri = new Uri(FullUrl)
};
// generic setup
switch (Method)
{
case Methods.Get:
request.Method = HttpMethod.Get;
break;
case Methods.Post:
request.Method = HttpMethod.Post;
request.Content = GetContent(serializer);
break;
case Methods.Put:
request.Method = HttpMethod.Put;
request.Content = GetContent(serializer);
break;
case Methods.Patch:
#if NETSTANDARD2_0
// .NET Standard 2.0 doesn't have a PATCH method...
request.Method = new HttpMethod("PATCH");
#else
request.Method = HttpMethod.Patch;
#endif
request.Content = GetContent(serializer);
break;
case Methods.Delete:
request.Method = HttpMethod.Delete;
request.Content = GetContent(serializer);
break;
case Methods.Head:
request.Method = HttpMethod.Head;
break;
case Methods.Trace:
request.Method = HttpMethod.Trace;
break;
default:
throw new NotImplementedException();
}
if (CustomHeaderCollectionCreated)
{
foreach (var header in Headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
if (!request.Headers.Contains("Accept"))
{
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(serializer.Resolve(GetType(), DataDirection.In).ContentType));
}
return(request);
}
