import pytest
from jenkinsapi.node import Node


DATA = {
    "actions": [],
    "displayName": "bobnit",
    "executors": [{}],
    "icon": "computer.png",
    "idle": True,
    "jnlpAgent": False,
    "launchSupported": True,
    "loadStatistics": {},
    "manualLaunchAllowed": True,
    "monitorData": {
        "hudson.node_monitors.SwapSpaceMonitor": {
            "availablePhysicalMemory": 7681417216,
            "availableSwapSpace": 12195983360,
            "totalPhysicalMemory": 8374497280,
            "totalSwapSpace": 12195983360,
        },
        "hudson.node_monitors.ArchitectureMonitor": "Linux (amd64)",
        "hudson.node_monitors.ResponseTimeMonitor": {"average": 64},
        "hudson.node_monitors.TemporarySpaceMonitor": {
            "path": "/tmp",
            "size": 250172776448,
        },
        "hudson.node_monitors.DiskSpaceMonitor": {
            "path": "/home/sal/jenkins",
            "size": 170472026112,
        },
        "hudson.node_monitors.ClockMonitor": {"diff": 6736},
    },
    "numExecutors": 1,
    "offline": False,
    "offlineCause": None,
    "oneOffExecutors": [],
    "temporarilyOffline": False,
}


@pytest.fixture(scope="function")
def node(monkeypatch, mocker):
    def fake_poll(cls, tree=None):  # pylint: disable=unused-argument
        return DATA

    monkeypatch.setattr(Node, "_poll", fake_poll)
    jenkins = mocker.MagicMock()

    return Node(jenkins, "http://foo:8080", "bobnit", {})


def test_repr(node):
    # Can we produce a repr string for this object
    repr(node)


def test_name(node):
    with pytest.raises(AttributeError):
        node.id()
    assert node.name == "bobnit"


def test_online(node):
    assert node.is_online() is True


def test_available_physical_memory(node):
    monitor = DATA["monitorData"]["hudson.node_monitors.SwapSpaceMonitor"]
    expected_value = monitor["availablePhysicalMemory"]
    assert node.get_available_physical_memory() == expected_value


def test_available_swap_space(node):
    monitor = DATA["monitorData"]["hudson.node_monitors.SwapSpaceMonitor"]
    expected_value = monitor["availableSwapSpace"]
    assert node.get_available_swap_space() == expected_value


def test_total_physical_memory(node):
    monitor = DATA["monitorData"]["hudson.node_monitors.SwapSpaceMonitor"]
    expected_value = monitor["totalPhysicalMemory"]
    assert node.get_total_physical_memory() == expected_value


def test_total_swap_space(node):
    monitor = DATA["monitorData"]["hudson.node_monitors.SwapSpaceMonitor"]
    expected_value = monitor["totalSwapSpace"]
    assert node.get_total_swap_space() == expected_value


def test_workspace_path(node):
    monitor = DATA["monitorData"]["hudson.node_monitors.DiskSpaceMonitor"]
    expected_value = monitor["path"]
    assert node.get_workspace_path() == expected_value


def test_workspace_size(node):
    monitor = DATA["monitorData"]["hudson.node_monitors.DiskSpaceMonitor"]
    expected_value = monitor["size"]
    assert node.get_workspace_size() == expected_value


def test_temp_path(node):
    monitor = DATA["monitorData"]["hudson.node_monitors.TemporarySpaceMonitor"]
    expected_value = monitor["path"]
    assert node.get_temp_path() == expected_value


def test_temp_size(node):
    monitor = DATA["monitorData"]["hudson.node_monitors.TemporarySpaceMonitor"]
    expected_value = monitor["size"]
    assert node.get_temp_size() == expected_value


def test_architecture(node):
    expected_value = DATA["monitorData"][
        "hudson.node_monitors.ArchitectureMonitor"
    ]
    assert node.get_architecture() == expected_value


def test_response_time(node):
    monitor = DATA["monitorData"]["hudson.node_monitors.ResponseTimeMonitor"]
    expected_value = monitor["average"]
    assert node.get_response_time() == expected_value


def test_clock_difference(node):
    monitor = DATA["monitorData"]["hudson.node_monitors.ClockMonitor"]
    expected_value = monitor["diff"]
    assert node.get_clock_difference() == expected_value