Dimi.InstantRDF.BusinessLogic.ResourceFactory.GenerateNode C# (CSharp) Метод

        public Node GenerateNode(int nodeId)
        {
            var umbracoNode = _nodeRepository.GetByNodeId(nodeId);

            if (umbracoNode.Properties.Any(x => x.Name == "error"))
            {
                throw new Exception(string.Format("Tried to retrieve node {0}, which is not published.", nodeId));
            }

            var node = new Node
                           {
                               Iri = GetNodeIri(nodeId, umbracoNode.Name),
                               DocumentTypeIri = new OntologyFactory(_documentTypeRepository, _propertyTypeRepository)
                                   .GenerateDocumentType(umbracoNode.DocumentTypeId).Iri

                           };

            if (!string.IsNullOrEmpty(umbracoNode.Url))
            {
                node.Url = Configuration.Configuration.SitePreferredUrl + umbracoNode.Url;
            }

            if (umbracoNode.ParentId != -1)
            {
                node.ParentIri = GetNodeIri(umbracoNode.ParentId,
                    _nodeRepository.GetByNodeId(umbracoNode.ParentId).Name);
            }

            foreach (var childId in umbracoNode.ChildrenIds)
            {
                var childIri = GetNodeIri(childId,
                    _nodeRepository.GetByNodeId(childId).Name);
                node.ChildrenIris.Add(childIri);
            }

            foreach (var prop in umbracoNode.Properties.Where(x => !string.IsNullOrEmpty(x.Value) && !Configuration.Configuration.IgnoredProperties.Contains(x.Name)))
            {
                var nodeProperty = new Property
                                       {
                                           Value = prop.Value,
                                           PropertyType =
                                               new PropertyTypeFactory(_propertyTypeRepository).
                                               GenerateForDocumentTypeIdAlias(umbracoNode.DocumentTypeId, prop.Name)
                                       };
                node.Properties.Add(nodeProperty);
            }

            foreach (var imageUri in umbracoNode.ImageUris)
            {
                node.ImageUris.Add(imageUri);
            }

            foreach (var linkUri in umbracoNode.LinkUris)
            {
                node.LinkUris.Add(linkUri);
            }

            return node;
        }

        public void GenerateNode()
        {
            var focusedNode = new UmbracoNode
                                  {
                                      Name = "FocusedNode",
                                      ChildrenIds = new int[] { 2 },
                                      DocumentTypeId = 15,
                                      ParentId = 3
                                  };
            focusedNode.Properties.Add(new UmbracoProperty() { Name = "title", Value = "Focused node" });
            focusedNode.Properties.Add(new UmbracoProperty() { Name = "content4testing", Value = "Test content" });

            var childNode = new UmbracoNode
            {
                Name = "ChildNode"
            };

            var parentNode = new UmbracoNode
                                 {
                                     Name = "ParentNode"
                                 };

            var mockNodeRepo = new Mock<IUmbracoNodeRepository>();
            mockNodeRepo.Setup(x => x.GetByNodeId(1)).Returns(focusedNode);
            mockNodeRepo.Setup(x => x.GetByNodeId(2)).Returns(childNode);
            mockNodeRepo.Setup(x => x.GetByNodeId(3)).Returns(parentNode);

            var titleDt = new UmbracoPropertyType { DatabaseType = "nvarchar", Name = "title" };
            var contentDt = new UmbracoPropertyType { DatabaseType = "nvarchar", Name = "content" };
            var contentTestNameDt = new UmbracoPropertyType { DatabaseType = "nvarchar", Name = "content4testing" };

            var mockPropTypeRepo = new Mock<IUmbracoPropertyTypeRepository>();
            mockPropTypeRepo.Setup(x => x.GetForNativeDocumentTypePropertyAlias(15, "title"))
                .Returns(titleDt);
            mockPropTypeRepo.Setup(x => x.GetForNativeDocumentTypePropertyAlias(15, "content"))
                .Returns(contentDt);
            mockPropTypeRepo.Setup(x => x.GetForNativeDocumentTypePropertyAlias(15, "content4testing"))
               .Returns(contentTestNameDt);

            var dt15 = new UmbracoDocumentType()
            {
                AllowedContentTypeChildrenIds = new int[] { },
                InherritanceParentId = -1,
                Name = "TestDocumentType",
                PropertyTypes = new List<UmbracoPropertyType>()
                                                {
                                                    new UmbracoPropertyType()
                                                        {DatabaseType = "nvarchar", Name = "title"},
                                                    new UmbracoPropertyType()
                                                        {DatabaseType = "nvarchar", Name = "content"}
                                                }

            };

            var mockDocTypeRepo = new Mock<IUmbracoDocumentTypeRepository>();
            mockDocTypeRepo.Setup(x => x.GetById(15))
                .Returns(dt15);

            var resourceFactory = new ResourceFactory(mockNodeRepo.Object, mockPropTypeRepo.Object, mockDocTypeRepo.Object);

            var node = resourceFactory.GenerateNode(1);

            Assert.AreEqual("http://localhost/rdf/resource/FocusedNode", node.Iri);
            Assert.AreEqual("http://localhost/rdf/resource/ParentNode", node.ParentIri);
            Assert.AreEqual("http://localhost/rdf/resource/ChildNode", node.ChildrenIris.First());

            Assert.IsTrue(node.Properties.Any(x => x.PropertyType.Iri == "http://localhost/rdf/ontology#hasTitle" &&
                x.PropertyType.DatabaseType == "nvarchar" && x.Value == "Focused node"));

            Assert.IsTrue(node.Properties.Any(x => x.PropertyType.Iri == "http://localhost/rdf/ontology#hasTestedContent" &&
                x.PropertyType.DatabaseType == "nvarchar" && x.Value == "Test content"));
        }