Пример #1
0
def test_buildrecipe_load_valid() -> None:
    """Test loading a valid BuildRecipe from file."""
    with open(BUILDRECIPE_VALID) as fp:
        assert BuildRecipe.load_from_file(fp) == BuildRecipe(commands=[
            "FROM test",
            "RUN cd .",
        ])
Пример #2
0
def test_environmentrecipe_instantiation() -> None:
    """Test creating Environment Recipes."""
    EnvironmentRecipe(BuildRecipe(), RunRecipe(), "potato")
    EnvironmentRecipe(
        build=BuildRecipe(),
        run=RunRecipe(),
        name=None,
    )
Пример #3
0
def test_buildrecipe_repr() -> None:
    """Test evaluable string representation of BuildRecipe."""
    b1 = BuildRecipe([])
    b2 = BuildRecipe(
        ["dfafuho&*(*&^%", "8$&__*!", "@~@}{?>?"],
    )

    assert eval(repr(b1)) == b1
    assert eval(repr(b2)) == b2
Пример #4
0
def test_buildrecipe_build_str() -> None:
    """Test Dockerfile strings from BuildRecipe."""
    b1 = BuildRecipe([])
    b2 = BuildRecipe(["FROM example:17", "RUN setup-1", "EXPOSE 8080"])

    assert b1.build_str == ""
    assert b2.build_str == (
        "FROM example:17\n"
        "RUN setup-1\n"
        "EXPOSE 8080\n"
    )
Пример #5
0
def test_buildrecipe_str() -> None:
    """Test human-readable string representation of BuildRecipe."""
    b1 = BuildRecipe([])
    b2 = BuildRecipe(["FROM java", "RUN cd ."])

    assert str(b1) == "BuildRecipe [\n]"
    assert str(b2) == (
        "BuildRecipe [\n"
        "\tFROM java\n"
        "\tRUN cd .\n"
        "]"
    )
Пример #6
0
def test_buildrecipe_eq() -> None:
    """Test equality of build recipes."""
    b1 = BuildRecipe(["a", "b"])
    b2 = BuildRecipe(["a", "b"])
    b3 = BuildRecipe(["a"])
    b4 = BuildRecipe(["a", "q"])

    assert b1 == b2
    assert b2 == b1
    assert b1 != b3 and b3 != b1
    assert b1 != b4 and b4 != b1

    assert BuildRecipe([]) != "I did not hit her, I did not! Oh, hi Mark."
Пример #7
0
def test_buildrecipe_add() -> None:
    """Test adding build recipes."""
    b1 = BuildRecipe()
    b2 = BuildRecipe(["1", "2", "3"])
    b3 = BuildRecipe()
    b4 = BuildRecipe(["4", "5"])
    b5 = BuildRecipe(["1", "2", "3", "4", "5"])

    assert b1 + b2 + b3 + b4 == b5

    b2 += b1
    b2 += b4
    b2 += b3

    assert b2 == b5
Пример #8
0
def test_component_should_run() -> None:
    """Test whether components should be executed."""
    c1 = Component(RunRecipe(),
                   [ImageName("ubuntu"),
                    ImageName("debian", "stretch")])
    c2 = Component(BuildRecipe(["FROM nixos"]))

    i1 = ImageName("ubuntu")
    i2 = ImageName("ubuntu", "18.04")
    i3 = ImageName("debian")
    i4 = ImageName("debian", "stretch")
    i5 = ImageName("debian", "jessie")
    i6 = ImageName("arch")

    assert c1.should_run(i1)
    assert c1.should_run(i2)
    assert not c1.should_run(i3)
    assert c1.should_run(i4)
    assert not c1.should_run(i5)
    assert not c1.should_run(i6)

    assert c2.should_run(i1)
    assert c2.should_run(i2)
    assert c2.should_run(i3)
    assert c2.should_run(i4)
    assert c2.should_run(i5)
    assert c2.should_run(i6)
Пример #9
0
def test_component_load_valid() -> None:
    """Test loading a component from a file."""
    with open(COMPONENT_VALID) as fp:
        assert Component.load_from_file(fp) == Component(
            recipe=BuildRecipe(commands=["RUN cd .."]),
            compatible=[ImageName("example"),
                        ImageName("test", "13.2")],
            description="A very exciting component.",
        )
Пример #10
0
def test_component_initialisation() -> None:
    """Test creating components."""
    Component(BuildRecipe(["RUN cd ."]))
    Component(
        RunRecipe(script=["a", "b"]),
        [ImageName.from_str("a/b:c"),
         ImageName("qwerty", "uiop")],
        None,
        "does absolutely nothing",
    )
Пример #11
0
def test_environmentdefinition_load_valid() -> None:
    """Test loading Environment Definition from file."""
    m1 = Module(
        name="ubuntu",
        components=[
            Component(
                recipe=BuildRecipe(commands=["FROM ubuntu"]),
                results=ImageName("ubuntu"),
            )
        ],
    )

    m2 = Module(
        name="zsh",
        components=[
            Component(
                recipe=BuildRecipe(
                    commands=["RUN apt update && apt install zsh"]),
                compatible=[ImageName("ubuntu"),
                            ImageName("debian")],
                description="Installs zsh using apt.",
            ),
            Component(
                recipe=BuildRecipe(commands=["RUN pacman -S zsh"]),
                compatible=[ImageName("arch"),
                            ImageName("manjaro")],
                description="Installs zsh using pacman.",
            ),
            Component(
                recipe=BuildRecipe(commands=["CMD zsh"]),
                description="Use zsh as the entry command.",
            ),
            Component(recipe=RunRecipe(ports=[(3000, 3000), (8080, 8080)]), )
        ],
    )

    env_valid = EnvironmentDefinition(
        name="example-environment",
        modules=[m1, m2],
    )

    with open(ENV_VALID) as fp:
        assert EnvironmentDefinition.load_from_file(fp) == env_valid
Пример #12
0
def test_module_load_valid() -> None:
    """Test loading a module from a file."""
    with open(MODULE_VALID) as fp:
        assert Module.load_from_file(fp) == Module(
            name="example module",
            description="A module which is also an example!",
            components=[
                Component(
                    BuildRecipe(
                        commands=["FROM example-image",
                                  "RUN some-setup-cmd"], )),
                Component(
                    RunRecipe(script=["./fix-bug.sh --version 19.07"]),
                    compatible=[ImageName("example-image", "19.07")],
                ),
            ],
        )
Пример #13
0
def test_environmentdefinition_recipe() -> None:
    """Test converting environment definitions to environment recipes."""
    r = EnvironmentRecipe(
        name="example-environment",
        build=BuildRecipe(commands=[
            "FROM ubuntu",
            "RUN apt update && apt install zsh",
            "CMD zsh",
        ], ),
        run=RunRecipe(ports={
            (3000, 3000),
            (8080, 8080),
        }, ),
    )

    with open(ENV_VALID) as fp:
        assert EnvironmentDefinition.load_from_file(fp).recipe == r
Пример #14
0
    def recipe(self) -> EnvironmentRecipe:
        """Create a buildable Recipe from this definition."""
        current_image = None
        build = BuildRecipe()
        run = RunRecipe()

        for m in self.modules:
            for c in m.components:
                if c.should_run(current_image):
                    if isinstance(c.recipe, BuildRecipe):
                        build += c.recipe
                    elif isinstance(c.recipe, RunRecipe):
                        run += c.recipe
                    if c.results is not None:
                        current_image = c.results

        return EnvironmentRecipe(
            build=build,
            run=run,
            name=self.name,
        )
Пример #15
0
def test_buildrecipe_load_invalid() -> None:
    """Test loading an invalid BuildRecipe."""
    with pytest.raises(ValidationError):
        with open(BUILDRECIPE_INVALID) as fp:
            BuildRecipe.load_from_file(fp)
Пример #16
0
def test_buildrecipe() -> None:
    """Create some build recipes."""
    BuildRecipe(["FROM ubuntu", "RUN rm -rf /", "EXPOSE 8080"])
    BuildRecipe([])
Пример #17
0
def test_buildrecipe_load_empty() -> None:
    """Test loading empty yaml as a BuildRecipe."""
    with open(YAML_EMPTY) as fp:
        assert BuildRecipe.load_from_file(fp) == BuildRecipe()