Пример #1
0
    def test_volume_present(self):
        """
        Test if volume is present (existing volume)
        """
        ret = {
            "name": "myzpool/volume",
            "result": True,
            "comment": "volume myzpool/volume is uptodate",
            "changes": {},
        }

        mock_exists = MagicMock(return_value=True)
        mock_get = MagicMock(return_value=OrderedDict([
            (
                "myzpool/volume",
                OrderedDict([
                    ("type", OrderedDict([("value", "volume")])),
                    ("compression", OrderedDict([("value", False)])),
                ]),
            ),
        ]))
        with patch.dict(zfs.__salt__, {"zfs.exists": mock_exists}), patch.dict(
                zfs.__salt__,
            {"zfs.get": mock_get}), patch.dict(zfs.__utils__,
                                               self.utils_patch):
            self.assertEqual(
                ret, zfs.volume_present("myzpool/volume", volume_size="1G"))
Пример #2
0
def test_volume_present(utils_patch):
    """
    Test if volume is present (existing volume)
    """
    ret = {
        "name": "myzpool/volume",
        "result": True,
        "comment": "volume myzpool/volume is uptodate",
        "changes": {},
    }

    mock_exists = MagicMock(return_value=True)
    mock_get = MagicMock(return_value=OrderedDict([("myzpool/volume",
                                                    OrderedDict([]))]))
    with patch.dict(zfs.__salt__, {"zfs.exists": mock_exists}), patch.dict(
            zfs.__salt__,
        {"zfs.get": mock_get}), patch.dict(zfs.__utils__, utils_patch):
        assert ret == zfs.volume_present("myzpool/volume", volume_size="1G")
    mock_get.assert_called_with(
        "myzpool/volume",
        depth=0,
        properties="volsize",
        fields="value",
        parsable=True,
        type="volume",
    )
Пример #3
0
    def test_volume_present_fail(self):
        """
        Test if volume is present (non existing pool)
        """
        ret = {
            "name": "myzpool/volume",
            "result": False,
            "comment": "cannot create 'myzpool/volume': no such pool 'myzpool'",
            "changes": {},
        }

        mock_exists = MagicMock(return_value=False)
        mock_create = MagicMock(
            return_value=OrderedDict(
                [
                    ("created", False),
                    ("error", "cannot create 'myzpool/volume': no such pool 'myzpool'"),
                ]
            )
        )
        with patch.dict(zfs.__salt__, {"zfs.exists": mock_exists}), patch.dict(
            zfs.__salt__, {"zfs.create": mock_create}
        ), patch.dict(zfs.__utils__, self.utils_patch):
            self.assertEqual(
                ret, zfs.volume_present("myzpool/volume", volume_size="1G")
            )
Пример #4
0
def test_volume_present_new(utils_patch):
    """
    Test if volume is present (non existing volume)
    """
    ret = {
        "name": "myzpool/volume",
        "result": True,
        "comment": "volume myzpool/volume was created",
        "changes": {"myzpool/volume": "created"},
    }

    mock_exists = MagicMock(return_value=False)
    mock_create = MagicMock(return_value=OrderedDict([("created", True)]))
    with patch.dict(zfs.__salt__, {"zfs.exists": mock_exists}), patch.dict(
        zfs.__salt__, {"zfs.create": mock_create}
    ), patch.dict(zfs.__utils__, utils_patch):
        assert ret == zfs.volume_present("myzpool/volume", volume_size="1G")
Пример #5
0
def test_volume_present_update(utils_patch):
    """
    Test if volume is present (non existing volume)
    """
    ret = {
        "name": "myzpool/volume",
        "result": True,
        "comment": "volume myzpool/volume was updated",
        "changes": {
            "myzpool/volume": {
                "compression": "lz4"
            }
        },
    }

    mock_exists = MagicMock(return_value=True)
    mock_set = MagicMock(return_value=OrderedDict([("set", True)]))
    mock_get = MagicMock(return_value=OrderedDict([
        (
            "myzpool/volume",
            OrderedDict([("compression", OrderedDict([("value", False)]))]),
        ),
    ]))
    with patch.dict(zfs.__salt__, {"zfs.exists": mock_exists}), patch.dict(
            zfs.__salt__, {"zfs.get": mock_get}), patch.dict(
                zfs.__salt__,
                {"zfs.set": mock_set}), patch.dict(zfs.__utils__, utils_patch):
        assert ret == zfs.volume_present(
            name="myzpool/volume",
            volume_size="1G",
            properties={"compression": "lz4"},
        )
    mock_get.assert_called_with(
        "myzpool/volume",
        depth=0,
        properties="compression,volsize",
        fields="value",
        parsable=True,
        type="volume",
    )