public void should_build_value_for_parameter_using_parameter_type_and_tag(MethodArgumentTuner forParameter)
        {
            const string tag      = "tag398";
            const string expected = "expected 398752";

            // --arrange
            var target = CreateTarget();

            target
            .Treat <LevelOne>()
            .AsIs()
            .UsingArguments(forParameter.UseTag(tag), "bad");

            target
            .Treat <string>(tag)
            .AsInstance(expected);

            target
            .Treat <string>("bad_tag")
            .AsInstance("bad");

            target
            .Treat <string>()
            .AsInstance("bad");

            // --act
            var actual = target.Build <LevelOne>() !;

            // --assert
            actual.Text.Should().Be(expected);
        }
    public void should_add_build_argument_by_parameter_type_with_tag_build_action([Values(39, "tag")] object tag)
    {
        const int expectedWeight = 298;

        // --arrange
        var target = new MethodArgumentTuner((node, _) => node);
        var root   = new Root(expectedWeight);

        // --act
        target.UseTag(tag).Tune(root);

        // --assert
        var result = root.GatherBuildActions(default, out var actionBag, 0);
        public void should_pass_null_as_parameter_value(MethodArgumentTuner forParameter)
        {
            // --arrange
            var target = CreateTarget();

            target
            .Treat <string>()
            .AsInstance("938754");

            target
            .Treat <LevelOne>()
            .AsIs()
            .UsingArguments(forParameter.UseValue(null));

            // --act
            var actual = target.Build <LevelOne>() !;

            // --assert
            actual.Text.Should().BeNull();
        }
        public void should_use_factory_method(MethodArgumentTuner forParameter)
        {
            const int expectedInt = 392;

            // --arrange
            var target = CreateTarget();

            target.Treat <int>().AsInstance(expectedInt);

            target
            .Treat <LevelOne>()
            .AsIs()
            .UsingArguments(forParameter.UseFactoryMethod <int>(intValue => intValue.ToString()));

            // --act
            var actual = target.Build <LevelOne>() !;

            // --assert
            actual.Text.Should().Be(expectedInt.ToString());
        }
        public void should_fail_if_there_is_no_value_w_tag_registered(MethodArgumentTuner forParameter)
        {
            // --arrange
            var target = CreateTarget();

            target
            .Treat <string>()
            .AsInstance("09765");

            target
            .Treat <LevelOne>()
            .AsIs()
            .UsingArguments(forParameter.UseTag("tag"));

            // --act
            Action actual = () => target.Build <LevelOne>();

            // --assert
            actual.Should().ThrowExactly <ArmatureException>();
        }
        public void should_use_value_for_parameter(MethodArgumentTuner forParameter)
        {
            const string expected = "expected";

            // --arrange
            var target = CreateTarget();

            target.Treat <string>().AsInstance("bad");

            target
            .Treat <LevelOne>()
            .AsIs()
            .UsingArguments(forParameter.UseValue(expected), "bad");

            // --act
            var actual = target.Build <LevelOne>() !;

            // --assert
            actual.Text.Should().Be(expected);
        }