Dev2.Runtime.ServiceModel.Data.PluginService.ToXml C# (CSharp) 메소드

        public override XElement ToXml()
        {
            var result = CreateXml(enActionType.Plugin, Source, Recordsets,
                new XAttribute("Namespace", Namespace ?? string.Empty)
                );
            return result;
        }

        public void PluginServiceToXmlExpectedSerializesProperties()
        {
            var expected = new PluginService
            {
                Source = new PluginSource
                {
                    ResourceID = Guid.NewGuid(),
                    ResourceName = "TestWebSource",
                },
                Namespace = "abc.pqr",
            };

            expected.Method.Parameters.AddRange(
                new[]
                {
                    new MethodParameter
                    {
                        Name = "Param1",
                        DefaultValue = "123"
                    },
                    new MethodParameter
                    {
                        Name = "Param2",
                        DefaultValue = "456"
                    }
                });

            var rs1 = new Recordset
            {
                Name = "Recordset1()"
            };
            rs1.Fields.AddRange(new[]
            {
                new RecordsetField
                {
                    Name = "Field1",
                    Alias = "Alias1"
                },
                new RecordsetField
                {
                    Name = "Field2",
                    Alias = "Alias2",
                    Path = new XmlPath("actual", "display", "outputExpression", "sampleData")
                },
                new RecordsetField
                {
                    Name = "Field3",
                    Alias = null
                }
            });
            expected.Recordsets.Add(rs1);

            var xml = expected.ToXml();

            var actual = new PluginService(xml);

            Assert.AreEqual(expected.Source.ResourceType, actual.Source.ResourceType);
            Assert.AreEqual(expected.Source.ResourceID, actual.Source.ResourceID);
            Assert.AreEqual(expected.Source.ResourceName, actual.Source.ResourceName);
            Assert.AreEqual(expected.ResourceType, actual.ResourceType);
            Assert.AreEqual(expected.Namespace, actual.Namespace);

            foreach(var expectedParameter in expected.Method.Parameters)
            {
                var actualParameter = actual.Method.Parameters.First(p => p.Name == expectedParameter.Name);
                Assert.AreEqual(expectedParameter.DefaultValue, actualParameter.DefaultValue);
            }

            foreach(var expectedRecordset in expected.Recordsets)
            {
                // expect actual to have removed recordset notation ()...
                var actualRecordset = actual.Recordsets.First(rs => rs.Name == expectedRecordset.Name.Replace("()", ""));
                foreach(var expectedField in expectedRecordset.Fields)
                {
                    var actualField = actualRecordset.Fields.FirstOrDefault(f => expectedField.Name == null ? f.Name == "" : f.Name == expectedField.Name);
                    Assert.IsNotNull(actualField);
                    Assert.AreEqual(expectedField.Alias ?? "", actualField.Alias);
                    if(actualField.Path != null)
                    {
                        Assert.AreEqual(expectedField.Path.ActualPath, actualField.Path.ActualPath);
                        Assert.AreEqual(expectedField.Path.DisplayPath, actualField.Path.DisplayPath);
                        Assert.AreEqual(string.Format("[[{0}]]", expectedField.Alias), actualField.Path.OutputExpression);
                        Assert.AreEqual(expectedField.Path.SampleData, actualField.Path.SampleData);
                    }
                }
            }
        }