Beispiel #1
0
            public void Should_Throw_If_Method_Is_Null()
            {
                // Given, When
                var result = Record.Exception(() => PropertyAliasGenerator.Generate(null));

                // Then
                Assert.IsArgumentNullException(result, "method");
            }
            public void Should_Throw_If_Method_Is_Null()
            {
                // Given, When
                var result = Record.Exception(() => PropertyAliasGenerator.Generate(null));

                // Then
                Assert.IsType <ArgumentNullException>(result);
                Assert.Equal("method", ((ArgumentNullException)result).ParamName);
            }
Beispiel #3
0
            public void Should_Throw_If_Declaring_Type_Is_Not_Static()
            {
                // Given
                var method = GetType().GetMethod("Should_Throw_If_Declaring_Type_Is_Not_Static");

                // When
                var result = Record.Exception(() => PropertyAliasGenerator.Generate(method));

                // Then
                Assert.IsType <CakeException>(result);
                Assert.Equal("The type 'Cake.Core.Tests.Unit.Scripting.CodeGen.PropertyAliasGeneratorTests+TheGenerateMethod' is not static.", result.Message);
            }
Beispiel #4
0
        private static string GetAliasCode(Script context)
        {
            var result = new List <string>();

            foreach (var alias in context.Aliases)
            {
                result.Add(alias.Type == ScriptAliasType.Method
                    ? MethodAliasGenerator.Generate(alias.Method)
                    : PropertyAliasGenerator.Generate(alias.Method));
            }
            return(string.Join("\r\n", result));
        }
Beispiel #5
0
            public void Should_Throw_If_Method_Is_Generic()
            {
                // Given
                var method = typeof(PropertyAliasGeneratorFixture).GetMethod("GenericScriptMethod");

                // When
                var result = Record.Exception(() => PropertyAliasGenerator.Generate(method));

                // Then
                Assert.IsType <CakeException>(result);
                Assert.Equal("The property alias 'GenericScriptMethod' cannot be generic.",
                             result.Message);
            }
Beispiel #6
0
            public void Should_Throw_If_Property_Alias_Do_Not_Have_A_Cake_Context_As_First_Parameter()
            {
                // Given
                var method = typeof(PropertyAliasGeneratorFixture).GetMethod("PropertyAliasWithoutContext");

                // When
                var result = Record.Exception(() => PropertyAliasGenerator.Generate(method));

                // Then
                Assert.IsType <CakeException>(result);
                Assert.Equal("The property alias 'PropertyAliasWithoutContext' has an invalid signature.",
                             result.Message);
            }
Beispiel #7
0
            public void Should_Throw_If_Property_Alias_Have_More_Than_One_Argument()
            {
                // Given
                var method = typeof(PropertyAliasGeneratorFixture).GetMethod("PropertyAliasWithMoreThanOneMethod");

                // When
                var result = Record.Exception(() => PropertyAliasGenerator.Generate(method));

                // Then
                Assert.IsType <CakeException>(result);
                Assert.Equal("The property alias 'PropertyAliasWithMoreThanOneMethod' has an invalid signature.",
                             result.Message);
            }
Beispiel #8
0
            public void Should_Throw_If_Method_Is_Not_An_Cake_Property_Alias()
            {
                // Given
                var method = typeof(PropertyAliasGeneratorFixture).GetMethod("NotAScriptMethod");

                // When
                var result = Record.Exception(() => PropertyAliasGenerator.Generate(method));

                // Then
                Assert.IsType <CakeException>(result);
                Assert.Equal("The method 'NotAScriptMethod' is not a property alias.",
                             result.Message);
            }
Beispiel #9
0
            public void Should_Throw_If_Property_Alias_Returns_Void()
            {
                // Given
                var method = typeof(PropertyAliasGeneratorFixture).GetMethod("PropertyAliasReturningVoid");

                // When
                var result = Record.Exception(() => PropertyAliasGenerator.Generate(method));

                // Then
                Assert.IsType <CakeException>(result);
                Assert.Equal("The property alias 'PropertyAliasReturningVoid' cannot return void.",
                             result.Message);
            }
Beispiel #10
0
            public void Should_Generate_Correct_Code_For_Valid_Property_Alias()
            {
                // Given
                const string expected = "public System.Int32 PropertyAliasReturningInteger{get{return " +
                                        "Cake.Core.Tests.Fixtures.PropertyAliasGeneratorFixture.PropertyAliasReturningInteger(Context);}}";

                var method = typeof(PropertyAliasGeneratorFixture).GetMethod("PropertyAliasReturningInteger");

                // When
                var result = PropertyAliasGenerator.Generate(method);

                // Then
                Assert.Equal(expected, result);
            }
Beispiel #11
0
        private static string GenerateCode(MethodInfo method)
        {
            string code;

            if (method.IsDefined(typeof(CakeMethodAliasAttribute)))
            {
                code = MethodAliasGenerator.Generate(method);
            }
            else if (method.IsDefined(typeof(CakePropertyAliasAttribute)))
            {
                code = PropertyAliasGenerator.Generate(method);
            }
            else
            {
                throw new InvalidOperationException("Unknown alias type.");
            }
            return(code);
        }
Beispiel #12
0
            public void Should_Generate_Cached_Code_For_Cached_Property_Alias_Returning_Value_Type()
            {
                // Given
                var expected = new StringBuilder();

                expected.Append("private System.Boolean? _PropertyAliasReturningCachedBoolean;\n");
                expected.Append("public System.Boolean PropertyAliasReturningCachedBoolean{get{");
                expected.Append("if(_PropertyAliasReturningCachedBoolean==null){_PropertyAliasReturningCachedBoolean=");
                expected.Append("Cake.Core.Tests.Fixtures.PropertyAliasGeneratorFixture.PropertyAliasReturningCachedBoolean");
                expected.Append("(Context);}return _PropertyAliasReturningCachedBoolean.Value;}}");

                var method = typeof(PropertyAliasGeneratorFixture).GetMethod("PropertyAliasReturningCachedBoolean");

                // When
                var result = PropertyAliasGenerator.Generate(method);

                // Then
                Assert.Equal(expected.ToString(), result);
            }
Beispiel #13
0
        private static string GetAliasCode(Script context)
        {
            var result = new Dictionary <string, string>();

            foreach (var alias in context.Aliases)
            {
                string hash, code = alias.Type == ScriptAliasType.Method
                    ? MethodAliasGenerator.Generate(alias.Method, out hash)
                    : PropertyAliasGenerator.Generate(alias.Method, out hash);

                string @namespace = alias.Method.DeclaringType.Namespace ?? "@null";
                if (result.ContainsKey(hash))
                {
                    var message = $"{alias.Type.ToString().ToLowerInvariant()} \"{alias.Name}\" excluded from code generation and will need to be fully qualified on ICakeContext.";
                    if (context.ExcludedNamespaces.ContainsKey(@namespace))
                    {
                        context.ExcludedNamespaces[@namespace].Add(message);
                    }
                    else
                    {
                        context.ExcludedNamespaces.Add(@namespace,
                                                       new List <string>()
                        {
                            message
                        });
                    }
                    continue;
                }
                else if (context.ExcludedNamespaces.ContainsKey(@namespace))
                {
                    var message = $"{alias.Type.ToString().ToLowerInvariant()} \"{alias.Name}\" was included in code generation, but will need to be fully qualified on ICakeContext.";
                    context.ExcludedNamespaces[@namespace].Add(message);
                }

                result.Add(hash, code);
            }
            return(string.Join("\r\n", result.Values));
        }
Beispiel #14
0
        public string Generate(string name)
        {
            var method = _methods.SingleOrDefault(x => x.Name == name);

            return(PropertyAliasGenerator.Generate(method).NormalizeGeneratedCode());
        }