public void ShouldCompileWhenUsingClassesFromAPassedAssemblyInstance(
            [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
            [NoAutoProperties] RoslynScriptEngine engine,
            ScriptPackSession scriptPackSession)
        {
            // Arrange
            const string Code = "var x = new ScriptCs.Tests.TestMarkerClass();";

            scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny <IScriptPackManager>(), It.IsAny <string[]>()))
            .Returns <IScriptPackManager, ScriptEnvironment>((p, q) => new ScriptHost(p, q));

            var session = new SessionState <Session> {
                Session = new ScriptEngine().CreateSession()
            };

            scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
            var refs = new AssemblyReferences();

            refs.PathReferences.Add("System");
            refs.Assemblies.Add(Assembly.GetExecutingAssembly());

            // Act
            var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

            // Assert
            result.CompileExceptionInfo.ShouldBeNull();
            result.ExecuteExceptionInfo.ShouldBeNull();
        }
Example #2
0
            public void ShouldNotReturnReturnValueIfCodeExecutionDoesNotReturnValue(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                // Arrange
                const string Code = "var theNumber = 42; //this should not return a value";

                scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny <IScriptPackManager>(), It.IsAny <string[]>()))
                .Returns <IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
                var refs = new AssemblyReferences();

                refs.PathReferences.Add("System");

                // Act
                var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.ReturnValue.ShouldBeNull();
            }
            public void ShouldNotMarkSubmissionsAsIncompleteWhenRunningScript(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                // Arrange
                const string Code = "class test {";

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
                var refs = new AssemblyReferences();

                refs.PathReferences.Add("System");
                engine.FileName = "test.csx";

                // Act
                var result = engine.Execute(
                    Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.IsCompleteSubmission.ShouldBeTrue();
                result.CompileExceptionInfo.ShouldNotBeNull();
            }
Example #4
0
            public void ShouldSetIsPendingClosingCharToTrueIfCodeIsMissingCurlyBracket(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                // Arrange
                const string Code = "class test {";

                scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny <IScriptPackManager>(), It.IsAny <string[]>()))
                .Returns <IScriptPackManager, string[]>((p, q) => new ScriptHost(p, q));

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;

                // Act
                var result = engine.Execute(
                    Code, new string[0], new[] { "System" }, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.IsPendingClosingChar.ShouldBeTrue();
                result.ExpectingClosingChar.ShouldEqual('}');
            }
            public void ShouldSetIsPendingClosingCharToTrueIfCodeIsMissingParenthesis(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                // Arrange
                const string Code = "System.Diagnostics.Debug.WriteLine(\"a\"";

                scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny <IScriptPackManager>(), It.IsAny <string[]>()))
                .Returns <IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
                var refs = new AssemblyReferences();

                refs.PathReferences.Add("System");

                // Act
                var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.IsCompleteSubmission.ShouldBeFalse();
            }
Example #6
0
            public void ShouldSetIsPendingClosingCharToTrueIfCodeIsMissingSquareBracket(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                // Arrange
                const string Code = "var x = new[1] { 1 }; var y = x[0";

                scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny <IScriptPackManager>(), It.IsAny <string[]>()))
                .Returns <IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
                var refs = new AssemblyReferences();

                refs.PathReferences.Add("System");

                // Act
                var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.IsPendingClosingChar.ShouldBeTrue();
                result.ExpectingClosingChar.ShouldEqual(']');
            }
Example #7
0
            public void ShouldReturnInvalidNamespacesIfCS0241Encountered(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;

                // Act
                var result = engine.Execute(string.Empty, new string[0], new AssemblyReferences(), new[] { "foo" }, scriptPackSession);

                // Assert
                result.CompileExceptionInfo.ShouldNotBeNull();
                result.InvalidNamespaces.ShouldContain("foo");
            }
Example #8
0
        static public ScriptCSSession Create(Cmdlet cmdlet)
        {
            ScriptCSSession session = null;
            var             logger  = new CurrentLogger();

            using (logger.CreateActiveLoggerSession(new CmdletLogger(cmdlet)))
            {
                IScriptHostFactory factory = new ScriptHostFactory();
                var engine = new RoslynScriptEngine(factory, logger);
                engine.BaseDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
                var currentCmdletScriptPack = new CurrentCmdletScriptPack();
                var scriptPackSession       = new ScriptPackSession(new IScriptPack[] { currentCmdletScriptPack });
                scriptPackSession.InitializePacks();

                session = new ScriptCSSession(engine, scriptPackSession, currentCmdletScriptPack, logger);
            }

            return(session);
        }
Example #9
0
            public void ShouldReturnReturnValueIfCodeExecutionReturnsValue(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                const string Code = "\"Hello\" //this should return \"Hello\"";

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
                var refs = new AssemblyReferences(new[] { "System" });

                // Act
                var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.ReturnValue.ShouldEqual("Hello");
            }
Example #10
0
            public void ShouldReturnExecuteExceptionIfCodeExecutionThrowsException(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                // Arrange
                const string Code = "throw new System.Exception(); //this should throw an Exception";

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
                var refs = new AssemblyReferences(new[] { "System" });

                // Act
                var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.ExecuteExceptionInfo.ShouldNotBeNull();
            }
            public void ShouldCreateScriptHostWithContexts(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [Frozen] Mock <IScriptPack> scriptPack,
                ScriptPackSession scriptPackSession,
                [NoAutoProperties] RoslynScriptEngine engine)
            {
                // Arrange
                const string Code = "var a = 0;";

                scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny <IScriptPackManager>(), It.IsAny <string[]>()))
                .Returns <IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));

                scriptPack.Setup(p => p.Initialize(It.IsAny <IScriptPackSession>()));
                scriptPack.Setup(p => p.GetContext()).Returns((IScriptPackContext)null);

                // Act
                engine.Execute(Code, new string[0], new AssemblyReferences(), Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                scriptHostFactory.Verify(f => f.CreateScriptHost(It.IsAny <IScriptPackManager>(), It.IsAny <string[]>()));
            }
Example #12
0
        public void ShouldInitializeScriptLibraryWrapperHost(
            [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
            Mock <IScriptPackManager> manager,
            [NoAutoProperties] RoslynScriptEngine engine,
            ScriptPackSession scriptPackSession
            )
        {
            // Arrange
            const string Code = "var theNumber = 42; //this should compile";

            var refs = new AssemblyReferences(new[] { "System" });

            scriptHostFactory.Setup(s => s.CreateScriptHost(It.IsAny <IScriptPackManager>(), It.IsAny <string[]>()))
            .Returns(new ScriptHost(manager.Object, null));

            // Act
            engine.Execute(Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

            // Assert
            ScriptLibraryWrapper.ScriptHost.ShouldNotEqual(null);
        }
Example #13
0
            public void ShouldNotReturnReturnValueIfCodeExecutionDoesNotReturnValue(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                // Arrange
                const string Code = "var theNumber = 42; //this should not return a value";

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
                var refs = new AssemblyReferences(new[] { "System" });

                // Act
                var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.ReturnValue.ShouldBeNull();
            }
Example #14
0
            public void ShouldReturnReturnValueIfCodeExecutionReturnsValue(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                const string Code = "\"Hello\" //this should return \"Hello\"";

                // Arrange
                scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny <IScriptPackManager>(), It.IsAny <string[]>()))
                .Returns <IScriptPackManager, string[]>((p, q) => new ScriptHost(p, q));

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;

                // Act
                var result = engine.Execute(Code, new string[0], new[] { "System" }, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.ReturnValue.ShouldEqual("Hello");
            }
Example #15
0
            public void ShouldNotReturnExecuteExceptionIfCodeExecutionDoesNotThrowAnException(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                // Arrange
                const string Code = "var theNumber = 42; //this should not throw an Exception";

                scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny <IScriptPackManager>(), It.IsAny <string[]>()))
                .Returns <IScriptPackManager, string[]>((p, q) => new ScriptHost(p, q));

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;

                // Act
                var result = engine.Execute(Code, new string[0], new[] { "System" }, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.ExecuteExceptionInfo.ShouldBeNull();
            }
            public void ShouldNotReturnCompileExceptionIfCodeDoesCompile(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                // Arrange
                const string Code = "var theNumber = 42; //this should compile";

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
                var refs = new AssemblyReferences();

                refs.PathReferences.Add("System");

                // Act
                var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.CompileExceptionInfo.ShouldBeNull();
            }
Example #17
0
            public void ShouldRemoveInvalidNamespacesFromSessionStateAndEngine(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;

                // Act
                engine.Execute(string.Empty, new string[0], new AssemblyReferences(), new[] { "System", "foo" }, scriptPackSession);

                // Assert
                session.Namespaces.ShouldNotBeEmpty();
                session.Namespaces.ShouldNotContain("foo");
                var pendingNamespacesField = session.Session.GetType().GetField("pendingNamespaces", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
                var pendingNamespacesValue = (ReadOnlyArray <string>)pendingNamespacesField.GetValue(session.Session);

                pendingNamespacesValue.AsEnumerable().ShouldNotBeEmpty();
                pendingNamespacesValue.AsEnumerable().ShouldNotContain("foo");
            }
            public void ShouldSetIsPendingClosingCharToTrueIfCodeIsMissingCurlyBracket(
                [Frozen] Mock <IScriptHostFactory> scriptHostFactory,
                [NoAutoProperties] RoslynScriptEngine engine,
                ScriptPackSession scriptPackSession)
            {
                // Arrange
                const string Code = "class test {";

                var session = new SessionState <Session> {
                    Session = new ScriptEngine().CreateSession()
                };

                scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
                var refs = new AssemblyReferences();

                refs.PathReferences.Add("System");

                // Act
                var result = engine.Execute(
                    Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);

                // Assert
                result.IsCompleteSubmission.ShouldBeFalse();
            }
Example #19
0
        public void Test()
        {
            var sc         = new SparkContext("", "");
            var sqlContext = new SqlContext(sc);

            var scriptEngine = new RoslynScriptEngine(sc, sqlContext);
            var ioHandler    = new TestIoHandler();

            var repl = new Repl(scriptEngine, ioHandler);

            repl.Init();
            var thread = new Thread(() => { repl.Run(); })
            {
                IsBackground = false
            };

            thread.Start();

            Thread.Sleep(1000);

            Assert.IsTrue(ioHandler.output.Any());
            Assert.AreEqual("> ", ioHandler.output.Last());

            ioHandler.output.Clear();

            // empty input
            ioHandler.input.Add(" ");

            // incomplete code block
            ioHandler.input.Add("if (true) {");
            ioHandler.input.Add("return 1024; }");

            // execution exception
            ioHandler.input.Add("new Exception(\"Test\")");

            // compile exception
            ioHandler.input.Add("var a=;");

            // load non-exist library
            ioHandler.input.Add(":load \"non-exist.dll\"");

            // load library
            var sampleDLL = scriptEngine.CompilationDumpPath(0);

            ioHandler.input.Add(":load \"" + sampleDLL + "\"");

            // invalid :load directive
            ioHandler.input.Add(":load x");

            // invalid directive
            ioHandler.input.Add(":invalid directive");

            // :help directive
            ioHandler.input.Add(":help");

            // quit REPL
            ioHandler.input.Add(":quit");
            thread.Join();
            scriptEngine.Close();

            Console.WriteLine(string.Join("\r\n", ioHandler.output));
            var seq = 0;

            Assert.AreEqual("> ", ioHandler.output[seq++]);
            Assert.AreEqual(". ", ioHandler.output[seq++]);
            Assert.AreEqual("1024", ioHandler.output[seq++]);
            Assert.AreEqual("> ", ioHandler.output[seq++]);

            // execution exception
            Assert.IsTrue(ioHandler.output[seq++].Contains("System.Exception: Test"));
            Assert.AreEqual("> ", ioHandler.output[seq++]);

            // compile exception
            Assert.IsTrue(ioHandler.output[seq++].Contains("Exception"));
            Assert.AreEqual("> ", ioHandler.output[seq++]);

            // load non-exist library
            Assert.IsTrue(ioHandler.output[seq++].Contains("Failed to load assebmly"));
            Assert.AreEqual("> ", ioHandler.output[seq++]);

            // load library
            Assert.IsTrue(ioHandler.output[seq++].Contains("Loaded assebmly"));
            Assert.AreEqual("> ", ioHandler.output[seq++]);

            // invalid :load directive
            Assert.IsTrue(ioHandler.output[seq++].Contains("Invalid :load directive"));
            Assert.AreEqual("> ", ioHandler.output[seq++]);

            // invalid directive
            Assert.IsTrue(ioHandler.output[seq++].Contains("Invalid directive"));
            Assert.AreEqual("> ", ioHandler.output[seq++]);

            // help directive
            Assert.IsTrue(ioHandler.output[seq++].Contains("Commands"));
            Assert.AreEqual("> ", ioHandler.output[seq++]);
        }