Exemplo n.º 1
0
        public async Task NodeHost_CallsMethod()
        {
            var script = "module.exports = function() { return { method1: function(callback) { callback(null, 'result1'); }}}";

            using (var host = await NodeHost.CreateFromScript(script, "", GetApplicationStopping(), GetLogger(), null))
            {
                var result = await host.Invoke <string>("method1", new object[0]);

                Assert.Equal("result1", result);
            }
        }
Exemplo n.º 2
0
        public async Task NodeHost_CallsMethodWithArgs()
        {
            var script = "module.exports = function() { return { method1: function(arg1, arg2, callback) { callback(null, arg1 + arg2); }}}";

            using (var host = await NodeHost.CreateFromScript(script, "", GetApplicationStopping(), GetLogger(), null))
            {
                var result = await host.Invoke <string>("method1", new object[] { "quick", "fox" });

                Assert.Equal("quickfox", result.ToString());
            }
        }
Exemplo n.º 3
0
        public async Task NodeHost_HandlesUnicodeCharactersToNode()
        {
            var script = "module.exports = function() { return { method1: function(str, callback) { callback(null, str === '[’]'); }}}";

            using (var host = await NodeHost.CreateFromScript(script, "", GetApplicationStopping(), GetLogger(), null))
            {
                var result = await host.Invoke <bool>("method1", "[’]");

                Assert.True(result);
            }
        }
Exemplo n.º 4
0
        public async Task NodeHost_ConvertsFromBas64StringToByteArray()
        {
            var script = "module.exports = function() { return { method1: function(str, callback) { callback(null, Buffer.from(str).toString('base64')) }}}";

            using (var host = await NodeHost.CreateFromScript(script, "", GetApplicationStopping(), GetLogger(), null))
            {
                var result = await host.Invoke <byte[]>("method1", "BinaryData");

                Assert.Equal(result, System.Text.Encoding.UTF8.GetBytes("BinaryData"));
            }
        }
Exemplo n.º 5
0
        public async Task NodeHost_HandlesUnicodeCharactersFromNode()
        {
            var script = "module.exports = function() { return { method1: function(callback) { callback(null, '[’]'); }}}";

            using (var host = await NodeHost.CreateFromScript(script, "", GetApplicationStopping(), GetLogger(), null))
            {
                var result = await host.Invoke <string>("method1");

                Assert.Equal("[’]", result);
            }
        }
Exemplo n.º 6
0
        public async Task NodeHost_HandlesIncorrectArgs()
        {
            var script = "module.exports = function() { return { method1: function(callback) { callback(null, 42); }}}";

            using (var host = await NodeHost.CreateFromScript(script, "", GetApplicationStopping(), GetLogger(), null))
            {
                try
                {
                    var result = await host.Invoke <int>("method1", new object[] { "stokes" });

                    Assert.False(true);
                }
                catch (Exception ex)
                {
                    Assert.Equal("incorrect number of arguments for method [method1]", ex.Message);
                }
            }
        }
Exemplo n.º 7
0
        public async Task NodeHost_HandlesMethodError()
        {
            var script = "module.exports = function() { return { method1: function(callback) { callback(new Error('an error occurred'), null); }}}";

            using (var host = await NodeHost.CreateFromScript(script, "", GetApplicationStopping(), GetLogger(), null))
            {
                try
                {
                    var result = await host.Invoke <object>("method1", new object[0]);

                    Assert.False(true);
                }
                catch (Exception ex)
                {
                    Assert.Equal("an error occurred", ex.Message);
                }
            }
        }
        public async Task NodeHost_HandlesMissingMethod()
        {
            var script = "module.exports = function() { return { method1: function(callback) { callback('an error occurred', null); }}}";

            using (var host = NodeHost.CreateFromScript(script, "", GetLogger()))
            {
                try
                {
                    var result = await host.Invoke <object>("method2", new object[0]);

                    Assert.False(true);
                }
                catch (Exception ex)
                {
                    Assert.Equal("method [method2] does not exist", ex.Message);
                }
            }
        }
Exemplo n.º 9
0
        public async Task NodeHost_RaisesEventsWithStringArgs()
        {
            var script = "module.exports = function(emit) { return { start: function(callback) { emit('event1', 'arg1'); callback(null, 42); } }}";

            using (var host = await NodeHost.CreateFromScript(script, "", GetApplicationStopping(), GetLogger(), null))
            {
                string  emitEvt  = "";
                dynamic emitArgs = null;

                host.Emit += (sender, e) =>
                {
                    emitEvt  = e.Name;
                    emitArgs = e.Args;
                };

                var result = await host.Invoke <Int64>("start", new object[0]);

                Assert.Equal((Int64)42, result);

                Assert.Equal("event1", emitEvt);
                Assert.Equal("arg1", emitArgs.ToString());
            }
        }
Exemplo n.º 10
0
        public async Task NodeHost_SetsEnvironmentVariables()
        {
            var script = "module.exports = function() { return { retrieve: function(callback) { callback(null, process.env.TESTVAR); }}}";

            var environmentVariables = new Dictionary <string, string>();

            environmentVariables["TESTVAR"] = "TESTVALUE";

            using (var host = await NodeHost.CreateFromScript(script, "", GetApplicationStopping(), GetLogger(), environmentVariables))
            {
                string  emitEvt  = "";
                dynamic emitArgs = null;

                host.Emit += (sender, e) =>
                {
                    emitEvt  = e.Name;
                    emitArgs = e.Args;
                };

                var result = await host.Invoke <string>("retrieve", new object[0]);

                Assert.Equal("TESTVALUE", result);
            }
        }
Exemplo n.º 11
0
 //-----------------------------------------------------------------------------------------------------------------------------------------------------
 protected override void OnStop()
 {
     _nodeHost.DeactivateAndUnload();
     _nodeHost = null;
 }
Exemplo n.º 12
0
 //-----------------------------------------------------------------------------------------------------------------------------------------------------
 protected override void OnStart(string[] args)
 {
     _nodeHost = new NodeHost(Program.HostConfig, RegisterHostComponents);
     _nodeHost.LoadAndActivate();
 }
Exemplo n.º 13
0
        //-----------------------------------------------------------------------------------------------------------------------------------------------------
        private static void StartNodeHost()
        {
            _s_nodeHost = new NodeHost(_s_bootConfig, RegisterHostComponents);
            _s_nodeHost.LoadAndActivate();

            _s_stopRequested = new ManualResetEvent(initialState: false);
            System.Console.CancelKeyPress += Console_CancelKeyPress;
        }