From a8c3cbc5d3aeed0d1ea456c8c9ee657f2c4bf37b Mon Sep 17 00:00:00 2001 From: Peter Eckel Date: Sun, 7 Jun 2026 13:28:45 +0200 Subject: [PATCH 1/2] Fixed the ruff format action --- .github/workflows/lint.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index 06ccd579..d9fb4388 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -15,10 +15,10 @@ jobs: - name: Checkout code uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 + - name: Run the ruff code checker + uses: astral-sh/ruff-action@b79a7ac759a34911be97ecdf3d744c213336da60 + - name: Check conformance to Ruff formatting standards - uses: astral-sh/ruff-action@8c228c72ff504d587be6b6cfbcf074768fdd6883 + uses: astral-sh/ruff-action@b79a7ac759a34911be97ecdf3d744c213336da60 with: - options: "format --check --diff" - - - name: Run the ruff code checker - uses: astral-sh/ruff-action@8c228c72ff504d587be6b6cfbcf074768fdd6883 + args: "format --check --diff" From 99fec2a55c8398e9da52b76ecededb2aab87de4f Mon Sep 17 00:00:00 2001 From: Peter Eckel Date: Sun, 7 Jun 2026 13:35:14 +0200 Subject: [PATCH 2/2] Fixed formatting according to ruff standards --- examples/custom-scripts/AXFR_Importer.py | 8 +- .../management/commands/cleanup_rrset_ttl.py | 3 +- .../management/commands/dns_check_zone_cut.py | 3 +- netbox_dns/models/nameserver.py | 16 +- netbox_dns/models/record.py | 160 ++++++++++-------- netbox_dns/models/record_template.py | 20 ++- netbox_dns/models/view.py | 20 ++- netbox_dns/models/zone.py | 147 +++++++++------- netbox_dns/models/zone_template.py | 8 +- netbox_dns/signals/ipam_dnssync.py | 16 +- netbox_dns/tests/custom/netbox.py | 31 +++- netbox_dns/tests/dnssec_policy/test_api.py | 8 +- .../tests/record/test_name_validation.py | 10 +- netbox_dns/tests/record/test_views.py | 12 +- netbox_dns/tests/zone/test_auto_soa.py | 24 +-- netbox_dns/tests/zone/test_filtersets.py | 10 +- .../tests/zone_template/test_filtersets.py | 40 +++-- netbox_dns/utilities/conversions.py | 3 +- netbox_dns/validators/dnssec.py | 68 ++++---- netbox_dns/views/record.py | 12 +- 20 files changed, 353 insertions(+), 266 deletions(-) diff --git a/examples/custom-scripts/AXFR_Importer.py b/examples/custom-scripts/AXFR_Importer.py index fb43b8f4..93068363 100755 --- a/examples/custom-scripts/AXFR_Importer.py +++ b/examples/custom-scripts/AXFR_Importer.py @@ -113,9 +113,11 @@ def run(self, data, commit): ) return - keyring = tsigkeyring.from_text({ - tsig_key_name: tsig_key, - }) + keyring = tsigkeyring.from_text( + { + tsig_key_name: tsig_key, + } + ) nameserver = data.get("nameserver") relativize = data.get("relativize_names") diff --git a/netbox_dns/management/commands/cleanup_rrset_ttl.py b/netbox_dns/management/commands/cleanup_rrset_ttl.py index ae1a147f..d325707e 100644 --- a/netbox_dns/management/commands/cleanup_rrset_ttl.py +++ b/netbox_dns/management/commands/cleanup_rrset_ttl.py @@ -29,8 +29,7 @@ def _cleanup_rrset_ttl(self, **options): self.stdout.write("Cleaning up diverging RRset TTL values") ttl_records = ( - Record.objects - .filter(ttl__isnull=False) + Record.objects.filter(ttl__isnull=False) .exclude(type=RecordTypeChoices.SOA) .exclude(type=RecordTypeChoices.PTR, managed=True) ) diff --git a/netbox_dns/management/commands/dns_check_zone_cut.py b/netbox_dns/management/commands/dns_check_zone_cut.py index 43db740f..766594fc 100644 --- a/netbox_dns/management/commands/dns_check_zone_cut.py +++ b/netbox_dns/management/commands/dns_check_zone_cut.py @@ -38,8 +38,7 @@ def handle(self, *model_names, **options): name__endswith=record.fqdn.rstrip(".") ).last() new_name = ( - dns_name - .from_text(record.fqdn) + dns_name.from_text(record.fqdn) .relativize(dns_name.from_text(new_zone.name)) .to_text() ) diff --git a/netbox_dns/models/nameserver.py b/netbox_dns/models/nameserver.py index 0d695e21..cb216368 100644 --- a/netbox_dns/models/nameserver.py +++ b/netbox_dns/models/nameserver.py @@ -83,16 +83,20 @@ def clean(self, *args, **kwargs): try: self.name = normalize_name(self.name) except NameFormatError as exc: - raise ValidationError({ - "name": str(exc), - }) + raise ValidationError( + { + "name": str(exc), + } + ) try: validate_fqdn(self.name) except ValidationError as exc: - raise ValidationError({ - "name": exc, - }) + raise ValidationError( + { + "name": exc, + } + ) super().clean(*args, **kwargs) diff --git a/netbox_dns/models/record.py b/netbox_dns/models/record.py index 06b28514..0140f13b 100644 --- a/netbox_dns/models/record.py +++ b/netbox_dns/models/record.py @@ -62,8 +62,7 @@ def record_data_from_ip_address(ip_address, zone): data = { "name": ( - dns_name - .from_text(ip_address.dns_name) + dns_name.from_text(ip_address.dns_name) .relativize(dns_name.from_text(zone.name)) .to_text() ), @@ -343,8 +342,7 @@ def rfc2317_ptr_cname_name(self): def ptr_zone(self): if self.type == RecordTypeChoices.A: ptr_zone = ( - self.zone.view.zones - .filter( + self.zone.view.zones.filter( rfc2317_prefix__net_contains=self.value, ) .order_by("rfc2317_prefix__net_mask_length") @@ -355,8 +353,7 @@ def ptr_zone(self): return ptr_zone return ( - self.zone.view.zones - .filter(arpa_network__net_contains=self.value) + self.zone.view.zones.filter(arpa_network__net_contains=self.value) .order_by("arpa_network__net_mask_length") .last() ) @@ -439,8 +436,7 @@ def update_ptr_record(self, update_rfc2317_cname=True, save_zone_serial=True): ptr_name = self.rfc2317_ptr_name else: ptr_name = ( - dns_name - .from_text(ipaddress.ip_address(self.value).reverse_pointer) + dns_name.from_text(ipaddress.ip_address(self.value).reverse_pointer) .relativize(dns_name.from_text(ptr_zone.name)) .to_text() ) @@ -562,8 +558,9 @@ def remove_from_rfc2317_cname_record(self, save_zone_serial=True): def update_rfc2317_cname_record(self, save_zone_serial=True): if self.zone.rfc2317_parent_managed: cname_name = ( - dns_name - .from_text(ipaddress.ip_address(self.ip_address).reverse_pointer) + dns_name.from_text( + ipaddress.ip_address(self.ip_address).reverse_pointer + ) .relativize(dns_name.from_text(self.zone.rfc2317_parent_zone.name)) .to_text() ) @@ -573,8 +570,9 @@ def update_rfc2317_cname_record(self, save_zone_serial=True): self.rfc2317_cname_record.zone = self.zone.rfc2317_parent_zone self.rfc2317_cname_record.value = self.fqdn self.rfc2317_cname_record.ttl = min_ttl( - self.rfc2317_cname_record.rfc2317_ptr_records - .exclude(pk=self.pk) + self.rfc2317_cname_record.rfc2317_ptr_records.exclude( + pk=self.pk + ) .aggregate(Min("ttl")) .get("ttl__min"), self.ttl, @@ -594,8 +592,7 @@ def update_rfc2317_cname_record(self, save_zone_serial=True): if rfc2317_cname_record is not None: rfc2317_cname_record.ttl = min_ttl( - rfc2317_cname_record.rfc2317_ptr_records - .exclude(pk=self.pk) + rfc2317_cname_record.rfc2317_ptr_records.exclude(pk=self.pk) .aggregate(Min("ttl")) .get("ttl__min"), self.ttl, @@ -676,11 +673,13 @@ def update_fqdn(self, zone=None): fqdn = dns_name.from_text(self.name, origin=_zone) if not fqdn.is_subdomain(_zone): - raise ValidationError({ - "name": _("{name} is not a name in {zone}").format( - name=self.name, zone=zone.name - ), - }) + raise ValidationError( + { + "name": _("{name} is not a name in {zone}").format( + name=self.name, zone=zone.name + ), + } + ) _zone.to_unicode() name.to_unicode() @@ -698,9 +697,11 @@ def validate_name(self, new_zone=None): self.update_fqdn(zone=new_zone) except dns.exception.DNSException as exc: - raise ValidationError({ - "name": str(exc), - }) + raise ValidationError( + { + "name": str(exc), + } + ) if self.type not in get_plugin_config( "netbox_dns", "tolerate_non_rfc1035_types", default=[] @@ -718,9 +719,11 @@ def validate_name(self, new_zone=None): ), ) except ValidationError as exc: - raise ValidationError({ - "name": exc, - }) + raise ValidationError( + { + "name": exc, + } + ) if get_plugin_config("netbox_dns", "enforce_zone_cut_checking"): try: @@ -765,13 +768,15 @@ def check_unique_record(self, new_zone=None): ): return - raise ValidationError({ - "value": _( - "There is already an active {type} record for name {name} in zone {zone} with value {value}." - ).format( - type=self.type, name=self.name, zone=self.zone, value=self.value - ) - }) + raise ValidationError( + { + "value": _( + "There is already an active {type} record for name {name} in zone {zone} with value {value}." + ).format( + type=self.type, name=self.name, zone=self.zone, value=self.value + ) + } + ) @property def absolute_value(self): @@ -859,8 +864,7 @@ def check_unique_rrset_ttl(self): return records = ( - self.zone.records - .filter( + self.zone.records.filter( name=self.name, type=self.type, ) @@ -880,16 +884,18 @@ def check_unique_rrset_ttl(self): self.ttl = conflicting_ttls.pop() return - raise ValidationError({ - "ttl": _( - "There is at least one active {type} record for name {name} in zone {zone} and TTL is different ({ttls})." - ).format( - type=self.type, - name=self.name, - zone=self.zone, - ttls=", ".join(str(ttl) for ttl in conflicting_ttls), - ) - }) + raise ValidationError( + { + "ttl": _( + "There is at least one active {type} record for name {name} in zone {zone} and TTL is different ({ttls})." + ).format( + type=self.type, + name=self.name, + zone=self.zone, + ttls=", ".join(str(ttl) for ttl in conflicting_ttls), + ) + } + ) check_unique_rrset_ttl.alters_data = True @@ -907,8 +913,7 @@ def update_rrset_ttl(self, ttl=None): ttl = self.ttl records = ( - self.zone.records - .filter( + self.zone.records.filter( name=self.name, type=self.type, ) @@ -966,8 +971,7 @@ def clean(self, *args, new_zone=None, **kwargs): ) if ( - ptr_cname_zone.records - .filter( + ptr_cname_zone.records.filter( name=ptr_cname_name, active=True, ) @@ -978,44 +982,54 @@ def clean(self, *args, new_zone=None, **kwargs): .exclude(type=RecordTypeChoices.NSEC) .exists() ): - raise ValidationError({ - "value": _( - "There is already an active record for name {name} in zone {zone}, RFC2317 CNAME is not allowed." - ).format(name=ptr_cname_name, zone=ptr_cname_zone) - }) + raise ValidationError( + { + "value": _( + "There is already an active record for name {name} in zone {zone}, RFC2317 CNAME is not allowed." + ).format(name=ptr_cname_name, zone=ptr_cname_zone) + } + ) if self.type == RecordTypeChoices.SOA and self.name != "@": - raise ValidationError({ - "name": _( - "SOA records are only allowed with name @ and are created automatically by NetBox DNS" - ) - }) + raise ValidationError( + { + "name": _( + "SOA records are only allowed with name @ and are created automatically by NetBox DNS" + ) + } + ) if self.type == RecordTypeChoices.CNAME: if records.exclude(type=RecordTypeChoices.NSEC).exists(): - raise ValidationError({ - "type": _( - "There is already an active record for name {name} in zone {zone}, CNAME is not allowed." - ).format(name=self.name, zone=self.zone) - }) + raise ValidationError( + { + "type": _( + "There is already an active record for name {name} in zone {zone}, CNAME is not allowed." + ).format(name=self.name, zone=self.zone) + } + ) elif ( records.filter(type=RecordTypeChoices.CNAME).exists() and self.type != RecordTypeChoices.NSEC ): - raise ValidationError({ - "type": _( - "There is already an active CNAME record for name {name} in zone {zone}, no other record allowed." - ).format(name=self.name, zone=self.zone) - }) + raise ValidationError( + { + "type": _( + "There is already an active CNAME record for name {name} in zone {zone}, no other record allowed." + ).format(name=self.name, zone=self.zone) + } + ) elif self.type in RecordTypeChoices.SINGLETONS: if records.filter(type=self.type).exists(): - raise ValidationError({ - "type": _( - "There is already an active {type} record for name {name} in zone {zone}, more than one are not allowed." - ).format(type=self.type, name=self.name, zone=self.zone) - }) + raise ValidationError( + { + "type": _( + "There is already an active {type} record for name {name} in zone {zone}, more than one are not allowed." + ).format(type=self.type, name=self.name, zone=self.zone) + } + ) super().clean(*args, **kwargs) diff --git a/netbox_dns/models/record_template.py b/netbox_dns/models/record_template.py index e09ebf42..8bfc329b 100644 --- a/netbox_dns/models/record_template.py +++ b/netbox_dns/models/record_template.py @@ -121,9 +121,11 @@ def validate_name(self): ), ) except ValidationError as exc: - raise ValidationError({ - "record_name": exc, - }) + raise ValidationError( + { + "record_name": exc, + } + ) def validate_value(self): try: @@ -150,11 +152,13 @@ def create_record(self, zone): try: record = Record.objects.create(**record_data) except ValidationError as exc: - raise ValidationError({ - None: _( - "Error while processing record template {template}: {error}" - ).format(template=self, error=exc.messages[0]) - }) + raise ValidationError( + { + None: _( + "Error while processing record template {template}: {error}" + ).format(template=self, error=exc.messages[0]) + } + ) if tags := self.tags.all(): record.tags.set(tags) diff --git a/netbox_dns/models/view.py b/netbox_dns/models/view.py index b4056218..10aa0130 100644 --- a/netbox_dns/models/view.py +++ b/netbox_dns/models/view.py @@ -81,11 +81,13 @@ def clean(self, *args, **kwargs): and not self.default_view and not View.objects.filter(default_view=True).exclude(pk=self.pk).exists() ): - raise ValidationError({ - "default_view": _( - "Please select a different view as default view to change this setting!" - ) - }) + raise ValidationError( + { + "default_view": _( + "Please select a different view as default view to change this setting!" + ) + } + ) if "ip_address_filter" in changed_fields and self.get_saved_value( "ip_address_filter" @@ -96,9 +98,11 @@ def clean(self, *args, **kwargs): ): check_dns_records(ip_address, view=self) except ValidationError as exc: - raise ValidationError({ - "ip_address_filter": exc.messages, - }) + raise ValidationError( + { + "ip_address_filter": exc.messages, + } + ) super().clean(*args, **kwargs) diff --git a/netbox_dns/models/zone.py b/netbox_dns/models/zone.py index ec3d07e4..3cfad119 100644 --- a/netbox_dns/models/zone.py +++ b/netbox_dns/models/zone.py @@ -442,8 +442,7 @@ def get_rfc2317_parent_zone(self): return None return ( - self.view.zones - .filter(arpa_network__net_contains=self.rfc2317_prefix) + self.view.zones.filter(arpa_network__net_contains=self.rfc2317_prefix) .order_by("arpa_network__net_mask_length") .last() ) @@ -484,8 +483,7 @@ def parent_zone(self): @property def ancestor_zones(self): return ( - self.view.zones - .annotate(name_length=Length("name")) + self.view.zones.annotate(name_length=Length("name")) .filter(name__iregex=regex_from_list(get_parent_zone_names(self.name))) .order_by("name_length") ) @@ -501,8 +499,7 @@ def delegation_records(self): ] ns_records = ( - self.records - .filter(type=RecordTypeChoices.NS) + self.records.filter(type=RecordTypeChoices.NS) .exclude(fqdn__iexact=self.fqdn) .filter(fqdn__iregex=regex_from_list(descendant_zone_names)) ) @@ -674,11 +671,13 @@ def check_soa_serial_increment(self, old_serial, new_serial): return if (new_serial - old_serial) % SOA_SERIAL_WRAP > MAX_SOA_SERIAL_INCREMENT: - raise ValidationError({ - "soa_serial": _("soa_serial must not decrease for zone {zone}.").format( - zone=self.name - ) - }) + raise ValidationError( + { + "soa_serial": _( + "soa_serial must not decrease for zone {zone}." + ).format(zone=self.name) + } + ) def get_auto_serial(self): records = Record.objects.filter(zone_id=self.pk).exclude( @@ -686,8 +685,7 @@ def get_auto_serial(self): ) if records: soa_serial = ( - records - .aggregate(Max("last_updated")) + records.aggregate(Max("last_updated")) .get("last_updated__max") .timestamp() ) @@ -795,17 +793,21 @@ def clean_fields(self, exclude=None): try: self.soa_mname = NameServer.objects.get(name=default_soa_mname) except NameServer.DoesNotExist: - raise ValidationError({ - "soa_mname": _( - "Default soa_mname instance {nameserver} does not exist" - ).format(nameserver=default_soa_mname) - }) - else: - raise ValidationError({ - "soa_mname": _( - "soa_mname not set and no template or default value defined" + raise ValidationError( + { + "soa_mname": _( + "Default soa_mname instance {nameserver} does not exist" + ).format(nameserver=default_soa_mname) + } ) - }) + else: + raise ValidationError( + { + "soa_mname": _( + "soa_mname not set and no template or default value defined" + ) + } + ) super().clean_fields(exclude=exclude) @@ -828,38 +830,48 @@ def clean(self, *args, **kwargs): try: self.name = normalize_name(self.name) except NameFormatError as exc: - raise ValidationError({ - "name": str(exc), - }) + raise ValidationError( + { + "name": str(exc), + } + ) try: validate_domain_name(self.name, zone_name=True) except ValidationError as exc: - raise ValidationError({ - "name": exc, - }) + raise ValidationError( + { + "name": exc, + } + ) if self.soa_rname in (None, ""): - raise ValidationError({ - "soa_rname": _( - "soa_rname not set and no template or default value defined" - ), - }) + raise ValidationError( + { + "soa_rname": _( + "soa_rname not set and no template or default value defined" + ), + } + ) try: dns_name.from_text(self.soa_rname, origin=dns_name.root) validate_rname(self.soa_rname) except (DNSException, ValidationError) as exc: - raise ValidationError({ - "soa_rname": exc, - }) + raise ValidationError( + { + "soa_rname": exc, + } + ) if not self.soa_serial_auto: if self.soa_serial is None: - raise ValidationError({ - "soa_serial": _( - "soa_serial is not defined and soa_serial_auto is disabled for zone {zone}." - ).format(zone=self.name) - }) + raise ValidationError( + { + "soa_serial": _( + "soa_serial is not defined and soa_serial_auto is disabled for zone {zone}." + ).format(zone=self.name) + } + ) if not self._state.adding: old_soa_serial = self.get_saved_value("soa_serial") @@ -873,11 +885,13 @@ def clean(self, *args, **kwargs): old_soa_serial, self.get_auto_serial() ) except ValidationError: - raise ValidationError({ - "soa_serial_auto": _( - "Enabling soa_serial_auto would decrease soa_serial for zone {zone}." - ).format(zone=self.name) - }) + raise ValidationError( + { + "soa_serial_auto": _( + "Enabling soa_serial_auto would decrease soa_serial for zone {zone}." + ).format(zone=self.name) + } + ) old_name = self.get_saved_value("name") old_view_id = self.get_saved_value("view_id") @@ -909,21 +923,25 @@ def clean(self, *args, **kwargs): if self.is_rfc2317_zone: if self.arpa_network is not None: - raise ValidationError({ - "rfc2317_prefix": _( - "A regular reverse zone can not be used as an RFC2317 zone." - ) - }) + raise ValidationError( + { + "rfc2317_prefix": _( + "A regular reverse zone can not be used as an RFC2317 zone." + ) + } + ) if self.rfc2317_parent_managed: rfc2317_parent_zone = self.get_rfc2317_parent_zone() if rfc2317_parent_zone is None: - raise ValidationError({ - "rfc2317_parent_managed": _( - "Parent zone not found in view {view}." - ).format(view=self.view) - }) + raise ValidationError( + { + "rfc2317_parent_managed": _( + "Parent zone not found in view {view}." + ).format(view=self.view) + } + ) self.rfc2317_parent_zone = rfc2317_parent_zone else: @@ -935,11 +953,13 @@ def clean(self, *args, **kwargs): ).exclude(pk=self.pk) if overlapping_zones.exists(): - raise ValidationError({ - "rfc2317_prefix": _( - "RFC2317 prefix overlaps with zone {zone}." - ).format(zone=overlapping_zones.first()) - }) + raise ValidationError( + { + "rfc2317_prefix": _( + "RFC2317 prefix overlaps with zone {zone}." + ).format(zone=overlapping_zones.first()) + } + ) else: self.rfc2317_parent_managed = False @@ -1100,8 +1120,7 @@ def delete(self, *args, **kwargs): ) ipam_ip_addresses = list( - IPAddress.objects - .filter( + IPAddress.objects.filter( netbox_dns_records__in=self.records.filter( ipam_ip_address__isnull=False ) diff --git a/netbox_dns/models/zone_template.py b/netbox_dns/models/zone_template.py index 593c12c8..91fcd19b 100644 --- a/netbox_dns/models/zone_template.py +++ b/netbox_dns/models/zone_template.py @@ -182,9 +182,11 @@ def clean(self, *args, **kwargs): dns_name.from_text(self.soa_rname, origin=dns_name.root) validate_rname(self.soa_rname) except (DNSException, ValidationError) as exc: - raise ValidationError({ - "soa_rname": exc, - }) + raise ValidationError( + { + "soa_rname": exc, + } + ) @register_search diff --git a/netbox_dns/signals/ipam_dnssync.py b/netbox_dns/signals/ipam_dnssync.py index 1afdac40..0023ff8d 100644 --- a/netbox_dns/signals/ipam_dnssync.py +++ b/netbox_dns/signals/ipam_dnssync.py @@ -59,13 +59,15 @@ def ipam_dnssync_ipaddress_post_clean(instance, **kwargs): if ENFORCE_UNIQUE_RECORDS and instance.status in IPADDRESS_ACTIVE_STATUS: for ip_address in duplicate_addresses.only("custom_field_data"): if not ip_address.custom_field_data.get("ipaddress_dns_disabled"): - raise ValidationError({ - "dns_name": _( - "Unique DNS records are enforced and there is already " - "an active IP address {address} with DNS name {name}. Please choose " - "a different name or disable record creation for this IP address." - ).format(address=instance.address, name=instance.dns_name) - }) + raise ValidationError( + { + "dns_name": _( + "Unique DNS records are enforced and there is already " + "an active IP address {address} with DNS name {name}. Please choose " + "a different name or disable record creation for this IP address." + ).format(address=instance.address, name=instance.dns_name) + } + ) # + # Check NetBox DNS record permission for changes to IPAddress custom fields diff --git a/netbox_dns/tests/custom/netbox.py b/netbox_dns/tests/custom/netbox.py index b4c1a780..0b8e2f20 100644 --- a/netbox_dns/tests/custom/netbox.py +++ b/netbox_dns/tests/custom/netbox.py @@ -51,26 +51,37 @@ def _build_query_with_filter(self, name, filter_string): strawberry_django.fields.types.DjangoImageType, ) for field in type_class.__strawberry_definition__.fields: - if ( - field.type in file_fields or ( - type(field.type) is StrawberryOptional and field.type.of_type in file_fields - ) + if field.type in file_fields or ( + type(field.type) is StrawberryOptional + and field.type.of_type in file_fields ): # image / file fields nullable or not... fields_string += f"{field.name} {{ name }}\n" - elif type(field.type) is StrawberryList and type(field.type.of_type) is LazyType: + elif ( + type(field.type) is StrawberryList + and type(field.type.of_type) is LazyType + ): # List of related objects (queryset) fields_string += f"{field.name} {{ id }}\n" - elif type(field.type) is StrawberryList and type(field.type.of_type) is StrawberryUnion: + elif ( + type(field.type) is StrawberryList + and type(field.type.of_type) is StrawberryUnion + ): # this would require a fragment query continue elif type(field.type) is StrawberryUnion: # this would require a fragment query continue - elif type(field.type) is StrawberryOptional and type(field.type.of_type) is StrawberryUnion: + elif ( + type(field.type) is StrawberryOptional + and type(field.type.of_type) is StrawberryUnion + ): # this would require a fragment query continue - elif type(field.type) is StrawberryOptional and type(field.type.of_type) is LazyType: + elif ( + type(field.type) is StrawberryOptional + and type(field.type.of_type) is LazyType + ): fields_string += f"{field.name} {{ id }}\n" elif hasattr(field, "is_relation") and field.is_relation: # Ignore private fields @@ -78,7 +89,9 @@ def _build_query_with_filter(self, name, filter_string): continue # Note: StrawberryField types do not have is_relation fields_string += f"{field.name} {{ id }}\n" - elif inspect.isclass(field.type) and issubclass(field.type, IPAddressFamilyType): + elif inspect.isclass(field.type) and issubclass( + field.type, IPAddressFamilyType + ): fields_string += f"{field.name} {{ value, label }}\n" else: fields_string += f"{field.name}\n" diff --git a/netbox_dns/tests/dnssec_policy/test_api.py b/netbox_dns/tests/dnssec_policy/test_api.py index d45fc441..b83c981b 100644 --- a/netbox_dns/tests/dnssec_policy/test_api.py +++ b/netbox_dns/tests/dnssec_policy/test_api.py @@ -148,10 +148,10 @@ def setUpTestData(cls): max_zone_ttl=86400, zone_propagation_delay=300, create_cdnskey=True, -# + -# TODO: Uncomment when the upstream bug in test_graphql_filter_objects is fixed -# - -# cds_digest_types=[DNSSECPolicyDigestChoices.SHA256], + # + + # TODO: Uncomment when the upstream bug in test_graphql_filter_objects is fixed + # - + # cds_digest_types=[DNSSECPolicyDigestChoices.SHA256], parent_ds_ttl=86400, parent_propagation_delay=3600, use_nsec3=True, diff --git a/netbox_dns/tests/record/test_name_validation.py b/netbox_dns/tests/record/test_name_validation.py index 317c63f6..7d0e630b 100644 --- a/netbox_dns/tests/record/test_name_validation.py +++ b/netbox_dns/tests/record/test_name_validation.py @@ -342,10 +342,12 @@ def test_zone_cut_delegation_ok(self): zone = self.zones[5] child_zone = self.zones[0] - child_zone.nameservers.set(( - NameServer.objects.create(name="ns1.zone1.example.com"), - NameServer.objects.create(name="ns2.zone1.example.com"), - )) + child_zone.nameservers.set( + ( + NameServer.objects.create(name="ns1.zone1.example.com"), + NameServer.objects.create(name="ns2.zone1.example.com"), + ) + ) Record.objects.create( name="zone1", diff --git a/netbox_dns/tests/record/test_views.py b/netbox_dns/tests/record/test_views.py index 3e5956a8..8d685455 100644 --- a/netbox_dns/tests/record/test_views.py +++ b/netbox_dns/tests/record/test_views.py @@ -344,9 +344,9 @@ def test_warning_mask_record_glue_a_ok(self): zone = Zone.objects.create(name="example.com", **self.zone_data) - self.zones[0].nameservers.set(( - NameServer.objects.create(name="ns1.zone1.example.com"), - )) + self.zones[0].nameservers.set( + (NameServer.objects.create(name="ns1.zone1.example.com"),) + ) Record.objects.create( name="zone1", @@ -400,9 +400,9 @@ def test_warning_mask_record_nonglue_a_warn(self): def test_warning_mask_record_glue_aaaa_ok(self): self.add_permissions("netbox_dns.view_record") - self.zones[0].nameservers.set(( - NameServer.objects.create(name="ns1.zone1.example.com"), - )) + self.zones[0].nameservers.set( + (NameServer.objects.create(name="ns1.zone1.example.com"),) + ) zone = Zone.objects.create(name="example.com", **self.zone_data) Record.objects.create( diff --git a/netbox_dns/tests/zone/test_auto_soa.py b/netbox_dns/tests/zone/test_auto_soa.py index d4c925e7..3c94c09c 100644 --- a/netbox_dns/tests/zone/test_auto_soa.py +++ b/netbox_dns/tests/zone/test_auto_soa.py @@ -37,17 +37,19 @@ def test_zone_soa(self): soa = parse_soa_value(soa_records[0].value) self.assertTrue( - all(( - zone.soa_mname.name + "." == soa.mname.to_text(), - zone.soa_rname + "." == soa.rname.to_text(), - zone.soa_serial == soa.serial, - zone.soa_refresh == soa.refresh, - zone.soa_retry == soa.retry, - zone.soa_expire == soa.expire, - zone.soa_minimum == soa.minimum, - zone.soa_ttl == soa_records[0].ttl, - len(soa_records) == 1, - )) + all( + ( + zone.soa_mname.name + "." == soa.mname.to_text(), + zone.soa_rname + "." == soa.rname.to_text(), + zone.soa_serial == soa.serial, + zone.soa_refresh == soa.refresh, + zone.soa_retry == soa.retry, + zone.soa_expire == soa.expire, + zone.soa_minimum == soa.minimum, + zone.soa_ttl == soa_records[0].ttl, + len(soa_records) == 1, + ) + ) ) def test_zone_soa_change_mname_no_dot(self): diff --git a/netbox_dns/tests/zone/test_filtersets.py b/netbox_dns/tests/zone/test_filtersets.py index 3748d0d2..5fc9f0f5 100644 --- a/netbox_dns/tests/zone/test_filtersets.py +++ b/netbox_dns/tests/zone/test_filtersets.py @@ -303,10 +303,12 @@ def setUpTestData(cls): for i in range(3): cls.zones[i].nameservers.set([cls.nameservers[0].pk, cls.nameservers[1].pk]) for i in range(3): - cls.zones[3 + i].nameservers.set([ - cls.nameservers[1].pk, - cls.nameservers[2].pk, - ]) + cls.zones[3 + i].nameservers.set( + [ + cls.nameservers[1].pk, + cls.nameservers[2].pk, + ] + ) def test_name(self): params = {"name": ["zone1.example.com", "zone2.example.com"]} diff --git a/netbox_dns/tests/zone_template/test_filtersets.py b/netbox_dns/tests/zone_template/test_filtersets.py index afa04b47..c5415a0a 100644 --- a/netbox_dns/tests/zone_template/test_filtersets.py +++ b/netbox_dns/tests/zone_template/test_filtersets.py @@ -169,23 +169,31 @@ def setUpTestData(cls): ) ZoneTemplate.objects.bulk_create(cls.zone_templates) for i in range(3): - cls.zone_templates[i].nameservers.set([ - cls.nameservers[0].pk, - cls.nameservers[1].pk, - ]) - cls.zone_templates[i].record_templates.set([ - cls.record_templates[0].pk, - cls.record_templates[1].pk, - ]) + cls.zone_templates[i].nameservers.set( + [ + cls.nameservers[0].pk, + cls.nameservers[1].pk, + ] + ) + cls.zone_templates[i].record_templates.set( + [ + cls.record_templates[0].pk, + cls.record_templates[1].pk, + ] + ) for i in range(3): - cls.zone_templates[3 + i].nameservers.set([ - cls.nameservers[1].pk, - cls.nameservers[2].pk, - ]) - cls.zone_templates[3 + i].record_templates.set([ - cls.record_templates[1].pk, - cls.record_templates[2].pk, - ]) + cls.zone_templates[3 + i].nameservers.set( + [ + cls.nameservers[1].pk, + cls.nameservers[2].pk, + ] + ) + cls.zone_templates[3 + i].record_templates.set( + [ + cls.record_templates[1].pk, + cls.record_templates[2].pk, + ] + ) def test_name(self): params = {"name": ["Zone Template 1", "Zone Template 3"]} diff --git a/netbox_dns/utilities/conversions.py b/netbox_dns/utilities/conversions.py index 5b197564..76c2564a 100644 --- a/netbox_dns/utilities/conversions.py +++ b/netbox_dns/utilities/conversions.py @@ -77,8 +77,7 @@ def normalize_name(name): try: return ( - dns_name - .from_text(name, origin=dns_name.root) + dns_name.from_text(name, origin=dns_name.root) .relativize(dns_name.root) .to_text() ) diff --git a/netbox_dns/validators/dnssec.py b/netbox_dns/validators/dnssec.py index e71f9399..c8b72f26 100644 --- a/netbox_dns/validators/dnssec.py +++ b/netbox_dns/validators/dnssec.py @@ -19,18 +19,22 @@ def validate_key_template(key_template): return if key_template.key_size not in DNSSECKeyTemplateKeySizeChoices.values(): - raise ValidationError({ - "key_size": _("{key_size} is not a supported key size.").format( - key_size=key_template.key_size - ) - }) + raise ValidationError( + { + "key_size": _("{key_size} is not a supported key size.").format( + key_size=key_template.key_size + ) + } + ) if key_template.algorithm != DNSSECKeyTemplateAlgorithmChoices.RSASHA256: - raise ValidationError({ - "key_size": _( - "Specifying the key size is not supported for algorithm {algorithm}." - ).format(algorithm=key_template.algorithm) - }) + raise ValidationError( + { + "key_size": _( + "Specifying the key size is not supported for algorithm {algorithm}." + ).format(algorithm=key_template.algorithm) + } + ) def validate_key_template_assignment(key_templates): @@ -42,27 +46,33 @@ def validate_key_template_assignment(key_templates): zsk = key_templates.filter(type=DNSSECKeyTemplateTypeChoices.TYPE_ZSK) if csk and (ksk or zsk): - raise ValidationError({ - "key_templates": _( - "Specifying a CSK together with any other key template type is not allowed." - ) - }) - - if any(( - csk.count() > 1, - ksk.count() > 1, - zsk.count() > 1, - )): - raise ValidationError({ - "key_templates": _( - "At most one key template per type (CSK, KSK and ZSK) is allowed." - ) - }) + raise ValidationError( + { + "key_templates": _( + "Specifying a CSK together with any other key template type is not allowed." + ) + } + ) + + if any( + ( + csk.count() > 1, + ksk.count() > 1, + zsk.count() > 1, + ) + ): + raise ValidationError( + { + "key_templates": _( + "At most one key template per type (CSK, KSK and ZSK) is allowed." + ) + } + ) if (ksk and zsk) and (ksk.first().algorithm != zsk.first().algorithm): - raise ValidationError({ - "key_templates": _("KSK and ZSK must use the same algorithm.") - }) + raise ValidationError( + {"key_templates": _("KSK and ZSK must use the same algorithm.")} + ) def validate_key_template_lifetime(key_template, policy, raise_exception=True): diff --git a/netbox_dns/views/record.py b/netbox_dns/views/record.py index 3260acfc..92ba7509 100644 --- a/netbox_dns/views/record.py +++ b/netbox_dns/views/record.py @@ -115,11 +115,13 @@ def get_cname_records(self, instance): zone=parent_zone, active=True, ) - cname_records = cname_records.union({ - record - for record in parent_cname_records - if record.value_fqdn == instance.fqdn - }) + cname_records = cname_records.union( + { + record + for record in parent_cname_records + if record.value_fqdn == instance.fqdn + } + ) if cname_records: return RelatedRecordTable(