internal void MetadataOracleNetTypeDefinition_Properties_WithMap(ServForOracleCache cache, MetadataOracleTypeDefinition baseMetadataDefinition, bool fuzzyNameMatch)
{
var props = baseMetadataDefinition.Properties.ToArray();
var type = typeof(SimpleClass);
var presetProperties = new UdtPropertyNetPropertyMap[]
{
new UdtPropertyNetPropertyMap(nameof(SimpleClass.Prop1), props[0].Name),
new UdtPropertyNetPropertyMap(nameof(SimpleClass.Prop2), props[1].Name),
new UdtPropertyNetPropertyMap(nameof(SimpleClass.Prop3), props[2].Name)
};
var typedef = new MetadataOracleNetTypeDefinition(cache, type, baseMetadataDefinition, presetProperties, fuzzyNameMatch);
Assert.NotNull(typedef);
Assert.Same(baseMetadataDefinition.UDTInfo, typedef.UDTInfo);
Assert.NotNull(typedef.Properties);
Assert.NotEmpty(typedef.Properties);
Assert.Equal(baseMetadataDefinition.Properties.Count(), typedef.Properties.Count());
Assert.All(typedef.Properties, c => Assert.Contains(baseMetadataDefinition.Properties, d => d.Name == c.Name && d.Order == c.Order));
Assert.Collection(typedef.Properties,
c => Assert.Equal(type.GetProperty(nameof(SimpleClass.Prop1)), c.NETProperty),
c => Assert.Equal(type.GetProperty(nameof(SimpleClass.Prop2)), c.NETProperty),
c => Assert.Equal(type.GetProperty(nameof(SimpleClass.Prop3)), c.NETProperty)
);
}
internal void MetadataOracleObject_Constructor_Collection(ServForOracleCache cache, MetadataOracleTypeDefinition metadataOracleType, UdtPropertyNetPropertyMap[] customProperties, bool fuzzyNameMatch)
{
var typedef = new MetadataOracleNetTypeDefinition(cache, typeof(TestClass[]).GetCollectionUnderType(), metadataOracleType, customProperties, fuzzyNameMatch);
var metadata = new MetadataOracleObject <TestClass[]>(typedef, new MetadataOracleCommon());
Assert.NotNull(metadata);
Assert.NotNull(metadata.OracleTypeNetMetadata);
Assert.NotNull(metadata.OracleTypeNetMetadata.Properties);
CompareOracleTypeNetMetadata(metadataOracleType.Properties.ToArray(), metadata.OracleTypeNetMetadata.Properties.ToArray());
Assert.Equal(metadataOracleType.UDTInfo, metadata.OracleTypeNetMetadata.UDTInfo);
}
public MetadataBuilder(DbConnection connection, ServForOracleCache cache, ILogger logger)
{
if (connection is null || string.IsNullOrWhiteSpace(connection.ConnectionString))
{
throw new ArgumentNullException(nameof(connection));
}
Cache = cache ?? throw new ArgumentNullException(nameof(cache));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
OracleConnection = connection;
}
internal void GetMetadata_ExistsInCache(MetadataBase metadata, string name, Mock <IMemoryCache> memoryCache)
{
object validParameter = metadata;
memoryCache.Setup(m => m.TryGetValue($"metadata-{name}", out validParameter)).Returns(true);
var cache = new ServForOracleCache(memoryCache.Object);
var actual = cache.GetMetadata(name);
Assert.Equal(metadata, actual);
}
internal void MetadataOracleNetTypeDefinition_NoTypeProperties(ServForOracleCache cache, MetadataOracleTypeDefinition baseMetadataDefinition, UdtPropertyNetPropertyMap[] presetProperties, bool fuzzyNameMatch)
{
var typedef = new MetadataOracleNetTypeDefinition(cache, typeof(TestClass), baseMetadataDefinition, presetProperties, fuzzyNameMatch);
Assert.NotNull(typedef);
Assert.Same(baseMetadataDefinition.UDTInfo, typedef.UDTInfo);
Assert.NotNull(typedef.Properties);
Assert.NotEmpty(typedef.Properties);
Assert.Equal(baseMetadataDefinition.Properties.Count(), typedef.Properties.Count());
Assert.All(typedef.Properties, c => Assert.Contains(baseMetadataDefinition.Properties, d => d.Name == c.Name));
Assert.All(typedef.Properties, c => Assert.Null(c.NETProperty));
}
internal void SaveMetadata_CreatesEntryInCache(Mock <IMemoryCache> memoryCache, Mock <ICacheEntry> entry, string name, MetadataBase metadata)
{
var cache = new ServForOracleCache(memoryCache.Object);
memoryCache.Setup(m => m.CreateEntry($"metadata-{name}")).Returns(entry.Object);
entry.SetupSet((e) => e.Value = metadata).Verifiable();
cache.SaveMetadata(name, metadata);
entry.Verify();
}
public MetadataOracleNetTypeDefinition(ServForOracleCache cache, Type type, MetadataOracleTypeDefinition baseMetadataDefinition, UdtPropertyNetPropertyMap[] presetProperties, bool fuzzyNameMatch)
{
if (baseMetadataDefinition == null)
{
throw new ArgumentNullException(nameof(baseMetadataDefinition));
}
Cache = cache;
UDTInfo = baseMetadataDefinition.UDTInfo;
Properties = ProcessPresetNetTypePropertiesMap(type, baseMetadataDefinition, presetProperties, fuzzyNameMatch);
}
internal void GetMetadata_DoesNoExistsInCache_ReturnsDefault(string name, Mock <IMemoryCache> memoryCache)
{
object validParameter = null;
MetadataBase metadata = default;
memoryCache.Setup(m => m.TryGetValue($"metadata-{name}", out validParameter)).Returns(false);
var cache = new ServForOracleCache(memoryCache.Object);
var actual = cache.GetMetadata(name);
Assert.Equal(metadata, actual);
}
internal void GetTypeDefinition_ExistsInCache(Mock <IMemoryCache> memoryCache, MetadataOracleTypeDefinition definition)
{
object validParameter = definition;
memoryCache.Setup(m => m.TryGetValue($"def-{definition.UDTInfo.FullObjectName}", out validParameter)).Returns(true);
var cache = new ServForOracleCache(memoryCache.Object);
var actual = cache.GetTypeDefinition(definition.UDTInfo.FullObjectName);
Console.WriteLine("calls: " + memoryCache.Invocations);
Assert.Equal(definition, actual);
}
internal void GetTypeDefinition_DoesNotExistsInCache_ReturnsDefault(Mock <IMemoryCache> memoryCache, string name)
{
object validParameter = null;
MetadataOracleTypeDefinition definition = default;
memoryCache.Setup(m => m.TryGetValue($"def-{name}", out validParameter)).Returns(false);
var cache = new ServForOracleCache(memoryCache.Object);
var actual = cache.GetTypeDefinition(name);
Assert.Equal(definition, actual);
}
internal void CreateSaveUdtInfo_CreatesEntryInCache(Mock <IMemoryCache> memoryCache, Mock <ICacheEntry> entry, string name, OracleUdtInfo info, UdtPropertyNetPropertyMap[] props, bool fuzzyNameMatch)
{
var cache = new ServForOracleCache(memoryCache.Object);
memoryCache.Setup(m => m.CreateEntry($"udt-{name}")).Returns(entry.Object);
entry.SetupSet((e) => e.Value = (info, props, fuzzyNameMatch)).Verifiable();
cache.SaveUdtInfo(name, info, props, fuzzyNameMatch);
Console.WriteLine("entry: " + entry.Invocations);
entry.Verify();
}
internal void BuildQueryConstructorString_Object_NoMatch_AllPropertiesNull(ServForOracleCache cache, MetadataOracleTypeDefinition metadataOracleType, UdtPropertyNetPropertyMap[] customProperties, bool fuzzyNameMatch, TestClass model, string name, int startNumber)
{
var typedef = new MetadataOracleNetTypeDefinition(cache, typeof(TestClass), metadataOracleType, customProperties, fuzzyNameMatch);
var metadata = new MetadataOracleObject <TestClass>(typedef, new MetadataOracleCommon());
var(constructor, lastNumber) = metadata.BuildQueryConstructorString(model, name, startNumber);
Assert.NotNull(constructor);
var expectedConstructor = $"{name} := {metadataOracleType.UDTInfo.FullObjectName}({string.Join(',', metadataOracleType.Properties.OrderBy(c => c.Order).Select(c => $"{c.Name}=>null"))});" + Environment.NewLine;
Assert.Equal(expectedConstructor, constructor);
Assert.Equal(startNumber, lastNumber);
}
internal void AddOracleUDTPresets_CreatesEntryInCache(Mock <IMemoryCache> memoryCache, Mock <ICacheEntry> entry, Mock <Type> type, string fullName, OracleUdtInfo info, UdtPropertyNetPropertyMap[] props, bool fuzzyNameMatch)
{
var cache = new ServForOracleCache(memoryCache.Object);
memoryCache.Setup(m => m.CreateEntry($"udt-{fullName}")).Returns(entry.Object);
type.Setup(t => t.FullName).Returns(fullName);
entry.SetupSet((e) => e.Value = (info, props, fuzzyNameMatch)).Verifiable();
cache.AddOracleUDTPresets(type.Object, info, props, fuzzyNameMatch);
entry.Verify();
}
internal void PresetGetValueOrDefault_IsObject_Default(Mock <IMemoryCache> memoryMock, OracleUdtInfo info, UdtPropertyNetPropertyMap[] props, bool fuzzyNameMatch)
{
var expectedValue = (info, props, fuzzyNameMatch);
object validParameter = expectedValue;
var type = typeof(TestClass);
memoryMock.Setup(m => m.TryGetValue($"udt-{type.FullName}", out validParameter)).Returns(true);
var cache = new ServForOracleCache(memoryMock.Object);
var actualValue = cache.PresetGetValueOrDefault(type);
Assert.Equal(expectedValue, actualValue);
}
internal void GetOtherUdtInfo_GetsEntryNotInCache_ReturnsDefault(Mock <IMemoryCache> memoryCache, string name)
{
var cache = new ServForOracleCache(memoryCache.Object);
(OracleUdtInfo Info, UdtPropertyNetPropertyMap[] Props, bool FuzzyMatch)expectedValue = default;
object validParameter = null;
memoryCache.Setup(m => m.TryGetValue($"udt-{name}", out validParameter))
.Returns(false);
var actualValue = cache.GetOtherUdtInfo(name);
Assert.Equal(expectedValue, actualValue);
}
internal void GetOtherUdtInfo_GetsEntryInCache(Mock <IMemoryCache> memoryCache, string name, OracleUdtInfo info, UdtPropertyNetPropertyMap[] props, bool fuzzyNameMatch)
{
var cache = new ServForOracleCache(memoryCache.Object);
var expectedValue = (info, props, fuzzyNameMatch);
object validParameter = expectedValue;
memoryCache.Setup(m => m.TryGetValue($"udt-{name}", out validParameter))
.Returns(true);
var actualValue = cache.GetOtherUdtInfo(name);
Assert.Equal(expectedValue, actualValue);
}
internal void SaveTypeDefinition_CreatesEntryInCache(Mock <IMemoryCache> memoryCache, Mock <ICacheEntry> entry, MetadataOracleTypeDefinition definition)
{
var cache = new ServForOracleCache(memoryCache.Object);
//= ServForOracleCache.Create();
memoryCache.Setup(m => m.CreateEntry($"def-{definition.UDTInfo.FullObjectName}")).Returns(entry.Object);
entry.SetupSet((e) => e.Value = definition).Verifiable();
cache.SaveTypeDefinition(definition);
entry.Verify();
}
internal void PresetGetValueOrDefault_IsCollection_Default(Mock <Type> typeMock, Mock <Type> type, Mock <IMemoryCache> memoryMock, string fullName)
{
(OracleUdtInfo Info, UdtPropertyNetPropertyMap[] Props, bool FuzzyMatch)expectedValue = default;
object validParameter = null;
typeMock.SetReturnsDefault(true);
typeMock.Setup(t => t.GetGenericArguments()).Returns(new[] { type.Object });
type.Setup(t => t.FullName).Returns(fullName);
memoryMock.Setup(m => m.TryGetValue($"udt-{fullName}", out validParameter)).Returns(true);
var cache = new ServForOracleCache(memoryMock.Object);
var actualValue = cache.PresetGetValueOrDefault(typeMock.Object);
Assert.Equal(expectedValue, actualValue);
}
internal void GetUdtInfoFromAttributeOrPresetCache_FromAttribute_IsCollection(IMemoryCache memory, Mock <Type> colTypeMock, string schema, string objectName, string collectionSchema, string collectionName)
{
colTypeMock.SetReturnsDefault(true);
var type = udtInfoAttributeTests.GetTypeWithAttribute(schema, objectName, collectionSchema, collectionName);
colTypeMock.Setup(t => t.GetGenericArguments()).Returns(new[] { type });
var cache = new ServForOracleCache(memory);
var udtInfo = cache.GetUdtInfoFromAttributeOrPresetCache(colTypeMock.Object);
Assert.NotNull(udtInfo);
Assert.Equal(schema, udtInfo.ObjectSchema, ignoreCase: true);
Assert.Equal(objectName, udtInfo.ObjectName, ignoreCase: true);
Assert.Equal(collectionSchema, udtInfo.CollectionSchema, ignoreCase: true);
Assert.Equal(collectionName, udtInfo.CollectionName, ignoreCase: true);
}
public MetadataBuilderFactory(ServForOracleCache cache, ILogger logger)
{
_cache = cache ?? throw new ArgumentNullException(nameof(cache));
_logger = logger;
}
internal void Constructor_Internal_ThreeParameters_DbFactory(ILogger <ServiceForOracle> logger, ServForOracleCache cache, IDbConnectionFactory factory)
{
var service = new ServiceForOracle(logger, cache, factory);
Assert.NotNull(service);
}
internal ConfigurePresetMappings(ILogger <ConfigurePresetMappings> logger, ServForOracleCache cache)
{
_logger = logger;
_cache = cache;
}
internal void MetadataOracleNetTypeDefinition_Properties_WithMap_WithAttribute(ServForOracleCache cache, MetadataOracleTypeDefinition baseMetadataDefinition, bool fuzzyNameMatch)
{
var props = baseMetadataDefinition.Properties.ToArray();
var type = typeof(ClassWithAttribute);
props[0].Name = "Test";
var presetProperties = new UdtPropertyNetPropertyMap[]
{
new UdtPropertyNetPropertyMap(nameof(ClassWithAttribute.Prop1), props[0].Name)
};
var typedef = new MetadataOracleNetTypeDefinition(cache, type, baseMetadataDefinition, presetProperties, fuzzyNameMatch);
Assert.NotNull(typedef);
Assert.Same(baseMetadataDefinition.UDTInfo, typedef.UDTInfo);
Assert.NotNull(typedef.Properties);
Assert.NotEmpty(typedef.Properties);
Assert.Equal(baseMetadataDefinition.Properties.Count(), typedef.Properties.Count());
Assert.Collection(typedef.Properties,
c =>
{
Assert.Equal(type.GetProperty(nameof(ClassWithAttribute.Prop1)), c.NETProperty);
Assert.Equal("Test", c.Name, ignoreCase: true);
Assert.Equal(props[0].Order, c.Order);
Assert.Null(c.PropertyMetadata);
},
c =>
{
Assert.Equal(props[1].Name, c.Name, ignoreCase: true);
Assert.Equal(props[1].Order, c.Order);
Assert.Null(c.NETProperty);
Assert.Null(c.PropertyMetadata);
},
c =>
{
Assert.Equal(props[2].Name, c.Name, ignoreCase: true);
Assert.Equal(props[2].Order, c.Order);
Assert.Null(c.NETProperty);
Assert.Null(c.PropertyMetadata);
}
);
}
internal void MetadataOracleNetTypeDefinition_NullBase_ThrowsArgumentNull(ServForOracleCache cache, Type type, UdtPropertyNetPropertyMap[] presetProperties, bool fuzzyNameMatch)
{
Assert.Throws <ArgumentNullException>("baseMetadataDefinition", () => new MetadataOracleNetTypeDefinition(cache, type, null, presetProperties, fuzzyNameMatch));
}
internal void Constructor_ReturnsMetadataBuilder(Mock <DbConnection> connection, string connectionString, ServForOracleCache cache, ILogger logger)
{
connection.SetupGet(c => c.ConnectionString).Returns(connectionString);
var factory = new MetadataBuilderFactory(cache, logger);
var builder = factory.CreateBuilder(connection.Object);
Assert.NotNull(builder);
Assert.Equal(connection.Object, builder.OracleConnection);
}
internal void MetadataOracleNetTypeDefinition_Properties_WithMap_WithMetadata(ServForOracleCache cache, MetadataOracleTypeDefinition baseMetadataDefinition, bool fuzzyNameMatch, MetadataOracleTypeSubTypeDefinition subTypeDef,
MetadataOracleTypeSubTypeDefinition colSubTypeDef)
{
var props = baseMetadataDefinition.Properties.ToArray();
var type = typeof(SimpleClass);
var presetProperties = new UdtPropertyNetPropertyMap[]
{
new UdtPropertyNetPropertyMap(nameof(SimpleClass.Prop1), subTypeDef.Name),
new UdtPropertyNetPropertyMap(nameof(SimpleClass.Prop2), props[1].Name),
new UdtPropertyNetPropertyMap(nameof(SimpleClass.Prop3), props[2].Name),
new UdtPropertyNetPropertyMap(nameof(SimpleClass.Prop4), colSubTypeDef.Name)
};
baseMetadataDefinition.Properties = new MetadataOracleTypePropertyDefinition[]
{
subTypeDef,
props[1],
props[2],
colSubTypeDef
};
var typedef = new MetadataOracleNetTypeDefinition(cache, type, baseMetadataDefinition, presetProperties, fuzzyNameMatch);
Assert.NotNull(typedef);
Assert.Same(baseMetadataDefinition.UDTInfo, typedef.UDTInfo);
Assert.NotNull(typedef.Properties);
Assert.NotEmpty(typedef.Properties);
Assert.Equal(4, typedef.Properties.Count());
Assert.Collection(typedef.Properties,
c =>
{
Assert.Equal(subTypeDef.Name, c.Name, ignoreCase: true);
Assert.Equal(subTypeDef.Order, c.Order);
Assert.NotNull(c.PropertyMetadata);
Assert.NotNull(c.PropertyMetadata.Properties);
Assert.NotEmpty(c.PropertyMetadata.Properties);
Assert.All(c.PropertyMetadata.Properties, d => Assert.Contains(subTypeDef.MetadataOracleType.Properties, e => e.Name == d.Name && e.Order == d.Order));
},
c =>
{
Assert.Equal(props[1].Name, c.Name, ignoreCase: true);
Assert.Equal(props[1].Order, c.Order);
},
c =>
{
Assert.Equal(props[2].Name, c.Name, ignoreCase: true);
Assert.Equal(props[2].Order, c.Order);
},
c =>
{
Assert.Equal(colSubTypeDef.Name, c.Name, ignoreCase: true);
Assert.Equal(colSubTypeDef.Order, c.Order);
Assert.NotNull(c.PropertyMetadata);
Assert.NotNull(c.PropertyMetadata.Properties);
Assert.NotEmpty(c.PropertyMetadata.Properties);
Assert.All(c.PropertyMetadata.Properties, d => Assert.Contains(colSubTypeDef.MetadataOracleType.Properties, e => e.Name == d.Name && e.Order == d.Order));
}
);
Assert.Collection(typedef.Properties,
c => Assert.Equal(type.GetProperty(nameof(SimpleClass.Prop1)), c.NETProperty),
c => Assert.Equal(type.GetProperty(nameof(SimpleClass.Prop2)), c.NETProperty),
c => Assert.Equal(type.GetProperty(nameof(SimpleClass.Prop3)), c.NETProperty),
c => Assert.Equal(type.GetProperty(nameof(SimpleClass.Prop4)), c.NETProperty)
);
}
internal ServiceForOracle(ILogger <ServiceForOracle> logger, ServForOracleCache cache, IDbConnectionFactory factory)
: this(logger, factory, new MetadataBuilderFactory(cache, logger), new OracleRefCursorWrapperFactory(), new MetadataFactory())
{
}
