Esempio n. 1
0
        public void Given_service_set_When_adding_description_for_existing_services_When_can_get_it_back()
        {
            var set           = new ScriptServiceSet();
            var service       = new object();
            var scriptService = new ScriptService()
            {
                Name = "Test service", Version = 1
            };
            var scriptServiceSchema = new ScriptServiceSchema()
            {
                AccessName = "test",
                Language   = Language.JavaScriptEs5
            };

            set.Add(scriptService, service, scriptServiceSchema);

            IReadOnlyCollection <ScriptServiceSchema>?resolvedSchema = null;
            object?resolvedService = null;

            set.Inject((sc, s) =>
            {
                resolvedSchema  = sc;
                resolvedService = s;
            }, scriptService);

            resolvedService.Should().Be(service);
            resolvedSchema.Should().BeEquivalentTo(scriptServiceSchema);
        }
Esempio n. 2
0
        public void Given_service_set_When_injecting_existing_services_When_injector_is_called_with_provided_service_and_schemas()
        {
            var set        = new ScriptServiceSet();
            var service    = new object();
            var descriptor = new ScriptService()
            {
                Name = "Test service", Version = 1
            };

            set.Add(descriptor, service);

            object?resolved = null;
            IReadOnlyCollection <ScriptServiceSchema> schemas = null;

            set.Inject((sc, s) =>
            {
                resolved = s;
                schemas  = sc;
            }, descriptor);

            resolved.Should().Be(service);
            schemas.Should().BeEquivalentTo(ScriptServiceSchema.Default(descriptor));
        }
Esempio n. 3
0
        public PolicyExampleQueries(Persistence persistence)
        {
            var jintScriptEngine = new ScriptEngine()
            {
                Id   = "js",
                Name = "Jint",
                SupportedScriptLanguages = new List <Language>()
                {
                    Language.JavaScript
                },
                Version = "0.1"
            };
            var logicGraphFlowService = new ScriptService()
            {
                Id      = "logic-graph-flow",
                Name    = "Logic Graph Flow",
                Version = "0.1"
            };
            var nodeFlowServiceSchema = new ScriptServiceSchema()
            {
                Id      = "logic-graph-flow-json-schema",
                Service = logicGraphFlowService,
                Engine  = jintScriptEngine,
                Schema  = @"
    var flow = {
        stop : function(){} // returns nothing
        redirectToParent : function(){} // returns nothing
        redirectToChild: function(childNum){} // returns bool 
    }"
            };

            var templateGraph = new LogicGraph()
            {
                Id   = "1",
                Name = "graph template",
                AvailableServices = new List <ScriptService>()
                {
                    logicGraphFlowService
                },
                AvailableEngines = new List <ScriptEngine>()
                {
                    jintScriptEngine
                }
            };

            var goToSecondChildScript = new Script()
            {
                Body             = "flow.redirectToChild(1);",
                Id               = "redirectToChild1",
                Language         = Language.JavaScript,
                RequiredServices = new List <ScriptService>()
                {
                    logicGraphFlowService
                }
            };


            Field <ListGraphType <LanguageGraphType> >("language", resolve: r => new[] { Language.JavaScript });
            Field <ListGraphType <ScriptServiceGraphType> >("scriptEngine", resolve: r =>
            {
                return(new[] { jintScriptEngine });
            });
            Field <ListGraphType <ScriptServiceGraphType> >()
            .Name("scriptService")
            .Resolve(resolve: r =>
            {
                return(new[] { logicGraphFlowService });
            });

            Field <ListGraphType <ScriptServiceSchemaGraphType> >()
            .Name("scriptServiceSchema")
            .Resolve(r =>
            {
                return(new[]
                {
                    nodeFlowServiceSchema
                });
            });

            Field <ListGraphType <ScriptGraphType> >()
            .Name("script")
            .Resolve(r =>
            {
                return(new[]
                {
                    goToSecondChildScript
                });
            });

            Field <ListGraphType <LogicNodeGraphType> >()
            .Name("logicNode")
            .Resolve(r =>
            {
                return(new[]
                {
                    new LogicNode()
                    {
                        Id = "1",
                        Name = "Root",
                        Script = goToSecondChildScript
                    }
                });
            });

            Field <ListGraphType <LogicGraphGraphType> >()
            .Name("logicGraph")
            .Resolve(r =>
            {
                return(persistence.Graphs.Select(p => new LogicGraph()
                {
                    Id = p.Id,
                    Name = p.Name,
                    AvailableServices = new List <ScriptService>()
                    {
                        logicGraphFlowService
                    },
                    AvailableEngines = new List <ScriptEngine>()
                    {
                        jintScriptEngine
                    }
                }).ToArray());
            });
        }