public void A_ToEntity__It_Should_Throw_An_Exception() { var mapping = new MappingImpl(); mapping.FromTable = new Table(); new MappingSetSerialisationScheme().SerialiseMapping(mapping); }
public LambdaExpression GetExpression() { var pFrom = Parameter(_fromType, "from"); var pTo = Parameter(_toType, "to"); var pDic = Parameter(typeof(IDictionary <object, object>), "dic" + ++_data.NameCounter); if (_mapperBuilder.MappingSchema.IsScalarType(_fromType) || _mapperBuilder.MappingSchema.IsScalarType(_toType)) { return(Lambda( _mapperBuilder.MappingSchema.GetConvertExpression(_fromType, _toType).ReplaceParameters(pFrom), pFrom, pTo, pDic)); } _data.LocalDic = Parameter(typeof(IDictionary <object, object>), "ldic" + ++_data.NameCounter); _data.Locals.Add(_data.LocalDic); _data.Expressions.Add(Assign(_data.LocalDic, pDic)); var expr = new MappingImpl(this, pFrom, pTo).GetExpression(); var l = Lambda(Block(_data.Locals, _data.Expressions.Concat(expr)), pFrom, pTo, pDic); return(l); }
public void The_Presenter_Fills_In_The_Form() { var m = new MappingImpl(); m.MappingSet = MockRepository.GenerateMock <MappingSet>(); m.ToEntity = new EntityImpl("entity1"); m.FromTable = new Table("table1"); //presenter.AttachToModel(m); form.AssertWasCalled(f => f.Clear()); form.AssertWasCalled(f => f.ToEntity = m.ToEntity); form.AssertWasCalled(f => f.FromTable = m.FromTable); form.AssertWasCalled(f => f.SetVirtualProperties(m.Ex)); // Need to ignore arguments on these one as the description of the // object being set is too complex, and gets us very little in the // way of coverage. If someone screws this up, it'd be a pretty basic mistake, // and very obvious in the UI. form.AssertWasCalled(f => f.Mappings = m.Mappings, c => c.IgnoreArguments()); form.AssertWasCalled(f => f.Entities = null, c => c.IgnoreArguments()); form.AssertWasCalled(f => f.Tables = null, c => c.IgnoreArguments()); // If these methods were called, then it is very likely that they // were used to initialise the Entities and Tables collections, // unlesss someone is trying to break something on purpose. m.MappingSet.AssertWasCalled(ms => ms.GetEntitiesFromEntitySet()); m.MappingSet.AssertWasCalled(ms => ms.GetEntitiesFromDatabase()); }
public static Mapping GetMapping() { Mapping mapping = new MappingImpl(); mapping.FromTable = new Table("Table1"); mapping.FromTable.AddColumn(new Column("Column1")); mapping.ToEntity = new EntityImpl("Entity1"); mapping.ToEntity.AddProperty(new PropertyImpl("Property1")); mapping.AddPropertyAndColumn(mapping.ToEntity.Properties.ElementAt(0), mapping.FromTable.Columns[0]); return(mapping); }
public void It_Is_Deleted() { MappingSet ms = new MappingSetImpl(); Mapping m = new MappingImpl(); ms.AddMapping(m); Assert.That(ms.Mappings.Contains(m)); m.Delete(); Assert.That(ms.Mappings.Contains(m) == false); }
private static void CreateMappingForNewTableAndEntity(Entity entity, MappingSet set, ITable table) { Mapping mapping = new MappingImpl(); mapping.ToEntity = entity; mapping.FromTable = table; for (int i = 0; i < table.Columns.Count; i++) { mapping.AddPropertyAndColumn(entity.Properties.ElementAt(i), table.Columns[i]); } set.AddMapping(mapping); }
public void The_Mapping_Should_Be_Deleted() { var m = new MappingImpl(); var ms = new MappingSetImpl(); ms.AddMapping(m); Assert.That(ms.Mappings.Contains(m), Is.True); //presenter.AttachToModel(m); form.Raise(f => f.RemoveMapping += null, form, new EventArgs()); Assert.That(ms.Mappings.Contains(m), Is.False); }
public void It_Returns_The_Mapping_Objects() { ProviderInfo info = new ProviderInfo(); var mapping1 = new MappingImpl(); var mapping2 = new MappingImpl(); info.MappingSet.AddMapping(mapping1); info.MappingSet.AddMapping(mapping2); IEnumerable <IScriptBaseObject> objects = info.GetAllObjectsOfType(typeof(Mapping)); Assert.That(objects, Has.Length(2)); Assert.That(objects.Contains(mapping1), "Missing mapping1"); Assert.That(objects.Contains(mapping2), "Missing mapping2"); }
private LambdaExpression GetExpressionInner() { var pFrom = Parameter(_fromType, "from"); var pTo = Parameter(_toType, "to"); if (_mapperBuilder.MappingSchema.IsScalarType(_fromType) || _mapperBuilder.MappingSchema.IsScalarType(_toType)) { return(Lambda( _mapperBuilder.MappingSchema.GetConvertExpression(_fromType, _toType).ReplaceParameters(pFrom), pFrom, pTo)); } var expr = new MappingImpl(this, pFrom, pTo).GetExpression(); var l = Lambda(expr, pFrom, pTo); return(l); }
public LambdaExpression GetExpressionEx() { if (_mapperBuilder.MappingSchema.IsScalarType(_fromType) || _mapperBuilder.MappingSchema.IsScalarType(_toType)) { return(_mapperBuilder.MappingSchema.GetConvertExpression(_fromType, _toType)); } var pFrom = Parameter(_fromType, "from"); Expression expr; if (_mapperBuilder.MappingSchema.IsScalarType(_fromType) || _mapperBuilder.MappingSchema.IsScalarType(_toType)) { expr = GetExpressionExImpl(pFrom, _toType); } else if (_processCrossReferences) { _data.LocalDic = Parameter(typeof(IDictionary <object, object>), "ldic" + ++_data.NameCounter); _data.Locals.Add(_data.LocalDic); _data.Expressions.Add(Assign(_data.LocalDic, New(InfoOf.Constructor(() => new Dictionary <object, object>())))); expr = new MappingImpl(this, pFrom, Constant(_mapperBuilder.MappingSchema.GetDefaultValue(_toType), _toType)).GetExpression(); } else { expr = GetExpressionExImpl(pFrom, _toType); } if (_data.IsRestart) { _mapperBuilder.ProcessCrossReferences = true; return(new ExpressionBuilder(_mapperBuilder, new BuilderData(_data.MemberMappers)).GetExpressionEx()); } var l = Lambda( _data.Locals.Count > 0 || _data.Expressions.Count > 0 ? Block(_data.Locals, _data.Expressions.Concat(expr)) : expr, pFrom); return(l); }
private Expression BuildClassMapper(Expression getValue, MemberAccessor toMember) { var key = ValueTuple.Create(_fromExpression.Type, toMember.Type); var pFrom = Parameter(getValue.Type, "pFrom"); var pTo = Parameter(toMember.Type, "pTo"); var toObj = toMember.GetterExpression.ReplaceParameters(_localObject); ParameterExpression nullPrm = null; if (_cacheMapper) { if (_builder._data.Mappers.TryGetValue(key, out nullPrm)) { return(Invoke(nullPrm, getValue, toObj)); } nullPrm = Parameter( Lambda( Constant( _builder._mapperBuilder.MappingSchema.GetDefaultValue(toMember.Type), toMember.Type), pFrom, pTo).Type); _builder._data.Mappers.Add(key, nullPrm); _builder._data.Locals.Add(nullPrm); } var expr = new MappingImpl(_builder, _cacheMapper ? pFrom : getValue, _cacheMapper ? pTo : toObj).GetExpression(); if (_cacheMapper) { var lex = Lambda(expr, pFrom, pTo); _builder._data.Expressions.Add(Assign(nullPrm, lex)); expr = Invoke(nullPrm, getValue, toObj); } return(expr); }
public void The_Mapping_Mappings_Should_Be_Updated() { var m = new MappingImpl(); m.FromTable = new Table("table1"); m.ToEntity = new EntityImpl("entity1"); m.MappingSet = new MappingSetImpl(); var property = new PropertyImpl("Prop"); var column = new Column("Col"); m.FromTable.AddColumn(column); m.ToEntity.AddProperty(property); m.AddPropertyAndColumn(property, column); form.Mappings = m.Mappings; form.GetEventRaiser(f => f.FromTableChanged += null).Raise(form, new EventArgs()); var colAndProp = m.Mappings.ElementAt(0); Assert.That(colAndProp.Property, Is.SameAs(property)); Assert.That(colAndProp.Column, Is.SameAs(column)); }
public void Setup() { EntitySet entitySet = new EntitySetImpl(); entity = new EntityImpl("Entity1"); entity.AddProperty(new PropertyImpl { Name = "Property1" }); entitySet.AddEntity(entity); IDatabase database = new Database("DB1"); table = new Table("Table"); table.AddColumn(new Column("Column1")); database.AddEntity(table); Mapping mapping = new MappingImpl(); mapping.AddPropertyAndColumn(entity.Properties.ElementAt(0), table.Columns[0]); MappingSet mappingSet = new MappingSetImpl(database, entitySet); mappingSet.AddMapping(mapping); }
public void It_Does_Not_Throw_An_Exception() { Mapping m = new MappingImpl(); m.Delete(); }