public void PropertySettersNullTest()
        {
            AtomWorkspaceMetadata workspace = new AtomWorkspaceMetadata()
            {
                Title = null,
            };

            this.Assert.IsNull(workspace.Title, "Expected null value for property 'Title'.");
        }
        public void PropertyGettersAndSettersTest()
        {
            AtomTextConstruct title = new AtomTextConstruct();

            AtomWorkspaceMetadata workspace = new AtomWorkspaceMetadata()
            {
                Title = title,
            };

            this.Assert.AreSame(title, workspace.Title, "Expected reference equal values for property 'Title'.");
        }
            /// <summary>
            /// Visits a serviceDocument item.
            /// </summary>
            /// <param name="serviceDocument">The serviceDocument item to visit.</param>
            /// <returns>An ODataPayloadElement representing a service document enclosing the serviceDocument.</returns>
            protected override ODataPayloadElement VisitWorkspace(ODataServiceDocument serviceDocument)
            {
                ExceptionUtilities.CheckArgumentNotNull(serviceDocument, "serviceDocument");

                ServiceDocumentInstance wrappingServiceDocumentInstance = (ServiceDocumentInstance)base.VisitWorkspace(serviceDocument);

                WorkspaceInstance     workspaceInstance = wrappingServiceDocumentInstance.Workspaces.Single();
                AtomWorkspaceMetadata atomMetadata      = serviceDocument.GetAnnotation <AtomWorkspaceMetadata>();

                if (atomMetadata != null)
                {
                    if (atomMetadata.Title != null)
                    {
                        workspaceInstance.Title = atomMetadata.Title.Text;
                        workspaceInstance.AtomTitle(atomMetadata.Title.Text, ToString(atomMetadata.Title.Kind));
                    }
                }

                return(wrappingServiceDocumentInstance);
            }
        /// <summary>
        /// Writes the ATOM metadata for a single workspace element.
        /// </summary>
        /// <param name="writer">The <see cref="XmlWriter"/> to write to.</param>
        /// <param name="workspace">The workspace element to get the metadata for and write it.</param>
        internal static void WriteWorkspaceMetadata(XmlWriter writer, ODataWorkspace workspace)
        {
            DebugUtils.CheckNoExternalCallers();
            Debug.Assert(writer != null, "writer != null");
            Debug.Assert(workspace != null, "workspace != null");

            AtomWorkspaceMetadata metadata = workspace.Atom();
            string title = null;

            if (metadata != null)
            {
                title = metadata.Title;
            }

            if (title == null)
            {
                title = AtomConstants.AtomWorkspaceDefaultTitle;
            }

            // <atom:title>title</atom:title>
            ODataAtomWriterUtils.WriteElementWithTextContent(writer, AtomConstants.NonEmptyAtomNamespacePrefix, AtomConstants.AtomTitleElementName, AtomConstants.AtomNamespace, title);
        }
 /// <summary>
 /// Visits an ATOM serviceDocument metadata.
 /// </summary>
 /// <param name="atomWorkspaceMetadata">The serviceDocument metadata to visit.</param>
 protected virtual void VisitAtomWorkspaceMetadata(AtomWorkspaceMetadata atomWorkspaceMetadata)
 {
     this.VisitAtomMetadata(atomWorkspaceMetadata.Title);
 }
        /// <summary>
        /// Visits an ATOM metadata object.
        /// </summary>
        /// <param name="atomMetadata"></param>
        protected virtual void VisitAtomMetadata(object atomMetadata)
        {
            if (atomMetadata == null)
            {
                return;
            }

            AtomCategoryMetadata atomCategoryMetadata = atomMetadata as AtomCategoryMetadata;

            if (atomCategoryMetadata != null)
            {
                this.VisitAtomCategoryMetadata(atomCategoryMetadata);
                return;
            }

            AtomEntryMetadata atomEntryMetadata = atomMetadata as AtomEntryMetadata;

            if (atomEntryMetadata != null)
            {
                this.VisitAtomEntryMetadata(atomEntryMetadata);
                return;
            }

            AtomFeedMetadata atomFeedMetadata = atomMetadata as AtomFeedMetadata;

            if (atomFeedMetadata != null)
            {
                this.VisitAtomFeedMetadata(atomFeedMetadata);
                return;
            }

            AtomGeneratorMetadata atomGeneratorMetadata = atomMetadata as AtomGeneratorMetadata;

            if (atomGeneratorMetadata != null)
            {
                this.VisitAtomGeneratorMetadata(atomGeneratorMetadata);
                return;
            }

            AtomLinkMetadata atomLinkMetadata = atomMetadata as AtomLinkMetadata;

            if (atomLinkMetadata != null)
            {
                this.VisitAtomLinkMetadata(atomLinkMetadata);
                return;
            }

            AtomPersonMetadata atomPersonMetadata = atomMetadata as AtomPersonMetadata;

            if (atomPersonMetadata != null)
            {
                this.VisitAtomPersonMetadata(atomPersonMetadata);
                return;
            }

            AtomResourceCollectionMetadata atomResourceCollectionMetadata = atomMetadata as AtomResourceCollectionMetadata;

            if (atomResourceCollectionMetadata != null)
            {
                this.VisitAtomResourceCollectionMetadata(atomResourceCollectionMetadata);
                return;
            }

            AtomStreamReferenceMetadata atomStreamReferenceMetadata = atomMetadata as AtomStreamReferenceMetadata;

            if (atomStreamReferenceMetadata != null)
            {
                this.VisitAtomStreamReferenceMetadata(atomStreamReferenceMetadata);
                return;
            }

            AtomTextConstruct atomTextConstruct = atomMetadata as AtomTextConstruct;

            if (atomTextConstruct != null)
            {
                this.VisitAtomTextConstruct(atomTextConstruct);
                return;
            }

            AtomWorkspaceMetadata atomWorkspaceMetadata = atomMetadata as AtomWorkspaceMetadata;

            if (atomWorkspaceMetadata != null)
            {
                this.VisitAtomWorkspaceMetadata(atomWorkspaceMetadata);
                return;
            }

            AtomCategoriesMetadata atomCategoriesMetadata = atomMetadata as AtomCategoriesMetadata;

            if (atomCategoriesMetadata != null)
            {
                this.VisitAtomCategoriesMetadata(atomCategoriesMetadata);
                return;
            }

            ExceptionUtilities.Assert(false, "Unrecognized ATOM metadata object {0} of type {1}.", atomMetadata.ToString(), atomMetadata.GetType().ToString());
        }
        private static ODataServiceDocument CreateWorkspace(bool createMetadataFirst, string workspaceName = null, IEnumerable <CollectionInfo> incomingCollections = null, IEnumerable <SingletonInfo> incomingSingletons = null)
        {
            ODataServiceDocument serviceDocument = ObjectModelUtils.CreateDefaultWorkspace();

            if (createMetadataFirst)
            {
                serviceDocument.SetAnnotation(new AtomWorkspaceMetadata());
            }

            if (workspaceName != null)
            {
                AtomWorkspaceMetadata metadata = serviceDocument.Atom();
                metadata.Title = new AtomTextConstruct {
                    Text = workspaceName
                };
            }

            if (incomingCollections != null)
            {
                var collections = new List <ODataEntitySetInfo>();
                foreach (var collectionInfo in incomingCollections)
                {
                    var collection = new ODataEntitySetInfo()
                    {
                        Url = new Uri(collectionInfo.Url, UriKind.RelativeOrAbsolute), Name = collectionInfo.Name, Title = collectionInfo.TitleAnnotation
                    };
                    if (createMetadataFirst)
                    {
                        collection.SetAnnotation(new AtomResourceCollectionMetadata());
                    }

                    if (collectionInfo.TitleAnnotation != null)
                    {
                        AtomResourceCollectionMetadata metadata = collection.Atom();
                        metadata.Title = new AtomTextConstruct {
                            Text = collectionInfo.TitleAnnotation
                        };
                    }

                    collections.Add(collection);
                }

                serviceDocument.EntitySets = collections;
            }

            if (incomingSingletons != null)
            {
                var singletons = new List <ODataSingletonInfo>();
                foreach (var singletonInfo in incomingSingletons)
                {
                    var singleton = new ODataSingletonInfo()
                    {
                        Url = new Uri(singletonInfo.Url, UriKind.RelativeOrAbsolute), Name = singletonInfo.Name, Title = singletonInfo.TitleAnnotation
                    };
                    if (createMetadataFirst)
                    {
                        singleton.SetAnnotation(new AtomResourceCollectionMetadata());
                    }

                    singletons.Add(singleton);
                }

                serviceDocument.Singletons = singletons;
            }

            return(serviceDocument);
        }
        public void DefaultValuesTest()
        {
            AtomWorkspaceMetadata workspace = new AtomWorkspaceMetadata();

            this.Assert.IsNull(workspace.Title, "Expected null default value for property 'Title'.");
        }