Beispiel #1
0
        public void Can_Perform_Update_On_ScriptRepository()
        {
            // Arrange
            var provider = TestObjects.GetScopeProvider(Logger);

            using (var scope = ScopeProvider.CreateScope())
            {
                var repository = new ScriptRepository(_fileSystems, Mock.Of <IContentSection>());

                // Act
                var script = new Script("test-updated-script.js")
                {
                    Content = "/// <reference name=\"MicrosoftAjax.js\"/>"
                };
                repository.Save(script);


                script.Content = "/// <reference name=\"MicrosoftAjax-Updated.js\"/>";
                repository.Save(script);


                var scriptUpdated = repository.Get("test-updated-script.js");

                // Assert
                Assert.That(_fileSystem.FileExists("test-updated-script.js"), Is.True);
                Assert.That(scriptUpdated.Content, Is.EqualTo("/// <reference name=\"MicrosoftAjax-Updated.js\"/>"));
            }
        }
Beispiel #2
0
        public void Save()
        {
            Script myScript = new Script();

            myScript.Name        = "Prueba";
            myScript.Description = "Prueba";

            List <Action> myActionList = new List <Model.Action>();

            myActionList.Add(myActionRepository.GetById(8));
            myScriptRepository.Save(myScript, myActionList);

            Assert.IsTrue(myScriptRepository.GetAll().Any(item => item.Name.Equals("Prueba")));
        }
Beispiel #3
0
        public void Can_Perform_Move_On_ScriptRepository()
        {
            const string content = "/// <reference name=\"MicrosoftAjax.js\"/>";

            // Arrange
            var provider = TestObjects.GetScopeProvider(Logger);

            using (var scope = ScopeProvider.CreateScope())
            {
                var repository = new ScriptRepository(_fileSystems, Mock.Of <IContentSection>());

                var script = new Script("test-move-script.js")
                {
                    Content = content
                };
                repository.Save(script);


                // Act
                script      = repository.Get("test-move-script.js");
                script.Path = "moved/test-move-script.js";
                repository.Save(script);


                var existsOld = repository.Exists("test-move-script.js");
                var existsNew = repository.Exists("moved/test-move-script.js");

                script = repository.Get("moved/test-move-script.js");

                // Assert
                Assert.IsNotNull(script);
                Assert.IsFalse(existsOld);
                Assert.IsTrue(existsNew);
                Assert.AreEqual(content, script.Content);
            }
        }
Beispiel #4
0
        public void Can_Perform_GetAll_With_Params_On_ScriptRepository()
        {
            // Arrange
            var provider = TestObjects.GetScopeProvider(Logger);

            using (var scope = ScopeProvider.CreateScope())
            {
                var repository = new ScriptRepository(_fileSystems, Mock.Of <IContentSection>());

                var script = new Script("test-script1.js")
                {
                    Content = "/// <reference name=\"MicrosoftAjax.js\"/>"
                };
                repository.Save(script);
                var script2 = new Script("test-script2.js")
                {
                    Content = "/// <reference name=\"MicrosoftAjax.js\"/>"
                };
                repository.Save(script2);
                var script3 = new Script("test-script3.js")
                {
                    Content = "/// <reference name=\"MicrosoftAjax.js\"/>"
                };
                repository.Save(script3);


                // Act
                var scripts = repository.GetMany("test-script1.js", "test-script2.js");

                // Assert
                Assert.That(scripts, Is.Not.Null);
                Assert.That(scripts.Any(), Is.True);
                Assert.That(scripts.Any(x => x == null), Is.False);
                Assert.That(scripts.Count(), Is.EqualTo(2));
            }
        }
Beispiel #5
0
        public ActionResult Save(ScriptViewModel myModel)
        {
            try
            {
                _LoggingService.Write("ScriptController (Save) page access", true);

                var myModelState = ModelState;
                if (_ScriptRepository.Validate(ref myModelState, myModel))
                {
                    _ScriptRepository.Save(myModel.Current, myModel.Actions);
                    _LoggingService.Write("ScriptController - Save () successful: ", true);
                    return(RedirectToAction("Index", "Home"));
                }

                myModel.AllActions = _ActionRepository.GetAll(true);
                return(View("New", myModel));
            }
            catch (Exception ex)
            {
                _LoggingService.WriteWithInner(ex, true, "ScriptController(Save) error: ");
                return(new HttpNotFoundResult());
            }
        }
Beispiel #6
0
        public void PathTests()
        {
            // unless noted otherwise, no changes / 7.2.8

            var provider = TestObjects.GetScopeProvider(Logger);

            using (var scope = ScopeProvider.CreateScope())
            {
                var repository = new ScriptRepository(_fileSystems, Mock.Of <IContentSection>());

                var script = new Script("test-path-1.js")
                {
                    Content = "// script"
                };
                repository.Save(script);

                Assert.IsTrue(_fileSystem.FileExists("test-path-1.js"));
                Assert.AreEqual("test-path-1.js", script.Path);
                Assert.AreEqual("/scripts/test-path-1.js", script.VirtualPath);

                //ensure you can prefix the same path as the root path name
                script = new Script("scripts/path-2/test-path-2.js")
                {
                    Content = "// script"
                };
                repository.Save(script);

                Assert.IsTrue(_fileSystem.FileExists("scripts/path-2/test-path-2.js"));
                Assert.AreEqual("scripts\\path-2\\test-path-2.js", script.Path);
                Assert.AreEqual("/scripts/scripts/path-2/test-path-2.js", script.VirtualPath);

                script = new Script("path-2/test-path-2.js")
                {
                    Content = "// script"
                };
                repository.Save(script);

                Assert.IsTrue(_fileSystem.FileExists("path-2/test-path-2.js"));
                Assert.AreEqual("path-2\\test-path-2.js", script.Path); // fixed in 7.3 - 7.2.8 does not update the path
                Assert.AreEqual("/scripts/path-2/test-path-2.js", script.VirtualPath);

                script = repository.Get("path-2/test-path-2.js");
                Assert.IsNotNull(script);
                Assert.AreEqual("path-2\\test-path-2.js", script.Path);
                Assert.AreEqual("/scripts/path-2/test-path-2.js", script.VirtualPath);

                script = new Script("path-2\\test-path-3.js")
                {
                    Content = "// script"
                };
                repository.Save(script);

                Assert.IsTrue(_fileSystem.FileExists("path-2/test-path-3.js"));
                Assert.AreEqual("path-2\\test-path-3.js", script.Path);
                Assert.AreEqual("/scripts/path-2/test-path-3.js", script.VirtualPath);

                script = repository.Get("path-2/test-path-3.js");
                Assert.IsNotNull(script);
                Assert.AreEqual("path-2\\test-path-3.js", script.Path);
                Assert.AreEqual("/scripts/path-2/test-path-3.js", script.VirtualPath);

                script = repository.Get("path-2\\test-path-3.js");
                Assert.IsNotNull(script);
                Assert.AreEqual("path-2\\test-path-3.js", script.Path);
                Assert.AreEqual("/scripts/path-2/test-path-3.js", script.VirtualPath);

                script = new Script("\\test-path-4.js")
                {
                    Content = "// script"
                };
                Assert.Throws <UnauthorizedAccessException>(() => // fixed in 7.3 - 7.2.8 used to strip the \
                {
                    repository.Save(script);
                });

                script = repository.Get("missing.js");
                Assert.IsNull(script);

                // fixed in 7.3 - 7.2.8 used to...
                Assert.Throws <UnauthorizedAccessException>(() =>
                {
                    script = repository.Get("\\test-path-4.js"); // outside the filesystem, does not exist
                });
                Assert.Throws <UnauthorizedAccessException>(() =>
                {
                    script = repository.Get("../packages.config"); // outside the filesystem, exists
                });
            }
        }