public void TestExtractPatch__NeedsUnsatisfiedPassSpecifier()
        {
            UrlDir.UrlConfig urlConfig = CreateConfig("@NODE_TYPE");

            ITagList tagList = Substitute.For <ITagList>();

            tagListParser.Parse("NODE_TYPE", urlConfig).Returns(tagList);

            IPassSpecifier passSpecifier = Substitute.For <IPassSpecifier>();
            ProtoPatch     protoPatch    = new ProtoPatch(
                urlConfig,
                Command.Edit,
                "NODE_TYPE",
                "nodeName",
                "needs",
                "has",
                passSpecifier
                );

            protoPatchBuilder.Build(urlConfig, Command.Edit, tagList).Returns(protoPatch);
            needsChecker.CheckNeedsExpression("needs").Returns(true);
            passSpecifier.CheckNeeds(needsChecker, progress).Returns(false);

            Assert.Null(patchExtractor.ExtractPatch(urlConfig));

            AssertNoErrors();

            Assert.Empty(root.AllConfigs);

            needsChecker.DidNotReceiveWithAnyArgs().CheckNeedsRecursive(null, null);
            patchCompiler.DidNotReceiveWithAnyArgs().CompilePatch(null);

            progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedRoot(null);
        }
Ejemplo n.º 2
0
        public void TestPassSpecifier()
        {
            IPassSpecifier passSpecifier = Substitute.For <IPassSpecifier>();
            EditPatch      patch         = new EditPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), Substitute.For <INodeMatcher>(), passSpecifier);

            Assert.Same(passSpecifier, patch.PassSpecifier);
        }
Ejemplo n.º 3
0
        public void TestPassSpecifier()
        {
            IPassSpecifier passSpecifier = Substitute.For <IPassSpecifier>();
            InsertPatch    patch         = new InsertPatch(UrlBuilder.CreateConfig("abc/def", new ConfigNode()), "A_NODE", passSpecifier);

            Assert.Same(passSpecifier, patch.PassSpecifier);
        }
Ejemplo n.º 4
0
        public EditPatch(UrlDir.UrlConfig urlConfig, INodeMatcher nodeMatcher, IPassSpecifier passSpecifier)
        {
            UrlConfig     = urlConfig ?? throw new ArgumentNullException(nameof(urlConfig));
            NodeMatcher   = nodeMatcher ?? throw new ArgumentNullException(nameof(nodeMatcher));
            PassSpecifier = passSpecifier ?? throw new ArgumentNullException(nameof(passSpecifier));

            loop = urlConfig.config.HasNode("MM_PATCH_LOOP");
        }
Ejemplo n.º 5
0
 public ProtoPatch(UrlDir.UrlConfig urlConfig, Command command, string nodeType, string nodeName, string needs, string has, IPassSpecifier passSpecifier)
 {
     this.urlConfig     = urlConfig;
     this.command       = command;
     this.nodeType      = nodeType;
     this.nodeName      = nodeName;
     this.needs         = needs;
     this.has           = has;
     this.passSpecifier = passSpecifier;
 }
        public void TestExtractPatch__Insert()
        {
            UrlDir.UrlConfig urlConfig = CreateConfig("NODE_TYPE");

            ITagList tagList = Substitute.For <ITagList>();

            tagListParser.Parse("NODE_TYPE", urlConfig).Returns(tagList);

            IPassSpecifier passSpecifier = Substitute.For <IPassSpecifier>();
            ProtoPatch     protoPatch    = new ProtoPatch(
                urlConfig,
                Command.Insert,
                "NODE_TYPE",
                null,
                "needs",
                null,
                passSpecifier
                );

            protoPatchBuilder.Build(urlConfig, Command.Insert, tagList).Returns(protoPatch);
            needsChecker.CheckNeedsExpression("needs").Returns(true);
            passSpecifier.CheckNeeds(needsChecker, progress).Returns(true);

            ConfigNode needsCheckedNode = null;

            needsChecker.CheckNeedsRecursive(Arg.Do <ConfigNode>(node => needsCheckedNode = node), urlConfig);

            Assert.Null(patchExtractor.ExtractPatch(urlConfig));

            AssertNoErrors();

            Received.InOrder(delegate
            {
                tagListParser.Parse("NODE_TYPE", urlConfig);
                protoPatchBuilder.Build(urlConfig, Command.Insert, tagList);
                needsChecker.CheckNeedsExpression("needs");
                passSpecifier.CheckNeeds(needsChecker, progress);
                needsChecker.CheckNeedsRecursive(needsCheckedNode, urlConfig);
            });

            patchCompiler.DidNotReceiveWithAnyArgs().CompilePatch(null);

            Assert.Equal(1, root.AllConfigs.Count());
            UrlDir.UrlConfig newUrlConfig = root.AllConfigs.First();
            Assert.NotSame(urlConfig, newUrlConfig);
            Assert.NotSame(urlConfig.config, newUrlConfig.config);
            AssertConfigNodesEqual(urlConfig.config, newUrlConfig.config);
            Assert.Same(needsCheckedNode, newUrlConfig.config);

            progress.DidNotReceiveWithAnyArgs().NeedsUnsatisfiedRoot(null);
        }
Ejemplo n.º 7
0
        public void TestConstructor__UnknownPassSpecifier()
        {
            IPatch patch = Substitute.For <IPatch>();

            UrlDir.UrlConfig urlConfig     = UrlBuilder.CreateConfig("abc/def", new ConfigNode("NODE"));
            IPassSpecifier   passSpecifier = Substitute.For <IPassSpecifier>();

            passSpecifier.Descriptor.Returns(":SOMEPASS");
            patch.PassSpecifier.Returns(passSpecifier);
            IPatchProgress progress = Substitute.For <IPatchProgress>();

            NotImplementedException ex = Assert.Throws <NotImplementedException>(delegate
            {
                new PatchList(new string[0], new[] { patch }, progress);
            });

            Assert.Equal("Don't know what to do with pass specifier: :SOMEPASS", ex.Message);

            progress.DidNotReceive().PatchAdded();
        }
Ejemplo n.º 8
0
 public CopyPatch(UrlDir.UrlConfig urlConfig, INodeMatcher nodeMatcher, IPassSpecifier passSpecifier)
 {
     UrlConfig     = urlConfig ?? throw new ArgumentNullException(nameof(urlConfig));
     NodeMatcher   = nodeMatcher ?? throw new ArgumentNullException(nameof(nodeMatcher));
     PassSpecifier = passSpecifier ?? throw new ArgumentNullException(nameof(passSpecifier));
 }
Ejemplo n.º 9
0
 public InsertPatch(UrlDir.UrlConfig urlConfig, string nodeType, IPassSpecifier passSpecifier)
 {
     UrlConfig     = urlConfig ?? throw new ArgumentNullException(nameof(urlConfig));
     NodeType      = nodeType ?? throw new ArgumentNullException(nameof(nodeType));
     PassSpecifier = passSpecifier ?? throw new ArgumentNullException(nameof(passSpecifier));
 }
Ejemplo n.º 10
0
        public ProtoPatch Build(UrlDir.UrlConfig urlConfig, Command command, ITagList tagList)
        {
            if (urlConfig == null)
            {
                throw new ArgumentNullException(nameof(urlConfig));
            }
            if (tagList == null)
            {
                throw new ArgumentNullException(nameof(tagList));
            }
            if (progress == null)
            {
                throw new ArgumentNullException(nameof(progress));
            }

            bool error = false;

            string nodeType = tagList.PrimaryTag.key;
            string nodeName = tagList.PrimaryTag.value;

            if (command == Command.Insert && nodeName != null)
            {
                progress.Error(urlConfig, "name specifier detected on insert node (not a patch): " + urlConfig.SafeUrl());
                error = true;
            }

            if (nodeName == string.Empty)
            {
                progress.Warning(urlConfig, "empty brackets detected on patch name: " + urlConfig.SafeUrl());
                nodeName = null;
            }

            if (tagList.PrimaryTag.trailer != null)
            {
                progress.Warning(urlConfig, "unrecognized trailer: '" + tagList.PrimaryTag.trailer + "' on: " + urlConfig.SafeUrl());
            }

            string         needs         = null;
            string         has           = null;
            IPassSpecifier passSpecifier = null;

            foreach (Tag tag in tagList)
            {
                if (tag.trailer != null)
                {
                    progress.Warning(urlConfig, "unrecognized trailer: '" + tag.trailer + "' on: " + urlConfig.SafeUrl());
                }

                if (tag.key.Equals("NEEDS", StringComparison.CurrentCultureIgnoreCase))
                {
                    if (needs != null)
                    {
                        progress.Warning(urlConfig, "more than one :NEEDS tag detected, ignoring all but the first: " + urlConfig.SafeUrl());
                        continue;
                    }
                    if (string.IsNullOrEmpty(tag.value))
                    {
                        progress.Error(urlConfig, "empty :NEEDS tag detected: " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }

                    needs = tag.value;
                }
                else if (tag.key.Equals("HAS", StringComparison.CurrentCultureIgnoreCase))
                {
                    if (command == Command.Insert)
                    {
                        progress.Error(urlConfig, ":HAS detected on insert node (not a patch): " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }
                    if (has != null)
                    {
                        progress.Warning(urlConfig, "more than one :HAS tag detected, ignoring all but the first: " + urlConfig.SafeUrl());
                        continue;
                    }
                    if (string.IsNullOrEmpty(tag.value))
                    {
                        progress.Error(urlConfig, "empty :HAS tag detected: " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }

                    has = tag.value;
                }
                else if (tag.key.Equals("FIRST", StringComparison.CurrentCultureIgnoreCase))
                {
                    if (tag.value != null)
                    {
                        progress.Warning(urlConfig, "value detected on :FIRST tag: " + urlConfig.SafeUrl());
                    }

                    if (command == Command.Insert)
                    {
                        progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }
                    if (passSpecifier != null)
                    {
                        progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl());
                        continue;
                    }

                    passSpecifier = new FirstPassSpecifier();
                }
                else if (tag.key.Equals("BEFORE", StringComparison.CurrentCultureIgnoreCase))
                {
                    if (string.IsNullOrEmpty(tag.value))
                    {
                        progress.Error(urlConfig, "empty :BEFORE tag detected: " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }

                    if (command == Command.Insert)
                    {
                        progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }
                    if (passSpecifier != null)
                    {
                        progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl());
                        continue;
                    }

                    passSpecifier = new BeforePassSpecifier(tag.value, urlConfig);
                }
                else if (tag.key.Equals("FOR", StringComparison.CurrentCultureIgnoreCase))
                {
                    if (string.IsNullOrEmpty(tag.value))
                    {
                        progress.Error(urlConfig, "empty :FOR tag detected: " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }

                    if (command == Command.Insert)
                    {
                        progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }
                    if (passSpecifier != null)
                    {
                        progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl());
                        continue;
                    }

                    passSpecifier = new ForPassSpecifier(tag.value, urlConfig);
                }
                else if (tag.key.Equals("AFTER", StringComparison.CurrentCultureIgnoreCase))
                {
                    if (string.IsNullOrEmpty(tag.value))
                    {
                        progress.Error(urlConfig, "empty :AFTER tag detected: " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }

                    if (command == Command.Insert)
                    {
                        progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }
                    if (passSpecifier != null)
                    {
                        progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl());
                        continue;
                    }

                    passSpecifier = new AfterPassSpecifier(tag.value, urlConfig);
                }
                else if (tag.key.Equals("LAST", StringComparison.CurrentCultureIgnoreCase))
                {
                    if (string.IsNullOrEmpty(tag.value))
                    {
                        progress.Error(urlConfig, "empty :LAST tag detected: " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }

                    if (command == Command.Insert)
                    {
                        progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }
                    if (passSpecifier != null)
                    {
                        progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl());
                        continue;
                    }

                    passSpecifier = new LastPassSpecifier(tag.value);
                }
                else if (tag.key.Equals("FINAL", StringComparison.CurrentCultureIgnoreCase))
                {
                    if (tag.value != null)
                    {
                        progress.Warning(urlConfig, "value detected on :FINAL tag: " + urlConfig.SafeUrl());
                    }

                    if (command == Command.Insert)
                    {
                        progress.Error(urlConfig, "pass specifier detected on insert node (not a patch): " + urlConfig.SafeUrl());
                        error = true;
                        continue;
                    }
                    if (passSpecifier != null)
                    {
                        progress.Warning(urlConfig, "more than one pass specifier detected, ignoring all but the first: " + urlConfig.SafeUrl());
                        continue;
                    }

                    passSpecifier = new FinalPassSpecifier();
                }
                else
                {
                    progress.Warning(urlConfig, "unrecognized tag: '" + tag.key + "' on: " + urlConfig.SafeUrl());
                }
            }

            if (error)
            {
                return(null);
            }

            if (passSpecifier == null)
            {
                if (command == Command.Insert)
                {
                    passSpecifier = new InsertPassSpecifier();
                }
                else
                {
                    passSpecifier = new LegacyPassSpecifier();
                }
            }

            return(new ProtoPatch(urlConfig, command, nodeType, nodeName, needs, has, passSpecifier));
        }