public void CreateSingleCrossReferenceFieldMappingTest()
        {
            // Arrange.
            const string ProcessName = "TestProcess";
            var fieldName = ReflectionHelper.GetPropertyName<TestEditable>(x => x.CR);
            const string ReferencedProcessName = "CRProcess";

            var keyMapping = new FieldMappingDefinition
                                 {
                                     FieldName = ReflectionHelper.GetPropertyName<ReferenceEdit>(x => x.Field1),
                                     ValueExpression = context => null,
                                     IsKey = true,
                                 };
            var fieldMapping = new FieldMappingDefinition { FieldName = fieldName, ValueExpression = context => null, IsKey = true, Subfields = { keyMapping } };
            var dtm = new Mock<IDynamicTypeManager>();
            dtm.Setup(x => x.GetEditableRootType(ProcessName)).Returns(typeof(TestEditable));
            dtm.Setup(x => x.GetEditableRootType(ReferencedProcessName)).Returns(typeof(ReferenceEdit));

            var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
            var runtimeDatabase = Mock.Create<IRuntimeDatabase>(Behavior.Loose);
            var factory = new ProcessFieldMappingFactory { DynamicTypeManager = dtm.Object, TypeConverter = typeConverter, RuntimeDatabase = runtimeDatabase };

            // Act.
            var mapping = factory.CreateMapping(ProcessName, fieldMapping);

            // Assert.
            Assert.IsTrue(mapping is SingleCrossReferenceFieldMapping);
       }
        public void CreateSimpleFieldMappingTest()
        {
            // Arrange.
            const string ProcessName = "TestProcess";
            var fieldName = ReflectionHelper.GetPropertyName<TestEditable>(x => x.Text);
            var fieldMapping = new FieldMappingDefinition { FieldName = fieldName, IsKey = true, ValueExpression = context => null };

            var dtm = new Mock<IDynamicTypeManager>();
            dtm.Setup(x => x.GetEditableRootType(ProcessName)).Returns(typeof(TestEditable));

            var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
            var factory = new ProcessFieldMappingFactory { DynamicTypeManager = dtm.Object, TypeConverter = typeConverter };

            // Act.
            var mapping = factory.CreateMapping(ProcessName, fieldMapping);

            // Assert.
            Assert.IsTrue(mapping is SimpleFieldMapping);
        }
        public void CreateSampleFieldMappingTest()
        {
            // Arrange.
            const string ProcessName = "TestProcess";
            var fieldName = ReflectionHelper.GetPropertyName<TestEditable>(x => x.Sample);

            var valueMapping = new FieldMappingDefinition
                                   {
                                       FieldName = ReflectionHelper.GetPropertyName<ISampleEdit>(s => s.SampleNumeric),
                                       ValueExpression = context => null
                                   };

            var fieldMapping = new FieldMappingDefinition { FieldName = fieldName, ValueExpression = context => null, Subfields = { valueMapping } };

            var dtm = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
            Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(TestEditable));

            var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
            var runtimeDatabase = Mock.Create<IRuntimeDatabase>(Behavior.Loose);
            var factory = new ProcessFieldMappingFactory { DynamicTypeManager = dtm, TypeConverter = typeConverter, RuntimeDatabase = runtimeDatabase };

            // Act.
            var mapping = factory.CreateMapping(ProcessName, fieldMapping);

            // Assert.
            Assert.IsTrue(mapping is SampleFieldMapping);
        }
        public void CreateFileFieldMappingTest()
        {
            // Arrange.
            const string ProcessName = "TestProcess";

            var nameMapping = new FieldMappingDefinition
                                  {
                                      FieldName = Constants.ExpressionDesignerFileNameFieldName,
                                      ValueExpression = context => null,
                                      IsKey = false
                                  };
            var contentMapping = new FieldMappingDefinition
                                     {
                                         FieldName = Constants.ExpressionDesignerFileContentFieldName,
                                         ValueExpression = context => null,
                                         IsKey = false
                                     };
            var locationMapping = new FieldMappingDefinition
                                      {
                                          FieldName = Constants.ExpressionDesignerFileLocationFieldName,
                                          ValueExpression = context => null,
                                          IsKey = false
                                      };

            var fileMapping = new FieldMappingDefinition
                                  {
                                      FieldName = ReflectionHelper.GetPropertyName<TestEditable>(x => x.File),
                                      ValueExpression = null,
                                      IsKey = false,
                                      Subfields = { nameMapping, contentMapping, locationMapping }
                                  };

            var dtm = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
            Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(TestEditable));

            var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
            var fileManager = Mock.Create<IFileManager>(Behavior.Loose);
            var factory = new ProcessFieldMappingFactory { DynamicTypeManager = dtm, TypeConverter = typeConverter, FileManager = fileManager };

            // Act.
            var mapping = factory.CreateMapping(ProcessName, fileMapping);

            // Assert.
            Assert.IsTrue(mapping is FileFieldMapping);
        }