public void CreateNewScript()
        {
            var verifier = new Mock <ISyntaxVerifier>();

            var scriptHost = new Mock <IHostScripts>();
            {
                scriptHost.Setup(s => s.IsExecutingScript)
                .Returns(true);
                scriptHost.Setup(s => s.VerifySyntax(It.IsAny <ScriptLanguage>()))
                .Returns(verifier.Object)
                .Verifiable();
            }

            var context = new Mock <IContextAware>();
            var model   = new ScriptDescriptionModel(context.Object, ScriptLanguage.IronPython);

            Func <Tuple <FileInfo, ScriptDescriptionModel> > selectScript =
                () => new Tuple <FileInfo, ScriptDescriptionModel>(new FileInfo(@"c:\temp\file.txt"), model);
            Action <ScriptDescriptionModel, FileInfo, ISyntaxVerifier> storeScript =
                (s, f, v) =>
            {
                Assert.AreSame(model, s);
                Assert.AreSame(verifier.Object, v);
            };
            Func <string, IDisposable> timerFunc = s => new MockDisposable();

            var command = new OpenScriptCommand(scriptHost.Object, selectScript, storeScript, timerFunc);

            command.Execute(null);
        }
Example #2
0
        public void ScriptLanguage()
        {
            var context = new Mock<IContextAware>();
            {
                context.Setup(c => c.IsSynchronized)
                    .Returns(true);
            }

            var model = new ScriptModel(context.Object);

            var propertyChangedWasRaised = 0;
            var properties = new List<string>();
            model.PropertyChanged += (s, e) =>
            {
                propertyChangedWasRaised++;
                properties.Add(e.PropertyName);
            };

            var description = new ScriptDescriptionModel(context.Object, Core.Host.Scripting.ScriptLanguage.IronRuby);
            model.ScriptLanguage = description;

            Assert.AreEqual(1, propertyChangedWasRaised);
            Assert.That(
                properties,
                Is.EquivalentTo(
                    new List<string>
                    {
                        "ScriptLanguage",
                    }));

            var newDescription = new ScriptDescriptionModel(context.Object, Core.Host.Scripting.ScriptLanguage.IronRuby);
            model.ScriptLanguage = newDescription;

            Assert.AreEqual(1, propertyChangedWasRaised);
        }
        public void CreateNewScript()
        {
            var verifier = new Mock<ISyntaxVerifier>();

            var scriptHost = new Mock<IHostScripts>();
            {
                scriptHost.Setup(s => s.IsExecutingScript)
                    .Returns(true);
                scriptHost.Setup(s => s.VerifySyntax(It.IsAny<ScriptLanguage>()))
                    .Returns(verifier.Object)
                    .Verifiable();
            }

            var context = new Mock<IContextAware>();
            var model = new ScriptDescriptionModel(context.Object, ScriptLanguage.IronPython);

            Func<Tuple<FileInfo, ScriptDescriptionModel>> selectScript =
                () => new Tuple<FileInfo, ScriptDescriptionModel>(new FileInfo(@"c:\temp\file.txt"), model);
            Action<ScriptDescriptionModel, FileInfo, ISyntaxVerifier> storeScript =
                (s, f, v) =>
                {
                    Assert.AreSame(model, s);
                    Assert.AreSame(verifier.Object, v);
                };
            Func<string, IDisposable> timerFunc = s => new MockDisposable();

            var command = new OpenScriptCommand(scriptHost.Object, selectScript, storeScript, timerFunc);
            command.Execute(null);
        }
        public void ConvertWithScriptDescriptionModel()
        {
            var context = new Mock<IContextAware>();
            var value = new ScriptDescriptionModel(context.Object, ScriptLanguage.IronPython);

            var converter = new ScriptDescriptionModelToTextConverter();
            var convertedValue = converter.Convert(value, null, null, null);
            Assert.AreEqual(value.Description, convertedValue);
        }
        public void ConvertWithScriptDescriptionModel()
        {
            var context = new Mock <IContextAware>();
            var value   = new ScriptDescriptionModel(context.Object, ScriptLanguage.IronPython);

            var converter      = new ScriptDescriptionModelToTextConverter();
            var convertedValue = converter.Convert(value, null, null, null);

            Assert.AreEqual(value.Description, convertedValue);
        }