/// <summary>
/// Initializes a new instance of the <see cref="SqlServerStreamConfig"/> class.
/// </summary>
/// <param name="name">Name of the stream.</param>
/// <param name="accessKinds">Access the stream has.</param>
/// <param name="defaultConnectionTimeout">Default timeout to use when connecting to SQL Server.</param>
/// <param name="defaultCommandTimeout">Default timeout to use when running a command on SQL Server.</param>
/// <param name="defaultSerializerRepresentation">Default <see cref="SerializerRepresentation"/> to use (used for identifier serialization).</param>
/// <param name="defaultSerializationFormat">Default <see cref="SerializationFormat"/> to use.</param>
/// <param name="allLocators">All <see cref="ISqlServerLocator"/>'s.</param>
public SqlServerStreamConfig(
string name,
StreamAccessKinds accessKinds,
TimeSpan defaultConnectionTimeout,
TimeSpan defaultCommandTimeout,
SerializerRepresentation defaultSerializerRepresentation,
SerializationFormat defaultSerializationFormat,
IReadOnlyCollection <ISqlServerLocator> allLocators)
{
name.MustForArg(nameof(name)).NotBeNullNorWhiteSpace();
accessKinds.MustForArg(nameof(accessKinds)).NotBeEqualTo(StreamAccessKinds.None);
defaultConnectionTimeout.TotalMilliseconds.MustForArg(Invariant($"{nameof(defaultConnectionTimeout)}.{nameof(TimeSpan.TotalMilliseconds)}")).BeGreaterThanOrEqualTo(0d);
defaultCommandTimeout.TotalMilliseconds.MustForArg(Invariant($"{nameof(defaultCommandTimeout)}.{nameof(TimeSpan.TotalMilliseconds)}")).BeGreaterThanOrEqualTo(0d);
defaultSerializerRepresentation.MustForArg(nameof(defaultSerializerRepresentation)).NotBeNull();
defaultSerializationFormat.MustForArg(nameof(defaultSerializationFormat)).NotBeEqualTo(SerializationFormat.Invalid);
allLocators.MustForArg(nameof(allLocators)).NotBeNullNorEmptyEnumerableNorContainAnyNulls();
this.Name = name;
this.AccessKinds = accessKinds;
this.DefaultConnectionTimeout = defaultConnectionTimeout;
this.DefaultCommandTimeout = defaultCommandTimeout;
this.DefaultSerializerRepresentation = defaultSerializerRepresentation;
this.DefaultSerializationFormat = defaultSerializationFormat;
this.AllLocators = allLocators;
}
/// <inheritdoc />
public override ISerializer BuildSerializer(
SerializerRepresentation serializerRepresentation,
AssemblyMatchStrategy assemblyMatchStrategy = AssemblyMatchStrategy.AnySingleVersion)
{
if (serializerRepresentation == null)
{
throw new ArgumentNullException(nameof(serializerRepresentation));
}
// ReSharper disable once RedundantArgumentDefaultValue
var configurationType = serializerRepresentation.SerializationConfigType?.ResolveFromLoadedTypes(assemblyMatchStrategy, throwIfCannotResolve: true);
ISerializer serializer;
switch (serializerRepresentation.SerializationKind)
{
case SerializationKind.PropertyBag:
serializer = new ObcPropertyBagSerializer(configurationType?.ToPropertyBagSerializationConfigurationType());
break;
default:
throw new NotSupportedException(Invariant($"{nameof(serializerRepresentation)} from enumeration {nameof(SerializationKind)} of {serializerRepresentation.SerializationKind} is not supported."));
}
var result = this.WrapInCompressingSerializerIfAppropriate(serializer, serializerRepresentation.CompressionKind);
return(result);
}
public IdentifiedSerializerRepresentation GetIdAddIfNecessarySerializerRepresentation(
SqlServerLocator resourceLocator,
SerializerRepresentation serializerRepresentation = null,
SerializationFormat serializationFormat = SerializationFormat.String)
{
var localSerializerRepresentation = serializerRepresentation ?? this.DefaultSerializerRepresentation;
var found = this.serializerRepresentationToIdentifiedSerializerMap.TryGetValue(serializerRepresentation, out var result);
if (found)
{
return(result);
}
else
{
var id = this.Execute(
new GetOrAddIdentifiedSerializerRepresentationOp(resourceLocator, localSerializerRepresentation, serializationFormat));
var item = new IdentifiedSerializerRepresentation(id, localSerializerRepresentation, serializationFormat);
this.serializerRepresentationIdToIdentifiedSerializerMap.TryAdd(item.Id, item);
this.serializerRepresentationToIdentifiedSerializerMap.TryAdd(item.SerializerRepresentation, item);
var newFound = this.serializerRepresentationToIdentifiedSerializerMap.TryGetValue(serializerRepresentation, out var newResult);
newFound.MustForOp("failedToFindSerializationRepresentationAfterAdding").BeTrue();
return(newResult);
}
}
/// <summary>
/// Sets the serialization logic to be used when reading configuration data (from files or otherwise).
/// </summary>
/// <param name="configurationSerializerRepresentation">The serializer representation.</param>
/// <param name="configurationSerializerFactory">Optional serializer factory; DEFAULT is JSON.</param>
public static void SetSerialization(SerializerRepresentation configurationSerializerRepresentation, ISerializerFactory configurationSerializerFactory = null)
{
lock (SyncUpdateSettings)
{
Config.serializerRepresentation = configurationSerializerRepresentation;
Config.serializerFactory = configurationSerializerFactory ?? new JsonSerializerFactory();
}
}
/// <summary>
/// Gets a settings object of the specified type.
/// </summary>
/// <param name="type">Type to fetch.</param>
/// <param name="configurationSerializerRepresentation">Optional; configuration serializer representation; DEFAULT is JSON.</param>
/// <param name="configurationSerializerFactory">Optional; configuration serializer factory; DEFAULT is JSON.</param>
/// <returns>Deserialized configuration.</returns>
public static object Get(Type type, SerializerRepresentation configurationSerializerRepresentation = null, ISerializerFactory configurationSerializerFactory = null)
{
return(ResolvedSettings.GetOrAdd(type, t =>
{
dynamic settingsFor = typeof(For <>).MakeGenericType(type).Construct(configurationSerializerRepresentation ?? serializerRepresentation, configurationSerializerFactory ?? serializerFactory, null);
return settingsFor.Value;
}));
}
/// <summary>
/// Setup the subject serialization to be used when packing and handing in payload object to a writer.
/// </summary>
/// <param name="subjectSerializerRepresentation">The subject serializer representation.</param>
/// <param name="subjectSerializerFactory">The subject serializer factory.</param>
public static void SetupSubjectSerialization(SerializerRepresentation subjectSerializerRepresentation, ISerializerFactory subjectSerializerFactory)
{
lock (SyncSerializationSettings)
{
SubjectSerializerRepresentation = subjectSerializerRepresentation;
SubjectSerializerFactory = subjectSerializerFactory;
}
}
/// <summary>
/// Gets the specified configuration.
/// </summary>
/// <typeparam name="T">Type of configuration item.</typeparam>
/// <param name="configurationSerializerRepresentation">Optional; configuration serializer representation; DEFAULT is JSON.</param>
/// <param name="configurationSerializerFactory">Optional; configuration serializer factory; DEFAULT is JSON.</param>
/// <returns>T.</returns>
public static T Get <T>(SerializerRepresentation configurationSerializerRepresentation = null, ISerializerFactory configurationSerializerFactory = null)
{
return((T)ResolvedSettings.GetOrAdd(
typeof(T),
t =>
new For <T>(
configurationSerializerRepresentation ?? serializerRepresentation,
configurationSerializerFactory ?? serializerFactory).Value));
}
private static DescribedSerialization Serialize(
SerializerRepresentation serializerRepresentation,
SerializationFormat serializationFormat,
object objectToSerialize)
{
var result = objectToSerialize.ToDescribedSerialization(serializerRepresentation, serializationFormat);
return(result);
}
public static void File_exists__Gets_deserialized()
{
// Arrange
var expected = new Contains
{
Property = new DerivedProperty
{
PropertyOnBase = "propBase",
PropertyOnDerived = "propDerived",
},
};
var configurationSerializerRepresentation = new SerializerRepresentation(SerializationKind.Json, typeof(PropertyJsonConfig).ToRepresentation());
var serializer = new ObcJsonSerializer(typeof(PropertyJsonConfig).ToJsonSerializationConfigurationType());
var expectedJson = serializer.SerializeToString(expected);
// Act - Method specified serialization.
Config.Reset();
var actualViaParameterMethodSpecific = Config.Get(expected.GetType(), configurationSerializerRepresentation);
var actualJsonViaParameterMethodSpecific = serializer.SerializeToString(actualViaParameterMethodSpecific);
var actualViaGenericMethodSpecific = Config.Get(expected.GetType(), configurationSerializerRepresentation);
var actualJsonViaGenericMethodSpecific = serializer.SerializeToString(actualViaGenericMethodSpecific);
// Act - Default via type parameter.
var exceptionGet = Record.Exception(() =>
{
Config.Reset();
return(Config.Get(expected.GetType()));
});
// Act - Default via generic call.
var exceptionGetGeneric = Record.Exception(() =>
{
Config.Reset();
return(Config.Get <Contains>());
});
// Act - Global specified
Config.Reset();
Config.SetSerialization(configurationSerializerRepresentation);
var actualViaParameterGlobal = Config.Get(expected.GetType());
var actualJsonViaParameterGlobal = serializer.SerializeToString(actualViaParameterGlobal);
var actualViaGenericGlobal = Config.Get <Contains>();
var actualJsonViaGenericGlobal = serializer.SerializeToString(actualViaGenericGlobal);
// Assert
exceptionGet.Should().NotBeNull();
exceptionGet.InnerException.Should().NotBeNull();
exceptionGet.InnerException.Message.Should().StartWith("Could not create an instance of type Naos.Configuration.Test.IBase. Type is an interface or abstract class and cannot be instantiated.");
exceptionGetGeneric.Should().NotBeNull();
exceptionGetGeneric.Message.Should().StartWith("Could not create an instance of type Naos.Configuration.Test.IBase. Type is an interface or abstract class and cannot be instantiated.");
actualJsonViaParameterMethodSpecific.Should().Be(expectedJson);
actualJsonViaGenericMethodSpecific.Should().Be(expectedJson);
actualJsonViaParameterGlobal.Should().Be(expectedJson);
actualJsonViaGenericGlobal.Should().Be(expectedJson);
}
private static SerializerRepresentation GetSerializerRepresentation()
{
SerializerRepresentation defaultSerializerRepresentation;
var configurationTypeRepresentation =
typeof(DependencyOnlyJsonSerializationConfiguration <SqlServerJsonSerializationConfiguration, TypesToRegisterJsonSerializationConfiguration <MyObject> >).ToRepresentation();
defaultSerializerRepresentation = new SerializerRepresentation(
SerializationKind.Json,
configurationTypeRepresentation);
return(defaultSerializerRepresentation);
}
/// <summary>
/// Initializes a new instance of the <see cref="IdentifiedSerializerRepresentation"/> class.
/// </summary>
/// <param name="id">The serializer representation identifier.</param>
/// <param name="serializerRepresentation">The serializer description.</param>
/// <param name="serializationFormat">The serialization format.</param>
public IdentifiedSerializerRepresentation(
int id,
SerializerRepresentation serializerRepresentation,
SerializationFormat serializationFormat)
{
serializerRepresentation.MustForArg(nameof(serializerRepresentation)).NotBeNull();
serializationFormat.MustForArg(nameof(serializationFormat)).NotBeEqualTo(SerializationFormat.Invalid);
this.Id = id;
this.SerializerRepresentation = serializerRepresentation;
this.SerializationFormat = serializationFormat;
}
/// <summary>
/// Gets the serializer representation from identifier (first by cache and then by database).
/// </summary>
/// <param name="sqlServerLocator">The resource locator.</param>
/// <param name="serializerRepresentationId">The serializer representation identifier.</param>
/// <returns>IdentifiedSerializerRepresentation.</returns>
public IdentifiedSerializerRepresentation GetSerializerRepresentationFromId(
SqlServerLocator sqlServerLocator,
int serializerRepresentationId)
{
var found = this.serializerRepresentationIdToIdentifiedSerializerMap.TryGetValue(serializerRepresentationId, out var result);
if (found)
{
return(result);
}
else
{
var storedProcOp = StreamSchema.Sprocs.GetSerializerRepresentationFromId.BuildExecuteStoredProcedureOp(
this.Name,
serializerRepresentationId);
var sqlProtocol = this.BuildSqlOperationsProtocol(sqlServerLocator);
var sprocResult = sqlProtocol.Execute(storedProcOp);
SerializationKind serializationKind = sprocResult
.OutputParameters[nameof(StreamSchema
.Sprocs.GetSerializerRepresentationFromId.OutputParamName
.SerializationKind)]
.GetValueOfType <SerializationKind>();
int configTypeWithVersionId = sprocResult
.OutputParameters[nameof(StreamSchema
.Sprocs.GetSerializerRepresentationFromId.OutputParamName
.ConfigTypeWithVersionId)]
.GetValueOfType <int>();
CompressionKind compressionKind = sprocResult
.OutputParameters[nameof(StreamSchema
.Sprocs.GetSerializerRepresentationFromId.OutputParamName
.CompressionKind)]
.GetValueOfType <CompressionKind>();
SerializationFormat serializationFormat = sprocResult
.OutputParameters[nameof(StreamSchema
.Sprocs.GetSerializerRepresentationFromId.OutputParamName
.SerializationFormat)]
.GetValueOfType <SerializationFormat>();
var configType = this.GetTypeById(sqlServerLocator, configTypeWithVersionId, true);
var rep = new SerializerRepresentation(serializationKind, configType.WithVersion, compressionKind);
var item = new IdentifiedSerializerRepresentation(serializerRepresentationId, rep, serializationFormat);
this.serializerRepresentationIdToIdentifiedSerializerMap.TryAdd(item.Id, item);
this.serializerRepresentationToIdentifiedSerializerMap.TryAdd(item.SerializerRepresentation, item);
var newFound = this.serializerRepresentationIdToIdentifiedSerializerMap.TryGetValue(serializerRepresentationId, out var newResult);
newFound.MustForOp("failedToFindSerializationRepresentationAfterAdding").BeTrue();
return(newResult);
}
}
public SqlServerStreamConfig DeepCloneWithDefaultSerializerRepresentation(SerializerRepresentation defaultSerializerRepresentation)
{
var result = new SqlServerStreamConfig(
this.Name?.DeepClone(),
this.AccessKinds.DeepClone(),
this.DefaultConnectionTimeout.DeepClone(),
this.DefaultCommandTimeout.DeepClone(),
defaultSerializerRepresentation,
this.DefaultSerializationFormat.DeepClone(),
this.AllLocators?.DeepClone());
return(result);
}
/// <summary>
/// Gets the specified configuration.
/// </summary>
/// <typeparam name="T">Type of configuration item.</typeparam>
/// <param name="name">Name of the resource.</param>
/// <param name="configurationSerializerRepresentation">Optional; configuration serializer representation; DEFAULT is JSON.</param>
/// <param name="configurationSerializerFactory">Optional; configuration serializer factory; DEFAULT is JSON.</param>
/// <returns>T.</returns>
public static T GetByName <T>(
string name,
SerializerRepresentation configurationSerializerRepresentation = null,
ISerializerFactory configurationSerializerFactory = null)
{
return((T)ResolvedByNameSettings.GetOrAdd(
name,
t =>
new For <T>(
configurationSerializerRepresentation ?? serializerRepresentation,
configurationSerializerFactory ?? serializerFactory,
name).Value));
}
/// <summary>
/// Initializes a new instance of the <see cref="GetOrAddIdentifiedSerializerRepresentationOp"/> class.
/// </summary>
/// <param name="specifiedResourceLocator">The stream locator to inspect.</param>
/// <param name="serializerRepresentation">The serializer representation.</param>
/// <param name="serializationFormat">The serialization format.</param>
public GetOrAddIdentifiedSerializerRepresentationOp(
IResourceLocator specifiedResourceLocator,
SerializerRepresentation serializerRepresentation,
SerializationFormat serializationFormat)
{
specifiedResourceLocator.MustForArg(nameof(specifiedResourceLocator)).NotBeNull();
serializerRepresentation.MustForArg(nameof(serializerRepresentation)).NotBeNull();
serializationFormat.MustForArg(nameof(serializationFormat)).NotBeEqualTo(SerializationFormat.Invalid);
this.SpecifiedResourceLocator = specifiedResourceLocator;
this.SerializerRepresentation = serializerRepresentation;
this.SerializationFormat = serializationFormat;
}
/// <inheritdoc />
public override ISerializer BuildSerializer(
SerializerRepresentation serializerRepresentation,
AssemblyMatchStrategy assemblyMatchStrategy = AssemblyMatchStrategy.AnySingleVersion)
{
if (serializerRepresentation == null)
{
throw new ArgumentNullException(nameof(serializerRepresentation));
}
ISerializer result;
if (CachedSerializerRepresentationToSerializerMap.TryGetValue(serializerRepresentation, out ConcurrentDictionary <AssemblyMatchStrategy, ISerializer> assemblyMatchStrategyToSerializerMap))
{
if (assemblyMatchStrategyToSerializerMap.TryGetValue(assemblyMatchStrategy, out result))
{
return(result);
}
}
// ReSharper disable once RedundantArgumentDefaultValue
var configurationType = serializerRepresentation.SerializationConfigType?.ResolveFromLoadedTypes(assemblyMatchStrategy, throwIfCannotResolve: true);
ISerializer serializer;
switch (serializerRepresentation.SerializationKind)
{
case SerializationKind.Bson:
serializer = new ObcBsonSerializer(configurationType?.ToBsonSerializationConfigurationType());
break;
case SerializationKind.Json:
serializer = new ObcJsonSerializer(configurationType?.ToJsonSerializationConfigurationType());
break;
case SerializationKind.PropertyBag:
serializer = new ObcPropertyBagSerializer(configurationType?.ToPropertyBagSerializationConfigurationType());
break;
default:
throw new NotSupportedException(Invariant($"{nameof(serializerRepresentation)} from enumeration {nameof(SerializationKind)} of {serializerRepresentation.SerializationKind} is not supported."));
}
result = this.WrapInCompressingSerializerIfAppropriate(serializer, serializerRepresentation.CompressionKind);
CachedSerializerRepresentationToSerializerMap.TryAdd(serializerRepresentation, new ConcurrentDictionary <AssemblyMatchStrategy, ISerializer>());
CachedSerializerRepresentationToSerializerMap[serializerRepresentation].TryAdd(assemblyMatchStrategy, result);
return(result);
}
public static DescribedSerializationBase ToDescribedSerialization <T>(
this T objectToPackageIntoDescribedSerialization,
SerializerRepresentation serializerRepresentation,
SerializationFormat serializationFormat,
VersionMatchStrategy assemblyVersionMatchStrategy = VersionMatchStrategy.AnySingleVersion)
{
var result = objectToPackageIntoDescribedSerialization.ToDescribedSerializationUsingSpecificFactory(
serializerRepresentation,
SerializerFactory.Instance,
serializationFormat,
assemblyVersionMatchStrategy);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="LogWriterConfigBase"/> class.
/// </summary>
/// <param name="logInclusionKindToOriginsMap">The log items to log.</param>
/// <param name="logItemPropertiesToIncludeInLogMessage">The properties/aspects of an <see cref="LogItem"/> to include when building a log message.</param>
/// <param name="logItemSerializerRepresentation">Optional serializer representation; DEFAULT is JSON.</param>
protected LogWriterConfigBase(
IReadOnlyDictionary <LogItemKind, IReadOnlyCollection <string> > logInclusionKindToOriginsMap,
LogItemPropertiesToIncludeInLogMessage logItemPropertiesToIncludeInLogMessage,
SerializerRepresentation logItemSerializerRepresentation = null)
{
new { logInclusionKindToOriginsMap }.AsArg().Must().NotBeNull();
this.LogInclusionKindToOriginsMap = logInclusionKindToOriginsMap;
this.LogItemPropertiesToIncludeInLogMessage = logItemPropertiesToIncludeInLogMessage;
this.LogInclusionKindToOriginsMapFriendlyString = GenerateFriendlyStringFromLogInclusionKindToOriginsMap(this.LogInclusionKindToOriginsMap);
this.LogItemSerializerRepresentation = logItemSerializerRepresentation
?? new SerializerRepresentation(
SerializationKind.Json,
typeof(LoggingJsonSerializationConfiguration).ToRepresentation());
}
/// <summary>
/// Initializes a new instance of the <see cref="For{T}"/> class.
/// </summary>
/// <param name="configurationSerializerRepresentation">The configuration serializer representation.</param>
/// <param name="configurationSerializerFactory">The configuration serializer factory.</param>
/// <param name="keyOverride">The optional specified key to use; DEFAULT is null and will build a key from the supplied <typeparamref name="T"/>.</param>
public For(SerializerRepresentation configurationSerializerRepresentation, ISerializerFactory configurationSerializerFactory, string keyOverride = null)
{
this.Key = keyOverride ?? BuildKey();
var configSetting = GetSerializedSetting(this.Key);
var serializer = configurationSerializerFactory.BuildSerializer(configurationSerializerRepresentation);
if (!string.IsNullOrWhiteSpace(configSetting))
{
this.Value = serializer.Deserialize <T>(configSetting);
}
else
{
throw new FileNotFoundException(FormattableString.Invariant($"Could not find config for: {typeof(T).AssemblyQualifiedName}."));
}
}
public static void ToDescribedSerialization___Valid___Just_passes_to_specific_factory_version_with_default_factory()
{
// Arrange
var objectToPackageIntoDescribedSerialization = A.Dummy <string>();
var serializerRepresentation = new SerializerRepresentation(SerializationKind.Json, typeof(NullJsonSerializationConfiguration).ToRepresentation(), CompressionKind.None);
// Act
var describedSerialization = objectToPackageIntoDescribedSerialization.ToDescribedSerialization(serializerRepresentation, SerializationFormat.String);
// Assert
describedSerialization.Should().NotBeNull();
describedSerialization.Should().BeOfType <StringDescribedSerialization>();
describedSerialization.PayloadTypeRepresentation.Should().Be(objectToPackageIntoDescribedSerialization.GetType().ToRepresentation());
((StringDescribedSerialization)describedSerialization).SerializedPayload.Should().Be("\"" + objectToPackageIntoDescribedSerialization + "\"");
describedSerialization.SerializerRepresentation.Should().Be(serializerRepresentation);
}
/// <inheritdoc />
public override ISerializer BuildSerializer(
SerializerRepresentation serializerRepresentation,
VersionMatchStrategy assemblyVersionMatchStrategy = VersionMatchStrategy.AnySingleVersion)
{
if (serializerRepresentation == null)
{
throw new ArgumentNullException(nameof(serializerRepresentation));
}
ISerializer result;
if (CachedSerializerRepresentationToSerializerMap.TryGetValue(serializerRepresentation, out ConcurrentDictionary <VersionMatchStrategy, ISerializer> assemblyVersionMatchStrategyToSerializerMap))
{
if (assemblyVersionMatchStrategyToSerializerMap.TryGetValue(assemblyVersionMatchStrategy, out result))
{
return(result);
}
}
ISerializer serializer;
switch (serializerRepresentation.SerializationKind)
{
case SerializationKind.Bson:
serializer = BsonSerializerFactory.BuildSerializer(serializerRepresentation, assemblyVersionMatchStrategy);
break;
case SerializationKind.Json:
serializer = JsonSerializerFactory.BuildSerializer(serializerRepresentation, assemblyVersionMatchStrategy);
break;
case SerializationKind.PropertyBag:
serializer = PropertyBagSerializerFactory.BuildSerializer(serializerRepresentation, assemblyVersionMatchStrategy);
break;
default:
throw new NotSupportedException(Invariant($"{nameof(serializerRepresentation)} from enumeration {nameof(SerializationKind)} of {serializerRepresentation.SerializationKind} is not supported."));
}
result = this.WrapInCompressingSerializerIfAppropriate(serializer, serializerRepresentation.CompressionKind);
CachedSerializerRepresentationToSerializerMap.TryAdd(serializerRepresentation, new ConcurrentDictionary <VersionMatchStrategy, ISerializer>());
CachedSerializerRepresentationToSerializerMap[serializerRepresentation].TryAdd(assemblyVersionMatchStrategy, result);
return(result);
}
private static Tuple <string, T> SerializeAndDeserialize <T>(
SerializerRepresentation serializerRepresentation,
SerializationFormat serializationFormat,
T objectToSerialize)
{
var serializer = SerializerFactory.Instance.BuildSerializer(serializerRepresentation);
var describedSerialization = objectToSerialize.ToDescribedSerializationUsingSpecificSerializer(serializer, serializationFormat);
var deserializedObject = (T)describedSerialization.DeserializePayloadUsingSpecificSerializer(serializer);
// note that we cannot return a ValueTuple (DescribedSerialization DescribedSerialization, T actual)
// here because ValueTuple is not [Serializable]
var result = new Tuple <string, T>(describedSerialization.SerializedPayload, deserializedObject);
return(result);
}
public static void FromDescribedSerializationGeneric___Valid___Just_passes_to_specific_factory_version_with_default_factory()
{
// Arrange
var expected = A.Dummy <string>();
var serializerRepresentation = new SerializerRepresentation(SerializationKind.Json, typeof(NullJsonSerializationConfiguration).ToRepresentation(), CompressionKind.None);
var payload = "\"" + expected + "\"";
var describedSerialization = new StringDescribedSerialization(
expected.GetType().ToRepresentation(),
serializerRepresentation,
payload);
// Act
var actual = describedSerialization.DeserializePayload <string>();
// Assert
actual.Should().NotBeNull();
actual.Should().Be(expected);
}
public static void BuildSerializer___Json___Gets_Json_serializer()
{
// Arrange
var serializerRepresentation = new SerializerRepresentation(
SerializationKind.Json,
null,
CompressionKind.None);
// Act
var serializer = SerializerFactory.Instance.BuildSerializer(serializerRepresentation);
var jsonSerializer = new JsonSerializerFactory(CompressorFactory.Instance).BuildSerializer(serializerRepresentation);
// Assert
serializer.Should().NotBeNull();
serializer.Should().BeOfType <ObcJsonSerializer>();
jsonSerializer.Should().NotBeNull();
jsonSerializer.Should().BeOfType <ObcJsonSerializer>();
}
public static void ToDescribedSerializationWithSpecificSerializer___Valid_object_and_serializer___Works()
{
// Arrange
string objectToPackageIntoDescribedSerialization = null;
var serializerRepresentation = new SerializerRepresentation(SerializationKind.Json, typeof(NullJsonSerializationConfiguration).ToRepresentation(), CompressionKind.None);
// Act
var describedSerialization = objectToPackageIntoDescribedSerialization.ToDescribedSerializationUsingSpecificFactory(
serializerRepresentation,
SerializerFactory.Instance,
SerializationFormat.String);
// Assert
describedSerialization.Should().NotBeNull();
describedSerialization.Should().BeOfType <StringDescribedSerialization>();
describedSerialization.PayloadTypeRepresentation.Should().Be(typeof(string).ToRepresentation());
((StringDescribedSerialization)describedSerialization).SerializedPayload.Should().Be("null");
describedSerialization.SerializerRepresentation.Should().Be(serializerRepresentation);
}
public static void FromDescribedSerializationWithSpecificFactory___Null_object___Works()
{
// Arrange
string expected = null;
var serializerRepresentation = new SerializerRepresentation(SerializationKind.Json, typeof(NullJsonSerializationConfiguration).ToRepresentation(), CompressionKind.None);
var payload = "null";
var describedSerialization = new StringDescribedSerialization(
typeof(string).ToRepresentation(),
serializerRepresentation,
payload);
// Act
var actual = DomainExtensions.DeserializePayloadUsingSpecificFactory(
describedSerialization,
SerializerFactory.Instance);
// Assert
actual.Should().Be(expected);
}
private static void RunVerification <T>(
SerializerRepresentation serializerRepresentation,
SerializationFormat serializationFormat,
RoundtripSerializationVerification <T> verificationCallback,
AppDomainScenarios appDomainScenario,
string serializedPayload,
T deserializedObject)
{
new { verificationCallback }.AsArg().Must().NotBeNull();
try
{
verificationCallback(serializedPayload, serializationFormat, deserializedObject);
}
catch (Exception ex)
{
throw new InvalidOperationException(Invariant($"Failed to roundtrip specified object to/from {serializerRepresentation.SerializationKind} {serializationFormat} using {serializerRepresentation.SerializationConfigType.ResolveFromLoadedTypes().ToStringReadable()} with the App Domain Scenario '{appDomainScenario}'. Serialized payload is: {serializedPayload}. Deserialized object is: {deserializedObject}."), ex);
}
}
/// <summary>
/// Resets settings to the default behavior.
/// </summary>
/// <param name="rootDirectoryOverride">Optional root directory to look in override; DEFAULT is (AppDomain.CurrentDomain.BaseDirectory).</param>
/// <param name="configDirectoryNameOverride">Optional config directory override; DEFAULT is ".config".</param>
public static void Reset(string rootDirectoryOverride = null, string configDirectoryNameOverride = DefaultConfigDirectoryName)
{
lock (SyncUpdateSettings)
{
var baseDirectory = rootDirectoryOverride ?? AppDomain.CurrentDomain.BaseDirectory;
var directoryName = configDirectoryNameOverride ?? DefaultConfigDirectoryName;
ResolvedSettings.Clear();
ResolvedByNameSettings.Clear();
SettingsDirectory = Path.Combine(baseDirectory, directoryName);
GetSerializedSetting = GetSerializedSettingDefault;
sources = DefaultSources.Value;
precedence = new Lazy <string[]>(DefaultPrecedence);
serializerRepresentation = new SerializerRepresentation(
SerializationKind.Json,
typeof(AttemptOnUnregisteredTypeJsonSerializationConfiguration <NullJsonSerializationConfiguration>).ToRepresentation());
serializerFactory = new JsonSerializerFactory();
}
}
public static void FromDescribedSerializationWithSpecificFactory___All_valid___Works()
{
// Arrange
var expected = A.Dummy <string>();
var serializerRepresentation = new SerializerRepresentation(SerializationKind.Json, typeof(NullJsonSerializationConfiguration).ToRepresentation(), CompressionKind.None);
var payload = "\"" + expected + "\"";
var describedSerialization = new StringDescribedSerialization(
expected.GetType().ToRepresentation(),
serializerRepresentation,
payload);
// Act
var actual = DomainExtensions.DeserializePayloadUsingSpecificFactory(
describedSerialization,
SerializerFactory.Instance);
// Assert
actual.Should().NotBeNull();
actual.Should().Be(expected);
}
public static void ToDescribedSerializationWithSpecificFactory___All_valid___Works()
{
// Arrange
var objectToPackageIntoDescribedSerialization = A.Dummy <string>();
var serializerRepresentation = new SerializerRepresentation(SerializationKind.Json, typeof(NullJsonSerializationConfiguration).ToRepresentation(), CompressionKind.None);
// Act
var describedSerialization = DomainExtensions.ToDescribedSerializationUsingSpecificFactory(
objectToPackageIntoDescribedSerialization,
serializerRepresentation,
SerializerFactory.Instance,
SerializationFormat.String);
// Assert
describedSerialization.Should().NotBeNull();
describedSerialization.Should().BeOfType <StringDescribedSerialization>();
describedSerialization.PayloadTypeRepresentation.Should().Be(objectToPackageIntoDescribedSerialization.GetType().ToRepresentation());
((StringDescribedSerialization)describedSerialization).SerializedPayload.Should().Be("\"" + objectToPackageIntoDescribedSerialization + "\"");
describedSerialization.SerializerRepresentation.Should().Be(serializerRepresentation);
}
