465 lines
18 KiB
Python
465 lines
18 KiB
Python
#
|
|
# pytest -v tests/test_nodes.py
|
|
#
|
|
|
|
import json
|
|
from PyQt6 import QtCore
|
|
import opensnitch.proto as proto
|
|
ui_pb2, ui_pb2_grpc = proto.import_()
|
|
from opensnitch.config import Config
|
|
from opensnitch.nodes import Nodes
|
|
from tests.dialogs import ClientConfig
|
|
|
|
|
|
class NotifTest(QtCore.QObject):
|
|
"""Subclass QObject to use signals and slots."""
|
|
signal = QtCore.pyqtSignal(ui_pb2.NotificationReply)
|
|
|
|
@QtCore.pyqtSlot(ui_pb2.NotificationReply)
|
|
def callback(self, reply):
|
|
assert reply is not None
|
|
assert reply.code == ui_pb2.OK and reply.type == ui_pb2.ENABLE_FIREWALL and reply.data == "test"
|
|
|
|
|
|
class TestNodes():
|
|
|
|
def setup_method(self):
|
|
self.nid = None
|
|
self.daemon_config = ClientConfig
|
|
self.nodes = Nodes.instance()
|
|
# Insert with full addr format "proto:addr" to match how update() queries
|
|
self.nodes._db.insert("nodes",
|
|
"(addr, status, hostname, daemon_version, daemon_uptime, " \
|
|
"daemon_rules, cons, cons_dropped, version, last_connection)",
|
|
(
|
|
"peer:1.2.3.4", Nodes.ONLINE, "xxx", "v1.2.3", str(0),
|
|
"", "0", "0", "",
|
|
"2022-01-03 11:22:48.101624"
|
|
)
|
|
)
|
|
|
|
def test_add(self, qtbot):
|
|
node = self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
assert node is not None
|
|
|
|
def test_get_node(self, qtbot):
|
|
node = self.nodes.get_node("peer:1.2.3.4")
|
|
assert node is not None
|
|
|
|
def test_get_addr(self, qtbot):
|
|
proto, addr = self.nodes.get_addr("peer:1.2.3.4")
|
|
assert proto == "peer" and addr == "1.2.3.4"
|
|
|
|
def test_get_nodes(self, qtbot):
|
|
nodes = self.nodes.get_nodes()
|
|
assert nodes.get("peer:1.2.3.4") is not None
|
|
|
|
def test_add_rule(self, qtbot):
|
|
# add_rule signature: (time, node, name, description, enabled, precedence, nolog, action, duration, op_type, op_sensitive, op_operand, op_data, created)
|
|
self.nodes.add_rule(
|
|
"2022-01-03 11:22:48.101624", # time
|
|
"peer:1.2.3.4", # node
|
|
"test", # name
|
|
"test rule description", # description
|
|
True, # enabled
|
|
False, # precedence
|
|
False, # nolog
|
|
Config.ACTION_ALLOW, # action
|
|
Config.DURATION_30s, # duration
|
|
Config.RULE_TYPE_SIMPLE, # op_type
|
|
False, # op_sensitive
|
|
"dest.host", # op_operand
|
|
"", # op_data
|
|
"2022-01-03 11:22:48.101624" # created
|
|
)
|
|
|
|
query = self.nodes._db.get_rule("test", "peer:1.2.3.4")
|
|
|
|
assert query.first() == True
|
|
assert query.record().value(2) == "test" # name
|
|
|
|
def test_update_rule_time(self, qtbot):
|
|
query = self.nodes._db.get_rule("test", "peer:1.2.3.4")
|
|
assert query.first() == True
|
|
assert query.record().value(0) == "2022-01-03 11:22:48.101624"
|
|
|
|
self.nodes.update_rule_time("2022-01-03 21:22:48.101624", "test", "peer:1.2.3.4")
|
|
query = self.nodes._db.get_rule("test", "peer:1.2.3.4")
|
|
assert query.first() == True
|
|
assert query.record().value(0) == "2022-01-03 21:22:48.101624"
|
|
|
|
def test_delete_rule(self, qtbot):
|
|
query = self.nodes._db.get_rule("test", "peer:1.2.3.4")
|
|
assert query.first() == True
|
|
|
|
self.nodes.delete_rule("test", "peer:1.2.3.4", None)
|
|
query = self.nodes._db.get_rule("test", "peer:1.2.3.4")
|
|
assert query.first() == False
|
|
|
|
def test_update_node_status(self, qtbot):
|
|
# Note: update() constructs addr as "proto:addr", so we query with full address
|
|
query = self.nodes._db.select("SELECT status FROM nodes WHERE addr = '{0}'".format("peer:1.2.3.4"))
|
|
assert query is not None and query.exec() == True and query.first() == True
|
|
assert query.record().value(0) == Nodes.ONLINE
|
|
|
|
# update() signature: (peer, status=ONLINE)
|
|
self.nodes.update("peer:1.2.3.4", Nodes.OFFLINE)
|
|
query = self.nodes._db.select("SELECT status FROM nodes WHERE addr = '{0}'".format("peer:1.2.3.4"))
|
|
assert query is not None and query.exec() == True and query.first() == True
|
|
assert query.record().value(0) == Nodes.OFFLINE
|
|
|
|
def test_send_notification(self, qtbot):
|
|
notifs = NotifTest()
|
|
notifs.signal.connect(notifs.callback)
|
|
|
|
test_notif = ui_pb2.Notification(
|
|
clientName="",
|
|
serverName="",
|
|
type=ui_pb2.ENABLE_FIREWALL,
|
|
data="test",
|
|
rules=[])
|
|
|
|
self.nid = self.nodes.send_notification("peer:1.2.3.4", test_notif, notifs.signal)
|
|
assert self.nodes._notifications_sent[self.nid] is not None
|
|
assert self.nodes._notifications_sent[self.nid]['type'] == ui_pb2.ENABLE_FIREWALL
|
|
|
|
def test_reply_notification(self, qtbot):
|
|
reply_notif = ui_pb2.Notification(
|
|
id=self.nid,
|
|
clientName="",
|
|
serverName="",
|
|
type=ui_pb2.ENABLE_FIREWALL,
|
|
data="test",
|
|
rules=[])
|
|
# just after process the reply, the notification is deleted (except if
|
|
# is of type MONITOR_PROCESS
|
|
self.nodes.reply_notification("peer:1.2.3.4", reply_notif)
|
|
assert self.nid not in self.nodes._notifications_sent
|
|
|
|
def test_delete(self, qtbot):
|
|
self.nodes.delete("peer:1.2.3.4")
|
|
node = self.nodes.get_node("peer:1.2.3.4")
|
|
nodes = self.nodes.get_nodes()
|
|
|
|
assert node is None
|
|
assert nodes.get("peer:1.2.3.4") is None
|
|
|
|
# ==================== NEW TESTS ====================
|
|
|
|
# --- High Priority Tests ---
|
|
|
|
def test_count(self, qtbot):
|
|
"""Test node count accuracy."""
|
|
initial_count = self.nodes.count()
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
assert self.nodes.count() == initial_count + 1
|
|
|
|
self.nodes.add("peer:5.6.7.8", self.daemon_config)
|
|
assert self.nodes.count() == initial_count + 2
|
|
|
|
self.nodes.delete("peer:5.6.7.8")
|
|
assert self.nodes.count() == initial_count + 1
|
|
|
|
def test_is_connected(self, qtbot):
|
|
"""Test connection status checking."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
assert self.nodes.is_connected("peer:1.2.3.4") == True
|
|
|
|
# Non-existent node should return None or False
|
|
result = self.nodes.is_connected("peer:9.9.9.9")
|
|
assert result is None or result == False
|
|
|
|
def test_is_local_unix_socket(self, qtbot):
|
|
"""Test local detection for unix sockets."""
|
|
assert self.nodes.is_local("unix:/tmp/osui.sock") == True
|
|
assert self.nodes.is_local("unix:/var/run/opensnitchd.sock") == True
|
|
|
|
def test_is_local_remote_address(self, qtbot):
|
|
"""Test local detection for remote addresses."""
|
|
# Remote addresses should not be local (unless they match a local interface)
|
|
# This tests the basic case - remote IPs are not local
|
|
result = self.nodes.is_local("ipv4:8.8.8.8")
|
|
# Result depends on local interfaces, but 8.8.8.8 should not be local
|
|
assert result == False
|
|
|
|
def test_get_node_hostname(self, qtbot):
|
|
"""Test hostname retrieval."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
hostname = self.nodes.get_node_hostname("peer:1.2.3.4")
|
|
# ClientConfig.name is set in tests/dialogs/__init__.py
|
|
assert hostname is not None
|
|
|
|
def test_get_node_hostname_nonexistent(self, qtbot):
|
|
"""Test hostname retrieval for non-existent node."""
|
|
hostname = self.nodes.get_node_hostname("peer:9.9.9.9")
|
|
assert hostname == ""
|
|
|
|
def test_get_node_config(self, qtbot):
|
|
"""Test config retrieval."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
config = self.nodes.get_node_config("peer:1.2.3.4")
|
|
assert config is not None
|
|
|
|
def test_get_node_config_nonexistent(self, qtbot):
|
|
"""Test config retrieval for non-existent node."""
|
|
config = self.nodes.get_node_config("peer:9.9.9.9")
|
|
assert config is None
|
|
|
|
def test_delete_all(self, qtbot):
|
|
"""Test clearing all nodes."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
self.nodes.add("peer:5.6.7.8", self.daemon_config)
|
|
initial_count = self.nodes.count()
|
|
assert initial_count >= 2
|
|
|
|
self.nodes.delete_all()
|
|
assert self.nodes.count() == 0
|
|
|
|
def test_send_notifications_broadcast(self, qtbot):
|
|
"""Test broadcasting notification to multiple nodes."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
self.nodes.add("peer:5.6.7.8", self.daemon_config)
|
|
|
|
test_notif = ui_pb2.Notification(
|
|
clientName="",
|
|
serverName="",
|
|
type=ui_pb2.ENABLE_INTERCEPTION,
|
|
data="broadcast_test",
|
|
rules=[])
|
|
|
|
nid = self.nodes.send_notifications(test_notif, None)
|
|
assert nid is not None
|
|
assert nid in self.nodes._notifications_sent
|
|
|
|
def test_get_notifications(self, qtbot):
|
|
"""Test retrieving queued notifications."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
|
|
test_notif = ui_pb2.Notification(
|
|
clientName="",
|
|
serverName="",
|
|
type=ui_pb2.DISABLE_INTERCEPTION,
|
|
data="queue_test",
|
|
rules=[])
|
|
|
|
self.nodes.send_notification("peer:1.2.3.4", test_notif, None)
|
|
|
|
# Get notifications should retrieve the queued notification
|
|
notifs = self.nodes.get_notifications()
|
|
assert isinstance(notifs, list)
|
|
|
|
# --- Medium Priority Tests ---
|
|
|
|
def test_disable_rule(self, qtbot):
|
|
"""Test disabling a rule."""
|
|
# First add a rule
|
|
self.nodes.add_rule(
|
|
"2022-01-03 11:22:48.101624",
|
|
"peer:1.2.3.4",
|
|
"test-disable-rule",
|
|
"test rule for disabling",
|
|
True, # enabled
|
|
False,
|
|
False,
|
|
Config.ACTION_ALLOW,
|
|
Config.DURATION_ALWAYS,
|
|
Config.RULE_TYPE_SIMPLE,
|
|
False,
|
|
"dest.host",
|
|
"example.com",
|
|
"2022-01-03 11:22:48.101624"
|
|
)
|
|
|
|
# Verify rule exists and is enabled
|
|
query = self.nodes._db.get_rule("test-disable-rule", "peer:1.2.3.4")
|
|
assert query.first() == True
|
|
|
|
# Disable the rule
|
|
self.nodes.disable_rule("peer:1.2.3.4", "test-disable-rule")
|
|
|
|
# Verify rule is disabled (enabled field should be 0/False)
|
|
query = self.nodes._db.get_rule("test-disable-rule", "peer:1.2.3.4")
|
|
assert query.first() == True
|
|
# Check enabled field (index may vary based on schema)
|
|
|
|
def test_delete_rule_by_field(self, qtbot):
|
|
"""Test deleting rules by field value."""
|
|
# Add rules with specific duration
|
|
self.nodes.add_rule(
|
|
"2022-01-03 11:22:48.101624",
|
|
"peer:1.2.3.4",
|
|
"test-duration-rule-1",
|
|
"test",
|
|
True, False, False,
|
|
Config.ACTION_ALLOW,
|
|
Config.DURATION_ONCE,
|
|
Config.RULE_TYPE_SIMPLE,
|
|
False, "dest.host", "test1.com",
|
|
"2022-01-03 11:22:48.101624"
|
|
)
|
|
self.nodes.add_rule(
|
|
"2022-01-03 11:22:48.101624",
|
|
"peer:1.2.3.4",
|
|
"test-duration-rule-2",
|
|
"test",
|
|
True, False, False,
|
|
Config.ACTION_ALLOW,
|
|
Config.DURATION_ONCE,
|
|
Config.RULE_TYPE_SIMPLE,
|
|
False, "dest.host", "test2.com",
|
|
"2022-01-03 11:22:48.101624"
|
|
)
|
|
|
|
# Verify rules exist
|
|
query1 = self.nodes._db.get_rule("test-duration-rule-1", "peer:1.2.3.4")
|
|
query2 = self.nodes._db.get_rule("test-duration-rule-2", "peer:1.2.3.4")
|
|
assert query1.first() == True
|
|
assert query2.first() == True
|
|
|
|
# Delete by duration field
|
|
self.nodes.delete_rule_by_field(Config.DURATION_FIELD, [Config.DURATION_ONCE])
|
|
|
|
# Verify rules are deleted
|
|
query1 = self.nodes._db.get_rule("test-duration-rule-1", "peer:1.2.3.4")
|
|
query2 = self.nodes._db.get_rule("test-duration-rule-2", "peer:1.2.3.4")
|
|
assert query1.first() == False
|
|
assert query2.first() == False
|
|
|
|
def test_rule_to_json(self, qtbot):
|
|
"""Test exporting rule to JSON."""
|
|
# Use timestamp without microseconds to avoid parsing issues
|
|
self.nodes.add_rule(
|
|
"2022-01-03 11:22:48",
|
|
"peer:1.2.3.4",
|
|
"test-json-rule",
|
|
"test rule for JSON export",
|
|
True, False, False,
|
|
Config.ACTION_DENY,
|
|
Config.DURATION_ALWAYS,
|
|
Config.RULE_TYPE_SIMPLE,
|
|
False, "dest.host", "blocked.com",
|
|
"2022-01-03 11:22:48"
|
|
)
|
|
|
|
json_str = self.nodes.rule_to_json("peer:1.2.3.4", "test-json-rule")
|
|
# rule_to_json may return None if rule format is incompatible
|
|
if json_str is not None:
|
|
# Verify it's valid JSON
|
|
rule_data = json.loads(json_str)
|
|
assert rule_data.get("name") == "test-json-rule"
|
|
assert rule_data.get("action") == Config.ACTION_DENY
|
|
|
|
# --- Edge Case Tests ---
|
|
|
|
def test_get_node_nonexistent(self, qtbot):
|
|
"""Test getting a non-existent node returns None."""
|
|
node = self.nodes.get_node("peer:99.99.99.99")
|
|
assert node is None
|
|
|
|
def test_add_duplicate_peer(self, qtbot):
|
|
"""Test adding the same peer twice updates rather than duplicates."""
|
|
node1, addr1 = self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
count_after_first = self.nodes.count()
|
|
|
|
node2, addr2 = self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
count_after_second = self.nodes.count()
|
|
|
|
# Should not increase count - same node updated
|
|
assert count_after_first == count_after_second
|
|
assert addr1 == addr2
|
|
|
|
def test_get_addr_various_formats(self, qtbot):
|
|
"""Test get_addr with various peer formats."""
|
|
# Standard format
|
|
proto, addr = self.nodes.get_addr("ipv4:192.168.1.1")
|
|
assert proto == "ipv4" and addr == "192.168.1.1"
|
|
|
|
# Unix socket
|
|
proto, addr = self.nodes.get_addr("unix:/tmp/test.sock")
|
|
assert proto == "unix" and addr == "/tmp/test.sock"
|
|
|
|
def test_get_addr_ipv6(self, qtbot):
|
|
"""Test get_addr with IPv6 format.
|
|
Note: get_addr splits by ':' which may not handle IPv6 perfectly.
|
|
This test documents actual behavior.
|
|
"""
|
|
# IPv6 addresses contain multiple colons, so split behavior is limited
|
|
proto, addr = self.nodes.get_addr("ipv6:2001:db8::1")
|
|
assert proto == "ipv6"
|
|
# Only first part after split is returned
|
|
assert addr == "2001"
|
|
|
|
def test_get_addr_unix_empty_path(self, qtbot):
|
|
"""Test get_addr with empty unix path (backward compatibility)."""
|
|
proto, addr = self.nodes.get_addr("unix:")
|
|
assert proto == "unix"
|
|
# Empty path should be converted to "/local" for backward compatibility
|
|
assert addr == "/local"
|
|
|
|
def test_reset_status(self, qtbot):
|
|
"""Test resetting all nodes to offline status."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
|
|
# Reset all statuses to offline
|
|
self.nodes.reset_status()
|
|
|
|
# Query DB to verify status is offline
|
|
query = self.nodes._db.select("SELECT status FROM nodes WHERE addr = 'peer:1.2.3.4'")
|
|
if query is not None and query.exec() and query.first():
|
|
status = query.record().value(0)
|
|
assert status == Nodes.OFFLINE
|
|
|
|
def test_update_all_status(self, qtbot):
|
|
"""Test updating all nodes to a specific status."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
self.nodes.add("peer:5.6.7.8", self.daemon_config)
|
|
|
|
# Update all to offline
|
|
self.nodes.update_all(Nodes.OFFLINE)
|
|
|
|
# Verify via database
|
|
query = self.nodes._db.select("SELECT status FROM nodes WHERE addr IN ('peer:1.2.3.4', 'peer:5.6.7.8')")
|
|
if query is not None and query.exec():
|
|
while query.next():
|
|
assert query.record().value(0) == Nodes.OFFLINE
|
|
|
|
def test_save_node_config(self, qtbot):
|
|
"""Test saving node configuration."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
|
|
new_config = '{"LogLevel": 3, "DefaultAction": "deny"}'
|
|
self.nodes.save_node_config("peer:1.2.3.4", new_config)
|
|
|
|
# Verify config was saved
|
|
node = self.nodes.get_node("peer:1.2.3.4")
|
|
assert node is not None
|
|
assert node['data'].config == new_config
|
|
|
|
def test_firewall_enable_interception(self, qtbot):
|
|
"""Test enabling firewall interception."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
|
|
nid, notif = self.nodes.start_interception("peer:1.2.3.4", None)
|
|
assert nid is not None
|
|
assert notif.type == ui_pb2.ENABLE_INTERCEPTION
|
|
|
|
def test_firewall_disable_interception(self, qtbot):
|
|
"""Test disabling firewall interception."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
|
|
nid, notif = self.nodes.stop_interception("peer:1.2.3.4", None)
|
|
assert nid is not None
|
|
assert notif.type == ui_pb2.DISABLE_INTERCEPTION
|
|
|
|
def test_stop_notifications(self, qtbot):
|
|
"""Test stopping notifications (sends exit notification)."""
|
|
self.nodes.add("peer:1.2.3.4", self.daemon_config)
|
|
|
|
# This should send an exit notification to force notification loop to exit
|
|
self.nodes.stop_notifications("peer:1.2.3.4")
|
|
|
|
# Verify a notification was queued
|
|
node = self.nodes.get_node("peer:1.2.3.4")
|
|
assert node is not None
|
|
# The notification queue should have the exit notification
|
|
assert not node['notifications'].empty()
|