Beispiel #1
0
        public void ParseODataUriTemplate_ForActionImport()
        {
            // Arrange
            EdmAction setSalaray = new EdmAction("NS", "SetWholeSalaryImport", IntType, isBound: false, entitySetPathExpression: null);

            setSalaray.AddParameter("minSalary", IntType);
            setSalaray.AddOptionalParameter("maxSalary", IntType);
            setSalaray.AddOptionalParameter("aveSalary", IntType, "129");
            _edmModel.AddElement(setSalaray);

            EdmEntityContainer container = _edmModel.SchemaElements.OfType <EdmEntityContainer>().First();

            container.AddActionImport(setSalaray);

            IODataPathTemplateParser parser = new DefaultODataPathTemplateParser();

            // Act
            ODataPathTemplate path = parser.Parse(_edmModel, "SetWholeSalaryImport", null);

            // Assert
            Assert.NotNull(path);
            ODataSegmentTemplate        segmentTemplate     = Assert.Single(path);
            ActionImportSegmentTemplate actionImportSegment = Assert.IsType <ActionImportSegmentTemplate>(segmentTemplate);

            Assert.Equal("SetWholeSalaryImport", actionImportSegment.Literal);
        }
        public void TryTranslateActionImportSegmentTemplate_ThrowsArgumentNull_Context()
        {
            // Arrange
            ActionImportSegmentTemplate segment = GetSegmentTemplate(out _);

            // Act & Assert
            ExceptionAssert.ThrowsArgumentNull(() => segment.TryTranslate(null), "context");
        }
        public void GetTemplatesActionImportSegmentTemplate_ReturnsTemplates()
        {
            // Arrange
            ActionImportSegmentTemplate segment = GetSegmentTemplate(out _);

            // Act & Assert
            IEnumerable <string> templates = segment.GetTemplates();
            string template = Assert.Single(templates);

            Assert.Equal("/actionImport", template);
        }
        public void CtorActionSegmentTemplate_SetsProperties()
        {
            // Arrange & Act
            ActionImportSegmentTemplate segment = GetSegmentTemplate(out IEdmActionImport actionImport);

            // Assert
            Assert.Same(actionImport, segment.ActionImport);
            Assert.NotNull(segment.Segment);
            Assert.Single(segment.Segment.OperationImports);

            // Act & Assert
            ActionImportSegmentTemplate segment1 = new ActionImportSegmentTemplate(segment.Segment);

            Assert.Same(segment.Segment, segment1.Segment);
        }
        public void CommonProperties_ReturnsAsExpected()
        {
            // Assert
            EdmEntityContainer container    = new EdmEntityContainer("NS", "default");
            EdmAction          action       = new EdmAction("NS", "action", null);
            EdmActionImport    actionImport = new EdmActionImport(container, "actionImport", action);

            ActionImportSegmentTemplate template = new ActionImportSegmentTemplate(actionImport, null);

            // Act & Assert
            Assert.Equal(ODataSegmentKind.ActionImport, template.Kind);
            Assert.Equal("actionImport", template.Literal);
            Assert.False(template.IsSingle);
            Assert.Null(template.EdmType);
            Assert.Null(template.NavigationSource);
        }
        public void TryTranslateActionImportSegmentTemplate_ReturnsODataActionImportSegment()
        {
            // Arrange
            ActionImportSegmentTemplate   template = GetSegmentTemplate(out IEdmActionImport actionImport);
            ODataTemplateTranslateContext context  = new ODataTemplateTranslateContext();

            // Act
            bool ok = template.TryTranslate(context);

            // Assert
            Assert.True(ok);
            ODataPathSegment       actual = Assert.Single(context.Segments);
            OperationImportSegment actionImportSegment = Assert.IsType <OperationImportSegment>(actual);

            Assert.Same(actionImport, actionImportSegment.OperationImports.First());
        }
        public void Translate_ReturnsODataActionImportSegment()
        {
            // Arrange
            EdmEntityContainer container    = new EdmEntityContainer("NS", "default");
            EdmAction          action       = new EdmAction("NS", "action", null);
            EdmActionImport    actionImport = new EdmActionImport(container, "name", action);

            ActionImportSegmentTemplate   template = new ActionImportSegmentTemplate(actionImport, null);
            ODataTemplateTranslateContext context  = new ODataTemplateTranslateContext();

            // Act
            ODataPathSegment actual = template.Translate(context);

            // Assert
            Assert.NotNull(actual);
            OperationImportSegment actionImportSegment = Assert.IsType <OperationImportSegment>(actual);

            Assert.Same(actionImport, actionImportSegment.OperationImports.First());
        }
Beispiel #8
0
 public static ODataOperationImportSegment ConvertTo(this ActionImportSegmentTemplate actionImport)
 {
     return(new ODataOperationImportSegment(actionImport.ActionImport));
 }
Beispiel #9
0
        public static ODataPath Translate(this ODataPathTemplate pathTemplate)
        {
            if (pathTemplate.Count == 0)
            {
                // It's service root, so far, let's skip it.
                return(null);
            }

            IList <ODataSegment> newSegments = new List <ODataSegment>();

            foreach (var segment in pathTemplate)
            {
                switch (segment.Kind)
                {
                case ODataSegmentKind.Metadata:
                    newSegments.Add(new ODataMetadataSegment());
                    break;

                case ODataSegmentKind.EntitySet:
                    EntitySetSegmentTemplate entitySet = (EntitySetSegmentTemplate)segment;
                    newSegments.Add(entitySet.ConvertTo());
                    break;

                case ODataSegmentKind.Singleton:
                    SingletonSegmentTemplate singleton = (SingletonSegmentTemplate)segment;
                    newSegments.Add(singleton.ConvertTo());
                    break;

                case ODataSegmentKind.Key:
                    KeySegmentTemplate key = (KeySegmentTemplate)segment;
                    newSegments.Add(key.ConvertTo());
                    break;

                case ODataSegmentKind.Cast:
                    CastSegmentTemplate cast = (CastSegmentTemplate)segment;
                    newSegments.Add(cast.ConvertTo());
                    break;

                case ODataSegmentKind.Property:
                    // TODO:
                    return(null);

                //PropertySegmentTemplate property = (PropertySegmentTemplate)segment;
                //newSegments.Add(property.ConvertTo());
                //break;

                case ODataSegmentKind.Navigation:
                    NavigationSegmentTemplate navigation = (NavigationSegmentTemplate)segment;
                    newSegments.Add(navigation.ConvertTo());
                    break;

                case ODataSegmentKind.Function:
                    FunctionSegmentTemplate function = (FunctionSegmentTemplate)segment;
                    newSegments.Add(function.ConvertTo());
                    break;

                case ODataSegmentKind.Action:
                    ActionSegmentTemplate action = (ActionSegmentTemplate)segment;
                    newSegments.Add(action.ConvertTo());
                    break;

                case ODataSegmentKind.FunctionImport:
                    FunctionImportSegmentTemplate functionImport = (FunctionImportSegmentTemplate)segment;
                    newSegments.Add(functionImport.ConvertTo());
                    break;

                case ODataSegmentKind.ActionImport:
                    ActionImportSegmentTemplate actionImport = (ActionImportSegmentTemplate)segment;
                    newSegments.Add(actionImport.ConvertTo());
                    break;

                case ODataSegmentKind.Value:
                    return(null);

                //ValueSegmentTemplate value = (ValueSegmentTemplate)segment;
                //newSegments.Add(value.ConvertTo());
                //break;

                case ODataSegmentKind.Ref:
                    return(null);

                //KeySegmentTemplate key = (KeySegmentTemplate)segment;
                //newSegments.Add(key.ConvertTo());
                //break;

                case ODataSegmentKind.NavigationLink:
                    return(null);

                //NavigationLinkSegmentTemplate navigationLink = (NavigationLinkSegmentTemplate)segment;
                //newSegments.Add(navigationLink.ConvertTo());
                //break;

                case ODataSegmentKind.Count:
                    CountSegmentTemplate count = (CountSegmentTemplate)segment;
                    newSegments.Add(count.ConvertTo());
                    break;

                case ODataSegmentKind.PathTemplate:
                    return(null);

                //KeySegmentTemplate key = (KeySegmentTemplate)segment;
                //newSegments.Add(key.ConvertTo());
                //break;

                case ODataSegmentKind.Dynamic:
                    return(null);

                //KeySegmentTemplate key = (KeySegmentTemplate)segment;
                //newSegments.Add(key.ConvertTo());
                //break;

                default:
                    throw new NotSupportedException();
                }
            }

            return(new ODataPath(newSegments));
        }