protected override void Act()
            {
                _actualDefinitions = SwaggerDocumentFactoryHelper
                                     .CreateSwaggerDefinitionsFactory(
                    new SwaggerDocumentContext(ResourceModelProvider.GetResourceModel())
                {
                    RenderType = RenderType.GeneralizedExtensions
                }).Create(_resources.Select(r => new SwaggerResource(r)).ToList());

                _actualEdfiResourceDefinitions = _resources.Where(r => r.IsEdFiStandardResource).Select(r => r.Name.ToCamelCase())
                                                 .Where(_actualDefinitions.ContainsKey).Select(r => _actualDefinitions[r]).ToList();

                // link definitions are excluded here and tested in a separate assertion.
                _actualExtendableEdfiResourceDefinitions = _resources.Where(r => r.IsEdFiStandardResource && !r.Entity.IsLookup)
                                                           .Select(r => r.Name.ToCamelCase()).Where(_actualDefinitions.ContainsKey).Select(r => _actualDefinitions[r])
                                                           .ToList();

                _actualPropertyNamesByDefinitionName = _actualDefinitions.Where(d => d.Key != "link").Select(
                    d => new
                {
                    DefinitionName =
                        d.Key,

                    // Separate tests verify that these properties must exist in resource definitions
                    Properties = d.Value.properties.Keys.Except(
                        new[]
                    {
                        "_ext",
                        "_etag",
                        "link"
                    }).ToList()
                }).ToDictionary(k => k.DefinitionName, v => v.Properties);
            }
            protected override void Act()
            {
                var swaggerResources = ResourceModelProvider.GetResourceModel()
                                       .GetAllResources()
                                       .Select(r => new SwaggerResource(r))
                                       .ToList();

                _actualPaths = SwaggerDocumentFactoryHelper.CreateSwaggerPathsFactory(
                    DomainModelDefinitionsProviderHelper.DefaultSwaggerDocumentContext)
                               .Create(swaggerResources);
            }
            protected override void Arrange()
            {
                _swaggerDocumentContext = new SwaggerDocumentContext(
                    DomainModelDefinitionsProviderHelper
                    .ResourceModelProvider
                    .GetResourceModel())
                {
                    RenderType          = RenderType.GeneralizedExtensions,
                    IsIncludedExtension = x => x.FullName.Schema.Equals(EdFiConventions.PhysicalSchemaName)
                };

                _genericSwaggerDefinitionFactory =
                    SwaggerDocumentFactoryHelper.CreateSwaggerDefinitionsFactory(
                        _swaggerDocumentContext);
            }
            protected override void Arrange()
            {
                _swaggerDocumentContext = new SwaggerDocumentContext(
                    DomainModelDefinitionsProviderHelper
                    .ResourceModelProvider
                    .GetResourceModel());

                _genericSwaggerDefinitionFactory =
                    SwaggerDocumentFactoryHelper.CreateSwaggerDefinitionsFactory(
                        _swaggerDocumentContext);

                _domainModelProvider = DomainModelDefinitionsProviderHelper.DomainModelProvider;

                _schemaNameMapProvider = _domainModelProvider.GetDomainModel()
                                         .SchemaNameMapProvider;
            }
            protected override void Arrange()
            {
                var schemaDefinition = DomainModelDefinitionsProviderHelper
                                       .DefinitionProviders
                                       .Select(
                    x => x.GetDomainModelDefinitions()
                    .SchemaDefinition)
                                       .Where(s => s.PhysicalName == requestedExtensionPhysicalName)
                                       .Select(s => new EdFiSchema(s.LogicalName, s.PhysicalName))
                                       .First();

                _extensionOnlySwaggerDocumentFactory = SwaggerDocumentFactoryHelper
                                                       .GetExtensionOnlySwaggerDocumentFactory(
                    DomainModelDefinitionsProviderHelper.ResourceModelProvider.GetResourceModel(),
                    schemaDefinition);

                _resourceStrategy = new SdkGenExtensionResourceStrategy();
            }
        private IEnumerable <OpenApiContent> CreateSchemaSpecificSections()
        {
            return(new[]
            {
                new OpenApiContent(
                    OpenApiMetadataSections.SdkGen,
                    EdFi,
                    new Lazy <string>(
                        () =>
                        new SwaggerDocumentFactory(
                            new SwaggerDocumentContext(_resourceModelProvider.GetResourceModel())
                {
                    RenderType = RenderType.GeneralizedExtensions,
                    IsIncludedExtension = x => x.FullName.Schema.Equals(EdFiConventions.PhysicalSchemaName)
                }).Create(_openApiMetadataResourceFilters[EdFi])),
                    _odsDataBasePath)
            }.Concat(
                       _domainModelProvider.GetDomainModel()

                       // All the extension schemas.
                       .Schemas.Where(
                           x => !x.LogicalName.EqualsIgnoreCase(EdFiConventions.LogicalName))
                       .Select(
                           schema =>
                           new
            {
                UriSegment = _schemaNameMapProvider.GetSchemaMapByLogicalName(schema.LogicalName)
                             .UriSegment,
                Factory =
                    SwaggerDocumentFactoryHelper.GetExtensionOnlySwaggerDocumentFactory(
                        _resourceModelProvider.GetResourceModel(),
                        schema)
            })
                       .Select(
                           sf =>
                           new OpenApiContent(
                               OpenApiMetadataSections.Extensions,
                               sf.UriSegment,
                               new Lazy <string>(() => sf.Factory.Create(_openApiMetadataResourceFilters[Extensions])),
                               _odsDataBasePath))
                       ));
        }
 protected override void Act()
 {
     _actualPaths = SwaggerDocumentFactoryHelper
                    .CreateSwaggerPathsFactory(_swaggerDocumentContext)
                    .Create(_swaggerResources);
 }