Beispiel #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);
        }
Beispiel #2
0
        public Task <NodeExecutionResult> Execute(LogicNode node)
        {
            if (node.Script?.Language == Language.JavaScriptEs5)
            {
                var service = new NodeFlowService(node);
                _engine.SetValue(KnownServices.ExecutionFlowServiceSchema.AccessName, service);

                try
                {
                    _serviceSet.Inject((injectedSchemas, injectedService) =>
                    {
                        var schema = injectedSchemas.FirstOrDefault(_ =>
                                                                    _.Language == Language.JavaScriptEs5);

                        if (schema == null)
                        {
                            schema = injectedSchemas.First(_ => _.Language == null);
                        }

                        _engine.SetValue(schema.AccessName, injectedService);
                    }, node.Script.RequiredServices.ToArray());

                    _engine.Execute(node.Script.Code);
                }
                catch (Exception ex)
                {
                    service.Result = new ExecutionError()
                    {
                        Message = ex.ToString()
                    };
                }
                if (service.Result != null)
                {
                    return(Task.FromResult(service.Result));
                }
            }

            return(Task.FromResult <NodeExecutionResult>(ExecutionSuccessAndContinue.Instance));
        }
Beispiel #3
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));
        }