async def test__interfaces_service__lagg_update_members_invalid(attr_val):
m = Middleware()
m['interface.query'] = m._query_filter(INTERFACES_WITH_LAG)
with pytest.raises(ValidationErrors) as ve:
await InterfaceService(m).update('em0', {
attr_val[0]: attr_val[1],
})
assert f'interface_update.{attr_val[0]}' in ve.value
async def test__interfaces_service__lagg_update_members_invalid(attr_val):
m = Middleware()
m['interfaces.query'] = m._query_filter(INTERFACES_WITH_LAG)
with pytest.raises(ValidationErrors) as ve:
await InterfacesService(m).update('em0', {
attr_val[0]: attr_val[1],
})
assert f'interface_update.{attr_val[0]}' in ve.value
async def test__interfaces_service__update_vlan_mtu_bigger_parent():
m = Middleware()
m['interface.query'] = m._query_filter(INTERFACES_WITH_VLAN)
with pytest.raises(ValidationErrors) as ve:
await InterfaceService(m).update(INTERFACES_WITH_VLAN[-1]['id'], {
'mtu': 9000,
})
assert 'interface_update.mtu' in ve.value
async def test__interfaces_service__update_vlan_mtu_bigger_parent():
m = Middleware()
m['interfaces.query'] = m._query_filter(INTERFACES_WITH_VLAN)
with pytest.raises(ValidationErrors) as ve:
await InterfacesService(m).update(INTERFACES_WITH_VLAN[-1]['id'], {
'mtu': 9000,
})
assert 'interface_update.mtu' in ve.value
async def test__interfaces_service__lagg_update_members_invalid(attr_val):
m = Middleware()
m['interface.query'] = m._query_filter(INTERFACES_WITH_LAG)
m['datastore.query'] = Mock(return_value=[])
m['kubernetes.config'] = Mock(return_value={'dataset': None})
m['network.common.check_failover_disabled'] = Mock()
with pytest.raises(ValidationErrors) as ve:
await create_service(m,
InterfaceService).update(Mock(), 'em0', {
attr_val[0]: attr_val[1],
})
assert f'interface_update.{attr_val[0]}' in ve.value
async def test__interfaces_service__update_mtu():
m = Middleware()
m['interfaces.query'] = m._query_filter(INTERFACES)
m['datastore.query'] = Mock(return_value=[])
m['datastore.insert'] = Mock(return_value=5)
update_interface = INTERFACES[1]
await InterfacesService(m).update(
update_interface['id'], {
'mtu': 1550,
},
)
async def test__interfaces_service__update_vlan_mtu_bigger_parent():
m = Middleware()
m['interface.query'] = m._query_filter(INTERFACES_WITH_VLAN)
m['interface.validate_name'] = Mock()
m['datastore.query'] = Mock(return_value=[])
m['kubernetes.config'] = Mock(return_value={'dataset': None})
m['network.common.check_failover_disabled'] = Mock()
with pytest.raises(ValidationErrors) as ve:
await create_service(m, InterfaceService).update(
Mock(), INTERFACES_WITH_VLAN[-1]['id'], {
'mtu': 9000,
})
assert 'interface_update.mtu' in ve.value
async def test_get_disk__unknown_usb_bridge():
m = Middleware()
m['system.is_enterprise_ix_hardware'] = Mock(return_value=False)
with patch("middlewared.common.smart.smartctl.run") as run:
run.return_value = Mock(
stdout="/dev/da0: Unknown USB bridge [0x0930:0x6544 (0x100)]\n"
"Please specify device type with the -d option.")
with patch("middlewared.common.smart.smartctl.osc.IS_LINUX", False):
assert await get_smartctl_args(
m, {
"ada0": {
"driver": "ata",
"controller_id": 1,
"bus": 0,
"channel_no": 2,
"lun_id": 10,
}
}, "ada0", "") == ["/dev/ada0", "-d", "sat"]
run.assert_called_once_with(["smartctl", "/dev/ada0", "-i"],
stderr=subprocess.STDOUT,
check=False,
encoding="utf8",
errors="ignore")
async def test__disk_service__sata_dom_lifetime_left():
m = Middleware()
m["disk.smartctl"] = Mock(return_value=textwrap.dedent("""\
smartctl 6.6 2017-11-05 r4594 [FreeBSD 11.2-STABLE amd64] (local build)
Copyright (C) 2002-17, Bruce Allen, Christian Franke, www.smartmontools.org
=== START OF READ SMART DATA SECTION ===
SMART Attributes Data Structure revision number: 0
Vendor Specific SMART Attributes with Thresholds:
ID# ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE
9 Power_On_Hours 0x0012 100 100 000 Old_age Always - 8693
12 Power_Cycle_Count 0x0012 100 100 000 Old_age Always - 240
163 Unknown_Attribute 0x0000 100 100 001 Old_age Offline - 1065
164 Unknown_Attribute 0x0000 100 100 001 Old_age Offline - 322
166 Unknown_Attribute 0x0000 100 100 010 Old_age Offline - 0
167 Unknown_Attribute 0x0022 100 100 000 Old_age Always - 0
168 Unknown_Attribute 0x0012 100 100 000 Old_age Always - 0
175 Program_Fail_Count_Chip 0x0013 100 100 010 Pre-fail Always - 0
192 Power-Off_Retract_Count 0x0012 100 100 000 Old_age Always - 208
194 Temperature_Celsius 0x0022 060 060 030 Old_age Always - 40 (Min/Max 30/60)
241 Total_LBAs_Written 0x0032 100 100 000 Old_age Always - 14088053817
"""))
assert abs(await SmartAttributesDiskService(m).sata_dom_lifetime_left("ada1") - 0.8926) < 1e-4
async def datastore_test():
m = Middleware()
with patch("middlewared.plugins.datastore.connection.FREENAS_DATABASE", ":memory:"):
with patch("middlewared.plugins.datastore.schema.Model", Model):
with patch("middlewared.plugins.datastore.util.Model", Model):
ds = DatastoreService(m)
await ds.setup()
for part in ds.parts:
if hasattr(part, "connection"):
Model.metadata.create_all(bind=part.connection)
break
else:
raise RuntimeError("Could not find part that provides connection")
m["datastore.execute"] = ds.execute
m["datastore.execute_write"] = ds.execute_write
m["datastore.fetchall"] = ds.fetchall
m["datastore.query"] = ds.query
m["datastore.send_insert_events"] = ds.send_insert_events
m["datastore.send_update_events"] = ds.send_update_events
m["datastore.send_delete_events"] = ds.send_delete_events
yield ds
async def test__interfaces_service__update_two_dhcp():
interfaces_with_one_dhcp = copy.deepcopy(INTERFACES)
interfaces_with_one_dhcp[0]['ipv4_dhcp'] = True
m = Middleware()
m['interface.query'] = Mock(return_value=interfaces_with_one_dhcp)
m['datastore.query'] = Mock(
return_value=[{
'int_interface': interfaces_with_one_dhcp[0]['name'],
'int_dhcp': True,
'int_ipv6auto': False
}])
m['kubernetes.config'] = Mock(return_value={'dataset': None})
m['network.common.check_failover_disabled'] = Mock()
update_interface = interfaces_with_one_dhcp[1]
with pytest.raises(ValidationErrors) as ve:
await create_service(m, InterfaceService).update(
Mock(),
update_interface['id'],
{
'ipv4_dhcp': True,
},
)
assert 'interface_update.ipv4_dhcp' in ve.value, list(ve.value)
async def test__interfaces_service__update_two_dhcp():
interfaces_with_one_dhcp = copy.deepcopy(INTERFACES)
interfaces_with_one_dhcp[0]['ipv4_dhcp'] = True
m = Middleware()
m['interface.query'] = Mock(return_value=interfaces_with_one_dhcp)
m['datastore.query'] = Mock(
return_value=[{
'int_interface': interfaces_with_one_dhcp[0]['name'],
'int_dhcp': True,
'int_ipv6auto': False
}])
update_interface = interfaces_with_one_dhcp[1]
with pytest.raises(ValidationErrors) as ve:
await InterfaceService(m).update(
Mock(),
update_interface['id'],
{
'ipv4_dhcp': True,
},
)
assert 'interface_update.ipv4_dhcp' in ve.value, list(ve.value)
async def test__interfaces_service__update_two_same_network():
interfaces_one_network = copy.deepcopy(INTERFACES)
interfaces_one_network[0]['aliases'] = [
{
'type': 'INET',
'address': '192.168.5.2',
'netmask': 24
},
]
m = Middleware()
m['interface.query'] = Mock(return_value=interfaces_one_network)
m['datastore.query'] = Mock(return_value=[])
m['datastore.insert'] = Mock(return_value=5)
update_interface = interfaces_one_network[1]
with pytest.raises(ValidationErrors) as ve:
await InterfaceService(m).update(
Mock(),
update_interface['id'],
{
'aliases': [{
'address': '192.168.5.3',
'netmask': 24
}],
},
)
assert 'interface_update.aliases.0' in ve.value
def test_amd_cpu_temperatures(model, core_count, reading, result):
middleware = Middleware()
middleware["system.cpu_info"] = Mock(return_value={
"cpu_model": model,
"physical_core_count": core_count
})
es = ReportingService(middleware)
assert es._amd_cpu_temperatures(reading) == result
async def test__annotate_disk_for_smart__skips_device_with_unavailable_smart():
m = Middleware()
m['system.is_enterprise_ix_hardware'] = Mock(return_value=False)
with patch("middlewared.etc_files.smartd.get_smartctl_args") as get_smartctl_args:
get_smartctl_args.return_value = ["/dev/ada1", "-d", "sat"]
with patch("middlewared.etc_files.smartd.ensure_smart_enabled") as ensure_smart_enabled:
ensure_smart_enabled.return_value = False
assert await annotate_disk_for_smart(m, {"ada1": {"driver": "ata"}}, "ada1") is None
def test_amd_cpu_temperature(model, core_count, reading, result):
middleware = Middleware()
middleware["system.cpu_info"] = Mock(return_value={
"cpu_model": model,
"physical_core_count": core_count
})
es = RealtimeEventSource(middleware, Mock(), Mock(), Mock(), Mock())
assert es._amd_cpu_temperature(reading) == result
async def test__annotate_disk_for_smart():
m = Middleware()
m['system.is_enterprise_ix_hardware'] = Mock(return_value=False)
with patch("middlewared.etc_files.smartd.get_smartctl_args") as get_smartctl_args:
get_smartctl_args.return_value = ["/dev/ada1", "-d", "sat"]
with patch("middlewared.etc_files.smartd.ensure_smart_enabled") as ensure_smart_enabled:
ensure_smart_enabled.return_value = True
assert await annotate_disk_for_smart(m, {"ada1": {"driver": "ata"}}, "ada1") == (
"ada1",
{"smartctl_args": ["/dev/ada1", "-d", "sat", "-a", "-d", "removable"]},
)
async def test__interfaces_service__create_bridge_invalid_ports():
m = Middleware()
m['interface.query'] = Mock(return_value=INTERFACES)
with pytest.raises(ValidationErrors) as ve:
await InterfaceService(m).create({
'type': 'BRIDGE',
'bridge_members': ['em0', 'igb2'],
})
assert 'interface_create.bridge_members.1' in ve.value
async def test__interfaces_service__create_lagg_invalid_ports_cloned():
m = Middleware()
m['interfaces.query'] = Mock(return_value=INTERFACES_WITH_VLAN)
with pytest.raises(ValidationErrors) as ve:
await InterfacesService(m).create({
'type': 'LINK_AGGREGATION',
'lag_protocol': 'LACP',
'lag_ports': ['em1', 'vlan5'],
})
assert 'interface_create.lag_ports.1' in ve.value
async def test__interfaces_service__create_vlan():
m = Middleware()
m['interfaces.query'] = Mock(return_value=INTERFACES)
m['datastore.query'] = Mock(return_value=[])
m['datastore.insert'] = Mock(return_value=5)
await InterfacesService(m).create({
'type': 'VLAN',
'vlan_tag': 5,
'vlan_parent_interface': 'em0',
})
async def test__interfaces_service__create_vlan_invalid_parent_used():
m = Middleware()
m['interfaces.query'] = Mock(return_value=INTERFACES_WITH_LAG)
with pytest.raises(ValidationErrors) as ve:
await InterfacesService(m).create({
'type': 'VLAN',
'vlan_tag': 5,
'vlan_parent_interface': 'em0',
})
assert 'interface_create.vlan_parent_interface' in ve.value
async def test__interfaces_service__create_lagg():
m = Middleware()
m['interfaces.query'] = Mock(return_value=INTERFACES)
m['datastore.query'] = Mock(return_value=[])
m['datastore.insert'] = Mock(return_value=5)
await InterfacesService(m).create({
'type': 'LINK_AGGREGATION',
'lag_protocol': 'LACP',
'lag_ports': ['em0', 'em1'],
})
async def test__interfaces_service__create_bridge_invalid_ports_used():
m = Middleware()
m['interface.query'] = Mock(return_value=INTERFACES_WITH_BRIDGE)
m['datastore.query'] = Mock(return_value=[])
with pytest.raises(ValidationErrors) as ve:
await InterfaceService(m).create(Mock(), {
'type': 'BRIDGE',
'bridge_members': ['em0'],
})
assert 'interface_create.bridge_members.0' in ve.value
def test__journal_sync__flush_journal__network_error():
middleware = Middleware()
middleware['failover.status'] = Mock(return_value='MASTER')
middleware['failover.call_remote'] = Mock(side_effect=CallError('Connection refused', errno.ECONNREFUSED))
journal = MagicMock()
journal.__bool__.side_effect = [True, False]
journal.peek.return_value = [Mock(), Mock()]
journal_sync = failover.JournalSync(middleware, Mock(), journal)
assert not journal_sync._flush_journal()
assert not journal_sync.last_query_failed
journal.shift.assert_not_called()
async def test__interfaces_service__create_vlan_invalid_parent():
m = Middleware()
m['interface.query'] = Mock(return_value=INTERFACES)
with pytest.raises(ValidationErrors) as ve:
await InterfaceService(m).create({
'type': 'VLAN',
'name': 'myvlan1',
'vlan_tag': 5,
'vlan_parent_interface': 'igb2',
})
assert 'interface_create.vlan_parent_interface' in ve.value
async def test__interfaces_service__create_lagg_invalid_name():
m = Middleware()
m['interfaces.query'] = Mock(return_value=INTERFACES)
with pytest.raises(ValidationErrors) as ve:
await InterfacesService(m).create({
'type': 'LINK_AGGREGATION',
'name': 'mylag11',
'lag_protocol': 'LACP',
'lag_ports': ['em0'],
})
assert 'interface_create.name' in ve.value
def test__journal_sync__flush_journal__error():
middleware = Middleware()
middleware['failover.status'] = Mock(return_value='MASTER')
middleware['failover.call_remote'] = Mock(side_effect=CallError('Invalid SQL query'))
middleware['alert.oneshot_create'] = Mock()
journal = MagicMock()
journal.__bool__.side_effect = [True, False]
journal.peek.return_value = [Mock(), Mock()]
journal_sync = failover.JournalSync(middleware, Mock(), journal)
assert not journal_sync._flush_journal()
assert journal_sync.last_query_failed
middleware['alert.oneshot_create'].assert_called_once_with('FailoverSyncFailed', None)
journal.shift.assert_not_called()
async def test__interfaces_service__create_bridge_invalid_ports():
m = Middleware()
m['interface.query'] = Mock(return_value=INTERFACES)
m['datastore.query'] = Mock(return_value=[])
m['kubernetes.config'] = Mock(return_value={'dataset': None})
m['network.common.check_failover_disabled'] = Mock()
with pytest.raises(ValidationErrors) as ve:
await create_service(m, InterfaceService).create(
Mock(), {
'type': 'BRIDGE',
'bridge_members': ['em0', 'igb2'],
})
assert 'interface_create.bridge_members.1' in ve.value
async def test__interfaces_service__create_lagg_invalid_ports_used():
m = Middleware()
m['interface.query'] = Mock(return_value=INTERFACES_WITH_LAG)
m['interface.lag_supported_protocols'] = Mock(return_value=['LACP'])
m['datastore.query'] = Mock(return_value=[])
with pytest.raises(ValidationErrors) as ve:
await InterfaceService(m).create(
Mock(), {
'type': 'LINK_AGGREGATION',
'lag_protocol': 'LACP',
'lag_ports': ['em0'],
})
assert 'interface_create.lag_ports.0' in ve.value
async def test__interfaces_service__update_mtu_options():
m = Middleware()
m['interfaces.query'] = Mock(return_value=INTERFACES)
m['datastore.query'] = Mock(return_value=[])
m['datastore.insert'] = Mock(return_value=5)
update_interface = INTERFACES[1]
with pytest.raises(ValidationErrors) as ve:
await InterfacesService(m).update(
update_interface['id'], {
'options': 'mtu 1550',
},
)
assert 'interface_update.options' in ve.value
async def test__interfaces_service__create_vlan_invalid_parent_used():
m = Middleware()
m['interface.query'] = Mock(return_value=INTERFACES_WITH_LAG)
m['datastore.query'] = Mock(return_value=[])
m['kubernetes.config'] = Mock(return_value={'dataset': None})
m['network.common.check_failover_disabled'] = Mock()
with pytest.raises(ValidationErrors) as ve:
await create_service(m, InterfaceService).create(
Mock(), {
'type': 'VLAN',
'vlan_tag': 5,
'vlan_parent_interface': 'em0',
})
assert 'interface_create.vlan_parent_interface' in ve.value
async def test__interfaces_service__update_two_dhcp():
interfaces_with_one_dhcp = copy.deepcopy(INTERFACES)
interfaces_with_one_dhcp[0]['ipv4_dhcp'] = True
m = Middleware()
m['interfaces.query'] = Mock(return_value=interfaces_with_one_dhcp)
update_interface = interfaces_with_one_dhcp[1]
with pytest.raises(ValidationErrors) as ve:
await InterfacesService(m).update(
update_interface['id'], {
'ipv4_dhcp': True,
},
)
assert 'interface_update.ipv4_dhcp' in ve.value