122 lines
7.6 KiB
TypeScript
122 lines
7.6 KiB
TypeScript
// Copyright 2016-2018, Pulumi Corporation.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
import * as assert from "assert";
|
|
import { Config, runtime } from "../index";
|
|
|
|
describe("config", () => {
|
|
it("works, basically", () => {
|
|
// Set up some config and then read them back as strings.
|
|
runtime.setConfig("pkg:a", "foo");
|
|
runtime.setConfig("pkg:bar", "b");
|
|
runtime.setConfig("pkg:baz", "baz");
|
|
runtime.setConfig("otherpkg:a", "babble");
|
|
runtime.setConfig("otherpkg:nothere", "bazzle");
|
|
const config = new Config("pkg");
|
|
assert.strictEqual("foo", config.get("a"));
|
|
assert.strictEqual("foo", config.require("a"));
|
|
assert.strictEqual("b", config.get("bar"));
|
|
assert.strictEqual("b", config.require("bar"));
|
|
assert.strictEqual("baz", config.get("baz"));
|
|
assert.strictEqual("baz", config.require("baz"));
|
|
assert.strictEqual(undefined, config.get("nothere"));
|
|
assert.throws(() => { config.require("missing"); });
|
|
});
|
|
it("does strongly typed too!", () => {
|
|
// Set up some config and then read them back as typed things.
|
|
runtime.setConfig("pkg:boolf", "false");
|
|
runtime.setConfig("pkg:boolt", "true");
|
|
runtime.setConfig("pkg:num", "42.333");
|
|
runtime.setConfig("pkg:array", "[ 0, false, 2, \"foo\" ]");
|
|
runtime.setConfig("pkg:struct", "{ \"foo\": \"bar\", \"mim\": [] }");
|
|
const config = new Config("pkg");
|
|
assert.strictEqual(false, config.getBoolean("boolf"));
|
|
assert.strictEqual(false, config.requireBoolean("boolf"));
|
|
assert.strictEqual(true, config.getBoolean("boolt"));
|
|
assert.strictEqual(true, config.requireBoolean("boolt"));
|
|
assert.strictEqual(undefined, config.getBoolean("boolmissing"));
|
|
assert.strictEqual(42.333, config.getNumber("num"));
|
|
assert.strictEqual(42.333, config.requireNumber("num"));
|
|
assert.strictEqual(undefined, config.getNumber("nummissing"));
|
|
assert.deepStrictEqual([ 0, false, 2, "foo" ], config.getObject<any>("array"));
|
|
assert.deepStrictEqual([ 0, false, 2, "foo" ], config.requireObject<any>("array"));
|
|
assert.deepStrictEqual({ "foo": "bar", "mim": [] }, config.getObject<any>("struct"));
|
|
assert.deepStrictEqual({ "foo": "bar", "mim": [] }, config.requireObject<any>("struct"));
|
|
assert.strictEqual(undefined, config.getObject<any>("complexmissing"));
|
|
// ensure requireX throws when missing:
|
|
assert.throws(() => { config.requireBoolean("missing"); });
|
|
assert.throws(() => { config.requireNumber("missing"); });
|
|
assert.throws(() => { config.requireObject<any>("missing"); });
|
|
// ensure getX throws when the value is of the wrong type:
|
|
assert.throws(() => { config.getBoolean("num"); });
|
|
assert.throws(() => { config.getNumber("boolf"); });
|
|
});
|
|
it("does enums", () => {
|
|
runtime.setConfig("pkg:color", "orange");
|
|
const config = new Config("pkg");
|
|
assert.strictEqual("orange", config.get("color", { allowedValues: [ "purple", "orange", "blue" ] }));
|
|
assert.strictEqual(undefined, config.get("missing", { allowedValues: [ "purple", "orange", "blue" ] }));
|
|
assert.strictEqual("orange", config.require("color", { allowedValues: [ "purple", "orange", "blue" ] }));
|
|
assert.throws(() => { config.get("color", { allowedValues: [ "purple", "black", "blue" ] }); });
|
|
assert.throws(() => { config.require("color", { allowedValues: [ "purple", "black", "blue" ] }); });
|
|
assert.throws(() => { config.require("missing", { allowedValues: [ "purple", "orange", "blue" ] }); });
|
|
});
|
|
it("does min/max (strlen)", () => {
|
|
runtime.setConfig("pkg:strlen", "abcdefgh");
|
|
const config = new Config("pkg");
|
|
assert.strictEqual("abcdefgh", config.get("strlen", { minLength: 0, maxLength: 8 }));
|
|
assert.strictEqual("abcdefgh", config.get("strlen", { minLength: 8, maxLength: 8 }));
|
|
assert.strictEqual("abcdefgh", config.get("strlen", { minLength: 0, maxLength: 16 }));
|
|
assert.strictEqual(undefined, config.get("missing", { minLength: 0, maxLength: 8 }));
|
|
assert.strictEqual("abcdefgh", config.require("strlen", { minLength: 0, maxLength: 8 }));
|
|
assert.strictEqual("abcdefgh", config.require("strlen", { minLength: 8, maxLength: 8 }));
|
|
assert.strictEqual("abcdefgh", config.require("strlen", { minLength: 0, maxLength: 16 }));
|
|
assert.throws(() => { config.get("strlen", { minLength: 9, maxLength: 16 }); });
|
|
assert.throws(() => { config.get("strlen", { minLength: 0, maxLength: 7 }); });
|
|
assert.throws(() => { config.require("strlen", { minLength: 9, maxLength: 16 }); });
|
|
assert.throws(() => { config.require("strlen", { minLength: 0, maxLength: 7 }); });
|
|
assert.throws(() => { config.require("missing", { minLength: 0, maxLength: 8 }); });
|
|
});
|
|
it("does pattern matching", () => {
|
|
runtime.setConfig("pkg:pattern", "aBcDeFgH");
|
|
const config = new Config("pkg");
|
|
assert.strictEqual("aBcDeFgH", config.get("pattern", { pattern: /^[a-zA-Z]*$/ }));
|
|
assert.strictEqual("aBcDeFgH", config.get("pattern", { pattern: "^[a-zA-Z]*$" }));
|
|
assert.strictEqual(undefined, config.get("missing", { pattern: /^[a-zA-Z]*$/ }));
|
|
assert.strictEqual("aBcDeFgH", config.require("pattern", { pattern: /^[a-zA-Z]*$/ }));
|
|
assert.strictEqual("aBcDeFgH", config.require("pattern", { pattern: "^[a-zA-Z]*$" }));
|
|
assert.throws(() => { config.get("pattern", { pattern: /^[a-z]*$/ }); }, "bad pattern: get");
|
|
assert.throws(() => { config.get("pattern", { pattern: "/^[a-z]*$/" }); }, "bad pattern (string): get");
|
|
assert.throws(() => { config.require("pattern", { pattern: /^[a-z]*$/ }); }, "bad pattern: require");
|
|
assert.throws(() => { config.require("pattern", { pattern: "/^[a-z]*$/" }); }, "bad pattern (string): require");
|
|
assert.throws(() => { config.require("missing", { pattern: /^[a-z]*$/ }); }, "missing");
|
|
});
|
|
it("does min/max (numbers)", () => {
|
|
runtime.setConfig("pkg:quantity", "8");
|
|
const config = new Config("pkg");
|
|
assert.strictEqual(8, config.getNumber("quantity", { min: 0, max: 8 }));
|
|
assert.strictEqual(8, config.getNumber("quantity", { min: 8, max: 8 }));
|
|
assert.strictEqual(8, config.getNumber("quantity", { min: 0, max: 16 }));
|
|
assert.strictEqual(undefined, config.getNumber("missing", { min: 0, max: 8 }));
|
|
assert.strictEqual(8, config.requireNumber("quantity", { min: 0, max: 8 }));
|
|
assert.strictEqual(8, config.requireNumber("quantity", { min: 8, max: 8 }));
|
|
assert.strictEqual(8, config.requireNumber("quantity", { min: 0, max: 16 }));
|
|
assert.throws(() => { config.getNumber("quantity", { min: 9, max: 16 }); });
|
|
assert.throws(() => { config.getNumber("quantity", { min: 0, max: 7 }); });
|
|
assert.throws(() => { config.requireNumber("quantity", { min: 9, max: 16 }); });
|
|
assert.throws(() => { config.requireNumber("quantity", { min: 0, max: 7 }); });
|
|
assert.throws(() => { config.requireNumber("missing", { min: 0, max: 8 }); });
|
|
});
|
|
});
|