public void DependencyGraphNode_doesnt_satisfy_request_for_enumerable_of_other_service()
        {
            var sut = new DependencyGraphNode();
            sut.InterfaceType = typeof(Sword);

            Assert.False(sut.SatisfiesDependencyOn(typeof(IList<Shuriken>)));
        }
        public void DependencyGraphNode_satisfies_request_for_service()
        {
            var sut = new DependencyGraphNode();
            sut.InterfaceType = typeof(Sword);

            Assert.True(sut.SatisfiesDependencyOn(typeof(Sword)));
        }
        public void DependencyGraphNode_doesnt_satisfy_other_services()
        {
            var sut = new DependencyGraphNode();
            sut.InterfaceType = typeof(Sword);

            Assert.False(sut.SatisfiesDependencyOn(typeof(Shuriken)));
        }
        private string DoBeginNodeVisitForNode(DependencyGraphNode node, int offset)
        {
            StringBuilder result = new StringBuilder();
            TextWriter writer = new StringWriter(result);

            var sut = new PrintingDependencyGraphVisitor(writer);

            sut.BeginNodeVisit(node, offset, new Type[0]);

            return result.ToString();
        }
        public void prints_interface_name()
        {
            var node = new DependencyGraphNode()
            {
                InterfaceType = interfaceType
            };

            string resultString = DoBeginNodeVisitForNode(node, 0);

            resultString.ShouldContain("IList");
        }
        public void prints_implementation_name()
        {
            var node = new DependencyGraphNode()
            {
                InterfaceType = interfaceType,
                ImplementationName = "someString1254"
            };

            string resultString = DoBeginNodeVisitForNode(node, 0);

            resultString.ShouldContain(node.ImplementationName);
        }
        public void prints_spacing()
        {
            int offset = 2;
            string expectedSpacing = "        ";

            var node = new DependencyGraphNode()
            {
                InterfaceType = interfaceType
            };

            string resultString = DoBeginNodeVisitForNode(node, offset);

            resultString.Substring(0, 8).ShouldBe(expectedSpacing);
        }
        public void GetBoundServices_includes_Dependencies()
        {
            var expectedNode = new DependencyGraphNode()
            {
                InterfaceType = typeof(IWeapon)
            };

            var sut = new DependencyGraphNode();
            sut.Dependencies = new[] { typeof(IWeapon) };

            var result = sut.GetBoundServices(new DependencyGraphNode[] {
                expectedNode,
                sut
            });

            result.ShouldContain(expectedNode);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="node"></param>
        /// <param name="i"></param>
        /// <param name="missingDependencies"></param>
        public void BeginNodeVisit(DependencyGraphNode node, int i, IEnumerable<Type> missingDependencies)
        {
            if (i == 0)
                _writer.WriteLine();

            _writer.Write(String.Concat(Enumerable.Range(0, i).Select(_ => "    ").ToArray()));

            if (node.ImplementationName == null
                || node.ImplementationName == node.InterfaceType.Format())
            {
                _writer.WriteLine("{0}", node.InterfaceType.Name);
            } else
            {
                _writer.WriteLine("{0} ({1})", node.ImplementationName, node.InterfaceType.Format());
            }

            if (missingDependencies.Any())
            {
                _writer.WriteLine("MISSING DEPENDENCIES: " +
                                  string.Join(", ", missingDependencies.Select(d => d.Format()).ToArray()));
            }
        }
Esempio n. 10
0
        public void GetMissingDependencies_includes_missing_dependencies()
        {
            var expectedNode = new DependencyGraphNode()
            {
                InterfaceType = typeof(IWeapon)
            };

            var sut = new DependencyGraphNode();
            sut.Dependencies = new[] { typeof(IWeapon), typeof(IWarrior) };

            var result = sut.GetMissingDependencies(new DependencyGraphNode[] {
                expectedNode,
                sut
            });

            result.ShouldContain(typeof(IWarrior));
        }