Ejemplo n.º 1
0
        public Task <object> CallAsync(MockCallArgs args)
        {
            var outputs = ImmutableDictionary.CreateBuilder <string, object>();

            if (args.Token == "aws:index/getAmi:getAmi")
            {
                outputs.Add("architecture", "x86_64");
                outputs.Add("id", "ami-0eb1f3cdeeb8eed2a");
            }

            return(Task.FromResult((object)outputs));
        }
Ejemplo n.º 2
0
        public Task <object> CallAsync(MockCallArgs args)
        {
            if (args.Token == "mypkg::listStorageAccountKeys")
            {
                var argsString   = string.Join(", ", args.Args.Keys.OrderBy(k => k).Select(k => $"{k}: {args.Args[k]}"));
                var dictBuilder  = ImmutableDictionary.CreateBuilder <string, Object>();
                var arrayBuilder = ImmutableArray.CreateBuilder <object>();
                var elemBuilder  = ImmutableDictionary.CreateBuilder <string, Object>();
                elemBuilder.Add("creationTime", "my-creation-time");
                elemBuilder.Add("keyName", "my-key-name");
                elemBuilder.Add("permissions", "my-permissions");
                elemBuilder.Add("value", "[" + argsString + "]");
                arrayBuilder.Add(elemBuilder.ToImmutableDictionary());
                dictBuilder.Add("keys", arrayBuilder.ToImmutableArray());
                var result = dictBuilder.ToImmutableDictionary();
                return(Task.FromResult((Object)result));
            }

            if (args.Token == "mypkg::getAmiIds")
            {
                // NOTE: only subset of possible fields are tested here in the smoke-test.
                var filters      = (ImmutableArray <object>)args.Args["filters"];
                var filterString = string.Join(
                    ", ",
                    filters
                    .Select(f => (ImmutableDictionary <string, object>)f)
                    .Select(d =>
                {
                    var name   = (string)d["name"];
                    var values = string.Join(", ", ((ImmutableArray <object>)d["values"]).Select(x => (string)x));
                    return($"name={name} values=[{values}]");
                }));
                filterString = $"[{filterString}]";
                var owners        = (ImmutableArray <object>)args.Args["owners"];
                var ownersString  = string.Join(", ", owners.Select(x => (string)x));
                var sortAscending = (bool)args.Args["sortAscending"];
                var nameRegex     = (string)args.Args["nameRegex"];
                var dictBuilder   = ImmutableDictionary.CreateBuilder <string, Object>();
                dictBuilder.Add("id", $"my-id [owners: {ownersString}] [filters: {filterString}]");
                dictBuilder.Add("nameRegex", nameRegex);
                dictBuilder.Add("sortAscending", sortAscending);
                var result = dictBuilder.ToImmutableDictionary();
                return(Task.FromResult((Object)result));
            }

            throw new Exception($"CallAsync not implemented for {args.Token}..");
        }
Ejemplo n.º 3
0
 public Task <object> CallAsync(MockCallArgs args)
 {
     // We don't use this method in this particular test suite.
     // Default to returning whatever we got as input.
     return(Task.FromResult((object)args.Args));
 }
Ejemplo n.º 4
0
 public Task <object> CallAsync(MockCallArgs args)
 {
     return(Task.FromResult <object>(args));
 }
Ejemplo n.º 5
0
 public Task <object> CallAsync(MockCallArgs args)
 {
     throw new Exception($"Unknown function {args.Token}");
 }
Ejemplo n.º 6
0
 public Task <object> CallAsync(MockCallArgs args)
 {
     throw new Exception("CallAsync should not be called");
 }
Ejemplo n.º 7
0
        public Task <object> CallAsync(MockCallArgs args)
        {
            if (args.Token == "mypkg::funcWithAllOptionalInputs" ||
                args.Token == "mypkg::funcWithDefaultValue")
            {
                var dictBuilder = ImmutableDictionary.CreateBuilder <string, Object>();
                var a           = args.Args.GetValueOrDefault("a", "null");
                var b           = args.Args.GetValueOrDefault("b", "null");
                dictBuilder.Add("r", $"a={a} b={b}");
                var result = dictBuilder.ToImmutableDictionary();
                return(Task.FromResult((Object)result));
            }

            if (args.Token == "mypkg::funcWithDictParam")
            {
                string aString = "null";
                if (args.Args.ContainsKey("a"))
                {
                    var a = (ImmutableDictionary <string, object>)args.Args["a"];
                    aString = string.Join(", ", a.Keys.OrderBy(k => k).Select(k => $"{k}: {a[k]}"));
                    aString = $"[{aString}]";
                }
                var b           = args.Args.GetValueOrDefault("b", "null");
                var dictBuilder = ImmutableDictionary.CreateBuilder <string, Object>();
                dictBuilder.Add("r", $"a={aString} b={b}");
                var result = dictBuilder.ToImmutableDictionary();
                return(Task.FromResult((Object)result));
            }

            if (args.Token == "mypkg::funcWithListParam")
            {
                string aString = "null";
                if (args.Args.ContainsKey("a"))
                {
                    var a = (ImmutableArray <object>)args.Args["a"];
                    aString = string.Join(", ", a.OrderBy(k => k).Select(e => $"{e}"));
                    aString = $"[{aString}]";
                }
                var b           = args.Args.GetValueOrDefault("b", "null");
                var dictBuilder = ImmutableDictionary.CreateBuilder <string, Object>();
                dictBuilder.Add("r", $"a={aString} b={b}");
                var result = dictBuilder.ToImmutableDictionary();
                return(Task.FromResult((Object)result));
            }

            if (args.Token == "mypkg::getIntegrationRuntimeObjectMetadatum")
            {
                var argsString   = string.Join(", ", args.Args.Keys.OrderBy(k => k).Select(k => $"{k}: {args.Args[k]}"));
                var dictBuilder  = ImmutableDictionary.CreateBuilder <string, Object>();
                var arrayBuilder = ImmutableArray.CreateBuilder <object>();
                arrayBuilder.Add(argsString);
                dictBuilder.Add("value", arrayBuilder.ToImmutableArray());
                dictBuilder.Add("nextLink", "my-next-link");
                var result = dictBuilder.ToImmutableDictionary();
                return(Task.FromResult((Object)result));
            }

            if (args.Token == "mypkg::listStorageAccountKeys")
            {
                var argsString   = string.Join(", ", args.Args.Keys.OrderBy(k => k).Select(k => $"{k}: {args.Args[k]}"));
                var dictBuilder  = ImmutableDictionary.CreateBuilder <string, Object>();
                var arrayBuilder = ImmutableArray.CreateBuilder <object>();
                var elemBuilder  = ImmutableDictionary.CreateBuilder <string, Object>();
                elemBuilder.Add("creationTime", "my-creation-time");
                elemBuilder.Add("keyName", "my-key-name");
                elemBuilder.Add("permissions", "my-permissions");
                elemBuilder.Add("value", "[" + argsString + "]");
                arrayBuilder.Add(elemBuilder.ToImmutableDictionary());
                dictBuilder.Add("keys", arrayBuilder.ToImmutableArray());
                var result = dictBuilder.ToImmutableDictionary();
                return(Task.FromResult((Object)result));
            }

            throw new Exception($"CallAsync not implemented for {args.Token}..");
        }