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()) { }