From 81e0f2b42aba8dfda167646308583d919b7087b2 Mon Sep 17 00:00:00 2001 From: Ludovic Fernandez Date: Thu, 30 Oct 2025 13:02:35 +0100 Subject: [PATCH] chore: update linter (#2699) --- .github/workflows/pr.yml | 2 +- .golangci.yml | 3 --- acme/api/account.go | 5 +++++ acme/api/api.go | 1 + acme/api/authorization.go | 4 ++++ acme/api/challenge.go | 4 ++++ acme/api/internal/nonces/nonce_manager.go | 6 ++++- .../api/internal/nonces/nonce_manager_test.go | 5 +++++ acme/api/internal/secure/jws.go | 4 ++++ acme/api/internal/secure/jws_test.go | 5 +++++ acme/api/internal/sender/sender.go | 2 ++ acme/api/internal/sender/sender_test.go | 3 +++ acme/api/order.go | 3 +++ acme/api/order_test.go | 2 ++ acme/api/service.go | 2 ++ acme/commons.go | 8 ++++--- acme/errors.go | 19 ++++++++++------ certcrypto/crypto.go | 17 ++++++++++---- certcrypto/crypto_test.go | 1 + certificate/authorization.go | 2 ++ certificate/certificates.go | 5 +++++ certificate/renewal.go | 1 + challenge/challenges.go | 1 + challenge/dns01/dns_challenge.go | 6 +++++ challenge/dns01/dns_challenge_manual_test.go | 1 + challenge/dns01/dns_challenge_test.go | 1 + challenge/dns01/fqdn.go | 1 + challenge/dns01/mock_test.go | 3 +++ challenge/dns01/nameserver.go | 19 +++++++++++----- challenge/dns01/precheck.go | 3 +++ challenge/http01/domain_matcher.go | 9 ++++++++ challenge/http01/http_challenge.go | 2 ++ challenge/http01/http_challenge_server.go | 2 ++ challenge/http01/http_challenge_test.go | 5 +++++ challenge/resolver/errors.go | 2 ++ challenge/resolver/prober.go | 14 ++++++++++-- challenge/resolver/solver_manager.go | 3 +++ challenge/resolver/solver_manager_test.go | 2 ++ challenge/tlsalpn01/tls_alpn_challenge.go | 2 ++ .../tlsalpn01/tls_alpn_challenge_test.go | 11 ++++++++-- cmd/accounts_storage.go | 7 ++++++ cmd/certs_storage.go | 4 ++++ cmd/cmd_list.go | 3 +++ cmd/cmd_renew.go | 22 +++++++++++++++---- cmd/cmd_run.go | 7 ++++++ cmd/flags.go | 1 + cmd/hook.go | 2 ++ cmd/lego/main.go | 1 + cmd/setup.go | 5 +++++ cmd/setup_challenges.go | 5 +++++ e2e/challenges_test.go | 17 ++++++++++++++ e2e/dnschallenge/dns_challenges_test.go | 6 +++++ e2e/loader/loader.go | 17 ++++++++++++++ internal/clihelp/generator.go | 5 +++++ internal/dns/docs/generator.go | 11 ++++++++-- internal/dns/providers/generator.go | 1 + internal/releaser/releaser.go | 4 ++++ platform/config/env/env.go | 5 +++++ platform/tester/api.go | 1 + platform/tester/env.go | 2 ++ platform/tester/env_test.go | 3 +++ platform/tester/servermock/link_form.go | 3 +++ platform/tester/servermock/link_headers.go | 1 + platform/tester/servermock/link_query.go | 3 +++ .../tester/servermock/link_request_body.go | 1 + .../servermock/link_request_body_json.go | 3 +++ platform/wait/wait.go | 4 ++++ platform/wait/wait_test.go | 1 + providers/dns/acmedns/acmedns.go | 1 + providers/dns/acmedns/mock_test.go | 1 + providers/dns/active24/active24_test.go | 3 +++ providers/dns/alidns/alidns.go | 3 +++ providers/dns/alidns/alidns_test.go | 3 +++ providers/dns/allinkl/allinkl.go | 1 + providers/dns/allinkl/allinkl_test.go | 3 +++ providers/dns/allinkl/internal/client.go | 3 +++ providers/dns/allinkl/internal/types.go | 2 ++ providers/dns/anexia/anexia.go | 1 + providers/dns/anexia/anexia_test.go | 3 +++ providers/dns/anexia/internal/client.go | 2 ++ providers/dns/arvancloud/arvancloud.go | 1 + providers/dns/arvancloud/arvancloud_test.go | 3 +++ providers/dns/arvancloud/internal/client.go | 2 ++ .../dns/arvancloud/internal/client_test.go | 6 +++-- providers/dns/auroradns/auroradns_test.go | 1 + providers/dns/autodns/autodns_test.go | 3 +++ providers/dns/autodns/internal/client.go | 1 + providers/dns/axelname/axelname_test.go | 3 +++ providers/dns/axelname/internal/client.go | 1 + providers/dns/azion/azion.go | 3 +++ providers/dns/azion/azion_test.go | 3 +++ providers/dns/azure/azure.go | 5 +++++ providers/dns/azure/azure_test.go | 4 ++++ providers/dns/azure/private.go | 3 +++ providers/dns/azure/public.go | 3 +++ providers/dns/azuredns/azuredns_test.go | 3 +++ providers/dns/azuredns/credentials.go | 1 + providers/dns/azuredns/private.go | 1 + providers/dns/azuredns/public.go | 1 + providers/dns/azuredns/servicediscovery.go | 1 + providers/dns/baiducloud/baiducloud_test.go | 3 +++ providers/dns/beget/beget.go | 1 + providers/dns/beget/beget_test.go | 3 +++ providers/dns/beget/internal/client.go | 2 ++ providers/dns/beget/internal/types.go | 2 +- providers/dns/binarylane/binarylane.go | 1 + providers/dns/binarylane/binarylane_test.go | 3 +++ providers/dns/binarylane/internal/client.go | 2 ++ providers/dns/binarylane/internal/types.go | 8 ++++--- providers/dns/bindman/bindman.go | 2 ++ providers/dns/bindman/bindman_test.go | 3 +++ providers/dns/bluecat/bluecat_test.go | 3 +++ providers/dns/bluecat/internal/client.go | 2 ++ providers/dns/bluecat/internal/client_test.go | 1 + providers/dns/bookmyname/bookmyname_test.go | 3 +++ providers/dns/brandit/brandit.go | 2 ++ providers/dns/brandit/brandit_test.go | 3 +++ providers/dns/brandit/internal/client.go | 3 +++ providers/dns/bunny/bunny.go | 3 +++ providers/dns/bunny/bunny_test.go | 3 +++ providers/dns/checkdomain/checkdomain.go | 1 + providers/dns/checkdomain/checkdomain_test.go | 3 +++ providers/dns/checkdomain/internal/client.go | 6 +++++ providers/dns/civo/civo.go | 1 + providers/dns/civo/civo_test.go | 3 +++ providers/dns/civo/internal/client.go | 1 + providers/dns/civo/internal/client_test.go | 1 - providers/dns/clouddns/clouddns_test.go | 3 +++ providers/dns/clouddns/internal/client.go | 3 +++ providers/dns/clouddns/internal/identity.go | 1 + providers/dns/clouddns/internal/types.go | 2 +- providers/dns/cloudflare/cloudflare.go | 2 ++ providers/dns/cloudflare/cloudflare_test.go | 7 ++++++ providers/dns/cloudflare/internal/client.go | 1 + providers/dns/cloudflare/internal/types.go | 13 ++++++----- providers/dns/cloudflare/wrapper.go | 1 + providers/dns/cloudns/cloudns.go | 1 + providers/dns/cloudns/cloudns_test.go | 3 +++ providers/dns/cloudns/internal/client.go | 2 ++ providers/dns/cloudns/internal/client_test.go | 1 + providers/dns/cloudru/cloudru_test.go | 3 +++ providers/dns/cloudru/internal/client.go | 3 +++ providers/dns/cloudru/internal/identity.go | 2 ++ providers/dns/cloudru/internal/types.go | 6 ++--- providers/dns/conoha/conoha_test.go | 3 +++ providers/dns/conoha/internal/client.go | 1 + providers/dns/conoha/internal/client_test.go | 2 ++ providers/dns/conohav3/conohav3_test.go | 3 +++ providers/dns/conohav3/internal/client.go | 1 + .../dns/conohav3/internal/client_test.go | 2 ++ providers/dns/conohav3/internal/identity.go | 1 + providers/dns/constellix/constellix.go | 1 + providers/dns/constellix/constellix_test.go | 3 +++ providers/dns/constellix/internal/auth.go | 2 ++ providers/dns/constellix/internal/domains.go | 3 +++ .../dns/constellix/internal/txtrecords.go | 5 +++++ .../dns/corenetworks/corenetworks_test.go | 3 +++ providers/dns/corenetworks/internal/client.go | 3 +++ .../dns/corenetworks/internal/identity.go | 1 + providers/dns/cpanel/cpanel.go | 18 +++++++++++---- providers/dns/cpanel/cpanel_test.go | 3 +++ providers/dns/cpanel/internal/cpanel/types.go | 2 +- providers/dns/cpanel/internal/whm/types.go | 2 +- providers/dns/derak/derak.go | 1 + providers/dns/derak/derak_test.go | 3 +++ providers/dns/derak/internal/client.go | 7 ++++++ providers/dns/derak/internal/types.go | 2 +- providers/dns/desec/desec.go | 1 + providers/dns/desec/desec_test.go | 3 +++ providers/dns/designate/designate.go | 3 ++- providers/dns/designate/designate_test.go | 4 ++++ providers/dns/digitalocean/digitalocean.go | 2 ++ .../dns/digitalocean/digitalocean_test.go | 1 + providers/dns/digitalocean/internal/client.go | 2 ++ providers/dns/directadmin/directadmin_test.go | 3 +++ providers/dns/directadmin/internal/client.go | 1 + providers/dns/dns_providers_test.go | 2 ++ providers/dns/dnshomede/dnshomede.go | 1 + providers/dns/dnshomede/dnshomede_test.go | 3 +++ providers/dns/dnsimple/dnsimple.go | 1 + providers/dns/dnsimple/dnsimple_test.go | 1 + providers/dns/dnsmadeeasy/dnsmadeeasy.go | 3 +++ providers/dns/dnsmadeeasy/dnsmadeeasy_test.go | 2 ++ providers/dns/dnsmadeeasy/internal/client.go | 4 ++++ providers/dns/dnspod/dnspod.go | 3 +++ providers/dns/dnspod/dnspod_test.go | 3 +++ providers/dns/dode/dode_test.go | 3 +++ providers/dns/dode/internal/client.go | 1 + providers/dns/domeneshop/domeneshop_test.go | 3 +++ providers/dns/dreamhost/dreamhost.go | 1 + providers/dns/dreamhost/dreamhost_test.go | 2 ++ providers/dns/dreamhost/internal/client.go | 1 + providers/dns/duckdns/duckdns_test.go | 3 +++ providers/dns/duckdns/internal/client.go | 2 ++ providers/dns/dyn/dyn_test.go | 3 +++ providers/dns/dyn/internal/client.go | 1 + providers/dns/dyn/internal/session.go | 1 + providers/dns/dyndnsfree/dyndnsfree.go | 1 - providers/dns/dyndnsfree/dyndnsfree_test.go | 3 +++ providers/dns/dynu/dynu_test.go | 3 +++ providers/dns/dynu/internal/auth.go | 1 + providers/dns/dynu/internal/client.go | 4 ++++ providers/dns/easydns/easydns.go | 2 ++ providers/dns/easydns/easydns_test.go | 3 +++ providers/dns/easydns/internal/client.go | 2 ++ providers/dns/edgedns/edgedns.go | 5 +++++ .../dns/edgedns/edgedns_integration_test.go | 2 ++ providers/dns/edgedns/edgedns_test.go | 2 ++ providers/dns/edgeone/edgeone.go | 1 + providers/dns/edgeone/edgeone_test.go | 3 +++ providers/dns/edgeone/wrapper.go | 1 + providers/dns/efficientip/efficientip.go | 3 +++ providers/dns/efficientip/efficientip_test.go | 3 +++ providers/dns/efficientip/internal/client.go | 2 ++ providers/dns/epik/epik_test.go | 3 +++ providers/dns/epik/internal/client.go | 4 ++++ providers/dns/exec/exec_test.go | 4 ++++ providers/dns/exoscale/exoscale.go | 2 ++ providers/dns/exoscale/exoscale_test.go | 3 +++ providers/dns/f5xc/f5xc_test.go | 3 +++ providers/dns/f5xc/internal/client.go | 1 + providers/dns/f5xc/internal/types.go | 4 ++-- providers/dns/freemyip/freemyip_test.go | 3 +++ providers/dns/gandi/gandi_test.go | 3 +++ providers/dns/gandi/internal/client.go | 8 +++++++ providers/dns/gandi/internal/types.go | 3 +++ providers/dns/gandiv5/gandiv5.go | 4 ++++ providers/dns/gandiv5/gandiv5_test.go | 3 +++ providers/dns/gandiv5/internal/client.go | 4 ++++ providers/dns/gcloud/googlecloud.go | 11 ++++++++++ providers/dns/gcloud/googlecloud_test.go | 4 ++++ providers/dns/gcore/gcore_test.go | 3 +++ providers/dns/gcore/internal/client.go | 3 +++ providers/dns/glesys/glesys.go | 2 ++ providers/dns/glesys/glesys_test.go | 3 +++ providers/dns/glesys/internal/client.go | 1 + providers/dns/godaddy/godaddy.go | 2 ++ providers/dns/godaddy/godaddy_test.go | 3 +++ providers/dns/godaddy/internal/client.go | 2 ++ providers/dns/godaddy/internal/types.go | 14 ++++++++---- providers/dns/hetzner/hetzner_test.go | 1 + .../internal/hetznerv1/hetznerv1_test.go | 3 +++ .../internal/hetznerv1/internal/client.go | 4 ++++ .../internal/hetznerv1/internal/types.go | 14 +++++++----- .../hetzner/internal/legacy/hetzner_test.go | 3 +++ .../internal/legacy/internal/client.go | 2 ++ .../hetzner/internal/legacy/internal/types.go | 4 ++-- providers/dns/hostingde/hostingde.go | 2 ++ providers/dns/hostingde/hostingde_test.go | 3 +++ providers/dns/hostinger/hostinger_test.go | 3 +++ providers/dns/hostinger/internal/client.go | 2 ++ providers/dns/hostinger/internal/types.go | 8 ++++--- providers/dns/hosttech/hosttech.go | 1 + providers/dns/hosttech/hosttech_test.go | 3 +++ providers/dns/hosttech/internal/client.go | 5 +++++ providers/dns/hosttech/internal/types.go | 11 +++++++--- providers/dns/httpnet/httpnet.go | 2 ++ providers/dns/httpnet/httpnet_test.go | 3 +++ providers/dns/httpreq/httpreq.go | 5 +++++ providers/dns/httpreq/httpreq_test.go | 2 ++ providers/dns/huaweicloud/huaweicloud.go | 1 + providers/dns/huaweicloud/huaweicloud_test.go | 3 +++ providers/dns/hurricane/hurricane.go | 1 + providers/dns/hurricane/hurricane_test.go | 3 +++ providers/dns/hyperone/hyperone.go | 2 ++ providers/dns/hyperone/hyperone_test.go | 3 +++ providers/dns/hyperone/internal/passport.go | 1 + providers/dns/hyperone/internal/token_test.go | 2 ++ providers/dns/ibmcloud/ibmcloud_test.go | 3 +++ providers/dns/iij/iij.go | 2 ++ providers/dns/iij/iij_test.go | 3 +++ providers/dns/iijdpf/iijdpf_test.go | 3 +++ providers/dns/iijdpf/wrapper.go | 3 +++ providers/dns/infoblox/infoblox.go | 1 + providers/dns/infoblox/infoblox_test.go | 3 +++ providers/dns/infomaniak/infomaniak_test.go | 3 +++ providers/dns/infomaniak/internal/client.go | 2 ++ providers/dns/internal/active24/client.go | 4 ++++ providers/dns/internal/hostingde/types.go | 4 +++- providers/dns/internal/rimuhosting/client.go | 4 ++++ providers/dns/internal/selectel/client.go | 5 +++++ providers/dns/internetbs/internal/client.go | 3 +++ providers/dns/internetbs/internetbs_test.go | 3 +++ providers/dns/inwx/inwx.go | 2 ++ providers/dns/inwx/inwx_test.go | 2 ++ providers/dns/ionos/internal/client.go | 3 +++ providers/dns/ionos/internal/types.go | 13 ++++++----- providers/dns/ionos/ionos.go | 1 + providers/dns/ionos/ionos_test.go | 3 +++ providers/dns/ipv64/internal/client.go | 1 + providers/dns/ipv64/internal/types.go | 2 ++ providers/dns/ipv64/ipv64_test.go | 3 +++ providers/dns/joker/internal/dmapi/client.go | 3 +++ .../dns/joker/internal/dmapi/identity.go | 2 ++ providers/dns/joker/joker_test.go | 3 +++ providers/dns/joker/provider_dmapi.go | 3 +++ providers/dns/joker/provider_dmapi_test.go | 1 + providers/dns/joker/provider_svc_test.go | 1 + providers/dns/keyhelp/internal/client.go | 1 + providers/dns/keyhelp/keyhelp.go | 2 ++ providers/dns/keyhelp/keyhelp_test.go | 3 +++ providers/dns/liara/internal/client.go | 4 ++++ providers/dns/liara/liara.go | 4 ++++ providers/dns/liara/liara_test.go | 3 +++ providers/dns/lightsail/lightsail.go | 1 + .../lightsail/lightsail_integration_test.go | 1 + providers/dns/lightsail/lightsail_test.go | 1 + providers/dns/limacity/internal/client.go | 6 +++++ providers/dns/limacity/internal/types.go | 2 +- providers/dns/limacity/limacity.go | 2 ++ providers/dns/limacity/limacity_test.go | 3 +++ providers/dns/linode/linode.go | 3 +++ providers/dns/linode/linode_test.go | 3 +++ providers/dns/liquidweb/liquidweb.go | 2 ++ providers/dns/liquidweb/liquidweb_test.go | 2 ++ providers/dns/liquidweb/servermock_test.go | 7 ++++++ providers/dns/loopia/internal/types.go | 4 ++++ providers/dns/loopia/loopia_test.go | 3 +++ providers/dns/luadns/internal/client.go | 3 +++ providers/dns/luadns/luadns_test.go | 3 +++ providers/dns/mailinabox/mailinabox_test.go | 3 +++ providers/dns/manageengine/internal/client.go | 2 ++ providers/dns/manageengine/manageengine.go | 1 + .../dns/manageengine/manageengine_test.go | 3 +++ providers/dns/metaname/metaname.go | 1 + providers/dns/metaname/metaname_test.go | 3 +++ .../dns/metaregistrar/internal/client.go | 1 + .../dns/metaregistrar/metaregistrar_test.go | 3 +++ providers/dns/mijnhost/internal/client.go | 3 +++ providers/dns/mijnhost/mijnhost_test.go | 3 +++ providers/dns/mittwald/internal/client.go | 5 +++++ providers/dns/mittwald/internal/types.go | 19 ++++++++++------ providers/dns/mittwald/mittwald.go | 1 + providers/dns/mittwald/mittwald_test.go | 3 +++ providers/dns/myaddr/myaddr_test.go | 3 +++ providers/dns/mydnsjp/mydnsjp.go | 2 ++ providers/dns/mydnsjp/mydnsjp_test.go | 3 +++ providers/dns/mythicbeasts/internal/client.go | 1 + .../dns/mythicbeasts/internal/identity.go | 2 ++ providers/dns/mythicbeasts/mythicbeasts.go | 1 + .../dns/mythicbeasts/mythicbeasts_test.go | 4 ++++ providers/dns/namecheap/internal/client.go | 3 +++ providers/dns/namecheap/namecheap.go | 10 +++++++-- providers/dns/namecheap/namecheap_test.go | 1 + providers/dns/namedotcom/namedotcom.go | 2 ++ providers/dns/namedotcom/namedotcom_test.go | 3 +++ providers/dns/namesilo/namesilo.go | 1 + providers/dns/namesilo/namesilo_test.go | 2 ++ .../dns/nearlyfreespeech/internal/client.go | 2 +- .../nearlyfreespeech/internal/client_test.go | 1 + .../nearlyfreespeech/nearlyfreespeech_test.go | 3 +++ providers/dns/netcup/internal/client.go | 3 +++ providers/dns/netcup/internal/session.go | 1 + providers/dns/netcup/netcup_test.go | 2 ++ providers/dns/netlify/internal/client.go | 2 ++ providers/dns/netlify/netlify.go | 1 + providers/dns/netlify/netlify_test.go | 3 +++ providers/dns/nicmanager/internal/client.go | 1 + providers/dns/nicmanager/nicmanager.go | 7 ++++-- providers/dns/nicmanager/nicmanager_test.go | 3 +++ providers/dns/nicru/internal/client.go | 1 + providers/dns/nicru/nicru_test.go | 3 +++ providers/dns/nifcloud/internal/client.go | 5 +++++ providers/dns/nifcloud/nifcloud.go | 2 ++ providers/dns/nifcloud/nifcloud_test.go | 3 +++ providers/dns/njalla/internal/client.go | 2 ++ providers/dns/njalla/njalla.go | 1 + providers/dns/njalla/njalla_test.go | 3 +++ providers/dns/nodion/nodion.go | 1 + providers/dns/nodion/nodion_test.go | 3 +++ providers/dns/ns1/ns1.go | 2 ++ providers/dns/ns1/ns1_test.go | 3 +++ providers/dns/octenium/octenium.go | 1 + providers/dns/octenium/octenium_test.go | 3 +++ providers/dns/oraclecloud/oraclecloud.go | 1 + providers/dns/oraclecloud/oraclecloud_test.go | 9 +++++--- providers/dns/otc/internal/client.go | 6 +++++ providers/dns/otc/internal/identity.go | 3 +++ providers/dns/otc/internal/types.go | 8 +++---- providers/dns/otc/otc_test.go | 3 +++ providers/dns/ovh/ovh.go | 10 +++++++-- providers/dns/ovh/ovh_test.go | 4 ++++ providers/dns/pdns/internal/client.go | 5 +++++ providers/dns/pdns/pdns.go | 1 + providers/dns/pdns/pdns_test.go | 3 +++ providers/dns/plesk/internal/client.go | 2 ++ providers/dns/plesk/plesk.go | 1 + providers/dns/plesk/plesk_test.go | 3 +++ providers/dns/porkbun/porkbun.go | 1 + providers/dns/porkbun/porkbun_test.go | 3 +++ providers/dns/rackspace/internal/client.go | 2 ++ providers/dns/rackspace/internal/identity.go | 1 + providers/dns/rackspace/rackspace.go | 1 + providers/dns/rackspace/rackspace_test.go | 3 +++ providers/dns/rainyun/internal/client.go | 2 ++ providers/dns/rainyun/rainyun_test.go | 3 +++ providers/dns/rcodezero/internal/client.go | 2 ++ providers/dns/rcodezero/rcodezero_test.go | 2 ++ providers/dns/regfish/regfish.go | 1 + providers/dns/regfish/regfish_test.go | 3 +++ providers/dns/regru/internal/client.go | 2 ++ providers/dns/regru/regru_test.go | 3 +++ providers/dns/rfc2136/rfc2136.go | 3 +++ providers/dns/rfc2136/rfc2136_test.go | 2 ++ providers/dns/rimuhosting/rimuhosting_test.go | 3 +++ providers/dns/route53/route53.go | 5 +++++ providers/dns/route53/route53_test.go | 6 +++++ providers/dns/safedns/internal/client.go | 2 ++ providers/dns/safedns/safedns.go | 1 + providers/dns/safedns/safedns_test.go | 3 +++ providers/dns/sakuracloud/sakuracloud.go | 1 + providers/dns/sakuracloud/sakuracloud_test.go | 3 +++ providers/dns/sakuracloud/wrapper.go | 2 ++ providers/dns/sakuracloud/wrapper_test.go | 2 ++ providers/dns/scaleway/scaleway_test.go | 3 +++ providers/dns/selectel/selectel.go | 3 +++ providers/dns/selectel/selectel_test.go | 3 +++ providers/dns/selectelv2/selectelv2_test.go | 3 +++ providers/dns/selfhostde/mapping.go | 6 +++-- providers/dns/selfhostde/selfhostde.go | 1 + providers/dns/selfhostde/selfhostde_test.go | 3 +++ providers/dns/servercow/internal/client.go | 4 ++++ providers/dns/servercow/internal/types.go | 1 + providers/dns/servercow/servercow.go | 2 ++ providers/dns/servercow/servercow_test.go | 3 +++ providers/dns/shellrent/internal/client.go | 3 +++ providers/dns/shellrent/internal/types.go | 2 ++ providers/dns/shellrent/shellrent.go | 1 + providers/dns/shellrent/shellrent_test.go | 3 +++ providers/dns/simply/internal/client.go | 2 ++ providers/dns/simply/simply.go | 1 + providers/dns/simply/simply_test.go | 3 +++ providers/dns/sonic/internal/client.go | 1 + providers/dns/sonic/sonic_test.go | 3 +++ providers/dns/spaceship/internal/client.go | 2 ++ providers/dns/spaceship/spaceship_test.go | 3 +++ providers/dns/stackpath/internal/client.go | 3 +++ providers/dns/stackpath/stackpath_test.go | 3 +++ providers/dns/technitium/internal/client.go | 2 ++ providers/dns/technitium/technitium_test.go | 3 +++ .../dns/tencentcloud/tencentcloud_test.go | 3 +++ providers/dns/tencentcloud/wrapper.go | 2 ++ providers/dns/timewebcloud/internal/client.go | 2 ++ providers/dns/timewebcloud/timewebcloud.go | 1 + .../dns/timewebcloud/timewebcloud_test.go | 3 +++ providers/dns/transip/transip.go | 1 + providers/dns/transip/transip_test.go | 4 ++++ providers/dns/ultradns/ultradns.go | 6 +++-- providers/dns/ultradns/ultradns_test.go | 1 + providers/dns/variomedia/internal/client.go | 4 ++++ providers/dns/variomedia/variomedia.go | 1 + providers/dns/variomedia/variomedia_test.go | 3 +++ providers/dns/vegadns/vegadns_test.go | 5 +++++ providers/dns/vercel/internal/client.go | 2 ++ providers/dns/vercel/vercel.go | 1 + providers/dns/vercel/vercel_test.go | 3 +++ providers/dns/versio/internal/client.go | 4 ++++ providers/dns/versio/versio.go | 5 +++++ providers/dns/versio/versio_test.go | 5 +++++ providers/dns/vinyldns/vinyldns.go | 1 + providers/dns/vinyldns/vinyldns_test.go | 3 +++ providers/dns/vinyldns/wrapper.go | 1 + providers/dns/vkcloud/internal/client.go | 2 ++ providers/dns/vkcloud/vkcloud.go | 1 + providers/dns/vkcloud/vkcloud_test.go | 3 +++ providers/dns/volcengine/volcengine.go | 1 + providers/dns/volcengine/volcengine_test.go | 3 +++ providers/dns/vscale/vscale.go | 3 +++ providers/dns/vscale/vscale_test.go | 3 +++ providers/dns/vultr/vultr.go | 2 ++ providers/dns/vultr/vultr_test.go | 3 +++ providers/dns/webnames/internal/client.go | 1 + providers/dns/webnames/webnames_test.go | 3 +++ providers/dns/websupport/websupport_test.go | 3 +++ providers/dns/wedos/internal/client.go | 1 + providers/dns/wedos/internal/token.go | 4 ++++ providers/dns/wedos/wedos_test.go | 3 +++ providers/dns/westcn/westcn.go | 1 + providers/dns/westcn/westcn_test.go | 3 +++ providers/dns/yandex/internal/client.go | 3 +++ providers/dns/yandex/internal/types.go | 3 +++ providers/dns/yandex/yandex.go | 2 ++ providers/dns/yandex/yandex_test.go | 3 +++ providers/dns/yandex360/internal/client.go | 1 + providers/dns/yandex360/yandex360_test.go | 3 +++ providers/dns/yandexcloud/yandexcloud.go | 2 ++ providers/dns/yandexcloud/yandexcloud_test.go | 3 +++ providers/dns/zoneedit/internal/client.go | 1 + providers/dns/zoneedit/zoneedit_test.go | 3 +++ providers/dns/zoneee/zoneee.go | 3 +++ providers/dns/zoneee/zoneee_test.go | 5 +++++ providers/dns/zonomi/zonomi_test.go | 3 +++ providers/http/memcached/memcached.go | 2 ++ providers/http/memcached/memcached_test.go | 8 +++++++ providers/http/s3/s3.go | 1 + providers/http/webroot/webroot.go | 1 + providers/http/webroot/webroot_test.go | 1 + registration/registar.go | 3 ++- 498 files changed, 1439 insertions(+), 112 deletions(-) diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml index 6b9bce14e..91977bc28 100644 --- a/.github/workflows/pr.yml +++ b/.github/workflows/pr.yml @@ -13,7 +13,7 @@ jobs: runs-on: ubuntu-latest env: GO_VERSION: stable - GOLANGCI_LINT_VERSION: v2.5.0 + GOLANGCI_LINT_VERSION: v2.6.0 HUGO_VERSION: 0.148.2 CGO_ENABLED: 0 LEGO_E2E_TESTS: CI diff --git a/.golangci.yml b/.golangci.yml index 2fabe806c..a6f0c4bfa 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -50,11 +50,8 @@ linters: - tagliatelle - testpackage # not relevant - tparallel # not relevant - - usestdlibvars # false-positive https://github.com/sashamelentyev/usestdlibvars/issues/96 - varnamelen # not relevant - wrapcheck - - wsl_v5 # should be enabled the future. - - embeddedstructfieldcheck # should be enabled the future. settings: depguard: diff --git a/acme/api/account.go b/acme/api/account.go index cab5d477f..62e5ef9a6 100644 --- a/acme/api/account.go +++ b/acme/api/account.go @@ -13,6 +13,7 @@ type AccountService service // New Creates a new account. func (a *AccountService) New(req acme.Account) (acme.ExtendedAccount, error) { var account acme.Account + resp, err := a.core.post(a.core.GetDirectory().NewAccountURL, req, &account) location := getLocation(resp) @@ -51,10 +52,12 @@ func (a *AccountService) Get(accountURL string) (acme.Account, error) { } var account acme.Account + _, err := a.core.postAsGet(accountURL, &account) if err != nil { return acme.Account{}, err } + return account, nil } @@ -65,6 +68,7 @@ func (a *AccountService) Update(accountURL string, req acme.Account) (acme.Accou } var account acme.Account + _, err := a.core.post(accountURL, req, &account) if err != nil { return acme.Account{}, err @@ -81,6 +85,7 @@ func (a *AccountService) Deactivate(accountURL string) error { req := acme.Account{Status: acme.StatusDeactivated} _, err := a.core.post(accountURL, req, nil) + return err } diff --git a/acme/api/api.go b/acme/api/api.go index cdad156dc..da1c94d1b 100644 --- a/acme/api/api.go +++ b/acme/api/api.go @@ -155,6 +155,7 @@ func getDirectory(do *sender.Doer, caDirURL string) (acme.Directory, error) { if dir.NewAccountURL == "" { return dir, errors.New("directory missing new registration URL") } + if dir.NewOrderURL == "" { return dir, errors.New("directory missing new order URL") } diff --git a/acme/api/authorization.go b/acme/api/authorization.go index a9972aa94..4195bd1fe 100644 --- a/acme/api/authorization.go +++ b/acme/api/authorization.go @@ -15,10 +15,12 @@ func (c *AuthorizationService) Get(authzURL string) (acme.Authorization, error) } var authz acme.Authorization + _, err := c.core.postAsGet(authzURL, &authz) if err != nil { return acme.Authorization{}, err } + return authz, nil } @@ -29,6 +31,8 @@ func (c *AuthorizationService) Deactivate(authzURL string) error { } var disabledAuth acme.Authorization + _, err := c.core.post(authzURL, acme.Authorization{Status: acme.StatusDeactivated}, &disabledAuth) + return err } diff --git a/acme/api/challenge.go b/acme/api/challenge.go index 875dede6e..2af55fc1a 100644 --- a/acme/api/challenge.go +++ b/acme/api/challenge.go @@ -17,6 +17,7 @@ func (c *ChallengeService) New(chlgURL string) (acme.ExtendedChallenge, error) { // Challenge initiation is done by sending a JWS payload containing the trivial JSON object `{}`. // We use an empty struct instance as the postJSON payload here to achieve this result. var chlng acme.ExtendedChallenge + resp, err := c.core.post(chlgURL, struct{}{}, &chlng) if err != nil { return acme.ExtendedChallenge{}, err @@ -24,6 +25,7 @@ func (c *ChallengeService) New(chlgURL string) (acme.ExtendedChallenge, error) { chlng.AuthorizationURL = getLink(resp.Header, "up") chlng.RetryAfter = getRetryAfter(resp) + return chlng, nil } @@ -34,6 +36,7 @@ func (c *ChallengeService) Get(chlgURL string) (acme.ExtendedChallenge, error) { } var chlng acme.ExtendedChallenge + resp, err := c.core.postAsGet(chlgURL, &chlng) if err != nil { return acme.ExtendedChallenge{}, err @@ -41,5 +44,6 @@ func (c *ChallengeService) Get(chlgURL string) (acme.ExtendedChallenge, error) { chlng.AuthorizationURL = getLink(resp.Header, "up") chlng.RetryAfter = getRetryAfter(resp) + return chlng, nil } diff --git a/acme/api/internal/nonces/nonce_manager.go b/acme/api/internal/nonces/nonce_manager.go index d089cf07c..04a4ac620 100644 --- a/acme/api/internal/nonces/nonce_manager.go +++ b/acme/api/internal/nonces/nonce_manager.go @@ -11,10 +11,11 @@ import ( // Manager Manages nonces. type Manager struct { + sync.Mutex + do *sender.Doer nonceURL string nonces []string - sync.Mutex } // NewManager Creates a new Manager. @@ -36,6 +37,7 @@ func (n *Manager) Pop() (string, bool) { nonce := n.nonces[len(n.nonces)-1] n.nonces = n.nonces[:len(n.nonces)-1] + return nonce, true } @@ -43,6 +45,7 @@ func (n *Manager) Pop() (string, bool) { func (n *Manager) Push(nonce string) { n.Lock() defer n.Unlock() + n.nonces = append(n.nonces, nonce) } @@ -51,6 +54,7 @@ func (n *Manager) Nonce() (string, error) { if nonce, ok := n.Pop(); ok { return nonce, nil } + return n.getNonce() } diff --git a/acme/api/internal/nonces/nonce_manager_test.go b/acme/api/internal/nonces/nonce_manager_test.go index abaff02f5..4490165df 100644 --- a/acme/api/internal/nonces/nonce_manager_test.go +++ b/acme/api/internal/nonces/nonce_manager_test.go @@ -30,11 +30,13 @@ func TestNotHoldingLockWhileMakingHTTPRequests(t *testing.T) { ch := make(chan bool) resultCh := make(chan bool) + go func() { _, errN := manager.Nonce() if errN != nil { t.Log(errN) } + ch <- true }() go func() { @@ -42,13 +44,16 @@ func TestNotHoldingLockWhileMakingHTTPRequests(t *testing.T) { if errN != nil { t.Log(errN) } + ch <- true }() go func() { <-ch <-ch + resultCh <- true }() + select { case <-resultCh: case <-time.After(500 * time.Millisecond): diff --git a/acme/api/internal/secure/jws.go b/acme/api/internal/secure/jws.go index 7aa6c4c46..8cd598663 100644 --- a/acme/api/internal/secure/jws.go +++ b/acme/api/internal/secure/jws.go @@ -36,6 +36,7 @@ func (j *JWS) SetKid(kid string) { // SignContent Signs a content with the JWS. func (j *JWS) SignContent(url string, content []byte) (*jose.JSONWebSignature, error) { var alg jose.SignatureAlgorithm + switch k := j.privKey.(type) { case *rsa.PrivateKey: alg = jose.RS256 @@ -72,12 +73,14 @@ func (j *JWS) SignContent(url string, content []byte) (*jose.JSONWebSignature, e if err != nil { return nil, fmt.Errorf("failed to sign content: %w", err) } + return signed, nil } // SignEABContent Signs an external account binding content with the JWS. func (j *JWS) SignEABContent(url, kid string, hmac []byte) (*jose.JSONWebSignature, error) { jwk := jose.JSONWebKey{Key: j.privKey} + jwkJSON, err := jwk.Public().MarshalJSON() if err != nil { return nil, fmt.Errorf("acme: error encoding eab jwk key: %w", err) @@ -108,6 +111,7 @@ func (j *JWS) SignEABContent(url, kid string, hmac []byte) (*jose.JSONWebSignatu // GetKeyAuthorization Gets the key authorization for a token. func (j *JWS) GetKeyAuthorization(token string) (string, error) { var publicKey crypto.PublicKey + switch k := j.privKey.(type) { case *ecdsa.PrivateKey: publicKey = k.Public() diff --git a/acme/api/internal/secure/jws_test.go b/acme/api/internal/secure/jws_test.go index 6a9dc5459..d033cb0c4 100644 --- a/acme/api/internal/secure/jws_test.go +++ b/acme/api/internal/secure/jws_test.go @@ -31,11 +31,13 @@ func TestNotHoldingLockWhileMakingHTTPRequests(t *testing.T) { ch := make(chan bool) resultCh := make(chan bool) + go func() { _, errN := manager.Nonce() if errN != nil { t.Log(errN) } + ch <- true }() go func() { @@ -43,13 +45,16 @@ func TestNotHoldingLockWhileMakingHTTPRequests(t *testing.T) { if errN != nil { t.Log(errN) } + ch <- true }() go func() { <-ch <-ch + resultCh <- true }() + select { case <-resultCh: case <-time.After(500 * time.Millisecond): diff --git a/acme/api/internal/sender/sender.go b/acme/api/internal/sender/sender.go index e70a4bd9c..d5db5d410 100644 --- a/acme/api/internal/sender/sender.go +++ b/acme/api/internal/sender/sender.go @@ -127,6 +127,7 @@ func checkError(req *http.Request, resp *http.Response) error { } var errorDetails *acme.ProblemDetails + err = json.Unmarshal(body, &errorDetails) if err != nil { return fmt.Errorf("%d ::%s :: %s :: %w :: %s", resp.StatusCode, req.Method, req.URL, err, string(body)) @@ -150,6 +151,7 @@ func checkError(req *http.Request, resp *http.Response) error { return errorDetails } + return nil } diff --git a/acme/api/internal/sender/sender_test.go b/acme/api/internal/sender/sender_test.go index 69bb8ae4e..1f25c6d26 100644 --- a/acme/api/internal/sender/sender_test.go +++ b/acme/api/internal/sender/sender_test.go @@ -12,6 +12,7 @@ import ( func TestDo_UserAgentOnAllHTTPMethod(t *testing.T) { var ua, method string + server := httptest.NewTLSServer(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { ua = r.Header.Get("User-Agent") method = r.Method @@ -60,9 +61,11 @@ func TestDo_CustomUserAgent(t *testing.T) { ua := doer.formatUserAgent() assert.Contains(t, ua, ourUserAgent) assert.Contains(t, ua, customUA) + if strings.HasSuffix(ua, " ") { t.Errorf("UA should not have trailing spaces; got '%s'", ua) } + assert.Len(t, strings.Split(ua, " "), 5) } diff --git a/acme/api/order.go b/acme/api/order.go index 0c679fdb1..fad6be2b8 100644 --- a/acme/api/order.go +++ b/acme/api/order.go @@ -56,6 +56,7 @@ func (o *OrderService) NewWithOptions(domains []string, opts *OrderOptions) (acm } var order acme.Order + resp, err := o.core.post(o.core.GetDirectory().NewOrderURL, orderReq, &order) if err != nil { are := &acme.AlreadyReplacedError{} @@ -107,6 +108,7 @@ func (o *OrderService) Get(orderURL string) (acme.ExtendedOrder, error) { } var order acme.Order + _, err := o.core.postAsGet(orderURL, &order) if err != nil { return acme.ExtendedOrder{}, err @@ -122,6 +124,7 @@ func (o *OrderService) UpdateForCSR(orderURL string, csr []byte) (acme.ExtendedO } var order acme.Order + _, err := o.core.post(orderURL, csrMsg, &order) if err != nil { return acme.ExtendedOrder{}, err diff --git a/acme/api/order_test.go b/acme/api/order_test.go index e2fcbdf2c..f74f473d2 100644 --- a/acme/api/order_test.go +++ b/acme/api/order_test.go @@ -32,6 +32,7 @@ func TestOrderService_NewWithOptions(t *testing.T) { } order := acme.Order{} + err = json.Unmarshal(body, &order) if err != nil { http.Error(rw, err.Error(), http.StatusBadRequest) @@ -107,6 +108,7 @@ func readSignedBody(r *http.Request, privateKey *rsa.PrivateKey) ([]byte, error) } sigAlgs := []jose.SignatureAlgorithm{jose.RS256} + jws, err := jose.ParseSigned(string(reqBody), sigAlgs) if err != nil { return nil, err diff --git a/acme/api/service.go b/acme/api/service.go index 6f812ee03..65518e1d9 100644 --- a/acme/api/service.go +++ b/acme/api/service.go @@ -23,11 +23,13 @@ func getLinks(header http.Header, rel string) []string { linkExpr := regexp.MustCompile(`<(.+?)>(?:;[^;]+)*?;\s*rel="(.+?)"`) var links []string + for _, link := range header["Link"] { for _, m := range linkExpr.FindAllStringSubmatch(link, -1) { if len(m) != 3 { continue } + if m[2] == rel { links = append(links, m[1]) } diff --git a/acme/commons.go b/acme/commons.go index bd0506c09..0af623e4e 100644 --- a/acme/commons.go +++ b/acme/commons.go @@ -84,6 +84,7 @@ type Meta struct { // ExtendedAccount an extended Account. type ExtendedAccount struct { Account + // Contains the value of the response header `Location` Location string `json:"-"` } @@ -220,11 +221,11 @@ type Authorization struct { // The timestamp after which the server will consider this authorization invalid, // encoded in the format specified in RFC 3339 [RFC3339]. // This field is REQUIRED for objects with "valid" in the "status" field. - Expires time.Time `json:"expires,omitempty"` + Expires time.Time `json:"expires,omitzero"` // identifier (required, object): // The identifier that the account is authorized to represent - Identifier Identifier `json:"identifier,omitempty"` + Identifier Identifier `json:"identifier"` // challenges (required, array of objects): // For pending authorizations, the challenges that the client can fulfill in order to prove possession of the identifier. @@ -244,6 +245,7 @@ type Authorization struct { // ExtendedChallenge a extended Challenge. type ExtendedChallenge struct { Challenge + // Contains the value of the response header `Retry-After` RetryAfter string `json:"-"` // Contains the value of the response header `Link` rel="up" @@ -270,7 +272,7 @@ type Challenge struct { // The time at which the server validated this challenge, // encoded in the format specified in RFC 3339 [RFC3339]. // This field is REQUIRED if the "status" field is "valid". - Validated time.Time `json:"validated,omitempty"` + Validated time.Time `json:"validated,omitzero"` // error (optional, object): // Error that occurred while the server was validating the challenge, if any, diff --git a/acme/errors.go b/acme/errors.go index 9a255468d..161a47c38 100644 --- a/acme/errors.go +++ b/acme/errors.go @@ -2,6 +2,7 @@ package acme import ( "fmt" + "strings" ) // Errors types. @@ -27,21 +28,25 @@ type ProblemDetails struct { } func (p *ProblemDetails) Error() string { - msg := fmt.Sprintf("acme: error: %d", p.HTTPStatus) + var msg strings.Builder + + msg.WriteString(fmt.Sprintf("acme: error: %d", p.HTTPStatus)) + if p.Method != "" || p.URL != "" { - msg += fmt.Sprintf(" :: %s :: %s", p.Method, p.URL) + msg.WriteString(fmt.Sprintf(" :: %s :: %s", p.Method, p.URL)) } - msg += fmt.Sprintf(" :: %s :: %s", p.Type, p.Detail) + + msg.WriteString(fmt.Sprintf(" :: %s :: %s", p.Type, p.Detail)) for _, sub := range p.SubProblems { - msg += fmt.Sprintf(", problem: %q :: %s", sub.Type, sub.Detail) + msg.WriteString(fmt.Sprintf(", problem: %q :: %s", sub.Type, sub.Detail)) } if p.Instance != "" { - msg += ", url: " + p.Instance + msg.WriteString(", url: " + p.Instance) } - return msg + return msg.String() } // SubProblem a "subproblems". @@ -49,7 +54,7 @@ func (p *ProblemDetails) Error() string { type SubProblem struct { Type string `json:"type,omitempty"` Detail string `json:"detail,omitempty"` - Identifier Identifier `json:"identifier,omitempty"` + Identifier Identifier `json:"identifier"` } // NonceError represents the error which is returned diff --git a/certcrypto/crypto.go b/certcrypto/crypto.go index d6f53c3a1..00f0654b9 100644 --- a/certcrypto/crypto.go +++ b/certcrypto/crypto.go @@ -57,8 +57,10 @@ type DERCertificateBytes []byte // ParsePEMBundle parses a certificate bundle from top to bottom and returns // a slice of x509 certificates. This function will error if no certificates are found. func ParsePEMBundle(bundle []byte) ([]*x509.Certificate, error) { - var certificates []*x509.Certificate - var certDERBlock *pem.Block + var ( + certificates []*x509.Certificate + certDERBlock *pem.Block + ) for { certDERBlock, bundle = pem.Decode(bundle) @@ -71,6 +73,7 @@ func ParsePEMBundle(bundle []byte) ([]*x509.Certificate, error) { if err != nil { return nil, err } + certificates = append(certificates, cert) } } @@ -152,8 +155,11 @@ type CSROptions struct { } func CreateCSR(privateKey crypto.PrivateKey, opts CSROptions) ([]byte, error) { - var dnsNames []string - var ipAddresses []net.IP + var ( + dnsNames []string + ipAddresses []net.IP + ) + for _, altname := range opts.SAN { if ip := net.ParseIP(altname); ip != nil { ipAddresses = append(ipAddresses, ip) @@ -185,6 +191,7 @@ func PEMEncode(data any) []byte { func PEMBlock(data any) *pem.Block { var pemBlock *pem.Block + switch key := data.(type) { case *ecdsa.PrivateKey: keyBytes, _ := x509.MarshalECPrivateKey(key) @@ -265,6 +272,7 @@ func ExtractDomains(cert *x509.Certificate) []string { if sanDomain == cert.Subject.CommonName { continue } + domains = append(domains, sanDomain) } @@ -316,6 +324,7 @@ func GeneratePemCert(privateKey *rsa.PrivateKey, domain string, extensions []pki func generateDerCert(privateKey *rsa.PrivateKey, expiration time.Time, domain string, extensions []pkix.Extension) ([]byte, error) { serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128) + serialNumber, err := rand.Int(rand.Reader, serialNumberLimit) if err != nil { return nil, err diff --git a/certcrypto/crypto_test.go b/certcrypto/crypto_test.go index f6178fadd..f5609fdf4 100644 --- a/certcrypto/crypto_test.go +++ b/certcrypto/crypto_test.go @@ -179,6 +179,7 @@ func TestParsePEMPrivateKey(t *testing.T) { // ignoring precomputed values. decoded, err := ParsePEMPrivateKey(pemPrivateKey) require.NoError(t, err) + decodedRsaPrivateKey := decoded.(*rsa.PrivateKey) require.True(t, decodedRsaPrivateKey.Equal(privateKey)) diff --git a/certificate/authorization.go b/certificate/authorization.go index c77bcbd5f..49f958776 100644 --- a/certificate/authorization.go +++ b/certificate/authorization.go @@ -29,6 +29,7 @@ func (c *Certifier) getAuthorizations(order acme.ExtendedOrder) ([]acme.Authoriz var responses []acme.Authorization failures := newObtainError() + for range len(order.Authorizations) { select { case res := <-resc: @@ -62,6 +63,7 @@ func (c *Certifier) deactivateAuthorizations(order acme.ExtendedOrder, force boo } log.Infof("Deactivating auth: %s", authzURL) + if c.core.Authorizations.Deactivate(authzURL) != nil { log.Infof("Unable to deactivate the authorization: %s", authzURL) } diff --git a/certificate/certificates.go b/certificate/certificates.go index df51dc333..04904e794 100644 --- a/certificate/certificates.go +++ b/certificate/certificates.go @@ -198,6 +198,7 @@ func (c *Certifier) Obtain(request ObtainRequest) (*Resource, error) { log.Infof("[%s] acme: Validations succeeded; requesting certificates", strings.Join(domains, ", ")) failures := newObtainError() + cert, err := c.getForOrder(domains, order, request) if err != nil { for _, auth := range authz { @@ -295,6 +296,7 @@ func (c *Certifier) getForOrder(domains []string, order acme.ExtendedOrder, requ if privateKey == nil { var err error + privateKey, err = certcrypto.GeneratePrivateKey(c.options.KeyType) if err != nil { return nil, err @@ -490,6 +492,7 @@ type RenewOptions struct { // If bundle is true, the []byte contains both the issuer certificate and your issued certificate as a bundle. // // For private key reuse the PrivateKey property of the passed in Resource should be non-nil. +// // Deprecated: use RenewWithOptions instead. func (c *Certifier) Renew(certRes Resource, bundle, mustStaple bool, preferredChain string) (*Resource, error) { return c.RenewWithOptions(certRes, &RenewOptions{ @@ -722,6 +725,7 @@ func checkOrderStatus(order acme.ExtendedOrder) (bool, error) { // https://www.rfc-editor.org/rfc/rfc5280.html#section-7 func sanitizeDomain(domains []string) []string { var sanitizedDomains []string + for _, domain := range domains { sanitizedDomain, err := idna.ToASCII(domain) if err != nil { @@ -730,5 +734,6 @@ func sanitizeDomain(domains []string) []string { sanitizedDomains = append(sanitizedDomains, sanitizedDomain) } } + return sanitizedDomains } diff --git a/certificate/renewal.go b/certificate/renewal.go index 0a9059501..15e804745 100644 --- a/certificate/renewal.go +++ b/certificate/renewal.go @@ -85,6 +85,7 @@ func (c *Certifier) GetRenewalInfo(req RenewalInfoRequest) (*RenewalInfoResponse defer resp.Body.Close() var info RenewalInfoResponse + err = json.NewDecoder(resp.Body).Decode(&info) if err != nil { return nil, err diff --git a/challenge/challenges.go b/challenge/challenges.go index 39bf3bee2..f6d5cdb28 100644 --- a/challenge/challenges.go +++ b/challenge/challenges.go @@ -40,5 +40,6 @@ func GetTargetedDomain(authz acme.Authorization) string { if authz.Wildcard { return "*." + authz.Identifier.Value } + return authz.Identifier.Value } diff --git a/challenge/dns01/dns_challenge.go b/challenge/dns01/dns_challenge.go index 8594d2799..1d106d7b7 100644 --- a/challenge/dns01/dns_challenge.go +++ b/challenge/dns01/dns_challenge.go @@ -40,6 +40,7 @@ func CondOption(condition bool, opt ChallengeOption) ChallengeOption { return nil } } + return opt } @@ -118,6 +119,7 @@ func (c *Challenge) Solve(authz acme.Authorization) error { info := GetChallengeInfo(authz.Identifier.Value, keyAuth) var timeout, interval time.Duration + switch provider := c.provider.(type) { case challenge.ProviderTimeout: timeout, interval = provider.Timeout() @@ -134,6 +136,7 @@ func (c *Challenge) Solve(authz acme.Authorization) error { if !stop || errP != nil { log.Infof("[%s] acme: Waiting for DNS record propagation.", domain) } + return stop, errP }) if err != nil { @@ -141,6 +144,7 @@ func (c *Challenge) Solve(authz acme.Authorization) error { } chlng.KeyAuthorization = keyAuth + return c.validate(c.core, domain, chlng) } @@ -165,6 +169,7 @@ func (c *Challenge) Sequential() (bool, time.Duration) { if p, ok := c.provider.(sequential); ok { return ok, p.Sequential() } + return false, 0 } @@ -173,6 +178,7 @@ type sequential interface { } // GetRecord returns a DNS record which will fulfill the `dns-01` challenge. +// // Deprecated: use GetChallengeInfo instead. func GetRecord(domain, keyAuth string) (fqdn, value string) { info := GetChallengeInfo(domain, keyAuth) diff --git a/challenge/dns01/dns_challenge_manual_test.go b/challenge/dns01/dns_challenge_manual_test.go index e0a2dc93a..c183822bb 100644 --- a/challenge/dns01/dns_challenge_manual_test.go +++ b/challenge/dns01/dns_challenge_manual_test.go @@ -18,6 +18,7 @@ func TestDNSProviderManual(t *testing.T) { Build(t)) backupStdin := os.Stdin + defer func() { os.Stdin = backupStdin }() testCases := []struct { diff --git a/challenge/dns01/dns_challenge_test.go b/challenge/dns01/dns_challenge_test.go index 7c723497c..325f1656c 100644 --- a/challenge/dns01/dns_challenge_test.go +++ b/challenge/dns01/dns_challenge_test.go @@ -184,6 +184,7 @@ func TestChallenge_Solve(t *testing.T) { if test.preCheck != nil { options = append(options, WrapPreCheck(test.preCheck)) } + chlg := NewChallenge(core, test.validate, test.provider, options...) authz := acme.Authorization{ diff --git a/challenge/dns01/fqdn.go b/challenge/dns01/fqdn.go index 665804d8f..11ac3d0c2 100644 --- a/challenge/dns01/fqdn.go +++ b/challenge/dns01/fqdn.go @@ -19,6 +19,7 @@ func UnFqdn(name string) string { if n != 0 && name[n-1] == '.' { return name[:n-1] } + return name } diff --git a/challenge/dns01/mock_test.go b/challenge/dns01/mock_test.go index 535d79cda..5dcad3013 100644 --- a/challenge/dns01/mock_test.go +++ b/challenge/dns01/mock_test.go @@ -40,6 +40,7 @@ func mockResolver(t *testing.T, addr net.Addr) { require.NoError(t, err) originalDefaultNameserverPort := defaultNameserverPort + t.Cleanup(func() { defaultNameserverPort = originalDefaultNameserverPort }) @@ -47,6 +48,7 @@ func mockResolver(t *testing.T, addr net.Addr) { defaultNameserverPort = port originalResolver := net.DefaultResolver + t.Cleanup(func() { net.DefaultResolver = originalResolver }) @@ -70,6 +72,7 @@ func useAsNameserver(t *testing.T, addr net.Addr) { }) originalRecursiveNameservers := recursiveNameservers + t.Cleanup(func() { recursiveNameservers = originalRecursiveNameservers }) diff --git a/challenge/dns01/nameserver.go b/challenge/dns01/nameserver.go index bb6dc0841..554eb7cc2 100644 --- a/challenge/dns01/nameserver.go +++ b/challenge/dns01/nameserver.go @@ -81,6 +81,7 @@ func getNameservers(path string, defaults []string) []string { func ParseNameservers(servers []string) []string { var resolvers []string + for _, resolver := range servers { // ensure all servers have a port number if _, _, err := net.SplitHostPort(resolver); err != nil { @@ -89,6 +90,7 @@ func ParseNameservers(servers []string) []string { resolvers = append(resolvers, resolver) } } + return resolvers } @@ -132,6 +134,7 @@ func FindPrimaryNsByFqdnCustom(fqdn string, nameservers []string) (string, error if err != nil { return "", fmt.Errorf("[fqdn=%s] %w", fqdn, err) } + return soa.primaryNs, nil } @@ -148,6 +151,7 @@ func FindZoneByFqdnCustom(fqdn string, nameservers []string) (string, error) { if err != nil { return "", fmt.Errorf("[fqdn=%s] %w", fqdn, err) } + return soa.zone, nil } @@ -172,8 +176,10 @@ func lookupSoaByFqdn(fqdn string, nameservers []string) (*soaCacheEntry, error) } func fetchSoaByFqdn(fqdn string, nameservers []string) (*soaCacheEntry, error) { - var err error - var r *dns.Msg + var ( + err error + r *dns.Msg + ) for domain := range DomainsSeq(fqdn) { r, err = dnsQuery(domain, dns.TypeSOA, nameservers, true) @@ -229,9 +235,11 @@ func dnsQuery(fqdn string, rtype uint16, nameservers []string, recursive bool) ( return nil, &DNSError{Message: "empty list of nameservers"} } - var r *dns.Msg - var err error - var errAll error + var ( + r *dns.Msg + err error + errAll error + ) for _, ns := range nameservers { r, err = sendDNSQuery(m, ns) @@ -264,6 +272,7 @@ func createDNSMsg(fqdn string, rtype uint16, recursive bool) *dns.Msg { func sendDNSQuery(m *dns.Msg, ns string) (*dns.Msg, error) { if ok, _ := strconv.ParseBool(os.Getenv("LEGO_EXPERIMENTAL_DNS_TCP_ONLY")); ok { tcp := &dns.Client{Net: "tcp", Timeout: dnsTimeout} + r, _, err := tcp.Exchange(m, ns) if err != nil { return r, &DNSError{Message: "DNS call error", MsgIn: m, NS: ns, Err: err} diff --git a/challenge/dns01/precheck.go b/challenge/dns01/precheck.go index e10efa33e..45e17e3ac 100644 --- a/challenge/dns01/precheck.go +++ b/challenge/dns01/precheck.go @@ -29,6 +29,7 @@ func WrapPreCheck(wrap WrapPreCheckFunc) ChallengeOption { } // DisableCompletePropagationRequirement obsolete. +// // Deprecated: use DisableAuthoritativeNssPropagationRequirement instead. func DisableCompletePropagationRequirement() ChallengeOption { return DisableAuthoritativeNssPropagationRequirement() @@ -140,9 +141,11 @@ func checkNameserversPropagation(fqdn, value string, nameservers []string, addPo var records []string var found bool + for _, rr := range r.Answer { if txt, ok := rr.(*dns.TXT); ok { record := strings.Join(txt.Txt, "") + records = append(records, record) if record == value { found = true diff --git a/challenge/http01/domain_matcher.go b/challenge/http01/domain_matcher.go index c31aeed6a..058d1a314 100644 --- a/challenge/http01/domain_matcher.go +++ b/challenge/http01/domain_matcher.go @@ -88,6 +88,7 @@ func (m *forwardedMatcher) matches(r *http.Request, domain string) bool { } host := fwds[0]["host"] + return matchDomain(host, domain) } @@ -99,6 +100,7 @@ func parseForwardedHeader(s string) (elements []map[string]string, err error) { inquote := false pos := 0 + l := len(s) for i := 0; i < l; i++ { r := rune(s[i]) @@ -110,6 +112,7 @@ func parseForwardedHeader(s string) (elements []map[string]string, err error) { pos = i inquote = false } + continue } @@ -118,6 +121,7 @@ func parseForwardedHeader(s string) (elements []map[string]string, err error) { if key == "" { return nil, fmt.Errorf("unexpected quoted string as pos %d", i) } + inquote = true pos = i + 1 @@ -137,6 +141,7 @@ func parseForwardedHeader(s string) (elements []map[string]string, err error) { val = s[pos:i] cur[key] = val } + elements = append(elements, cur) cur = make(map[string]string) key = "" @@ -159,11 +164,14 @@ func parseForwardedHeader(s string) (elements []map[string]string, err error) { if pos < len(s) { val = s[pos:] } + cur[key] = val } + if len(cur) > 0 { elements = append(elements, cur) } + return elements, nil } @@ -178,6 +186,7 @@ func skipWS(s string, i int) int { for isWS(rune(s[i+1])) { i++ } + return i } diff --git a/challenge/http01/http_challenge.go b/challenge/http01/http_challenge.go index 79dbfb4d0..a042979c2 100644 --- a/challenge/http01/http_challenge.go +++ b/challenge/http01/http_challenge.go @@ -74,6 +74,7 @@ func (c *Challenge) Solve(authz acme.Authorization) error { if err != nil { return fmt.Errorf("[%s] acme: error presenting token: %w", domain, err) } + defer func() { err := c.provider.CleanUp(authz.Identifier.Value, chlng.Token, keyAuth) if err != nil { @@ -86,5 +87,6 @@ func (c *Challenge) Solve(authz acme.Authorization) error { } chlng.KeyAuthorization = keyAuth + return c.validate(c.core, domain, chlng) } diff --git a/challenge/http01/http_challenge_server.go b/challenge/http01/http_challenge_server.go index 009271cec..ab962917e 100644 --- a/challenge/http01/http_challenge_server.go +++ b/challenge/http01/http_challenge_server.go @@ -44,6 +44,7 @@ func NewUnixProviderServer(socketPath string, mode fs.FileMode) *ProviderServer // Present starts a web server and makes the token available at `ChallengePath(token)` for web requests. func (s *ProviderServer) Present(domain, token, keyAuth string) error { var err error + s.listener, err = net.Listen(s.network, s.GetAddress()) if err != nil { return fmt.Errorf("could not start HTTP server for challenge: %w", err) @@ -120,6 +121,7 @@ func (s *ProviderServer) serve(domain, token, keyAuth string) { } log.Infof("[%s] Served key authentication", domain) + return } diff --git a/challenge/http01/http_challenge_test.go b/challenge/http01/http_challenge_test.go index 1b322491a..06c555e42 100644 --- a/challenge/http01/http_challenge_test.go +++ b/challenge/http01/http_challenge_test.go @@ -88,6 +88,7 @@ func TestChallenge(t *testing.T) { if err != nil { return err } + bodyStr := string(body) if bodyStr != chlng.KeyAuthorization { @@ -157,6 +158,7 @@ func TestChallengeUnix(t *testing.T) { if err != nil { return err } + bodyStr := string(body) if bodyStr != chlng.KeyAuthorization { @@ -224,6 +226,7 @@ func (h *testProxyHeader) update(r *http.Request) { if h == nil || len(h.values) == 0 { return } + if h.name == "Host" { r.Host = h.values[0] } else if h.name != "" { @@ -385,6 +388,7 @@ func testServeWithProxy(t *testing.T, header, extra *testProxyHeader, expectErro if err != nil { return err } + header.update(req) extra.update(req) @@ -402,6 +406,7 @@ func testServeWithProxy(t *testing.T, header, extra *testProxyHeader, expectErro if err != nil { return err } + bodyStr := string(body) if bodyStr != chlng.KeyAuthorization { diff --git a/challenge/resolver/errors.go b/challenge/resolver/errors.go index 94ccbd76a..6a859922c 100644 --- a/challenge/resolver/errors.go +++ b/challenge/resolver/errors.go @@ -16,10 +16,12 @@ func (e obtainError) Error() string { for domain := range e { domains = append(domains, domain) } + sort.Strings(domains) for _, domain := range domains { _, _ = fmt.Fprintf(buffer, "[%s] %s\n", domain, e[domain]) } + return buffer.String() } diff --git a/challenge/resolver/prober.go b/challenge/resolver/prober.go index 021facbb5..aac1016d8 100644 --- a/challenge/resolver/prober.go +++ b/challenge/resolver/prober.go @@ -50,11 +50,14 @@ func NewProber(solverManager *SolverManager) *Prober { func (p *Prober) Solve(authorizations []acme.Authorization) error { failures := make(obtainError) - var authSolvers []*selectedAuthSolver - var authSolversSequential []*selectedAuthSolver + var ( + authSolvers []*selectedAuthSolver + authSolversSequential []*selectedAuthSolver + ) // Loop through the resources, basically through the domains. // First pass just selects a solver for each authz. + for _, authz := range authorizations { domain := challenge.GetTargetedDomain(authz) if authz.Status == acme.StatusValid { @@ -90,6 +93,7 @@ func (p *Prober) Solve(authorizations []acme.Authorization) error { if len(failures) > 0 { return failures } + return nil } @@ -102,7 +106,9 @@ func sequentialSolve(authSolvers []*selectedAuthSolver, failures obtainError) { err := solvr.PreSolve(authSolver.authz) if err != nil { failures[domain] = err + cleanUp(authSolver.solver, authSolver.authz) + continue } } @@ -111,7 +117,9 @@ func sequentialSolve(authSolvers []*selectedAuthSolver, failures obtainError) { err := authSolver.solver.Solve(authSolver.authz) if err != nil { failures[domain] = err + cleanUp(authSolver.solver, authSolver.authz) + continue } @@ -149,6 +157,7 @@ func parallelSolve(authSolvers []*selectedAuthSolver, failures obtainError) { // Finally solve all challenges for real for _, authSolver := range authSolvers { authz := authSolver.authz + domain := challenge.GetTargetedDomain(authz) if failures[domain] != nil { // already failed in previous loop @@ -165,6 +174,7 @@ func parallelSolve(authSolvers []*selectedAuthSolver, failures obtainError) { func cleanUp(solvr solver, authz acme.Authorization) { if solvr, ok := solvr.(cleanup); ok { domain := challenge.GetTargetedDomain(authz) + err := solvr.CleanUp(authz) if err != nil { log.Warnf("[%s] acme: cleaning up failed: %v ", domain, err) diff --git a/challenge/resolver/solver_manager.go b/challenge/resolver/solver_manager.go index 07687aaaf..48d9194b9 100644 --- a/challenge/resolver/solver_manager.go +++ b/challenge/resolver/solver_manager.go @@ -71,6 +71,7 @@ func (c *SolverManager) chooseSolver(authz acme.Authorization) solver { log.Infof("[%s] acme: use %s solver", domain, chlg.Type) return solvr } + log.Infof("[%s] acme: Could not find solver for: %s", domain, chlg.Type) } @@ -101,6 +102,7 @@ func validate(core *api.Core, domain string, chlg acme.Challenge) error { // https://github.com/letsencrypt/boulder/blob/master/docs/acme-divergences.md#section-82 ra = 5 } + initialInterval := time.Duration(ra) * time.Second ctx := context.Background() @@ -162,6 +164,7 @@ func checkAuthorizationStatus(authz acme.Authorization) (bool, error) { return false, fmt.Errorf("invalid authorization: %w", chlg.Err()) } } + return false, errors.New("invalid authorization") default: return false, fmt.Errorf("the server returned an unexpected authorization status: %s", authz.Status) diff --git a/challenge/resolver/solver_manager_test.go b/challenge/resolver/solver_manager_test.go index f2875912a..77149c73a 100644 --- a/challenge/resolver/solver_manager_test.go +++ b/challenge/resolver/solver_manager_test.go @@ -260,6 +260,7 @@ func validateNoBody(privateKey *rsa.PrivateKey, r *http.Request) error { } sigAlgs := []jose.SignatureAlgorithm{jose.RS256} + jws, err := jose.ParseSigned(string(reqBody), sigAlgs) if err != nil { return err @@ -276,5 +277,6 @@ func validateNoBody(privateKey *rsa.PrivateKey, r *http.Request) error { if bodyStr := string(body); bodyStr != "{}" && bodyStr != "" { return fmt.Errorf(`expected JWS POST body "{}" or "", got %q`, bodyStr) } + return nil } diff --git a/challenge/tlsalpn01/tls_alpn_challenge.go b/challenge/tlsalpn01/tls_alpn_challenge.go index 559e1f905..d8e939106 100644 --- a/challenge/tlsalpn01/tls_alpn_challenge.go +++ b/challenge/tlsalpn01/tls_alpn_challenge.go @@ -80,6 +80,7 @@ func (c *Challenge) Solve(authz acme.Authorization) error { if err != nil { return fmt.Errorf("[%s] acme: error presenting token: %w", challenge.GetTargetedDomain(authz), err) } + defer func() { err := c.provider.CleanUp(domain, chlng.Token, keyAuth) if err != nil { @@ -92,6 +93,7 @@ func (c *Challenge) Solve(authz acme.Authorization) error { } chlng.KeyAuthorization = keyAuth + return c.validate(c.core, domain, chlng) } diff --git a/challenge/tlsalpn01/tls_alpn_challenge_test.go b/challenge/tlsalpn01/tls_alpn_challenge_test.go index eec2cb152..59c2d61bc 100644 --- a/challenge/tlsalpn01/tls_alpn_challenge_test.go +++ b/challenge/tlsalpn01/tls_alpn_challenge_test.go @@ -42,6 +42,7 @@ func TestChallenge(t *testing.T) { assert.NotEmpty(t, remoteCert.Extensions, "Expected the challenge certificate to contain extensions") idx := -1 + for i, ext := range remoteCert.Extensions { if idPeAcmeIdentifierV1.Equal(ext.Id) { idx = i @@ -145,18 +146,24 @@ func TestChallengeIPaddress(t *testing.T) { assert.True(t, net.ParseIP("127.0.0.1").Equal(remoteCert.IPAddresses[0]), "challenge certificate IPAddress ") assert.NotEmpty(t, remoteCert.Extensions, "Expected the challenge certificate to contain extensions") - var foundAcmeIdentifier bool - var extValue []byte + var ( + foundAcmeIdentifier bool + extValue []byte + ) + for _, ext := range remoteCert.Extensions { if idPeAcmeIdentifierV1.Equal(ext.Id) { assert.True(t, ext.Critical, "Expected the challenge certificate id-pe-acmeIdentifier extension to be marked as critical") + foundAcmeIdentifier = true extValue = ext.Value + break } } require.True(t, foundAcmeIdentifier, "Expected the challenge certificate to contain an extension with the id-pe-acmeIdentifier id,") + zBytes := sha256.Sum256([]byte(chlng.KeyAuthorization)) value, err := asn1.Marshal(zBytes[:sha256.Size]) require.NoError(t, err, "Expected marshaling of the keyAuth to return no error") diff --git a/cmd/accounts_storage.go b/cmd/accounts_storage.go index c234c0060..1dbdfb84b 100644 --- a/cmd/accounts_storage.go +++ b/cmd/accounts_storage.go @@ -96,6 +96,7 @@ func (s *AccountsStorage) ExistsAccountFilePath() bool { } else if err != nil { log.Fatal(err) } + return true } @@ -127,6 +128,7 @@ func (s *AccountsStorage) LoadAccount(privateKey crypto.PrivateKey) *Account { } var account Account + err = json.Unmarshal(fileBytes, &account) if err != nil { log.Fatalf("Could not parse file for account %s: %v", s.userID, err) @@ -141,6 +143,7 @@ func (s *AccountsStorage) LoadAccount(privateKey crypto.PrivateKey) *Account { } account.Registration = reg + err = s.Save(&account) if err != nil { log.Fatalf("Could not save account for %s. Registration is nil: %#v", s.userID, err) @@ -163,6 +166,7 @@ func (s *AccountsStorage) GetPrivateKey(keyType certcrypto.KeyType) crypto.Priva } log.Printf("Saved key to %s", accKeyPath) + return privateKey } @@ -193,6 +197,7 @@ func generatePrivateKey(file string, keyType certcrypto.KeyType) (crypto.Private defer certOut.Close() pemKey := certcrypto.PEMBlock(privateKey) + err = pem.Encode(certOut, pemKey) if err != nil { return nil, err @@ -211,6 +216,7 @@ func loadPrivateKey(file string) (crypto.PrivateKey, error) { if err != nil { return nil, err } + return privateKey, nil } @@ -229,5 +235,6 @@ func tryRecoverRegistration(ctx *cli.Context, privateKey crypto.PrivateKey) (*re if err != nil { return nil, err } + return reg, nil } diff --git a/cmd/certs_storage.go b/cmd/certs_storage.go index e0b1a387a..25ef58075 100644 --- a/cmd/certs_storage.go +++ b/cmd/certs_storage.go @@ -158,6 +158,7 @@ func (s *CertificatesStorage) ExistsFile(domain, extension string) bool { } else if err != nil { log.Fatal(err) } + return true } @@ -283,6 +284,7 @@ func getCertificateChain(certRes *certificate.Resource) ([]*x509.Certificate, er } var certChain []*x509.Certificate + for chainCertPemBlock != nil { chainCert, err := x509.ParseCertificate(chainCertPemBlock.Bytes) if err != nil { @@ -298,6 +300,7 @@ func getCertificateChain(certRes *certificate.Resource) ([]*x509.Certificate, er func getPFXEncoder(pfxFormat string) (*pkcs12.Encoder, error) { var encoder *pkcs12.Encoder + switch pfxFormat { case "SHA256": encoder = pkcs12.Modern2023 @@ -318,5 +321,6 @@ func sanitizedDomain(domain string) string { if err != nil { log.Fatal(err) } + return safe } diff --git a/cmd/cmd_list.go b/cmd/cmd_list.go index bf7b232da..864b85977 100644 --- a/cmd/cmd_list.go +++ b/cmd/cmd_list.go @@ -67,6 +67,7 @@ func listCertificates(ctx *cli.Context) error { if !names { fmt.Println("No certificates found.") } + return nil } @@ -122,6 +123,7 @@ func listAccount(ctx *cli.Context) error { } fmt.Println("Found the following accounts:") + for _, filename := range matches { data, err := os.ReadFile(filename) if err != nil { @@ -129,6 +131,7 @@ func listAccount(ctx *cli.Context) error { } var account Account + err = json.Unmarshal(data, &account) if err != nil { return err diff --git a/cmd/cmd_renew.go b/cmd/cmd_renew.go index afedee0b6..99bc5ebbd 100644 --- a/cmd/cmd_renew.go +++ b/cmd/cmd_renew.go @@ -39,16 +39,20 @@ func createRenew() *cli.Command { Before: func(ctx *cli.Context) error { // we require either domains or csr, but not both hasDomains := len(ctx.StringSlice(flgDomains)) > 0 + hasCsr := ctx.String(flgCSR) != "" if hasDomains && hasCsr { log.Fatalf("Please specify either --%s/-d or --%s/-c, but not both", flgDomains, flgCSR) } + if !hasDomains && !hasCsr { log.Fatalf("Please specify --%s/-d (or --%s/-c if you already have a CSR)", flgDomains, flgCSR) } + if ctx.Bool(flgForceCertDomains) && hasCsr { log.Fatalf("--%s only works with --%s/-d, --%s/-c doesn't support this option.", flgForceCertDomains, flgDomains, flgCSR) } + return nil }, Flags: []cli.Flag{ @@ -165,8 +169,10 @@ func renewForDomains(ctx *cli.Context, account *Account, keyType certcrypto.KeyT cert := certificates[0] - var ariRenewalTime *time.Time - var replacesCertID string + var ( + ariRenewalTime *time.Time + replacesCertID string + ) var client *lego.Client @@ -208,6 +214,7 @@ func renewForDomains(ctx *cli.Context, account *Account, keyType certcrypto.KeyT log.Infof("[%s] acme: Trying renewal with %d hours remaining", domain, int(timeLeft.Hours())) var privateKey crypto.PrivateKey + if ctx.Bool(flgReuseKey) { keyBytes, errR := certsStorage.ReadFile(domain, keyExt) if errR != nil { @@ -225,6 +232,7 @@ func renewForDomains(ctx *cli.Context, account *Account, keyType certcrypto.KeyT if !isatty.IsTerminal(os.Stdout.Fd()) && !ctx.Bool(flgNoRandomSleep) { // https://github.com/certbot/certbot/blob/284023a1b7672be2bd4018dd7623b3b92197d4b0/certbot/certbot/_internal/renewal.py#L472 const jitter = 8 * time.Minute + rnd := rand.New(rand.NewSource(time.Now().UnixNano())) sleepTime := time.Duration(rnd.Int63n(int64(jitter))) @@ -288,8 +296,10 @@ func renewForCSR(ctx *cli.Context, account *Account, keyType certcrypto.KeyType, cert := certificates[0] - var ariRenewalTime *time.Time - var replacesCertID string + var ( + ariRenewalTime *time.Time + replacesCertID string + ) var client *lego.Client @@ -408,16 +418,20 @@ func getARIRenewalTime(ctx *cli.Context, cert *x509.Certificate, domain string, log.Warnf("[%s] acme: %v", domain, err) return nil } + log.Warnf("[%s] acme: calling renewal info endpoint: %v", domain, err) + return nil } now := time.Now().UTC() + renewalTime := renewalInfo.ShouldRenewAt(now, ctx.Duration(flgARIWaitToRenewDuration)) if renewalTime == nil { log.Infof("[%s] acme: renewalInfo endpoint indicates that renewal is not needed", domain) return nil } + log.Infof("[%s] acme: renewalInfo endpoint indicates that renewal is needed", domain) if renewalInfo.ExplanationURL != "" { diff --git a/cmd/cmd_run.go b/cmd/cmd_run.go index 905fc6bb2..16814b4de 100644 --- a/cmd/cmd_run.go +++ b/cmd/cmd_run.go @@ -35,13 +35,16 @@ func createRun() *cli.Command { Before: func(ctx *cli.Context) error { // we require either domains or csr, but not both hasDomains := len(ctx.StringSlice(flgDomains)) > 0 + hasCsr := ctx.String(flgCSR) != "" if hasDomains && hasCsr { log.Fatal("Please specify either --domains/-d or --csr/-c, but not both") } + if !hasDomains && !hasCsr { log.Fatal("Please specify --domains/-d (or --csr/-c if you already have a CSR)") } + return nil }, Action: run, @@ -155,10 +158,12 @@ func handleTOS(ctx *cli.Context, client *lego.Client) bool { } reader := bufio.NewReader(os.Stdin) + log.Printf("Please review the TOS at %s", client.GetToSURL()) for { fmt.Println("Do you accept the TOS? Y/n") + text, err := reader.ReadString('\n') if err != nil { log.Fatalf("Could not read from console: %v", err) @@ -219,6 +224,7 @@ func obtainCertificate(ctx *cli.Context, client *lego.Client) (*certificate.Reso if ctx.IsSet(flgPrivateKey) { var err error + request.PrivateKey, err = loadPrivateKey(ctx.String(flgPrivateKey)) if err != nil { return nil, fmt.Errorf("load private key: %w", err) @@ -247,6 +253,7 @@ func obtainCertificate(ctx *cli.Context, client *lego.Client) (*certificate.Reso if ctx.IsSet(flgPrivateKey) { var err error + request.PrivateKey, err = loadPrivateKey(ctx.String(flgPrivateKey)) if err != nil { return nil, fmt.Errorf("load private key: %w", err) diff --git a/cmd/flags.go b/cmd/flags.go index 3372de4ff..c7e8371b6 100644 --- a/cmd/flags.go +++ b/cmd/flags.go @@ -258,5 +258,6 @@ func getTime(ctx *cli.Context, name string) time.Time { if value == nil { return time.Time{} } + return *value } diff --git a/cmd/hook.go b/cmd/hook.go index c1de29c58..7883108b6 100644 --- a/cmd/hook.go +++ b/cmd/hook.go @@ -34,6 +34,7 @@ func launchHook(hook string, timeout time.Duration, meta map[string]string) erro parts := strings.Fields(hook) cmd := exec.CommandContext(ctxCmd, parts[0], parts[1:]...) + cmd.Env = append(os.Environ(), metaToEnv(meta)...) stdout, err := cmd.StdoutPipe() @@ -50,6 +51,7 @@ func launchHook(hook string, timeout time.Duration, meta map[string]string) erro go func() { <-ctxCmd.Done() + if ctxCmd.Err() != nil { _ = cmd.Process.Kill() _ = stdout.Close() diff --git a/cmd/lego/main.go b/cmd/lego/main.go index 61a3d532a..c301a51f1 100644 --- a/cmd/lego/main.go +++ b/cmd/lego/main.go @@ -26,6 +26,7 @@ func main() { } var defaultPath string + cwd, err := os.Getwd() if err == nil { defaultPath = filepath.Join(cwd, ".lego") diff --git a/cmd/setup.go b/cmd/setup.go index 72f881755..4d17f2e27 100644 --- a/cmd/setup.go +++ b/cmd/setup.go @@ -114,6 +114,7 @@ func getKeyType(ctx *cli.Context) certcrypto.KeyType { } log.Fatalf("Unsupported KeyType: %s", keyType) + return "" } @@ -122,6 +123,7 @@ func getEmail(ctx *cli.Context) string { if email == "" { log.Fatalf("You have to pass an account (email address) to the program using --%s or -m", flgEmail) } + return email } @@ -135,6 +137,7 @@ func createNonExistingFolder(path string) error { } else if err != nil { return err } + return nil } @@ -143,10 +146,12 @@ func readCSRFile(filename string) (*x509.CertificateRequest, error) { if err != nil { return nil, err } + raw := bytes // see if we can find a PEM-encoded CSR var p *pem.Block + rest := bytes for { // decode a PEM block diff --git a/cmd/setup_challenges.go b/cmd/setup_challenges.go index c923fa004..6968c7ba3 100644 --- a/cmd/setup_challenges.go +++ b/cmd/setup_challenges.go @@ -54,18 +54,21 @@ func setupHTTPProvider(ctx *cli.Context) challenge.Provider { if err != nil { log.Fatal(err) } + return ps case ctx.IsSet(flgHTTPMemcachedHost): ps, err := memcached.NewMemcachedProvider(ctx.StringSlice(flgHTTPMemcachedHost)) if err != nil { log.Fatal(err) } + return ps case ctx.IsSet(flgHTTPS3Bucket): ps, err := s3.NewHTTPProvider(ctx.String(flgHTTPS3Bucket)) if err != nil { log.Fatal(err) } + return ps case ctx.IsSet(flgHTTPPort): iface := ctx.String(flgHTTPPort) @@ -82,12 +85,14 @@ func setupHTTPProvider(ctx *cli.Context) challenge.Provider { if header := ctx.String(flgHTTPProxyHeader); header != "" { srv.SetProxyHeader(header) } + return srv case ctx.Bool(flgHTTP): srv := http01.NewProviderServer("", "") if header := ctx.String(flgHTTPProxyHeader); header != "" { srv.SetProxyHeader(header) } + return srv default: log.Fatal("Invalid HTTP challenge options.") diff --git a/e2e/challenges_test.go b/e2e/challenges_test.go index 174ac2ed9..be1d23131 100644 --- a/e2e/challenges_test.go +++ b/e2e/challenges_test.go @@ -205,6 +205,7 @@ func TestChallengeTLS_Run_Revoke_Non_ASCII(t *testing.T) { func TestChallengeHTTP_Client_Obtain(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "./fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) @@ -222,6 +223,7 @@ func TestChallengeHTTP_Client_Obtain(t *testing.T) { reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}) require.NoError(t, err) + user.registration = reg request := certificate.ObtainRequest{ @@ -243,6 +245,7 @@ func TestChallengeHTTP_Client_Obtain(t *testing.T) { func TestChallengeHTTP_Client_Obtain_profile(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "./fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) @@ -260,6 +263,7 @@ func TestChallengeHTTP_Client_Obtain_profile(t *testing.T) { reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}) require.NoError(t, err) + user.registration = reg request := certificate.ObtainRequest{ @@ -282,6 +286,7 @@ func TestChallengeHTTP_Client_Obtain_profile(t *testing.T) { func TestChallengeHTTP_Client_Obtain_emails_csr(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "./fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) @@ -299,6 +304,7 @@ func TestChallengeHTTP_Client_Obtain_emails_csr(t *testing.T) { reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}) require.NoError(t, err) + user.registration = reg request := certificate.ObtainRequest{ @@ -321,6 +327,7 @@ func TestChallengeHTTP_Client_Obtain_emails_csr(t *testing.T) { func TestChallengeHTTP_Client_Obtain_notBefore_notAfter(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "./fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) @@ -338,6 +345,7 @@ func TestChallengeHTTP_Client_Obtain_notBefore_notAfter(t *testing.T) { reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}) require.NoError(t, err) + user.registration = reg now := time.Now().UTC() @@ -368,6 +376,7 @@ func TestChallengeHTTP_Client_Obtain_notBefore_notAfter(t *testing.T) { func TestChallengeHTTP_Client_Registration_QueryRegistration(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "./fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) @@ -385,6 +394,7 @@ func TestChallengeHTTP_Client_Registration_QueryRegistration(t *testing.T) { reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}) require.NoError(t, err) + user.registration = reg resource, err := client.Registration.QueryRegistration() @@ -400,6 +410,7 @@ func TestChallengeHTTP_Client_Registration_QueryRegistration(t *testing.T) { func TestChallengeTLS_Client_Obtain(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "./fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) @@ -417,6 +428,7 @@ func TestChallengeTLS_Client_Obtain(t *testing.T) { reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}) require.NoError(t, err) + user.registration = reg // https://github.com/letsencrypt/pebble/issues/285 @@ -443,6 +455,7 @@ func TestChallengeTLS_Client_Obtain(t *testing.T) { func TestChallengeTLS_Client_ObtainForCSR(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "./fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) @@ -460,6 +473,7 @@ func TestChallengeTLS_Client_ObtainForCSR(t *testing.T) { reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}) require.NoError(t, err) + user.registration = reg csr, err := x509.ParseCertificateRequest(createTestCSR(t)) @@ -483,6 +497,7 @@ func TestChallengeTLS_Client_ObtainForCSR(t *testing.T) { func TestChallengeTLS_Client_ObtainForCSR_profile(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "./fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) @@ -500,6 +515,7 @@ func TestChallengeTLS_Client_ObtainForCSR_profile(t *testing.T) { reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}) require.NoError(t, err) + user.registration = reg csr, err := x509.ParseCertificateRequest(createTestCSR(t)) @@ -524,6 +540,7 @@ func TestChallengeTLS_Client_ObtainForCSR_profile(t *testing.T) { func TestRegistrar_UpdateAccount(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "./fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) diff --git a/e2e/dnschallenge/dns_challenges_test.go b/e2e/dnschallenge/dns_challenges_test.go index a44c353b3..509b57bb1 100644 --- a/e2e/dnschallenge/dns_challenges_test.go +++ b/e2e/dnschallenge/dns_challenges_test.go @@ -75,10 +75,12 @@ func TestChallengeDNS_Run(t *testing.T) { func TestChallengeDNS_Client_Obtain(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "../fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() err = os.Setenv("EXEC_PATH", "../fixtures/update-dns.sh") require.NoError(t, err) + defer func() { _ = os.Unsetenv("EXEC_PATH") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) @@ -101,6 +103,7 @@ func TestChallengeDNS_Client_Obtain(t *testing.T) { reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}) require.NoError(t, err) + user.registration = reg domains := []string{testDomain2, testDomain1} @@ -129,10 +132,12 @@ func TestChallengeDNS_Client_Obtain(t *testing.T) { func TestChallengeDNS_Client_Obtain_profile(t *testing.T) { err := os.Setenv("LEGO_CA_CERTIFICATES", "../fixtures/certs/pebble.minica.pem") require.NoError(t, err) + defer func() { _ = os.Unsetenv("LEGO_CA_CERTIFICATES") }() err = os.Setenv("EXEC_PATH", "../fixtures/update-dns.sh") require.NoError(t, err) + defer func() { _ = os.Unsetenv("EXEC_PATH") }() privateKey, err := rsa.GenerateKey(rand.Reader, 2048) @@ -155,6 +160,7 @@ func TestChallengeDNS_Client_Obtain_profile(t *testing.T) { reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}) require.NoError(t, err) + user.registration = reg domains := []string{testDomain2, testDomain1} diff --git a/e2e/loader/loader.go b/e2e/loader/loader.go index b5ac9cef8..3e63302a3 100644 --- a/e2e/loader/loader.go +++ b/e2e/loader/loader.go @@ -43,12 +43,14 @@ func (l *EnvLoader) MainTest(m *testing.M) int { if _, e2e := os.LookupEnv("LEGO_E2E_TESTS"); !e2e { fmt.Fprintln(os.Stderr, "skipping test: e2e tests are disabled. (no 'LEGO_E2E_TESTS' env var)") fmt.Println("PASS") + return 0 } if _, err := exec.LookPath("git"); err != nil { fmt.Fprintln(os.Stderr, "skipping because git command not found") fmt.Println("PASS") + return 0 } @@ -56,6 +58,7 @@ func (l *EnvLoader) MainTest(m *testing.M) int { if _, err := exec.LookPath(cmdNamePebble); err != nil { fmt.Fprintln(os.Stderr, "skipping because pebble binary not found") fmt.Println("PASS") + return 0 } } @@ -64,6 +67,7 @@ func (l *EnvLoader) MainTest(m *testing.M) int { if _, err := exec.LookPath(cmdNameChallSrv); err != nil { fmt.Fprintln(os.Stderr, "skipping because challtestsrv binary not found") fmt.Println("PASS") + return 0 } } @@ -76,6 +80,7 @@ func (l *EnvLoader) MainTest(m *testing.M) int { legoBinary, tearDown, err := buildLego() defer tearDown() + if err != nil { fmt.Fprintln(os.Stderr, err) return 1 @@ -136,6 +141,7 @@ func (l *EnvLoader) launchPebble() func() { } pebble, outPebble := l.cmdPebble() + go func() { err := pebble.Run() if err != nil { @@ -148,6 +154,7 @@ func (l *EnvLoader) launchPebble() func() { if err != nil { fmt.Println(err) } + fmt.Println(outPebble.String()) } } @@ -160,11 +167,13 @@ func (l *EnvLoader) cmdPebble() (*exec.Cmd, *bytes.Buffer) { if err != nil { panic(err) } + cmd.Dir = dir fmt.Printf("$ %s\n", strings.Join(cmd.Args, " ")) var b bytes.Buffer + cmd.Stdout = &b cmd.Stderr = &b @@ -173,6 +182,7 @@ func (l *EnvLoader) cmdPebble() (*exec.Cmd, *bytes.Buffer) { func pebbleHealthCheck(options *CmdOption) { client := &http.Client{Transport: &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}} + err := wait.For("pebble", 10*time.Second, 500*time.Millisecond, func() (bool, error) { resp, err := client.Get(options.HealthCheckURL) if err != nil { @@ -196,6 +206,7 @@ func (l *EnvLoader) launchChallSrv() func() { } challtestsrv, outChalSrv := l.cmdChallSrv() + go func() { err := challtestsrv.Run() if err != nil { @@ -208,6 +219,7 @@ func (l *EnvLoader) launchChallSrv() func() { if err != nil { fmt.Println(err) } + fmt.Println(outChalSrv.String()) } } @@ -218,6 +230,7 @@ func (l *EnvLoader) cmdChallSrv() (*exec.Cmd, *bytes.Buffer) { fmt.Printf("$ %s\n", strings.Join(cmd.Args, " ")) var b bytes.Buffer + cmd.Stdout = &b cmd.Stderr = &b @@ -229,6 +242,7 @@ func buildLego() (string, func(), error) { if err != nil { return "", func() {}, err } + defer func() { _ = os.Chdir(here) }() buildPath, err := os.MkdirTemp("", "lego_test") @@ -262,6 +276,7 @@ func buildLego() (string, func(), error) { return binary, func() { _ = os.RemoveAll(buildPath) + CleanLegoFiles() }, nil } @@ -283,6 +298,7 @@ func build(binary string) error { if err != nil { return err } + cmd := exec.Command(toolPath, "build", "-o", binary) output, err := cmd.CombinedOutput() @@ -334,6 +350,7 @@ func goTool() (string, error) { func CleanLegoFiles() { cmd := exec.Command("rm", "-rf", ".lego") fmt.Printf("$ %s\n", strings.Join(cmd.Args, " ")) + output, err := cmd.CombinedOutput() if err != nil { fmt.Println(string(output)) diff --git a/internal/clihelp/generator.go b/internal/clihelp/generator.go index 2d256b4d7..fcabde015 100644 --- a/internal/clihelp/generator.go +++ b/internal/clihelp/generator.go @@ -50,6 +50,7 @@ func generate() error { // collect output of various help pages var help []commandHelp + for _, args := range [][]string{ {"lego", "help"}, {"lego", "help", "run"}, @@ -72,7 +73,9 @@ func generate() error { } err = outputTpl.Execute(f, help) + defer func() { _ = f.Close() }() + if err != nil { return fmt.Errorf("failed to write cli_help.toml: %w", err) } @@ -98,9 +101,11 @@ func createStubApp() *cli.App { func run(app *cli.App, args []string) (h commandHelp, err error) { w := app.Writer + defer func() { app.Writer = w }() var buf bytes.Buffer + app.Writer = &buf if err := app.Run(args); err != nil { diff --git a/internal/dns/docs/generator.go b/internal/dns/docs/generator.go index 676f65f5b..c7f9ef8c7 100644 --- a/internal/dns/docs/generator.go +++ b/internal/dns/docs/generator.go @@ -116,6 +116,7 @@ func generateCLIHelp(models *descriptors.Providers) error { defer func() { _ = file.Close() }() b := &bytes.Buffer{} + err = template.Must( template.New(filepath.Base(cliTemplate)).Funcs(map[string]any{ "safe": func(src string) string { @@ -134,6 +135,7 @@ func generateCLIHelp(models *descriptors.Providers) error { } _, err = file.Write(source) + return err } @@ -161,6 +163,7 @@ func generateReadMe(models *descriptors.Providers) error { if err = tpl.Execute(buffer, providers); err != nil { return err } + skip = true } @@ -198,8 +201,10 @@ func orderProviders(models *descriptors.Providers) [][]descriptors.Provider { return strings.Compare(strings.ToLower(a.Name), strings.ToLower(b.Name)) }) - var matrix [][]descriptors.Provider - var row []descriptors.Provider + var ( + matrix [][]descriptors.Provider + row []descriptors.Provider + ) for i, p := range providers { switch { @@ -212,6 +217,7 @@ func orderProviders(models *descriptors.Providers) [][]descriptors.Provider { for j := len(row); j < nbCol; j++ { row = append(row, descriptors.Provider{}) } + matrix = append(matrix, row) default: @@ -223,6 +229,7 @@ func orderProviders(models *descriptors.Providers) [][]descriptors.Provider { for j := len(row); j < nbCol; j++ { row = append(row, descriptors.Provider{}) } + matrix = append(matrix, row) } diff --git a/internal/dns/providers/generator.go b/internal/dns/providers/generator.go index 8f133a765..df3f8a2e6 100644 --- a/internal/dns/providers/generator.go +++ b/internal/dns/providers/generator.go @@ -46,6 +46,7 @@ func generate() error { defer func() { _ = file.Close() }() b := &bytes.Buffer{} + err = template.Must( template.New("").Funcs(map[string]any{ "cleanName": func(src string) string { diff --git a/internal/releaser/releaser.go b/internal/releaser/releaser.go index 6047c427c..57b463933 100644 --- a/internal/releaser/releaser.go +++ b/internal/releaser/releaser.go @@ -108,6 +108,7 @@ func detach(_ *cli.Context) error { func readCurrentVersion(filename string) (*hcversion.Version, error) { fset := token.NewFileSet() + file, err := parser.ParseFile(fset, filename, nil, parser.AllErrors) if err != nil { return nil, err @@ -141,6 +142,7 @@ func (v visitor) Visit(n ast.Node) ast.Visitor { if !ok { continue } + if len(valueSpec.Names) != 1 || len(valueSpec.Values) != 1 { continue } @@ -149,6 +151,7 @@ func (v visitor) Visit(n ast.Node) ast.Visitor { if !ok { continue } + if va.Kind != token.STRING { continue } @@ -164,6 +167,7 @@ func (v visitor) Visit(n ast.Node) ast.Visitor { default: // noop } + return v } diff --git a/platform/config/env/env.go b/platform/config/env/env.go index b74a65cd9..33a0d6caa 100644 --- a/platform/config/env/env.go +++ b/platform/config/env/env.go @@ -16,11 +16,13 @@ func Get(names ...string) (map[string]string, error) { values := map[string]string{} var missingEnvVars []string + for _, envVar := range names { value := GetOrFile(envVar) if value == "" { missingEnvVars = append(missingEnvVars, envVar) } + values[envVar] = value } @@ -58,6 +60,7 @@ func GetWithFallback(groups ...[]string) (map[string]string, error) { values := map[string]string{} var missingEnvVars []string + for _, names := range groups { if len(names) == 0 { return nil, errors.New("undefined environment variable names") @@ -68,6 +71,7 @@ func GetWithFallback(groups ...[]string) (map[string]string, error) { missingEnvVars = append(missingEnvVars, envVar) continue } + values[envVar] = value } @@ -148,6 +152,7 @@ func GetOrFile(envVar string) string { } fileVar := envVar + "_FILE" + fileVarValue := os.Getenv(fileVar) if fileVarValue == "" { return envVarValue diff --git a/platform/tester/api.go b/platform/tester/api.go index 410fb1401..8343b487f 100644 --- a/platform/tester/api.go +++ b/platform/tester/api.go @@ -42,6 +42,7 @@ func WriteJSONResponse(w http.ResponseWriter, body any) error { } w.Header().Set("Content-Type", "application/json") + if _, err := w.Write(bs); err != nil { return err } diff --git a/platform/tester/env.go b/platform/tester/env.go index 26788be3b..a12c32ef8 100644 --- a/platform/tester/env.go +++ b/platform/tester/env.go @@ -21,6 +21,7 @@ type EnvTest struct { // NewEnvTest Creates an EnvTest. func NewEnvTest(keys ...string) *EnvTest { values := make(map[string]string) + for _, key := range keys { value := os.Getenv(key) if value != "" { @@ -39,6 +40,7 @@ func NewEnvTest(keys ...string) *EnvTest { func (e *EnvTest) WithDomain(key string) *EnvTest { e.domainKey = key e.domain = os.Getenv(key) + return e } diff --git a/platform/tester/env_test.go b/platform/tester/env_test.go index d5084056f..4d9e4e7d1 100644 --- a/platform/tester/env_test.go +++ b/platform/tester/env_test.go @@ -18,6 +18,7 @@ const ( func TestMain(m *testing.M) { exitCode := m.Run() + clearEnv() os.Exit(exitCode) } @@ -39,6 +40,7 @@ func clearEnv() { os.Unsetenv(strings.Split(key, "=")[0]) } } + os.Unsetenv("EXTRA_LEGO_TEST") } @@ -325,6 +327,7 @@ func TestEnvTest(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer clearEnv() + applyEnv(test.envVars) envTest := test.envTestSetup() diff --git a/platform/tester/servermock/link_form.go b/platform/tester/servermock/link_form.go index e7541cefa..581e27d66 100644 --- a/platform/tester/servermock/link_form.go +++ b/platform/tester/servermock/link_form.go @@ -43,6 +43,7 @@ func (l *FormLink) Bind(next http.Handler) http.Handler { if len(form) != len(l.values)+len(l.regexes) { msg := fmt.Sprintf("invalid query parameters, got %v, want %v", req.Form, l.values) http.Error(rw, msg, l.statusCode) + return } } @@ -52,6 +53,7 @@ func (l *FormLink) Bind(next http.Handler) http.Handler { if !slices.Equal(v, value) { msg := fmt.Sprintf("invalid %q form value, got %q, want %q", k, value, v) http.Error(rw, msg, l.statusCode) + return } } @@ -61,6 +63,7 @@ func (l *FormLink) Bind(next http.Handler) http.Handler { if !exp.MatchString(value) { msg := fmt.Sprintf("invalid %q form value, %q doesn't match to %q", k, value, exp) http.Error(rw, msg, l.statusCode) + return } } diff --git a/platform/tester/servermock/link_headers.go b/platform/tester/servermock/link_headers.go index 821c737fe..0ca519958 100644 --- a/platform/tester/servermock/link_headers.go +++ b/platform/tester/servermock/link_headers.go @@ -55,6 +55,7 @@ func (l *HeaderLink) Bind(next http.Handler) http.Handler { if !exp.MatchString(value) { msg := fmt.Sprintf("invalid %q header value, %q doesn't match to %q", k, value, exp) http.Error(rw, msg, l.statusCode) + return } } diff --git a/platform/tester/servermock/link_query.go b/platform/tester/servermock/link_query.go index 00d7450ae..14f776515 100644 --- a/platform/tester/servermock/link_query.go +++ b/platform/tester/servermock/link_query.go @@ -32,6 +32,7 @@ func (l *QueryParameterLink) Bind(next http.Handler) http.Handler { if len(query) != len(l.values)+len(l.regexes) { msg := fmt.Sprintf("invalid query parameters, got %v, want %v", query, l.values) http.Error(rw, msg, l.statusCode) + return } } @@ -41,6 +42,7 @@ func (l *QueryParameterLink) Bind(next http.Handler) http.Handler { if p != v { msg := fmt.Sprintf("invalid %q query parameter value, got %q, want %q", k, p, v) http.Error(rw, msg, l.statusCode) + return } } @@ -50,6 +52,7 @@ func (l *QueryParameterLink) Bind(next http.Handler) http.Handler { if !exp.MatchString(value) { msg := fmt.Sprintf("invalid %q query parameter value, %q doesn't match to %q", k, value, exp) http.Error(rw, msg, l.statusCode) + return } } diff --git a/platform/tester/servermock/link_request_body.go b/platform/tester/servermock/link_request_body.go index b58c3cc79..d6b2d9efd 100644 --- a/platform/tester/servermock/link_request_body.go +++ b/platform/tester/servermock/link_request_body.go @@ -76,6 +76,7 @@ func (l *RequestBodyLink) Bind(next http.Handler) http.Handler { msg := fmt.Sprintf("%s: request body differences: got: %s, want: %s", req.URL.Path, string(bytes.TrimSpace(body)), string(bytes.TrimSpace(expectedRaw))) http.Error(rw, msg, http.StatusBadRequest) + return } diff --git a/platform/tester/servermock/link_request_body_json.go b/platform/tester/servermock/link_request_body_json.go index 3dc2f0cfa..ed5a117ba 100644 --- a/platform/tester/servermock/link_request_body_json.go +++ b/platform/tester/servermock/link_request_body_json.go @@ -90,6 +90,7 @@ func (l *RequestBodyJSONLink) Bind(next http.Handler) http.Handler { if err != nil { msg := fmt.Sprintf("%s: the expected request body is not valid JSON: %v", req.URL.Path, err) http.Error(rw, msg, http.StatusBadRequest) + return } @@ -97,12 +98,14 @@ func (l *RequestBodyJSONLink) Bind(next http.Handler) http.Handler { if err != nil { msg := fmt.Sprintf("%s: request body is not valid JSON: %v", req.URL.Path, err) http.Error(rw, msg, http.StatusBadRequest) + return } if !cmp.Equal(actual, expected) { msg := fmt.Sprintf("%s: request body differences: %s", req.URL.Path, cmp.Diff(actual, expected)) http.Error(rw, msg, http.StatusBadRequest) + return } diff --git a/platform/wait/wait.go b/platform/wait/wait.go index e6420263d..c66f57446 100644 --- a/platform/wait/wait.go +++ b/platform/wait/wait.go @@ -14,13 +14,16 @@ func For(msg string, timeout, interval time.Duration, f func() (bool, error)) er log.Infof("Wait for %s [timeout: %s, interval: %s]", msg, timeout, interval) var lastErr error + timeUp := time.After(timeout) + for { select { case <-timeUp: if lastErr == nil { return fmt.Errorf("%s: time limit exceeded", msg) } + return fmt.Errorf("%s: time limit exceeded: last error: %w", msg, lastErr) default: } @@ -44,5 +47,6 @@ func Retry(ctx context.Context, operation func() error, opts ...backoff.RetryOpt _, err := backoff.Retry(ctx, func() (any, error) { return nil, operation() }, opts...) + return err } diff --git a/platform/wait/wait_test.go b/platform/wait/wait_test.go index b401c819f..36dbffe69 100644 --- a/platform/wait/wait_test.go +++ b/platform/wait/wait_test.go @@ -19,6 +19,7 @@ func TestFor_timeout(t *testing.T) { go func() { c <- For("test", 3*time.Second, 1*time.Second, func() (bool, error) { io.Add(1) + if io.Load() == 1 { return false, nil } diff --git a/providers/dns/acmedns/acmedns.go b/providers/dns/acmedns/acmedns.go index 9663a656b..8f1f16842 100644 --- a/providers/dns/acmedns/acmedns.go +++ b/providers/dns/acmedns/acmedns.go @@ -114,6 +114,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { } // NewDNSProviderClient creates an ACME-DNS DNSProvider with the given acmeDNSClient and [goacmedns.Storage]. +// // Deprecated: use [NewDNSProviderConfig] instead. func NewDNSProviderClient(client acmeDNSClient, store goacmedns.Storage) (*DNSProvider, error) { if client == nil { diff --git a/providers/dns/acmedns/mock_test.go b/providers/dns/acmedns/mock_test.go index 629f25a0c..a09a3ca91 100644 --- a/providers/dns/acmedns/mock_test.go +++ b/providers/dns/acmedns/mock_test.go @@ -107,6 +107,7 @@ func newMockStorage() *mockStorage { if acct, ok := m.accounts[domain]; ok { return acct, nil } + return goacmedns.Account{}, storage.ErrDomainNotFound } diff --git a/providers/dns/active24/active24_test.go b/providers/dns/active24/active24_test.go index d7d2c5535..363e0229a 100644 --- a/providers/dns/active24/active24_test.go +++ b/providers/dns/active24/active24_test.go @@ -50,6 +50,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -124,6 +125,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -137,6 +139,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/alidns/alidns.go b/providers/dns/alidns/alidns.go index eefc1162e..a5c883fcb 100644 --- a/providers/dns/alidns/alidns.go +++ b/providers/dns/alidns/alidns.go @@ -170,6 +170,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("alicloud: API call failed: %w", err) } + return nil } @@ -233,6 +234,7 @@ func (d *DNSProvider) getHostedZone(ctx context.Context, domain string) (string, } var hostedZone *alidns.DescribeDomainsResponseBodyDomainsDomain + for _, zone := range domains { if ptr.Deref(zone.DomainName) == dns01.UnFqdn(authZone) || ptr.Deref(zone.PunyCode) == dns01.UnFqdn(authZone) { hostedZone = zone @@ -287,6 +289,7 @@ func (d *DNSProvider) findTxtRecords(ctx context.Context, fqdn string) ([]*alidn records = append(records, record) } } + return records, nil } diff --git a/providers/dns/alidns/alidns_test.go b/providers/dns/alidns/alidns_test.go index 487997813..b1e482d2d 100644 --- a/providers/dns/alidns/alidns_test.go +++ b/providers/dns/alidns/alidns_test.go @@ -64,6 +64,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -142,6 +143,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -155,6 +157,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/allinkl/allinkl.go b/providers/dns/allinkl/allinkl.go index 5be194ed2..a5b27ff59 100644 --- a/providers/dns/allinkl/allinkl.go +++ b/providers/dns/allinkl/allinkl.go @@ -176,6 +176,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("allinkl: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/allinkl/allinkl_test.go b/providers/dns/allinkl/allinkl_test.go index af85f8c54..b42adce5d 100644 --- a/providers/dns/allinkl/allinkl_test.go +++ b/providers/dns/allinkl/allinkl_test.go @@ -53,6 +53,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -121,6 +122,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -134,6 +136,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/allinkl/internal/client.go b/providers/dns/allinkl/internal/client.go index 02a5a2c8f..d747e9b36 100644 --- a/providers/dns/allinkl/internal/client.go +++ b/providers/dns/allinkl/internal/client.go @@ -57,6 +57,7 @@ func (c *Client) GetDNSSettings(ctx context.Context, zone, recordID string) ([]R } var g GetDNSSettingsAPIResponse + err = c.do(req, &g) if err != nil { return nil, err @@ -75,6 +76,7 @@ func (c *Client) AddDNSSettings(ctx context.Context, record DNSRequest) (string, } var g AddDNSSettingsAPIResponse + err = c.do(req, &g) if err != nil { return "", err @@ -95,6 +97,7 @@ func (c *Client) DeleteDNSSettings(ctx context.Context, recordID string) (string } var g DeleteDNSSettingsAPIResponse + err = c.do(req, &g) if err != nil { return "", err diff --git a/providers/dns/allinkl/internal/types.go b/providers/dns/allinkl/internal/types.go index b5c6ba0d1..b0aa9b4ff 100644 --- a/providers/dns/allinkl/internal/types.go +++ b/providers/dns/allinkl/internal/types.go @@ -17,6 +17,7 @@ func (tr Trimmer) Token() (xml.Token, error) { if cd, ok := t.(xml.CharData); ok { t = xml.CharData(bytes.TrimSpace(cd)) } + return t, err } @@ -53,6 +54,7 @@ func decodeXML[T any](reader io.Reader) (*T, error) { } var result T + err = xml.NewTokenDecoder(Trimmer{decoder: xml.NewDecoder(bytes.NewReader(raw))}).Decode(&result) if err != nil { return nil, fmt.Errorf("decode XML response: %w", err) diff --git a/providers/dns/anexia/anexia.go b/providers/dns/anexia/anexia.go index 568ef5263..3ce7e2208 100644 --- a/providers/dns/anexia/anexia.go +++ b/providers/dns/anexia/anexia.go @@ -96,6 +96,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if config.APIURL != "" { var err error + client.BaseURL, err = url.Parse(config.APIURL) if err != nil { return nil, fmt.Errorf("anexia: %w", err) diff --git a/providers/dns/anexia/anexia_test.go b/providers/dns/anexia/anexia_test.go index f38bfd7f7..9960c14d1 100644 --- a/providers/dns/anexia/anexia_test.go +++ b/providers/dns/anexia/anexia_test.go @@ -42,6 +42,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -102,6 +103,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -115,6 +117,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/anexia/internal/client.go b/providers/dns/anexia/internal/client.go index 86f3b2697..1a4159be0 100644 --- a/providers/dns/anexia/internal/client.go +++ b/providers/dns/anexia/internal/client.go @@ -49,6 +49,7 @@ func (c *Client) CreateRecord(ctx context.Context, zoneName string, record Recor } var zone Zone + err = c.do(req, &zone) if err != nil { return nil, err @@ -147,6 +148,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/arvancloud/arvancloud.go b/providers/dns/arvancloud/arvancloud.go index 4b5fbab62..ed1d5ff7a 100644 --- a/providers/dns/arvancloud/arvancloud.go +++ b/providers/dns/arvancloud/arvancloud.go @@ -167,6 +167,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("arvancloud: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/arvancloud/arvancloud_test.go b/providers/dns/arvancloud/arvancloud_test.go index c31edf021..24013c437 100644 --- a/providers/dns/arvancloud/arvancloud_test.go +++ b/providers/dns/arvancloud/arvancloud_test.go @@ -37,6 +37,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -104,6 +105,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -117,6 +119,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/arvancloud/internal/client.go b/providers/dns/arvancloud/internal/client.go index 3caff392a..b447d97c4 100644 --- a/providers/dns/arvancloud/internal/client.go +++ b/providers/dns/arvancloud/internal/client.go @@ -70,6 +70,7 @@ func (c *Client) getRecords(ctx context.Context, domain, search string) ([]DNSRe } response := &apiResponse[[]DNSRecord]{} + err = c.do(req, http.StatusOK, response) if err != nil { return nil, fmt.Errorf("could not get records %s: Domain: %s: %w", search, domain, err) @@ -89,6 +90,7 @@ func (c *Client) CreateRecord(ctx context.Context, domain string, record DNSReco } response := &apiResponse[*DNSRecord]{} + err = c.do(req, http.StatusCreated, response) if err != nil { return nil, fmt.Errorf("could not create record; Domain: %s: %w", domain, err) diff --git a/providers/dns/arvancloud/internal/client_test.go b/providers/dns/arvancloud/internal/client_test.go index d13bc6f34..183a8acfd 100644 --- a/providers/dns/arvancloud/internal/client_test.go +++ b/providers/dns/arvancloud/internal/client_test.go @@ -81,8 +81,10 @@ func TestClient_CreateRecord(t *testing.T) { func TestClient_DeleteRecord(t *testing.T) { const apiKey = "myKeyC" - const domain = "example.com" - const recordID = "recordId" + const ( + domain = "example.com" + recordID = "recordId" + ) client := mockBuilder(apiKey). Route("DELETE /cdn/4.0/domains/"+domain+"/dns-records/"+recordID, nil). diff --git a/providers/dns/auroradns/auroradns_test.go b/providers/dns/auroradns/auroradns_test.go index c5a2ca877..8a9835d9c 100644 --- a/providers/dns/auroradns/auroradns_test.go +++ b/providers/dns/auroradns/auroradns_test.go @@ -71,6 +71,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) diff --git a/providers/dns/autodns/autodns_test.go b/providers/dns/autodns/autodns_test.go index bc9f3067e..632d24705 100644 --- a/providers/dns/autodns/autodns_test.go +++ b/providers/dns/autodns/autodns_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -131,6 +132,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -144,6 +146,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/autodns/internal/client.go b/providers/dns/autodns/internal/client.go index 1fc9589ea..547596f81 100644 --- a/providers/dns/autodns/internal/client.go +++ b/providers/dns/autodns/internal/client.go @@ -55,6 +55,7 @@ func (c *Client) RemoveTXTRecords(ctx context.Context, domain string, records [] zoneStream := &ZoneStream{Removes: records} _, err := c.updateZone(ctx, domain, zoneStream) + return err } diff --git a/providers/dns/axelname/axelname_test.go b/providers/dns/axelname/axelname_test.go index 52c4f38b9..1a8bac971 100644 --- a/providers/dns/axelname/axelname_test.go +++ b/providers/dns/axelname/axelname_test.go @@ -50,6 +50,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -120,6 +121,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -133,6 +135,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/axelname/internal/client.go b/providers/dns/axelname/internal/client.go index f6cf079e6..f2defec87 100644 --- a/providers/dns/axelname/internal/client.go +++ b/providers/dns/axelname/internal/client.go @@ -174,6 +174,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/azion/azion.go b/providers/dns/azion/azion.go index a257fa0f1..8150d90d5 100644 --- a/providers/dns/azion/azion.go +++ b/providers/dns/azion/azion.go @@ -137,6 +137,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { record.SetTtl(int32(d.config.TTL)) var resp *idns.PostOrPutRecordResponse + if existingRecord != nil { // Update existing record by adding the new value to the existing ones record.SetAnswersList(append(existingRecord.GetAnswersList(), info.Value)) @@ -161,6 +162,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { } results := resp.GetResults() + d.recordIDsMu.Lock() d.recordIDs[token] = results.GetId() d.recordIDsMu.Unlock() @@ -203,6 +205,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { currentAnswers := existingRecord.GetAnswersList() var updatedAnswers []string + for _, answer := range currentAnswers { if answer != info.Value { updatedAnswers = append(updatedAnswers, answer) diff --git a/providers/dns/azion/azion_test.go b/providers/dns/azion/azion_test.go index b3b553114..517594cdc 100644 --- a/providers/dns/azion/azion_test.go +++ b/providers/dns/azion/azion_test.go @@ -40,6 +40,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -99,6 +100,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -112,6 +114,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/azure/azure.go b/providers/dns/azure/azure.go index 5702acd8a..fd00bcbe2 100644 --- a/providers/dns/azure/azure.go +++ b/providers/dns/azure/azure.go @@ -89,6 +89,7 @@ type DNSProvider struct { // If the credentials are _not_ set via the environment, // then it will attempt to get a bearer token via the instance metadata service. // see: https://github.com/Azure/go-autorest/blob/v10.14.0/autorest/azure/auth/auth.go#L38-L42 +// // Deprecated: use azuredns instead. func NewDNSProvider() (*DNSProvider, error) { config := NewDefaultConfig() @@ -96,6 +97,7 @@ func NewDNSProvider() (*DNSProvider, error) { environmentName := env.GetOrFile(EnvEnvironment) if environmentName != "" { var environment aazure.Environment + switch environmentName { case "china": environment = aazure.ChinaCloud @@ -124,6 +126,7 @@ func NewDNSProvider() (*DNSProvider, error) { } // NewDNSProviderConfig return a DNSProvider instance configured for Azure. +// // Deprecated: use azuredns instead. func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if config == nil { @@ -148,6 +151,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if subsID == "" { return nil, errors.New("azure: SubscriptionID is missing") } + config.SubscriptionID = subsID } @@ -160,6 +164,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if resGroup == "" { return nil, errors.New("azure: ResourceGroup is missing") } + config.ResourceGroup = resGroup } diff --git a/providers/dns/azure/azure_test.go b/providers/dns/azure/azure_test.go index 496168362..44fb81eef 100644 --- a/providers/dns/azure/azure_test.go +++ b/providers/dns/azure/azure_test.go @@ -54,6 +54,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -158,6 +159,7 @@ func TestNewDNSProviderConfig(t *testing.T) { } else { mux.HandleFunc("/", test.handler) } + config.MetadataEndpoint = server.URL p, err := NewDNSProviderConfig(config) @@ -186,6 +188,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -199,6 +202,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/azure/private.go b/providers/dns/azure/private.go index d6c9fc7bd..f7c6a75b7 100644 --- a/providers/dns/azure/private.go +++ b/providers/dns/azure/private.go @@ -54,6 +54,7 @@ func (d *dnsProviderPrivate) Present(domain, token, keyAuth string) error { // Construct unique TXT records using map uniqRecords := map[string]struct{}{info.Value: {}} + if rset.RecordSetProperties != nil && rset.TxtRecords != nil { for _, txtRecord := range *rset.TxtRecords { // Assume Value doesn't contain multiple strings @@ -81,6 +82,7 @@ func (d *dnsProviderPrivate) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("azure: %w", err) } + return nil } @@ -106,6 +108,7 @@ func (d *dnsProviderPrivate) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("azure: %w", err) } + return nil } diff --git a/providers/dns/azure/public.go b/providers/dns/azure/public.go index 8e6fa182a..194956c9c 100644 --- a/providers/dns/azure/public.go +++ b/providers/dns/azure/public.go @@ -54,6 +54,7 @@ func (d *dnsProviderPublic) Present(domain, token, keyAuth string) error { // Construct unique TXT records using map uniqRecords := map[string]struct{}{info.Value: {}} + if rset.RecordSetProperties != nil && rset.TxtRecords != nil { for _, txtRecord := range *rset.TxtRecords { // Assume Value doesn't contain multiple strings @@ -81,6 +82,7 @@ func (d *dnsProviderPublic) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("azure: %w", err) } + return nil } @@ -106,6 +108,7 @@ func (d *dnsProviderPublic) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("azure: %w", err) } + return nil } diff --git a/providers/dns/azuredns/azuredns_test.go b/providers/dns/azuredns/azuredns_test.go index 7ddb4de45..594a0d6a3 100644 --- a/providers/dns/azuredns/azuredns_test.go +++ b/providers/dns/azuredns/azuredns_test.go @@ -35,6 +35,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -61,6 +62,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -74,6 +76,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/azuredns/credentials.go b/providers/dns/azuredns/credentials.go index efca10e59..a38b3f7dd 100644 --- a/providers/dns/azuredns/credentials.go +++ b/providers/dns/azuredns/credentials.go @@ -51,6 +51,7 @@ func getCredentials(config *Config) (azcore.TokenCredential, error) { if config.TenantID != "" { credOptions = &azidentity.AzureCLICredentialOptions{TenantID: config.TenantID} } + return azidentity.NewAzureCLICredential(credOptions) case authMethodOIDC: diff --git a/providers/dns/azuredns/private.go b/providers/dns/azuredns/private.go index 24fb3d5ee..43b39ed14 100644 --- a/providers/dns/azuredns/private.go +++ b/providers/dns/azuredns/private.go @@ -181,6 +181,7 @@ func (c privateZoneClient) Delete(ctx context.Context, subDomain string) (armpri func privateUniqueRecords(recordSet armprivatedns.RecordSet, value string) map[string]struct{} { uniqRecords := map[string]struct{}{value: {}} + if recordSet.Properties != nil && recordSet.Properties.TxtRecords != nil { for _, txtRecord := range recordSet.Properties.TxtRecords { // Assume Value doesn't contain multiple strings diff --git a/providers/dns/azuredns/public.go b/providers/dns/azuredns/public.go index f7e46150d..79b6e783f 100644 --- a/providers/dns/azuredns/public.go +++ b/providers/dns/azuredns/public.go @@ -179,6 +179,7 @@ func (c publicZoneClient) Delete(ctx context.Context, subDomain string) (armdns. func publicUniqueRecords(recordSet armdns.RecordSet, value string) map[string]struct{} { uniqRecords := map[string]struct{}{value: {}} + if recordSet.Properties != nil && recordSet.Properties.TxtRecords != nil { for _, txtRecord := range recordSet.Properties.TxtRecords { // Assume Value doesn't contain multiple strings diff --git a/providers/dns/azuredns/servicediscovery.go b/providers/dns/azuredns/servicediscovery.go index 882e19241..50a41da37 100644 --- a/providers/dns/azuredns/servicediscovery.go +++ b/providers/dns/azuredns/servicediscovery.go @@ -46,6 +46,7 @@ func discoverDNSZones(ctx context.Context, config *Config, credentials azcore.To } zones := map[string]ServiceDiscoveryZone{} + for { // create the query request request := armresourcegraph.QueryRequest{ diff --git a/providers/dns/baiducloud/baiducloud_test.go b/providers/dns/baiducloud/baiducloud_test.go index 3cc411323..483bfaf5e 100644 --- a/providers/dns/baiducloud/baiducloud_test.go +++ b/providers/dns/baiducloud/baiducloud_test.go @@ -48,6 +48,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -122,6 +123,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -135,6 +137,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/beget/beget.go b/providers/dns/beget/beget.go index e0d67572f..d4449deb8 100644 --- a/providers/dns/beget/beget.go +++ b/providers/dns/beget/beget.go @@ -145,6 +145,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var updatedRecords []internal.Record + for _, record := range records { if record.Data == info.Value { continue diff --git a/providers/dns/beget/beget_test.go b/providers/dns/beget/beget_test.go index e89b626b6..3cfb3c0b4 100644 --- a/providers/dns/beget/beget_test.go +++ b/providers/dns/beget/beget_test.go @@ -58,6 +58,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -132,6 +133,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() assert.NoError(t, err) @@ -145,6 +147,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() assert.NoError(t, err) diff --git a/providers/dns/beget/internal/client.go b/providers/dns/beget/internal/client.go index d8d300606..9b9746ba2 100644 --- a/providers/dns/beget/internal/client.go +++ b/providers/dns/beget/internal/client.go @@ -114,6 +114,7 @@ func (c *Client) doRequest(ctx context.Context, data any, fragments ...string) ( } var apiResp APIResponse + err = json.Unmarshal(raw, &apiResp) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -126,6 +127,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var apiResp APIResponse + err := json.Unmarshal(raw, &apiResp) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/beget/internal/types.go b/providers/dns/beget/internal/types.go index 90766da79..f453bf628 100644 --- a/providers/dns/beget/internal/types.go +++ b/providers/dns/beget/internal/types.go @@ -78,7 +78,7 @@ type GetRecordsRequest struct { // ChangeRecordsRequest data representation for data change request. type ChangeRecordsRequest struct { Fqdn string `json:"fqdn,omitempty"` - Records RecordList `json:"records,omitempty"` + Records RecordList `json:"records"` } // RecordList List of entries (in this case only described TXT). diff --git a/providers/dns/binarylane/binarylane.go b/providers/dns/binarylane/binarylane.go index 83016fff7..9ff80d698 100644 --- a/providers/dns/binarylane/binarylane.go +++ b/providers/dns/binarylane/binarylane.go @@ -141,6 +141,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("binarylane: unknown record ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/binarylane/binarylane_test.go b/providers/dns/binarylane/binarylane_test.go index 9519fe0f2..4f2cfd230 100644 --- a/providers/dns/binarylane/binarylane_test.go +++ b/providers/dns/binarylane/binarylane_test.go @@ -35,6 +35,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -94,6 +95,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -107,6 +109,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/binarylane/internal/client.go b/providers/dns/binarylane/internal/client.go index 45518cb41..3f10e9f8b 100644 --- a/providers/dns/binarylane/internal/client.go +++ b/providers/dns/binarylane/internal/client.go @@ -57,6 +57,7 @@ func (c *Client) CreateRecord(ctx context.Context, domain string, record Record) } var result APIResponse + err = c.do(req, &result) if err != nil { return nil, err @@ -137,6 +138,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/binarylane/internal/types.go b/providers/dns/binarylane/internal/types.go index e6c27410a..987e5c356 100644 --- a/providers/dns/binarylane/internal/types.go +++ b/providers/dns/binarylane/internal/types.go @@ -15,13 +15,15 @@ type APIError struct { } func (a *APIError) Error() string { - msg := fmt.Sprintf("%d: %s: %s: %s: %s", a.Status, a.Type, a.Title, a.Detail, a.Instance) + var msg strings.Builder + + msg.WriteString(fmt.Sprintf("%d: %s: %s: %s: %s", a.Status, a.Type, a.Title, a.Detail, a.Instance)) for s, values := range a.Errors { - msg += fmt.Sprintf(": %s: %s", s, strings.Join(values, ", ")) + msg.WriteString(fmt.Sprintf(": %s: %s", s, strings.Join(values, ", "))) } - return msg + return msg.String() } type Record struct { diff --git a/providers/dns/bindman/bindman.go b/providers/dns/bindman/bindman.go index bd026bf74..c529cb63c 100644 --- a/providers/dns/bindman/bindman.go +++ b/providers/dns/bindman/bindman.go @@ -98,6 +98,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err := d.client.AddRecord(info.EffectiveFQDN, "TXT", info.Value); err != nil { return fmt.Errorf("bindman: %w", err) } + return nil } @@ -108,6 +109,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err := d.client.RemoveRecord(info.EffectiveFQDN, "TXT"); err != nil { return fmt.Errorf("bindman: %w", err) } + return nil } diff --git a/providers/dns/bindman/bindman_test.go b/providers/dns/bindman/bindman_test.go index 15db9c424..978a1d006 100644 --- a/providers/dns/bindman/bindman_test.go +++ b/providers/dns/bindman/bindman_test.go @@ -46,6 +46,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -215,6 +216,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -228,6 +230,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/bluecat/bluecat_test.go b/providers/dns/bluecat/bluecat_test.go index 5a3670e3a..38b110470 100644 --- a/providers/dns/bluecat/bluecat_test.go +++ b/providers/dns/bluecat/bluecat_test.go @@ -105,6 +105,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -219,6 +220,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -232,6 +234,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/bluecat/internal/client.go b/providers/dns/bluecat/internal/client.go index de31579ea..d517ea857 100644 --- a/providers/dns/bluecat/internal/client.go +++ b/providers/dns/bluecat/internal/client.go @@ -106,6 +106,7 @@ func (c *Client) AddEntity(ctx context.Context, parentID uint, entity Entity) (u // addEntity responds only with body text containing the ID of the created record addTxtResp := string(raw) + id, err := strconv.ParseUint(addTxtResp, 10, 64) if err != nil { return 0, fmt.Errorf("addEntity request failed: %s", addTxtResp) @@ -147,6 +148,7 @@ func (c *Client) GetEntityByName(ctx context.Context, parentID uint, name, objTy } var entity EntityResponse + err = json.Unmarshal(raw, &entity) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/bluecat/internal/client_test.go b/providers/dns/bluecat/internal/client_test.go index 9d79f46b3..d4776b8a1 100644 --- a/providers/dns/bluecat/internal/client_test.go +++ b/providers/dns/bluecat/internal/client_test.go @@ -31,6 +31,7 @@ func TestClient_LookupParentZoneID(t *testing.T) { Type: ZoneType, Properties: "test", }) + return } diff --git a/providers/dns/bookmyname/bookmyname_test.go b/providers/dns/bookmyname/bookmyname_test.go index dd02d63d7..8b3fa21e6 100644 --- a/providers/dns/bookmyname/bookmyname_test.go +++ b/providers/dns/bookmyname/bookmyname_test.go @@ -50,6 +50,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -122,6 +123,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -135,6 +137,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/brandit/brandit.go b/providers/dns/brandit/brandit.go index 012e5ad15..fe3b52239 100644 --- a/providers/dns/brandit/brandit.go +++ b/providers/dns/brandit/brandit.go @@ -168,6 +168,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordsMu.Lock() dnsRecord, ok := d.records[token] d.recordsMu.Unlock() + if !ok { return fmt.Errorf("brandit: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } @@ -186,6 +187,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var recordID int + for i, r := range records.RR { if r == dnsRecord { recordID = i diff --git a/providers/dns/brandit/brandit_test.go b/providers/dns/brandit/brandit_test.go index 156e7c3f4..40abdd3d0 100644 --- a/providers/dns/brandit/brandit_test.go +++ b/providers/dns/brandit/brandit_test.go @@ -48,6 +48,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -120,6 +121,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -133,6 +135,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/brandit/internal/client.go b/providers/dns/brandit/internal/client.go index 59c57419a..cda3be5a2 100644 --- a/providers/dns/brandit/internal/client.go +++ b/providers/dns/brandit/internal/client.go @@ -62,6 +62,7 @@ func (c *Client) ListRecords(ctx context.Context, account, dnsZone string) (*Lis query.Add("first", strconv.Itoa(result.Response.Last[0]+1)) tmp := &Response[*ListRecordsResponse]{} + err := c.do(ctx, query, tmp) if err != nil { return nil, err @@ -156,6 +157,7 @@ func (c *Client) do(ctx context.Context, query url.Values, result any) error { // Unmarshal the error response, because the API returns a 200 OK even if there is an error. var apiError APIError + err = json.Unmarshal(raw, &apiError) if err != nil { return errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -183,6 +185,7 @@ func sign(apiUsername, apiKey string, query url.Values) (url.Values, error) { canonicalRequest := fmt.Sprintf("%s%s%s", apiUsername, timestamp, defaultBaseURL) mac := hmac.New(sha256.New, []byte(apiKey)) + _, err := mac.Write([]byte(canonicalRequest)) if err != nil { return nil, err diff --git a/providers/dns/bunny/bunny.go b/providers/dns/bunny/bunny.go index 67febeca6..29949608b 100644 --- a/providers/dns/bunny/bunny.go +++ b/providers/dns/bunny/bunny.go @@ -159,10 +159,12 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var record *bunny.DNSRecord + for _, r := range zone.Records { if ptr.Deref(r.Name) == subDomain && ptr.Deref(r.Type) == bunny.DNSRecordTypeTXT { r := r record = &r + break } } @@ -198,6 +200,7 @@ func findZone(zones *bunny.DNSZones, domain string) *bunny.DNSZone { var domainLength int var zone *bunny.DNSZone + for _, item := range zones.Items { if item == nil { continue diff --git a/providers/dns/bunny/bunny_test.go b/providers/dns/bunny/bunny_test.go index 4cf0f6b01..ca4e821e0 100644 --- a/providers/dns/bunny/bunny_test.go +++ b/providers/dns/bunny/bunny_test.go @@ -40,6 +40,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -107,6 +108,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -120,6 +122,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/checkdomain/checkdomain.go b/providers/dns/checkdomain/checkdomain.go index c615f5733..4bc926ed9 100644 --- a/providers/dns/checkdomain/checkdomain.go +++ b/providers/dns/checkdomain/checkdomain.go @@ -73,6 +73,7 @@ func NewDNSProvider() (*DNSProvider, error) { if err != nil { return nil, fmt.Errorf("checkdomain: invalid %s: %w", EnvEndpoint, err) } + config.Endpoint = endpoint return NewDNSProviderConfig(config) diff --git a/providers/dns/checkdomain/checkdomain_test.go b/providers/dns/checkdomain/checkdomain_test.go index d9d0b62a6..b2c940f7a 100644 --- a/providers/dns/checkdomain/checkdomain_test.go +++ b/providers/dns/checkdomain/checkdomain_test.go @@ -46,6 +46,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -108,6 +109,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -121,6 +123,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/checkdomain/internal/client.go b/providers/dns/checkdomain/internal/client.go index 74189dee4..d626275ab 100644 --- a/providers/dns/checkdomain/internal/client.go +++ b/providers/dns/checkdomain/internal/client.go @@ -63,6 +63,7 @@ func (c *Client) GetDomainIDByName(ctx context.Context, name string) (int, error c.domainIDMu.Lock() id, ok := c.domainIDMapping[name] c.domainIDMu.Unlock() + if ok { return id, nil } @@ -100,6 +101,7 @@ func (c *Client) listDomains(ctx context.Context) ([]*Domain, error) { totalPages := maxInt var domainList []*Domain + for currentPage <= totalPages { q.Set("page", strconv.Itoa(currentPage)) endpoint.RawQuery = q.Encode() @@ -151,6 +153,7 @@ func (c *Client) CheckNameservers(ctx context.Context, domainID int) error { } var found1, found2 bool + for _, item := range info.Nameservers { switch item.Name { case ns1: @@ -229,6 +232,7 @@ func (c *Client) getDomainInfo(ctx context.Context, domainID int) (*DomainRespon } var res DomainResponse + err = c.do(req, &res) if err != nil { return nil, err @@ -242,6 +246,7 @@ func (c *Client) listRecords(ctx context.Context, domainID int, recordType strin q := endpoint.Query() q.Set("limit", strconv.Itoa(maxLimit)) + if recordType != "" { q.Set("type", recordType) } @@ -250,6 +255,7 @@ func (c *Client) listRecords(ctx context.Context, domainID int, recordType strin totalPages := maxInt var recordList []*Record + for currentPage <= totalPages { q.Set("page", strconv.Itoa(currentPage)) endpoint.RawQuery = q.Encode() diff --git a/providers/dns/civo/civo.go b/providers/dns/civo/civo.go index a6af01e8a..dfb7c307f 100644 --- a/providers/dns/civo/civo.go +++ b/providers/dns/civo/civo.go @@ -169,6 +169,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var dnsRecord internal.Record + for _, entry := range dnsRecords { if entry.Name == subDomain && entry.Value == info.Value { dnsRecord = entry diff --git a/providers/dns/civo/civo_test.go b/providers/dns/civo/civo_test.go index 9b9e98b38..416dbac1d 100644 --- a/providers/dns/civo/civo_test.go +++ b/providers/dns/civo/civo_test.go @@ -42,6 +42,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -106,6 +107,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -119,6 +121,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/civo/internal/client.go b/providers/dns/civo/internal/client.go index 25a11ef60..dc1d57793 100644 --- a/providers/dns/civo/internal/client.go +++ b/providers/dns/civo/internal/client.go @@ -188,6 +188,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/civo/internal/client_test.go b/providers/dns/civo/internal/client_test.go index 5b47c185e..ad56b75de 100644 --- a/providers/dns/civo/internal/client_test.go +++ b/providers/dns/civo/internal/client_test.go @@ -93,7 +93,6 @@ func TestClient_ListDNSRecords_error_raw(t *testing.T) { // > So, for example, 404 Not Found pages are a standard page of text // > but 403 Unauthorized requests may have a reason attribute available in the JSON object. // https://www.civo.com/api#parameters-and-responses - client := mockBuilder(). Route("GET /dns/7088fcea-7658-43e6-97fa-273f901978fd/records", servermock.RawStringResponse(http.StatusText(http.StatusNotFound)). diff --git a/providers/dns/clouddns/clouddns_test.go b/providers/dns/clouddns/clouddns_test.go index d7bfc4a1f..f1e2a196e 100644 --- a/providers/dns/clouddns/clouddns_test.go +++ b/providers/dns/clouddns/clouddns_test.go @@ -63,6 +63,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -148,6 +149,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -161,6 +163,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/clouddns/internal/client.go b/providers/dns/clouddns/internal/client.go index cd3da50c7..9fb6902de 100644 --- a/providers/dns/clouddns/internal/client.go +++ b/providers/dns/clouddns/internal/client.go @@ -122,6 +122,7 @@ func (c *Client) getDomain(ctx context.Context, zone string) (Domain, error) { } var result SearchResponse + err = c.do(req, &result) if err != nil { return Domain{}, err @@ -143,6 +144,7 @@ func (c *Client) getRecord(ctx context.Context, domainID, recordName string) (Re } var result DomainInfo + err = c.do(req, &result) if err != nil { return Record{}, err @@ -232,6 +234,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var response APIError + err := json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/clouddns/internal/identity.go b/providers/dns/clouddns/internal/identity.go index 4ea5c5049..6b20ad814 100644 --- a/providers/dns/clouddns/internal/identity.go +++ b/providers/dns/clouddns/internal/identity.go @@ -20,6 +20,7 @@ func (c *Client) login(ctx context.Context) (*AuthResponse, error) { } var result AuthResponse + err = c.do(req, &result) if err != nil { return nil, err diff --git a/providers/dns/clouddns/internal/types.go b/providers/dns/clouddns/internal/types.go index a53c958a7..9de11d848 100644 --- a/providers/dns/clouddns/internal/types.go +++ b/providers/dns/clouddns/internal/types.go @@ -21,7 +21,7 @@ type Authorization struct { } type AuthResponse struct { - Auth Auth `json:"auth,omitempty"` + Auth Auth `json:"auth"` } type Auth struct { diff --git a/providers/dns/cloudflare/cloudflare.go b/providers/dns/cloudflare/cloudflare.go index 081025f34..98b3495bb 100644 --- a/providers/dns/cloudflare/cloudflare.go +++ b/providers/dns/cloudflare/cloudflare.go @@ -104,6 +104,7 @@ func NewDNSProvider() (*DNSProvider, error) { ) if err != nil { var errT error + values, errT = env.GetWithFallback( []string{EnvDNSAPIToken, altEnvName(EnvDNSAPIToken)}, []string{EnvZoneAPIToken, altEnvName(EnvZoneAPIToken), EnvDNSAPIToken, altEnvName(EnvDNSAPIToken)}, @@ -209,6 +210,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("cloudflare: unknown record ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/cloudflare/cloudflare_test.go b/providers/dns/cloudflare/cloudflare_test.go index 14d20ef2d..8de9dd848 100644 --- a/providers/dns/cloudflare/cloudflare_test.go +++ b/providers/dns/cloudflare/cloudflare_test.go @@ -81,6 +81,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -177,15 +178,18 @@ func TestNewDNSProviderWithToken(t *testing.T) { } defer envTest.RestoreEnv() + localEnvTest := tester.NewEnvTest( EnvDNSAPIToken, altEnvName(EnvDNSAPIToken), EnvZoneAPIToken, altEnvName(EnvZoneAPIToken), ).WithDomain(envDomain) + envTest.ClearEnv() for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer localEnvTest.RestoreEnv() + localEnvTest.ClearEnv() localEnvTest.Apply(test.envVars) @@ -200,6 +204,7 @@ func TestNewDNSProviderWithToken(t *testing.T) { require.NotNil(t, p) assert.Equal(t, test.expected.dnsToken, p.config.AuthToken) assert.Equal(t, test.expected.zoneToken, p.config.ZoneToken) + if test.expected.sameClient { assert.Equal(t, p.client.clientRead, p.client.clientEdit) } else { @@ -275,6 +280,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -288,6 +294,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/cloudflare/internal/client.go b/providers/dns/cloudflare/internal/client.go index 33b7b1ba8..b63612ce2 100644 --- a/providers/dns/cloudflare/internal/client.go +++ b/providers/dns/cloudflare/internal/client.go @@ -192,6 +192,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var response APIResponse[any] + err := json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/cloudflare/internal/types.go b/providers/dns/cloudflare/internal/types.go index 2b6d2e2b6..4a7f9e031 100644 --- a/providers/dns/cloudflare/internal/types.go +++ b/providers/dns/cloudflare/internal/types.go @@ -1,6 +1,9 @@ package internal -import "fmt" +import ( + "fmt" + "strings" +) type Record struct { ID string `json:"id,omitempty"` @@ -39,17 +42,17 @@ type ErrorChain struct { type Errors []Message func (e Errors) Error() string { - var msg string + var msg strings.Builder for _, item := range e { - msg = fmt.Sprintf("%d: %s", item.Code, item.Message) + msg.WriteString(fmt.Sprintf("%d: %s", item.Code, item.Message)) for _, link := range item.ErrorChain { - msg += fmt.Sprintf("; %d: %s", link.Code, link.Message) + msg.WriteString(fmt.Sprintf("; %d: %s", link.Code, link.Message)) } } - return msg + return msg.String() } type ResultInfo struct { diff --git a/providers/dns/cloudflare/wrapper.go b/providers/dns/cloudflare/wrapper.go index 1ab36800d..286c20ecd 100644 --- a/providers/dns/cloudflare/wrapper.go +++ b/providers/dns/cloudflare/wrapper.go @@ -99,6 +99,7 @@ func (m *metaClient) ZoneIDByName(ctx context.Context, fdqn string) (string, err m.zonesMu.Lock() m.zones[fdqn] = id m.zonesMu.Unlock() + return id, nil } diff --git a/providers/dns/cloudns/cloudns.go b/providers/dns/cloudns/cloudns.go index 39a4d45cd..916d73bde 100644 --- a/providers/dns/cloudns/cloudns.go +++ b/providers/dns/cloudns/cloudns.go @@ -68,6 +68,7 @@ type DNSProvider struct { // CLOUDNS_AUTH_ID and CLOUDNS_AUTH_PASSWORD. func NewDNSProvider() (*DNSProvider, error) { var subAuthID string + authID := env.GetOrFile(EnvAuthID) if authID == "" { subAuthID = env.GetOrFile(EnvSubAuthID) diff --git a/providers/dns/cloudns/cloudns_test.go b/providers/dns/cloudns/cloudns_test.go index ea4f25c95..024bd93d8 100644 --- a/providers/dns/cloudns/cloudns_test.go +++ b/providers/dns/cloudns/cloudns_test.go @@ -79,6 +79,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -169,6 +170,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -182,6 +184,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/cloudns/internal/client.go b/providers/dns/cloudns/internal/client.go index 60d7e6bbe..278b8de49 100644 --- a/providers/dns/cloudns/internal/client.go +++ b/providers/dns/cloudns/internal/client.go @@ -171,6 +171,7 @@ func (c *Client) ListTxtRecords(ctx context.Context, zoneName, fqdn string) ([]T } var records []TXTRecord + for _, record := range raw { if record.Host == subDomain && record.Type == "TXT" { records = append(records, record) @@ -279,6 +280,7 @@ func (c *Client) GetUpdateStatus(ctx context.Context, zoneName string) (*SyncPro } updatedCount := 0 + for _, record := range records { if record.Updated { updatedCount++ diff --git a/providers/dns/cloudns/internal/client_test.go b/providers/dns/cloudns/internal/client_test.go index dbfa32aee..b9f6c5431 100644 --- a/providers/dns/cloudns/internal/client_test.go +++ b/providers/dns/cloudns/internal/client_test.go @@ -19,6 +19,7 @@ func setupClient(subAuthID string) func(server *httptest.Server) (*Client, error client.BaseURL, _ = url.Parse(server.URL) client.HTTPClient = server.Client() + return client, nil } } diff --git a/providers/dns/cloudru/cloudru_test.go b/providers/dns/cloudru/cloudru_test.go index 88addde93..3e506cb1c 100644 --- a/providers/dns/cloudru/cloudru_test.go +++ b/providers/dns/cloudru/cloudru_test.go @@ -67,6 +67,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -153,6 +154,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -166,6 +168,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/cloudru/internal/client.go b/providers/dns/cloudru/internal/client.go index cb62c5bca..a00ae6ea8 100644 --- a/providers/dns/cloudru/internal/client.go +++ b/providers/dns/cloudru/internal/client.go @@ -61,6 +61,7 @@ func (c *Client) GetZones(ctx context.Context, parentID string) ([]Zone, error) } var zones APIResponse[Zone] + err = c.do(req, &zones) if err != nil { return nil, err @@ -78,6 +79,7 @@ func (c *Client) GetRecords(ctx context.Context, zoneID string) ([]Record, error } var records APIResponse[Record] + err = c.do(req, &records) if err != nil { return nil, err @@ -95,6 +97,7 @@ func (c *Client) CreateRecord(ctx context.Context, zoneID string, record Record) } var result Record + err = c.do(req, &result) if err != nil { return nil, err diff --git a/providers/dns/cloudru/internal/identity.go b/providers/dns/cloudru/internal/identity.go index 79df3c297..3bb09f3fa 100644 --- a/providers/dns/cloudru/internal/identity.go +++ b/providers/dns/cloudru/internal/identity.go @@ -49,6 +49,7 @@ func (c *Client) obtainToken(ctx context.Context) (*Token, error) { } tok := Token{} + err = json.Unmarshal(raw, &tok) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -88,6 +89,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errResp := &authResponseError{} + err := json.Unmarshal(raw, errResp) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/cloudru/internal/types.go b/providers/dns/cloudru/internal/types.go index d233c73bc..713fd459a 100644 --- a/providers/dns/cloudru/internal/types.go +++ b/providers/dns/cloudru/internal/types.go @@ -38,9 +38,9 @@ type Zone struct { Valid bool `json:"valid,omitempty"` ValidationText string `json:"validationText,omitempty"` Delegated bool `json:"delegated,omitempty"` - LastCheck time.Time `json:"lastCheck,omitempty"` - CreatedAt time.Time `json:"created_at,omitempty"` - UpdatedAt time.Time `json:"updated_at,omitempty"` + LastCheck time.Time `json:"lastCheck,omitzero"` + CreatedAt time.Time `json:"created_at,omitzero"` + UpdatedAt time.Time `json:"updated_at,omitzero"` } type Record struct { diff --git a/providers/dns/conoha/conoha_test.go b/providers/dns/conoha/conoha_test.go index 9db5ba79f..c1c445d48 100644 --- a/providers/dns/conoha/conoha_test.go +++ b/providers/dns/conoha/conoha_test.go @@ -72,6 +72,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -155,6 +156,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -168,6 +170,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/conoha/internal/client.go b/providers/dns/conoha/internal/client.go index 60d7fd6dc..2f039489b 100644 --- a/providers/dns/conoha/internal/client.go +++ b/providers/dns/conoha/internal/client.go @@ -124,6 +124,7 @@ func (c *Client) createRecord(ctx context.Context, domainID string, record Recor } newRecord := &Record{} + err = c.do(req, newRecord) if err != nil { return nil, err diff --git a/providers/dns/conoha/internal/client_test.go b/providers/dns/conoha/internal/client_test.go index 0b9242c08..5e06ffc1d 100644 --- a/providers/dns/conoha/internal/client_test.go +++ b/providers/dns/conoha/internal/client_test.go @@ -97,6 +97,7 @@ func TestClient_CreateRecord(t *testing.T) { http.Error(rw, err.Error(), http.StatusBadRequest) return } + defer func() { _ = req.Body.Close() }() if string(bytes.TrimSpace(raw)) != `{"name":"lego.com.","type":"TXT","data":"txtTXTtxt","ttl":300}` { @@ -109,6 +110,7 @@ func TestClient_CreateRecord(t *testing.T) { http.Error(rw, err.Error(), http.StatusInternalServerError) return } + defer func() { _ = file.Close() }() _, _ = io.Copy(rw, file) diff --git a/providers/dns/conohav3/conohav3_test.go b/providers/dns/conohav3/conohav3_test.go index 7bba8f0b5..d68ea3ebb 100644 --- a/providers/dns/conohav3/conohav3_test.go +++ b/providers/dns/conohav3/conohav3_test.go @@ -72,6 +72,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -155,6 +156,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -168,6 +170,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/conohav3/internal/client.go b/providers/dns/conohav3/internal/client.go index fcbd7f5ac..2a9e7c2bc 100644 --- a/providers/dns/conohav3/internal/client.go +++ b/providers/dns/conohav3/internal/client.go @@ -124,6 +124,7 @@ func (c *Client) createRecord(ctx context.Context, domainID string, record Recor } newRecord := &Record{} + err = c.do(req, newRecord) if err != nil { return nil, err diff --git a/providers/dns/conohav3/internal/client_test.go b/providers/dns/conohav3/internal/client_test.go index babdadf7e..66babae49 100644 --- a/providers/dns/conohav3/internal/client_test.go +++ b/providers/dns/conohav3/internal/client_test.go @@ -98,6 +98,7 @@ func TestClient_CreateRecord(t *testing.T) { http.Error(rw, err.Error(), http.StatusBadRequest) return } + defer func() { _ = req.Body.Close() }() if string(bytes.TrimSpace(raw)) != `{"name":"lego.com.","type":"TXT","data":"txtTXTtxt","ttl":300}` { @@ -110,6 +111,7 @@ func TestClient_CreateRecord(t *testing.T) { http.Error(rw, err.Error(), http.StatusInternalServerError) return } + defer func() { _ = file.Close() }() _, _ = io.Copy(rw, file) diff --git a/providers/dns/conohav3/internal/identity.go b/providers/dns/conohav3/internal/identity.go index 3bb7355ae..6a9ad7f1e 100644 --- a/providers/dns/conohav3/internal/identity.go +++ b/providers/dns/conohav3/internal/identity.go @@ -53,6 +53,7 @@ func (c *Identifier) do(req *http.Request) (string, error) { if err != nil { return "", errutils.NewHTTPDoError(req, err) } + defer func() { _ = resp.Body.Close() }() if resp.StatusCode != http.StatusCreated { diff --git a/providers/dns/constellix/constellix.go b/providers/dns/constellix/constellix.go index 66543903a..777e93308 100644 --- a/providers/dns/constellix/constellix.go +++ b/providers/dns/constellix/constellix.go @@ -200,6 +200,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("constellix: failed to delete TXT records: %w", err) } + return nil } diff --git a/providers/dns/constellix/constellix_test.go b/providers/dns/constellix/constellix_test.go index e3a30caca..e38258292 100644 --- a/providers/dns/constellix/constellix_test.go +++ b/providers/dns/constellix/constellix_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -129,6 +130,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -142,6 +144,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/constellix/internal/auth.go b/providers/dns/constellix/internal/auth.go index 1a136012d..9193572eb 100644 --- a/providers/dns/constellix/internal/auth.go +++ b/providers/dns/constellix/internal/auth.go @@ -28,6 +28,7 @@ func NewTokenTransport(apiKey, secretKey string) (*TokenTransport, error) { if apiKey == "" { return nil, errors.New("credentials missing: API key") } + if secretKey == "" { return nil, errors.New("credentials missing: secret key") } @@ -57,6 +58,7 @@ func (t *TokenTransport) transport() http.RoundTripper { if t.Transport != nil { return t.Transport } + return http.DefaultTransport } diff --git a/providers/dns/constellix/internal/domains.go b/providers/dns/constellix/internal/domains.go index 485f0d537..fa7027f55 100644 --- a/providers/dns/constellix/internal/domains.go +++ b/providers/dns/constellix/internal/domains.go @@ -30,10 +30,12 @@ func (s *DomainService) GetAll(ctx context.Context, params *PaginationParameters if errQ != nil { return nil, errQ } + req.URL.RawQuery = v.Encode() } var domains []Domain + err = s.client.do(req, &domains) if err != nil { return nil, err @@ -78,6 +80,7 @@ func (s *DomainService) Search(ctx context.Context, filter searchFilter, value s req.URL.RawQuery = query.Encode() var domains []Domain + err = s.client.do(req, &domains) if err != nil { var nf *NotFound diff --git a/providers/dns/constellix/internal/txtrecords.go b/providers/dns/constellix/internal/txtrecords.go index 7880da4d2..bd00d84b7 100644 --- a/providers/dns/constellix/internal/txtrecords.go +++ b/providers/dns/constellix/internal/txtrecords.go @@ -32,6 +32,7 @@ func (s *TxtRecordService) Create(ctx context.Context, domainID int64, record Re } var records []Record + err = s.client.do(req, &records) if err != nil { return nil, err @@ -54,6 +55,7 @@ func (s *TxtRecordService) GetAll(ctx context.Context, domainID int64) ([]Record } var records []Record + err = s.client.do(req, &records) if err != nil { return nil, err @@ -76,6 +78,7 @@ func (s *TxtRecordService) Get(ctx context.Context, domainID, recordID int64) (* } var records Record + err = s.client.do(req, &records) if err != nil { return nil, err @@ -103,6 +106,7 @@ func (s *TxtRecordService) Update(ctx context.Context, domainID, recordID int64, } var msg SuccessMessage + err = s.client.do(req, &msg) if err != nil { return nil, err @@ -125,6 +129,7 @@ func (s *TxtRecordService) Delete(ctx context.Context, domainID, recordID int64) } var msg *SuccessMessage + err = s.client.do(req, &msg) if err != nil { return nil, err diff --git a/providers/dns/corenetworks/corenetworks_test.go b/providers/dns/corenetworks/corenetworks_test.go index 3cd80f88d..911693468 100644 --- a/providers/dns/corenetworks/corenetworks_test.go +++ b/providers/dns/corenetworks/corenetworks_test.go @@ -43,6 +43,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -111,6 +112,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -124,6 +126,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/corenetworks/internal/client.go b/providers/dns/corenetworks/internal/client.go index ea2d7efa2..bdc17f2c1 100644 --- a/providers/dns/corenetworks/internal/client.go +++ b/providers/dns/corenetworks/internal/client.go @@ -47,6 +47,7 @@ func (c *Client) ListZone(ctx context.Context) ([]Zone, error) { } var zones []Zone + err = c.do(req, &zones) if err != nil { return nil, err @@ -66,6 +67,7 @@ func (c *Client) GetZoneDetails(ctx context.Context, zone string) (*ZoneDetails, } var details ZoneDetails + err = c.do(req, &details) if err != nil { return nil, err @@ -85,6 +87,7 @@ func (c *Client) ListRecords(ctx context.Context, zone string) ([]Record, error) } var records []Record + err = c.do(req, &records) if err != nil { return nil, err diff --git a/providers/dns/corenetworks/internal/identity.go b/providers/dns/corenetworks/internal/identity.go index 8f5a2ee9a..a7e7448c0 100644 --- a/providers/dns/corenetworks/internal/identity.go +++ b/providers/dns/corenetworks/internal/identity.go @@ -22,6 +22,7 @@ func (c *Client) CreateAuthenticationToken(ctx context.Context) (*Token, error) } var token Token + err = c.do(req, &token) if err != nil { return nil, err diff --git a/providers/dns/cpanel/cpanel.go b/providers/dns/cpanel/cpanel.go index a61a05c81..f335c0a8c 100644 --- a/providers/dns/cpanel/cpanel.go +++ b/providers/dns/cpanel/cpanel.go @@ -147,12 +147,16 @@ func (d *DNSProvider) Present(domain, _, keyAuth string) error { valueB64 := base64.StdEncoding.EncodeToString([]byte(info.Value)) - var found bool - var existingRecord shared.ZoneRecord + var ( + found bool + existingRecord shared.ZoneRecord + ) + for _, record := range zoneInfo { if slices.Contains(record.DataB64, valueB64) { existingRecord = record found = true + break } } @@ -221,12 +225,16 @@ func (d *DNSProvider) CleanUp(domain, _, keyAuth string) error { valueB64 := base64.StdEncoding.EncodeToString([]byte(info.Value)) - var found bool - var existingRecord shared.ZoneRecord + var ( + found bool + existingRecord shared.ZoneRecord + ) + for _, record := range zoneInfo { if slices.Contains(record.DataB64, valueB64) { existingRecord = record found = true + break } } @@ -236,6 +244,7 @@ func (d *DNSProvider) CleanUp(domain, _, keyAuth string) error { } var newData []string + for _, dataB64 := range existingRecord.DataB64 { if dataB64 == valueB64 { continue @@ -292,6 +301,7 @@ func getZoneSerial(zoneFqdn string, zoneInfo []shared.ZoneRecord) (uint32, error } var newSerial uint32 + _, err = fmt.Sscan(string(data), &newSerial) if err != nil { return 0, fmt.Errorf("decode serial DNameB64, invalid serial value %q: %w", string(data), err) diff --git a/providers/dns/cpanel/cpanel_test.go b/providers/dns/cpanel/cpanel_test.go index 614b9e1c7..5d85b8b5b 100644 --- a/providers/dns/cpanel/cpanel_test.go +++ b/providers/dns/cpanel/cpanel_test.go @@ -75,6 +75,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -282,6 +283,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -295,6 +297,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/cpanel/internal/cpanel/types.go b/providers/dns/cpanel/internal/cpanel/types.go index cb4dbd535..0a3053647 100644 --- a/providers/dns/cpanel/internal/cpanel/types.go +++ b/providers/dns/cpanel/internal/cpanel/types.go @@ -6,7 +6,7 @@ import ( ) type APIResponse[T any] struct { - Metadata Metadata `json:"metadata,omitempty"` + Metadata Metadata `json:"metadata"` Data T `json:"data,omitempty"` Status int `json:"status,omitempty"` diff --git a/providers/dns/cpanel/internal/whm/types.go b/providers/dns/cpanel/internal/whm/types.go index f1884a04d..d0604a565 100644 --- a/providers/dns/cpanel/internal/whm/types.go +++ b/providers/dns/cpanel/internal/whm/types.go @@ -7,7 +7,7 @@ import ( ) type APIResponse[T any] struct { - Metadata Metadata `json:"metadata,omitempty"` + Metadata Metadata `json:"metadata"` Data T `json:"data,omitempty"` } diff --git a/providers/dns/derak/derak.go b/providers/dns/derak/derak.go index 8a05d7608..78165b936 100644 --- a/providers/dns/derak/derak.go +++ b/providers/dns/derak/derak.go @@ -163,6 +163,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("derak: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/derak/derak_test.go b/providers/dns/derak/derak_test.go index e58cfb6c1..b83eb2c8c 100644 --- a/providers/dns/derak/derak_test.go +++ b/providers/dns/derak/derak_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -92,6 +93,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -105,6 +107,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/derak/internal/client.go b/providers/dns/derak/internal/client.go index a7c11f895..4352e198b 100644 --- a/providers/dns/derak/internal/client.go +++ b/providers/dns/derak/internal/client.go @@ -44,6 +44,7 @@ func (c *Client) GetRecords(ctx context.Context, zoneID string, params *GetRecor if err != nil { return nil, err } + endpoint.RawQuery = v.Encode() req, err := newJSONRequest(ctx, http.MethodGet, endpoint, nil) @@ -52,6 +53,7 @@ func (c *Client) GetRecords(ctx context.Context, zoneID string, params *GetRecor } response := &GetRecordsResponse{} + err = c.do(req, response) if err != nil { return nil, err @@ -70,6 +72,7 @@ func (c *Client) GetRecord(ctx context.Context, zoneID, recordID string) (*Recor } response := &Record{} + err = c.do(req, response) if err != nil { return nil, err @@ -88,6 +91,7 @@ func (c *Client) CreateRecord(ctx context.Context, zoneID string, record Record) } response := &Record{} + err = c.do(req, response) if err != nil { return nil, err @@ -106,6 +110,7 @@ func (c *Client) EditRecord(ctx context.Context, zoneID, recordID string, record } response := &Record{} + err = c.do(req, response) if err != nil { return nil, err @@ -147,6 +152,7 @@ func (c *Client) GetZones(ctx context.Context) ([]Zone, error) { } response := &APIResponse[[]Zone]{} + err = c.do(req, response) if err != nil { return nil, err @@ -221,6 +227,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var response APIResponse[any] + err := json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/derak/internal/types.go b/providers/dns/derak/internal/types.go index 15ed00617..02116314f 100644 --- a/providers/dns/derak/internal/types.go +++ b/providers/dns/derak/internal/types.go @@ -46,7 +46,7 @@ type Zone struct { HumanReadable string `json:"humanReadable,omitempty"` Serial string `json:"serial,omitempty"` CreationTime int64 `json:"creationTime,omitempty"` - CreationTimeDate time.Time `json:"creationTimeDate,omitempty"` + CreationTimeDate time.Time `json:"creationTimeDate,omitzero"` Status string `json:"status,omitempty"` IsMoved bool `json:"is_moved,omitempty"` Paused bool `json:"paused,omitempty"` diff --git a/providers/dns/desec/desec.go b/providers/dns/desec/desec.go index 08aebc2b4..75618b943 100644 --- a/providers/dns/desec/desec.go +++ b/providers/dns/desec/desec.go @@ -184,6 +184,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } records := make([]string, 0) + for _, record := range rrSet.Records { if record != fmt.Sprintf(`%q`, info.Value) { records = append(records, record) diff --git a/providers/dns/desec/desec_test.go b/providers/dns/desec/desec_test.go index f91f9e82a..93d9bd010 100644 --- a/providers/dns/desec/desec_test.go +++ b/providers/dns/desec/desec_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -93,6 +94,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -106,6 +108,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/designate/designate.go b/providers/dns/designate/designate.go index c58baaace..47c8ad8f1 100644 --- a/providers/dns/designate/designate.go +++ b/providers/dns/designate/designate.go @@ -85,7 +85,6 @@ func NewDNSProvider() (*DNSProvider, error) { opts, erro := clientconfig.AuthOptions(&clientconfig.ClientOpts{ Cloud: val[EnvCloud], }) - if erro != nil { return nil, fmt.Errorf("designate: %w", erro) } @@ -202,6 +201,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("designate: error for %s in CleanUp: %w", info.EffectiveFQDN, err) } + return nil } @@ -241,6 +241,7 @@ func (d *DNSProvider) updateRecord(record *recordsets.RecordSet, value string) e } result := recordsets.Update(d.client, record.ZoneID, record.ID, updateOpts) + return result.Err } diff --git a/providers/dns/designate/designate_test.go b/providers/dns/designate/designate_test.go index 1045baa95..e5edf81f8 100644 --- a/providers/dns/designate/designate_test.go +++ b/providers/dns/designate/designate_test.go @@ -105,6 +105,7 @@ func TestNewDNSProvider_fromEnv(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -192,6 +193,7 @@ func TestNewDNSProvider_fromCloud(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(map[string]string{ @@ -331,6 +333,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -344,6 +347,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/digitalocean/digitalocean.go b/providers/dns/digitalocean/digitalocean.go index f7ae68d60..26c6fb9d4 100644 --- a/providers/dns/digitalocean/digitalocean.go +++ b/providers/dns/digitalocean/digitalocean.go @@ -97,6 +97,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if config.BaseURL != "" { var err error + client.BaseURL, err = url.Parse(config.BaseURL) if err != nil { return nil, fmt.Errorf("digitalocean: %w", err) @@ -152,6 +153,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("digitalocean: unknown record ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/digitalocean/digitalocean_test.go b/providers/dns/digitalocean/digitalocean_test.go index 13f8b522d..d066e12db 100644 --- a/providers/dns/digitalocean/digitalocean_test.go +++ b/providers/dns/digitalocean/digitalocean_test.go @@ -51,6 +51,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) diff --git a/providers/dns/digitalocean/internal/client.go b/providers/dns/digitalocean/internal/client.go index e7dd181b2..395de478c 100644 --- a/providers/dns/digitalocean/internal/client.go +++ b/providers/dns/digitalocean/internal/client.go @@ -45,6 +45,7 @@ func (c *Client) AddTxtRecord(ctx context.Context, zone string, record Record) ( } respData := &TxtRecordResponse{} + err = c.do(req, respData) if err != nil { return nil, err @@ -120,6 +121,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errInfo APIError + err := json.Unmarshal(raw, &errInfo) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/directadmin/directadmin_test.go b/providers/dns/directadmin/directadmin_test.go index 10c079f73..aed3ba505 100644 --- a/providers/dns/directadmin/directadmin_test.go +++ b/providers/dns/directadmin/directadmin_test.go @@ -59,6 +59,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -135,6 +136,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -148,6 +150,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/directadmin/internal/client.go b/providers/dns/directadmin/internal/client.go index bf6d64371..64409a79d 100644 --- a/providers/dns/directadmin/internal/client.go +++ b/providers/dns/directadmin/internal/client.go @@ -94,6 +94,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errInfo APIError + err := json.Unmarshal(raw, &errInfo) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/dns_providers_test.go b/providers/dns/dns_providers_test.go index 1f39e2bdd..3b82784b4 100644 --- a/providers/dns/dns_providers_test.go +++ b/providers/dns/dns_providers_test.go @@ -13,6 +13,7 @@ var envTest = tester.NewEnvTest("EXEC_PATH") func TestKnownDNSProviderSuccess(t *testing.T) { defer envTest.RestoreEnv() + envTest.Apply(map[string]string{ "EXEC_PATH": "abc", }) @@ -26,6 +27,7 @@ func TestKnownDNSProviderSuccess(t *testing.T) { func TestKnownDNSProviderError(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() provider, err := NewDNSChallengeProviderByName("exec") diff --git a/providers/dns/dnshomede/dnshomede.go b/providers/dns/dnshomede/dnshomede.go index e3d56f098..c76ed6de2 100644 --- a/providers/dns/dnshomede/dnshomede.go +++ b/providers/dns/dnshomede/dnshomede.go @@ -57,6 +57,7 @@ type DNSProvider struct { // Credentials must be passed in the environment variable: DNSHOMEDE_CREDENTIALS. func NewDNSProvider() (*DNSProvider, error) { config := NewDefaultConfig() + values, err := env.Get(EnvCredentials) if err != nil { return nil, fmt.Errorf("dnshomede: %w", err) diff --git a/providers/dns/dnshomede/dnshomede_test.go b/providers/dns/dnshomede/dnshomede_test.go index bdb42f172..5035a7837 100644 --- a/providers/dns/dnshomede/dnshomede_test.go +++ b/providers/dns/dnshomede/dnshomede_test.go @@ -69,6 +69,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -144,6 +145,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -157,6 +159,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/dnsimple/dnsimple.go b/providers/dns/dnsimple/dnsimple.go index 4b7df0943..adf7d48e2 100644 --- a/providers/dns/dnsimple/dnsimple.go +++ b/providers/dns/dnsimple/dnsimple.go @@ -145,6 +145,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var lastErr error + for _, rec := range records { _, err := d.client.Zones.DeleteRecord(ctx, accountID, rec.ZoneID, rec.ID) if err != nil { diff --git a/providers/dns/dnsimple/dnsimple_test.go b/providers/dns/dnsimple/dnsimple_test.go index c07f965b4..2a52dd2de 100644 --- a/providers/dns/dnsimple/dnsimple_test.go +++ b/providers/dns/dnsimple/dnsimple_test.go @@ -51,6 +51,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) diff --git a/providers/dns/dnsmadeeasy/dnsmadeeasy.go b/providers/dns/dnsmadeeasy/dnsmadeeasy.go index 7d2f92726..69f2096fb 100644 --- a/providers/dns/dnsmadeeasy/dnsmadeeasy.go +++ b/providers/dns/dnsmadeeasy/dnsmadeeasy.go @@ -155,6 +155,7 @@ func (d *DNSProvider) Present(domainName, token, keyAuth string) error { if err != nil { return fmt.Errorf("dnsmadeeasy: unable to create record for %s: %w", name, err) } + return nil } @@ -177,6 +178,7 @@ func (d *DNSProvider) CleanUp(domainName, token, keyAuth string) error { // find matching records name := strings.Replace(info.EffectiveFQDN, "."+authZone, "", 1) + records, err := d.client.GetRecords(ctx, domain, name, "TXT") if err != nil { return fmt.Errorf("dnsmadeeasy: unable to get records for domain %s: %w", domain.Name, err) @@ -184,6 +186,7 @@ func (d *DNSProvider) CleanUp(domainName, token, keyAuth string) error { // delete records var lastError error + for _, record := range *records { err = d.client.DeleteRecord(ctx, record) if err != nil { diff --git a/providers/dns/dnsmadeeasy/dnsmadeeasy_test.go b/providers/dns/dnsmadeeasy/dnsmadeeasy_test.go index 5c508e60d..f6fc2e273 100644 --- a/providers/dns/dnsmadeeasy/dnsmadeeasy_test.go +++ b/providers/dns/dnsmadeeasy/dnsmadeeasy_test.go @@ -59,6 +59,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -135,6 +136,7 @@ func TestLivePresentAndCleanup(t *testing.T) { os.Setenv(EnvSandbox, "true") envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/dnsmadeeasy/internal/client.go b/providers/dns/dnsmadeeasy/internal/client.go index cb6f9d2cb..7963ad614 100644 --- a/providers/dns/dnsmadeeasy/internal/client.go +++ b/providers/dns/dnsmadeeasy/internal/client.go @@ -68,6 +68,7 @@ func (c *Client) GetDomain(ctx context.Context, authZone string) (*Domain, error } domain := &Domain{} + err = c.do(req, domain) if err != nil { return nil, err @@ -91,6 +92,7 @@ func (c *Client) GetRecords(ctx context.Context, domain *Domain, recordName, rec } records := &recordsResponse{} + err = c.do(req, records) if err != nil { return nil, err @@ -172,10 +174,12 @@ func (c *Client) sign(req *http.Request, timestamp string) error { func computeHMAC(message, secret string) (string, error) { key := []byte(secret) h := hmac.New(sha1.New, key) + _, err := h.Write([]byte(message)) if err != nil { return "", err } + return hex.EncodeToString(h.Sum(nil)), nil } diff --git a/providers/dns/dnspod/dnspod.go b/providers/dns/dnspod/dnspod.go index 46893fe5a..c9376b956 100644 --- a/providers/dns/dnspod/dnspod.go +++ b/providers/dns/dnspod/dnspod.go @@ -135,6 +135,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { return err } } + return nil } @@ -156,6 +157,7 @@ func (d *DNSProvider) getHostedZone(domain string) (string, string, error) { } var hostedZone dnspod.Domain + for _, zone := range zones { if zone.Name == dns01.UnFqdn(authZone) { hostedZone = zone @@ -191,6 +193,7 @@ func (d *DNSProvider) findTxtRecords(fqdn, zoneID, zoneName string) ([]dnspod.Re } var records []dnspod.Record + result, _, err := d.client.Records.List(zoneID, subDomain) if err != nil { return records, fmt.Errorf("API call has failed: %w", err) diff --git a/providers/dns/dnspod/dnspod_test.go b/providers/dns/dnspod/dnspod_test.go index 640ec34c6..5d339353a 100644 --- a/providers/dns/dnspod/dnspod_test.go +++ b/providers/dns/dnspod/dnspod_test.go @@ -37,6 +37,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -96,6 +97,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -109,6 +111,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/dode/dode_test.go b/providers/dns/dode/dode_test.go index 3d8e9395a..fefcc79b1 100644 --- a/providers/dns/dode/dode_test.go +++ b/providers/dns/dode/dode_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -93,6 +94,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -106,6 +108,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/dode/internal/client.go b/providers/dns/dode/internal/client.go index bbd98b399..6824e7c48 100644 --- a/providers/dns/dode/internal/client.go +++ b/providers/dns/dode/internal/client.go @@ -70,6 +70,7 @@ func (c *Client) UpdateTxtRecord(ctx context.Context, fqdn, txt string, clearRec } var response apiResponse + err = json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/domeneshop/domeneshop_test.go b/providers/dns/domeneshop/domeneshop_test.go index 389975bca..086efd44a 100644 --- a/providers/dns/domeneshop/domeneshop_test.go +++ b/providers/dns/domeneshop/domeneshop_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -130,6 +131,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -143,6 +145,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/dreamhost/dreamhost.go b/providers/dns/dreamhost/dreamhost.go index 5ad2611d9..8663e18ce 100644 --- a/providers/dns/dreamhost/dreamhost.go +++ b/providers/dns/dreamhost/dreamhost.go @@ -99,6 +99,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { // Present creates a TXT record using the specified parameters. func (d *DNSProvider) Present(domain, token, keyAuth string) error { info := dns01.GetChallengeInfo(domain, keyAuth) + err := d.client.AddRecord(context.Background(), dns01.UnFqdn(info.EffectiveFQDN), info.Value) if err != nil { return fmt.Errorf("dreamhost: %w", err) diff --git a/providers/dns/dreamhost/dreamhost_test.go b/providers/dns/dreamhost/dreamhost_test.go index 39b092c6f..5af0b892d 100644 --- a/providers/dns/dreamhost/dreamhost_test.go +++ b/providers/dns/dreamhost/dreamhost_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -160,6 +161,7 @@ func TestLivePresentAndCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/dreamhost/internal/client.go b/providers/dns/dreamhost/internal/client.go index dee808ac8..02b33ad57 100644 --- a/providers/dns/dreamhost/internal/client.go +++ b/providers/dns/dreamhost/internal/client.go @@ -101,6 +101,7 @@ func (c *Client) updateTxtRecord(ctx context.Context, endpoint *url.URL) error { } var response apiResponse + err = json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/duckdns/duckdns_test.go b/providers/dns/duckdns/duckdns_test.go index b89966a36..769513fbf 100644 --- a/providers/dns/duckdns/duckdns_test.go +++ b/providers/dns/duckdns/duckdns_test.go @@ -37,6 +37,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -94,6 +95,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -107,6 +109,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/duckdns/internal/client.go b/providers/dns/duckdns/internal/client.go index ced5bf187..c5d7ef97c 100644 --- a/providers/dns/duckdns/internal/client.go +++ b/providers/dns/duckdns/internal/client.go @@ -81,6 +81,7 @@ func (c *Client) UpdateTxtRecord(ctx context.Context, domain, txt string, clearR if body != "OK" { return fmt.Errorf("request to change TXT record for DuckDNS returned the following result (%s) this does not match expectation (OK) used url [%s]", body, endpoint) } + return nil } @@ -98,6 +99,7 @@ func getMainDomain(domain string) string { } firstSubDomainIndex := split[len(split)-3] + return domain[firstSubDomainIndex:] } diff --git a/providers/dns/dyn/dyn_test.go b/providers/dns/dyn/dyn_test.go index 25f1f5614..5b4d1c6b6 100644 --- a/providers/dns/dyn/dyn_test.go +++ b/providers/dns/dyn/dyn_test.go @@ -71,6 +71,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -155,6 +156,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -168,6 +170,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/dyn/internal/client.go b/providers/dns/dyn/internal/client.go index 83a1bfc0f..a54113eec 100644 --- a/providers/dns/dyn/internal/client.go +++ b/providers/dns/dyn/internal/client.go @@ -127,6 +127,7 @@ func (c *Client) do(req *http.Request) (*APIResponse, error) { } var response APIResponse + err = json.Unmarshal(raw, &response) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/dyn/internal/session.go b/providers/dns/dyn/internal/session.go index 647080fa8..088510152 100644 --- a/providers/dns/dyn/internal/session.go +++ b/providers/dns/dyn/internal/session.go @@ -33,6 +33,7 @@ func (c *Client) login(ctx context.Context) (session, error) { } var s session + err = json.Unmarshal(dynRes.Data, &s) if err != nil { return session{}, errutils.NewUnmarshalError(req, http.StatusOK, dynRes.Data, err) diff --git a/providers/dns/dyndnsfree/dyndnsfree.go b/providers/dns/dyndnsfree/dyndnsfree.go index 13a192793..09be2bfbd 100644 --- a/providers/dns/dyndnsfree/dyndnsfree.go +++ b/providers/dns/dyndnsfree/dyndnsfree.go @@ -110,7 +110,6 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { // CleanUp removes the TXT record matching the specified parameters. func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { // Records are deleted automatically. - return nil } diff --git a/providers/dns/dyndnsfree/dyndnsfree_test.go b/providers/dns/dyndnsfree/dyndnsfree_test.go index cb063a029..0b03bd27f 100644 --- a/providers/dns/dyndnsfree/dyndnsfree_test.go +++ b/providers/dns/dyndnsfree/dyndnsfree_test.go @@ -50,6 +50,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -122,6 +123,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -135,6 +137,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/dynu/dynu_test.go b/providers/dns/dynu/dynu_test.go index fe2c22dfb..ffc7c3a00 100644 --- a/providers/dns/dynu/dynu_test.go +++ b/providers/dns/dynu/dynu_test.go @@ -38,6 +38,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -96,6 +97,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -109,6 +111,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/dynu/internal/auth.go b/providers/dns/dynu/internal/auth.go index 7a21a10e8..0a91445d2 100644 --- a/providers/dns/dynu/internal/auth.go +++ b/providers/dns/dynu/internal/auth.go @@ -46,6 +46,7 @@ func (t *TokenTransport) transport() http.RoundTripper { if t.Transport != nil { return t.Transport } + return http.DefaultTransport } diff --git a/providers/dns/dynu/internal/client.go b/providers/dns/dynu/internal/client.go index f7e90c489..59e90d592 100644 --- a/providers/dns/dynu/internal/client.go +++ b/providers/dns/dynu/internal/client.go @@ -43,6 +43,7 @@ func (c *Client) GetRecords(ctx context.Context, hostname, recordType string) ([ endpoint.RawQuery = query.Encode() apiResp := RecordsResponse{} + err := c.doRetry(ctx, http.MethodGet, endpoint.String(), nil, &apiResp) if err != nil { return nil, err @@ -65,6 +66,7 @@ func (c *Client) AddNewRecord(ctx context.Context, domainID int64, record DNSRec } apiResp := RecordResponse{} + err = c.doRetry(ctx, http.MethodPost, endpoint.String(), reqBody, &apiResp) if err != nil { return err @@ -82,6 +84,7 @@ func (c *Client) DeleteRecord(ctx context.Context, domainID, recordID int64) err endpoint := c.baseURL.JoinPath("dns", strconv.FormatInt(domainID, 10), "record", strconv.FormatInt(recordID, 10)) apiResp := APIException{} + err := c.doRetry(ctx, http.MethodDelete, endpoint.String(), nil, &apiResp) if err != nil { return err @@ -99,6 +102,7 @@ func (c *Client) GetRootDomain(ctx context.Context, hostname string) (*DNSHostna endpoint := c.baseURL.JoinPath("dns", "getroot", hostname) apiResp := DNSHostname{} + err := c.doRetry(ctx, http.MethodGet, endpoint.String(), nil, &apiResp) if err != nil { return nil, err diff --git a/providers/dns/easydns/easydns.go b/providers/dns/easydns/easydns.go index c1119f3cc..ae0a0c3b8 100644 --- a/providers/dns/easydns/easydns.go +++ b/providers/dns/easydns/easydns.go @@ -78,6 +78,7 @@ func NewDNSProvider() (*DNSProvider, error) { if err != nil { return nil, fmt.Errorf("easydns: %w", err) } + config.Endpoint = endpoint values, err := env.Get(EnvToken, EnvKey) @@ -192,6 +193,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() defer delete(d.recordIDs, key) + d.recordIDsMu.Unlock() if err != nil { diff --git a/providers/dns/easydns/easydns_test.go b/providers/dns/easydns/easydns_test.go index 9a11ef6cc..5517928d7 100644 --- a/providers/dns/easydns/easydns_test.go +++ b/providers/dns/easydns/easydns_test.go @@ -76,6 +76,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -314,6 +315,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -327,6 +329,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/easydns/internal/client.go b/providers/dns/easydns/internal/client.go index c044d7e7f..33d7c724e 100644 --- a/providers/dns/easydns/internal/client.go +++ b/providers/dns/easydns/internal/client.go @@ -46,6 +46,7 @@ func (c *Client) ListZones(ctx context.Context, domain string) ([]ZoneRecord, er } response := &apiResponse[[]ZoneRecord]{} + err = c.do(req, response) if err != nil { return nil, err @@ -67,6 +68,7 @@ func (c *Client) AddRecord(ctx context.Context, domain string, record ZoneRecord } response := &apiResponse[*ZoneRecord]{} + err = c.do(req, response) if err != nil { return "", err diff --git a/providers/dns/edgedns/edgedns.go b/providers/dns/edgedns/edgedns.go index 1a92a967f..b5f4b99c9 100644 --- a/providers/dns/edgedns/edgedns.go +++ b/providers/dns/edgedns/edgedns.go @@ -53,6 +53,7 @@ var _ challenge.ProviderTimeout = (*DNSProvider)(nil) // Config is used to configure the creation of the DNSProvider. type Config struct { *edgegrid.Config + PropagationTimeout time.Duration PollingInterval time.Duration TTL int @@ -228,6 +229,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if isNotFound(err) { return nil } + return fmt.Errorf("edgedns: %w", err) } @@ -299,16 +301,19 @@ func isNotFound(err error) bool { } var e *edgegriddns.Error + return errors.As(err, &e) && e.StatusCode == http.StatusNotFound } func filterRData(existingRec *edgegriddns.GetRecordResponse, info dns01.ChallengeInfo) []string { var newRData []string + for _, val := range existingRec.Target { val = strings.Trim(val, `"`) if val == info.Value { continue } + newRData = append(newRData, val) } diff --git a/providers/dns/edgedns/edgedns_integration_test.go b/providers/dns/edgedns/edgedns_integration_test.go index c740aba4b..d20b8e5aa 100644 --- a/providers/dns/edgedns/edgedns_integration_test.go +++ b/providers/dns/edgedns/edgedns_integration_test.go @@ -19,6 +19,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -36,6 +37,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/edgedns/edgedns_test.go b/providers/dns/edgedns/edgedns_test.go index 2dafe9c82..a64efd6e2 100644 --- a/providers/dns/edgedns/edgedns_test.go +++ b/providers/dns/edgedns/edgedns_test.go @@ -143,6 +143,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() if test.envVars == nil { @@ -209,6 +210,7 @@ func TestNewDefaultConfig(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) diff --git a/providers/dns/edgeone/edgeone.go b/providers/dns/edgeone/edgeone.go index 88a795c69..3402122bb 100644 --- a/providers/dns/edgeone/edgeone.go +++ b/providers/dns/edgeone/edgeone.go @@ -165,6 +165,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("edgeone: unknown record ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/edgeone/edgeone_test.go b/providers/dns/edgeone/edgeone_test.go index e1c004d67..1c92118dc 100644 --- a/providers/dns/edgeone/edgeone_test.go +++ b/providers/dns/edgeone/edgeone_test.go @@ -54,6 +54,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -126,6 +127,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -139,6 +141,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/edgeone/wrapper.go b/providers/dns/edgeone/wrapper.go index 0d207f030..c3e9d965b 100644 --- a/providers/dns/edgeone/wrapper.go +++ b/providers/dns/edgeone/wrapper.go @@ -35,6 +35,7 @@ func (d *DNSProvider) getHostedZone(ctx context.Context, domain string) (*teo.Zo } var hostedZone *teo.Zone + for _, zone := range domains { unfqdn := dns01.UnFqdn(authZone) if ptr.Deref(zone.ZoneName) == unfqdn { diff --git a/providers/dns/efficientip/efficientip.go b/providers/dns/efficientip/efficientip.go index d99710920..81b4530b7 100644 --- a/providers/dns/efficientip/efficientip.go +++ b/providers/dns/efficientip/efficientip.go @@ -92,12 +92,15 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if config.Username == "" { return nil, errors.New("efficientip: missing username") } + if config.Password == "" { return nil, errors.New("efficientip: missing password") } + if config.Hostname == "" { return nil, errors.New("efficientip: missing hostname") } + if config.DNSName == "" { return nil, errors.New("efficientip: missing dnsname") } diff --git a/providers/dns/efficientip/efficientip_test.go b/providers/dns/efficientip/efficientip_test.go index 3ee2da777..c2751a79b 100644 --- a/providers/dns/efficientip/efficientip_test.go +++ b/providers/dns/efficientip/efficientip_test.go @@ -83,6 +83,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -178,6 +179,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -191,6 +193,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/efficientip/internal/client.go b/providers/dns/efficientip/internal/client.go index cc26c5412..5ccdf3973 100644 --- a/providers/dns/efficientip/internal/client.go +++ b/providers/dns/efficientip/internal/client.go @@ -108,6 +108,7 @@ func (c *Client) DeleteRecord(ctx context.Context, params DeleteInputParameters) if err != nil { return nil, fmt.Errorf("query parameters: %w", err) } + endpoint.RawQuery = v.Encode() req, err := newJSONRequest(ctx, http.MethodDelete, endpoint, nil) @@ -200,6 +201,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var response APIError + err := json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/epik/epik_test.go b/providers/dns/epik/epik_test.go index c0cd3d43b..b8b3c5c43 100644 --- a/providers/dns/epik/epik_test.go +++ b/providers/dns/epik/epik_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -92,6 +93,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -105,6 +107,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/epik/internal/client.go b/providers/dns/epik/internal/client.go index 70fb42fa9..2c3373953 100644 --- a/providers/dns/epik/internal/client.go +++ b/providers/dns/epik/internal/client.go @@ -46,6 +46,7 @@ func (c *Client) GetDNSRecords(ctx context.Context, domain string) ([]Record, er } var data GetDNSRecordResponse + err = c.do(req, &data) if err != nil { return nil, err @@ -67,6 +68,7 @@ func (c *Client) CreateHostRecord(ctx context.Context, domain string, record Rec } var data Data + err = c.do(req, &data) if err != nil { return nil, err @@ -89,6 +91,7 @@ func (c *Client) RemoveHostRecord(ctx context.Context, domain, recordID string) } var data Data + err = c.do(req, &data) if err != nil { return nil, err @@ -165,6 +168,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var apiErr APIError + err := json.Unmarshal(raw, &apiErr) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/exec/exec_test.go b/providers/dns/exec/exec_test.go index 3a2edbbf4..c1b6da55e 100644 --- a/providers/dns/exec/exec_test.go +++ b/providers/dns/exec/exec_test.go @@ -14,6 +14,7 @@ import ( func TestDNSProvider_Present(t *testing.T) { backupLogger := log.Logger + defer func() { log.Logger = backupLogger }() @@ -62,6 +63,7 @@ func TestDNSProvider_Present(t *testing.T) { } var message string + logRecorder.On("Println", mock.Anything).Run(func(args mock.Arguments) { message = args.String(0) fmt.Fprintln(os.Stdout, "XXX", message) @@ -87,6 +89,7 @@ func TestDNSProvider_Present(t *testing.T) { func TestDNSProvider_CleanUp(t *testing.T) { backupLogger := log.Logger + defer func() { log.Logger = backupLogger }() @@ -135,6 +138,7 @@ func TestDNSProvider_CleanUp(t *testing.T) { } var message string + logRecorder.On("Println", mock.Anything).Run(func(args mock.Arguments) { message = args.String(0) fmt.Fprintln(os.Stdout, "XXX", message) diff --git a/providers/dns/exoscale/exoscale.go b/providers/dns/exoscale/exoscale.go index 83baa9ade..05fcb6a6f 100644 --- a/providers/dns/exoscale/exoscale.go +++ b/providers/dns/exoscale/exoscale.go @@ -118,6 +118,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("exoscale: %w", err) } + if zone == nil { return fmt.Errorf("exoscale: zone %q not found", zoneName) } @@ -157,6 +158,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("exoscale: %w", err) } + if zone == nil { return fmt.Errorf("exoscale: zone %q not found", zoneName) } diff --git a/providers/dns/exoscale/exoscale_test.go b/providers/dns/exoscale/exoscale_test.go index fa58216a5..e9f6be602 100644 --- a/providers/dns/exoscale/exoscale_test.go +++ b/providers/dns/exoscale/exoscale_test.go @@ -58,6 +58,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -178,6 +179,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -195,6 +197,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/f5xc/f5xc_test.go b/providers/dns/f5xc/f5xc_test.go index a298b9e51..98f7484e7 100644 --- a/providers/dns/f5xc/f5xc_test.go +++ b/providers/dns/f5xc/f5xc_test.go @@ -62,6 +62,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -145,6 +146,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -158,6 +160,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/f5xc/internal/client.go b/providers/dns/f5xc/internal/client.go index 26eb03db5..b0b5d0468 100644 --- a/providers/dns/f5xc/internal/client.go +++ b/providers/dns/f5xc/internal/client.go @@ -201,6 +201,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) apiErr := APIError{StatusCode: resp.StatusCode} + err := json.Unmarshal(raw, &apiErr) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/f5xc/internal/types.go b/providers/dns/f5xc/internal/types.go index 3122ca4ef..346283fb7 100644 --- a/providers/dns/f5xc/internal/types.go +++ b/providers/dns/f5xc/internal/types.go @@ -27,13 +27,13 @@ type APIRRSet struct { Namespace string `json:"namespace,omitempty"` RecordName string `json:"record_name,omitempty"` Type string `json:"type,omitempty"` - RRSet RRSet `json:"rrset,omitempty"` + RRSet RRSet `json:"rrset"` } type RRSetRequest struct { DNSZoneName string `json:"dns_zone_name,omitempty"` GroupName string `json:"group_name,omitempty"` - RRSet RRSet `json:"rrset,omitempty"` + RRSet RRSet `json:"rrset"` } type RRSet struct { diff --git a/providers/dns/freemyip/freemyip_test.go b/providers/dns/freemyip/freemyip_test.go index dcf74dd6c..24d1b98f7 100644 --- a/providers/dns/freemyip/freemyip_test.go +++ b/providers/dns/freemyip/freemyip_test.go @@ -37,6 +37,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -94,6 +95,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -107,6 +109,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/gandi/gandi_test.go b/providers/dns/gandi/gandi_test.go index 46697190a..58c25d0db 100644 --- a/providers/dns/gandi/gandi_test.go +++ b/providers/dns/gandi/gandi_test.go @@ -39,6 +39,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -157,9 +158,11 @@ func TestDNSProvider(t *testing.T) { // override findZoneByFqdn function savedFindZoneByFqdn := provider.findZoneByFqdn + t.Cleanup(func() { provider.findZoneByFqdn = savedFindZoneByFqdn }) + provider.findZoneByFqdn = fakeFindZoneByFqdn // run Present diff --git a/providers/dns/gandi/internal/client.go b/providers/dns/gandi/internal/client.go index 6dc09648c..6ca46d072 100644 --- a/providers/dns/gandi/internal/client.go +++ b/providers/dns/gandi/internal/client.go @@ -50,6 +50,7 @@ func (c *Client) GetZoneID(ctx context.Context, domain string) (int, error) { } var zoneID int + for _, member := range resp.StructMembers { if member.Name == "zone_id" { zoneID = member.ValueInt @@ -59,6 +60,7 @@ func (c *Client) GetZoneID(ctx context.Context, domain string) (int, error) { if zoneID == 0 { return 0, fmt.Errorf("could not find zone_id for %s", domain) } + return zoneID, nil } @@ -88,6 +90,7 @@ func (c *Client) CloneZone(ctx context.Context, zoneID int, name string) (int, e } var newZoneID int + for _, member := range resp.StructMembers { if member.Name == "id" { newZoneID = member.ValueInt @@ -97,6 +100,7 @@ func (c *Client) CloneZone(ctx context.Context, zoneID int, name string) (int, e if newZoneID == 0 { return 0, errors.New("could not determine cloned zone_id") } + return newZoneID, nil } @@ -119,6 +123,7 @@ func (c *Client) NewZoneVersion(ctx context.Context, zoneID int) (int, error) { if resp.Value == 0 { return 0, errors.New("could not create new zone version") } + return resp.Value, nil } @@ -174,6 +179,7 @@ func (c *Client) SetZoneVersion(ctx context.Context, zoneID, version int) error if !resp.Value { return errors.New("could not set zone version") } + return nil } @@ -195,6 +201,7 @@ func (c *Client) SetZone(ctx context.Context, domain string, zoneID int) error { } var respZoneID int + for _, member := range resp.StructMembers { if member.Name == "zone_id" { respZoneID = member.ValueInt @@ -204,6 +211,7 @@ func (c *Client) SetZone(ctx context.Context, domain string, zoneID int) error { if respZoneID != zoneID { return fmt.Errorf("could not set new zone_id for %s", domain) } + return nil } diff --git a/providers/dns/gandi/internal/types.go b/providers/dns/gandi/internal/types.go index cdcd0a658..2cde62b53 100644 --- a/providers/dns/gandi/internal/types.go +++ b/providers/dns/gandi/internal/types.go @@ -69,6 +69,7 @@ func (r responseFault) faultString() string { return r.FaultString } type responseStruct struct { responseFault + StructMembers []struct { Name string `xml:"name"` ValueInt int `xml:"value>int"` @@ -77,11 +78,13 @@ type responseStruct struct { type responseInt struct { responseFault + Value int `xml:"params>param>value>int"` } type responseBool struct { responseFault + Value bool `xml:"params>param>value>boolean"` } diff --git a/providers/dns/gandiv5/gandiv5.go b/providers/dns/gandiv5/gandiv5.go index cd236631c..15014e207 100644 --- a/providers/dns/gandiv5/gandiv5.go +++ b/providers/dns/gandiv5/gandiv5.go @@ -114,6 +114,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if err != nil { return nil, fmt.Errorf("gandiv5: %w", err) } + client.BaseURL = baseURL } @@ -163,6 +164,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { authZone: authZone, fieldName: subDomain, } + return nil } @@ -173,6 +175,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { // acquire lock and retrieve authZone d.inProgressMu.Lock() defer d.inProgressMu.Unlock() + if _, ok := d.inProgressFQDNs[info.EffectiveFQDN]; !ok { // if there is no cleanup information then just return return nil @@ -187,6 +190,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("gandiv5: %w", err) } + return nil } diff --git a/providers/dns/gandiv5/gandiv5_test.go b/providers/dns/gandiv5/gandiv5_test.go index e0cdf86ff..d6f077243 100644 --- a/providers/dns/gandiv5/gandiv5_test.go +++ b/providers/dns/gandiv5/gandiv5_test.go @@ -35,6 +35,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -120,9 +121,11 @@ func TestDNSProvider(t *testing.T) { // override findZoneByFqdn function savedFindZoneByFqdn := provider.findZoneByFqdn + defer func() { provider.findZoneByFqdn = savedFindZoneByFqdn }() + provider.findZoneByFqdn = fakeFindZoneByFqdn // run Present diff --git a/providers/dns/gandiv5/internal/client.go b/providers/dns/gandiv5/internal/client.go index 57de9d615..018a05799 100644 --- a/providers/dns/gandiv5/internal/client.go +++ b/providers/dns/gandiv5/internal/client.go @@ -78,6 +78,7 @@ func (c *Client) getTXTRecord(ctx context.Context, domain, name string) (*Record } txtRecord := &Record{} + err = c.do(req, txtRecord) if err != nil { return nil, fmt.Errorf("unable to get TXT records for domain %s and name %s: %w", domain, name, err) @@ -95,6 +96,7 @@ func (c *Client) addTXTRecord(ctx context.Context, domain, name string, newRecor } message := apiResponse{} + err = c.do(req, &message) if err != nil { return fmt.Errorf("unable to create TXT record for domain %s and name %s: %w", domain, name, err) @@ -116,6 +118,7 @@ func (c *Client) DeleteTXTRecord(ctx context.Context, domain, name string) error } message := apiResponse{} + err = c.do(req, &message) if err != nil { return fmt.Errorf("unable to delete TXT record for domain %s and name %s: %w", domain, name, err) @@ -208,6 +211,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) response := apiResponse{} + err := json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/gcloud/googlecloud.go b/providers/dns/gcloud/googlecloud.go index abf40ebd4..ff317946d 100644 --- a/providers/dns/gcloud/googlecloud.go +++ b/providers/dns/gcloud/googlecloud.go @@ -93,6 +93,7 @@ func NewDNSProvider() (*DNSProvider, error) { // Use default credentials. project := env.GetOrDefaultString(EnvProject, autodetectProjectID(context.Background())) + return NewDNSProviderCredentials(project) } @@ -107,6 +108,7 @@ func NewDNSProviderCredentials(project string) (*DNSProvider, error) { config.Project = project var err error + config.HTTPClient, err = newClientFromCredentials(context.Background(), config) if err != nil { return nil, fmt.Errorf("googlecloud: %w", err) @@ -130,10 +132,12 @@ func NewDNSProviderServiceAccountKey(saKey []byte) (*DNSProvider, error) { var datJSON struct { ProjectID string `json:"project_id"` } + err := json.Unmarshal(saKey, &datJSON) if err != nil || datJSON.ProjectID == "" { return nil, errors.New("googlecloud: project ID not found in Google Cloud Service Account file") } + project = datJSON.ProjectID } @@ -141,6 +145,7 @@ func NewDNSProviderServiceAccountKey(saKey []byte) (*DNSProvider, error) { config.Project = project var err error + config.HTTPClient, err = newClientFromServiceAccountKey(context.Background(), config, saKey) if err != nil { return nil, fmt.Errorf("googlecloud: %w", err) @@ -169,6 +174,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if config == nil { return nil, errors.New("googlecloud: the configuration of the DNS provider is nil") } + if config.HTTPClient == nil { return nil, errors.New("googlecloud: unable to create Google Cloud DNS service: client is nil") } @@ -200,6 +206,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { for _, rrSet := range existingRrSet { var rrd []string + for _, rr := range rrSet.Rrdatas { data := mustUnquote(rr) rrd = append(rrd, data) @@ -209,6 +216,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { return nil } } + rrSet.Rrdatas = rrd } @@ -260,6 +268,7 @@ func (d *DNSProvider) applyChanges(ctx context.Context, zone string, change *gdn } data, _ := json.Marshal(change) + return fmt.Errorf("failed to perform changes [zone %s, change %s]: %w", zone, string(data), err) } @@ -316,6 +325,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("googlecloud: %w", err) } + return nil } @@ -450,6 +460,7 @@ func mustUnquote(raw string) string { if err != nil { return raw } + return clean } diff --git a/providers/dns/gcloud/googlecloud_test.go b/providers/dns/gcloud/googlecloud_test.go index 00d6c6c9a..28b08a2f9 100644 --- a/providers/dns/gcloud/googlecloud_test.go +++ b/providers/dns/gcloud/googlecloud_test.go @@ -86,6 +86,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -125,6 +126,7 @@ func TestNewDNSProviderConfig(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() config := NewDefaultConfig() @@ -237,12 +239,14 @@ func TestPresentWithExistingRR(t *testing.T) { } var prevVal string + for _, addition := range chgReq.Additions { for _, value := range addition.Rrdatas { if prevVal == value { http.Error(rw, fmt.Sprintf("The resource %s already exists", value), http.StatusConflict) return } + prevVal = value } } diff --git a/providers/dns/gcore/gcore_test.go b/providers/dns/gcore/gcore_test.go index a5eddee7c..88769df21 100644 --- a/providers/dns/gcore/gcore_test.go +++ b/providers/dns/gcore/gcore_test.go @@ -34,6 +34,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -93,6 +94,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -106,6 +108,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/gcore/internal/client.go b/providers/dns/gcore/internal/client.go index b76da4388..638aaf0d7 100644 --- a/providers/dns/gcore/internal/client.go +++ b/providers/dns/gcore/internal/client.go @@ -48,6 +48,7 @@ func (c *Client) GetZone(ctx context.Context, name string) (Zone, error) { endpoint := c.baseURL.JoinPath("v2", "zones", name) zone := Zone{} + err := c.doRequest(ctx, http.MethodGet, endpoint, nil, &zone) if err != nil { return Zone{}, fmt.Errorf("get zone %s: %w", name, err) @@ -62,6 +63,7 @@ func (c *Client) GetRRSet(ctx context.Context, zone, name string) (RRSet, error) endpoint := c.baseURL.JoinPath("v2", "zones", zone, name, txtRecordType) var result RRSet + err := c.doRequest(ctx, http.MethodGet, endpoint, nil, &result) if err != nil { return RRSet{}, fmt.Errorf("get txt records %s -> %s: %w", zone, name, err) @@ -180,6 +182,7 @@ func parseError(resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errAPI := APIError{StatusCode: resp.StatusCode} + err := json.Unmarshal(raw, &errAPI) if err != nil { errAPI.Message = string(raw) diff --git a/providers/dns/glesys/glesys.go b/providers/dns/glesys/glesys.go index 4fa689e28..729756235 100644 --- a/providers/dns/glesys/glesys.go +++ b/providers/dns/glesys/glesys.go @@ -136,6 +136,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { // save data necessary for CleanUp d.activeRecords[info.EffectiveFQDN] = recordID + return nil } @@ -146,6 +147,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { // acquire lock and retrieve authZone d.inProgressMu.Lock() defer d.inProgressMu.Unlock() + if _, ok := d.activeRecords[info.EffectiveFQDN]; !ok { // if there is no cleanup information then just return return nil diff --git a/providers/dns/glesys/glesys_test.go b/providers/dns/glesys/glesys_test.go index d5fdf36da..f2d65e514 100644 --- a/providers/dns/glesys/glesys_test.go +++ b/providers/dns/glesys/glesys_test.go @@ -56,6 +56,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -130,6 +131,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -143,6 +145,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/glesys/internal/client.go b/providers/dns/glesys/internal/client.go index 20bc363ba..ee6ebc058 100644 --- a/providers/dns/glesys/internal/client.go +++ b/providers/dns/glesys/internal/client.go @@ -102,6 +102,7 @@ func (c *Client) do(req *http.Request) (*apiResponse, error) { } var response apiResponse + err = json.Unmarshal(raw, &response) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/godaddy/godaddy.go b/providers/dns/godaddy/godaddy.go index 7c323ce0b..1603bb57e 100644 --- a/providers/dns/godaddy/godaddy.go +++ b/providers/dns/godaddy/godaddy.go @@ -131,6 +131,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { } var newRecords []internal.DNSRecord + for _, record := range existingRecords { if record.Data != "" { newRecords = append(newRecords, record) @@ -177,6 +178,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var recordsToKeep []internal.DNSRecord + for _, record := range existingRecords { if record.Data != info.Value && record.Data != "" { recordsToKeep = append(recordsToKeep, record) diff --git a/providers/dns/godaddy/godaddy_test.go b/providers/dns/godaddy/godaddy_test.go index 4cb5f2721..38b39672e 100644 --- a/providers/dns/godaddy/godaddy_test.go +++ b/providers/dns/godaddy/godaddy_test.go @@ -56,6 +56,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -126,6 +127,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -139,6 +141,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/godaddy/internal/client.go b/providers/dns/godaddy/internal/client.go index bf30d437f..9dd337ddc 100644 --- a/providers/dns/godaddy/internal/client.go +++ b/providers/dns/godaddy/internal/client.go @@ -48,6 +48,7 @@ func (c *Client) GetRecords(ctx context.Context, domainZone, rType, recordName s } var records []DNSRecord + err = c.do(req, &records) if err != nil { return nil, err @@ -141,6 +142,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/godaddy/internal/types.go b/providers/dns/godaddy/internal/types.go index a97a97896..c1e6d6638 100644 --- a/providers/dns/godaddy/internal/types.go +++ b/providers/dns/godaddy/internal/types.go @@ -1,6 +1,9 @@ package internal -import "fmt" +import ( + "fmt" + "strings" +) // DNSRecord a DNS record. type DNSRecord struct { @@ -23,13 +26,16 @@ type APIError struct { } func (a APIError) Error() string { - msg := fmt.Sprintf("%s: %s", a.Code, a.Message) + var msg strings.Builder + + msg.WriteString(fmt.Sprintf("%s: %s", a.Code, a.Message)) for _, field := range a.Fields { - msg += " " + field.String() + msg.WriteString(" ") + msg.WriteString(field.String()) } - return msg + return msg.String() } type Field struct { diff --git a/providers/dns/hetzner/hetzner_test.go b/providers/dns/hetzner/hetzner_test.go index 7f59e6323..430f0270b 100644 --- a/providers/dns/hetzner/hetzner_test.go +++ b/providers/dns/hetzner/hetzner_test.go @@ -56,6 +56,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) diff --git a/providers/dns/hetzner/internal/hetznerv1/hetznerv1_test.go b/providers/dns/hetzner/internal/hetznerv1/hetznerv1_test.go index e43dce068..bf52baa35 100644 --- a/providers/dns/hetzner/internal/hetznerv1/hetznerv1_test.go +++ b/providers/dns/hetzner/internal/hetznerv1/hetznerv1_test.go @@ -37,6 +37,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -96,6 +97,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -109,6 +111,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/hetzner/internal/hetznerv1/internal/client.go b/providers/dns/hetzner/internal/hetznerv1/internal/client.go index 2f87eb6a5..35c3d461b 100644 --- a/providers/dns/hetzner/internal/hetznerv1/internal/client.go +++ b/providers/dns/hetzner/internal/hetznerv1/internal/client.go @@ -54,6 +54,7 @@ func (c *Client) AddRRSetRecords(ctx context.Context, zoneIDName, recordType, re } var result ActionResponse + err = c.do(req, &result) if err != nil { return nil, err @@ -73,6 +74,7 @@ func (c *Client) RemoveRRSetRecords(ctx context.Context, zoneIDName, recordType, } var result ActionResponse + err = c.do(req, &result) if err != nil { return nil, err @@ -92,6 +94,7 @@ func (c *Client) GetAction(ctx context.Context, id int) (*Action, error) { } var result ActionResponse + err = c.do(req, &result) if err != nil { return nil, err @@ -157,6 +160,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/hetzner/internal/hetznerv1/internal/types.go b/providers/dns/hetzner/internal/hetznerv1/internal/types.go index 0dd9fb9a1..08d1684c0 100644 --- a/providers/dns/hetzner/internal/hetznerv1/internal/types.go +++ b/providers/dns/hetzner/internal/hetznerv1/internal/types.go @@ -12,25 +12,27 @@ type APIError struct { type ErrorInfo struct { Code string `json:"code,omitempty"` Message string `json:"message,omitempty"` - Details ErrorDetails `json:"details,omitempty"` + Details ErrorDetails `json:"details"` } func (i *ErrorInfo) Error() string { - msg := fmt.Sprintf("%s: %s", i.Code, i.Message) + var msg strings.Builder + + msg.WriteString(fmt.Sprintf("%s: %s", i.Code, i.Message)) if i.Details.Announcement != "" { - msg += fmt.Sprintf(": %s", i.Details.Announcement) + msg.WriteString(fmt.Sprintf(": %s", i.Details.Announcement)) } for _, limit := range i.Details.Limits { - msg += fmt.Sprintf("limit: %s", limit.Name) + msg.WriteString(fmt.Sprintf("limit: %s", limit.Name)) } for _, field := range i.Details.Fields { - msg += fmt.Sprintf("field: %s: %s", field.Name, strings.Join(field.Messages, ", ")) + msg.WriteString(fmt.Sprintf("field: %s: %s", field.Name, strings.Join(field.Messages, ", "))) } - return msg + return msg.String() } type ErrorDetails struct { diff --git a/providers/dns/hetzner/internal/legacy/hetzner_test.go b/providers/dns/hetzner/internal/legacy/hetzner_test.go index 07eae8149..c9258ecf8 100644 --- a/providers/dns/hetzner/internal/legacy/hetzner_test.go +++ b/providers/dns/hetzner/internal/legacy/hetzner_test.go @@ -37,6 +37,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -104,6 +105,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -117,6 +119,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/hetzner/internal/legacy/internal/client.go b/providers/dns/hetzner/internal/legacy/internal/client.go index 381922264..cd187f6e5 100644 --- a/providers/dns/hetzner/internal/legacy/internal/client.go +++ b/providers/dns/hetzner/internal/legacy/internal/client.go @@ -83,6 +83,7 @@ func (c *Client) getRecords(ctx context.Context, zoneID string) (*DNSRecords, er } records := &DNSRecords{} + err = json.Unmarshal(raw, records) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -190,6 +191,7 @@ func (c *Client) getZones(ctx context.Context, name string) (*Zones, error) { } zones := &Zones{} + err = json.Unmarshal(raw, zones) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/hetzner/internal/legacy/internal/types.go b/providers/dns/hetzner/internal/legacy/internal/types.go index d0e284511..3b332cc8f 100644 --- a/providers/dns/hetzner/internal/legacy/internal/types.go +++ b/providers/dns/hetzner/internal/legacy/internal/types.go @@ -25,12 +25,12 @@ type Zone struct { // Zones a set of DNS zones. type Zones struct { Zones []Zone `json:"zones"` - Meta Meta `json:"meta,omitempty"` + Meta Meta `json:"meta"` } // Meta response metadata. type Meta struct { - Pagination Pagination `json:"pagination,omitempty"` + Pagination Pagination `json:"pagination"` } // Pagination information about pagination. diff --git a/providers/dns/hostingde/hostingde.go b/providers/dns/hostingde/hostingde.go index 3ad6e4a61..48c44998f 100644 --- a/providers/dns/hostingde/hostingde.go +++ b/providers/dns/hostingde/hostingde.go @@ -188,6 +188,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("hostingde: %w", err) } + zoneConfig.Name = zoneName rec := []hostingde.DNSRecord{{ @@ -210,6 +211,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("hostingde: %w", err) } + return nil } diff --git a/providers/dns/hostingde/hostingde_test.go b/providers/dns/hostingde/hostingde_test.go index d7681f953..1611cb51b 100644 --- a/providers/dns/hostingde/hostingde_test.go +++ b/providers/dns/hostingde/hostingde_test.go @@ -49,6 +49,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -116,6 +117,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -129,6 +131,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/hostinger/hostinger_test.go b/providers/dns/hostinger/hostinger_test.go index 1315cee97..90ecba529 100644 --- a/providers/dns/hostinger/hostinger_test.go +++ b/providers/dns/hostinger/hostinger_test.go @@ -38,6 +38,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -156,6 +157,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -169,6 +171,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/hostinger/internal/client.go b/providers/dns/hostinger/internal/client.go index 0fbf8acf6..9da712d61 100644 --- a/providers/dns/hostinger/internal/client.go +++ b/providers/dns/hostinger/internal/client.go @@ -52,6 +52,7 @@ func (c *Client) GetDNSRecords(ctx context.Context, domain string) ([]RecordSet, } var result []RecordSet + err = c.do(req, &result) if err != nil { return nil, err @@ -145,6 +146,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/hostinger/internal/types.go b/providers/dns/hostinger/internal/types.go index ba0970dfb..534dfa5e5 100644 --- a/providers/dns/hostinger/internal/types.go +++ b/providers/dns/hostinger/internal/types.go @@ -12,13 +12,15 @@ type APIError struct { } func (a *APIError) Error() string { - msg := fmt.Sprintf("%s: %s", a.CorrelationID, a.Message) + var msg strings.Builder + + msg.WriteString(fmt.Sprintf("%s: %s", a.CorrelationID, a.Message)) for field, values := range a.Errors { - msg += fmt.Sprintf(": %s: %s", field, strings.Join(values, ", ")) + msg.WriteString(fmt.Sprintf(": %s: %s", field, strings.Join(values, ", "))) } - return msg + return msg.String() } type ZoneRequest struct { diff --git a/providers/dns/hosttech/hosttech.go b/providers/dns/hosttech/hosttech.go index 20fa1d710..fac64f054 100644 --- a/providers/dns/hosttech/hosttech.go +++ b/providers/dns/hosttech/hosttech.go @@ -164,6 +164,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("hosttech: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/hosttech/hosttech_test.go b/providers/dns/hosttech/hosttech_test.go index 6f0d0bd3e..042b73353 100644 --- a/providers/dns/hosttech/hosttech_test.go +++ b/providers/dns/hosttech/hosttech_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -92,6 +93,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -105,6 +107,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/hosttech/internal/client.go b/providers/dns/hosttech/internal/client.go index 399b18d0e..557d54298 100644 --- a/providers/dns/hosttech/internal/client.go +++ b/providers/dns/hosttech/internal/client.go @@ -58,6 +58,7 @@ func (c *Client) GetZones(ctx context.Context, query string, limit, offset int) } result := apiResponse[[]Zone]{} + err = c.do(req, &result) if err != nil { return nil, err @@ -77,6 +78,7 @@ func (c *Client) GetZone(ctx context.Context, zoneID string) (*Zone, error) { } result := apiResponse[*Zone]{} + err = c.do(req, &result) if err != nil { return nil, err @@ -104,6 +106,7 @@ func (c *Client) GetRecords(ctx context.Context, zoneID, recordType string) ([]R } result := apiResponse[[]Record]{} + err = c.do(req, &result) if err != nil { return nil, err @@ -123,6 +126,7 @@ func (c *Client) AddRecord(ctx context.Context, zoneID string, record Record) (* } result := apiResponse[*Record]{} + err = c.do(req, &result) if err != nil { return nil, err @@ -202,6 +206,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errAPI := &APIError{StatusCode: resp.StatusCode} + err := json.Unmarshal(raw, errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/hosttech/internal/types.go b/providers/dns/hosttech/internal/types.go index bf86964f7..854fc4883 100644 --- a/providers/dns/hosttech/internal/types.go +++ b/providers/dns/hosttech/internal/types.go @@ -2,6 +2,7 @@ package internal import ( "fmt" + "strings" ) type apiResponse[T any] struct { @@ -15,11 +16,15 @@ type APIError struct { } func (a APIError) Error() string { - msg := fmt.Sprintf("%d: %s", a.StatusCode, a.Message) + var msg strings.Builder + + msg.WriteString(fmt.Sprintf("%d: %s", a.StatusCode, a.Message)) + for k, v := range a.Errors { - msg += fmt.Sprintf(" %s: %v", k, v) + msg.WriteString(fmt.Sprintf(" %s: %v", k, v)) } - return msg + + return msg.String() } type Zone struct { diff --git a/providers/dns/httpnet/httpnet.go b/providers/dns/httpnet/httpnet.go index e69c43e6d..f18eefd97 100644 --- a/providers/dns/httpnet/httpnet.go +++ b/providers/dns/httpnet/httpnet.go @@ -190,6 +190,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("httpnet: %w", err) } + zoneConfig.Name = zoneName rec := []hostingde.DNSRecord{{ @@ -212,6 +213,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("httpnet: %w", err) } + return nil } diff --git a/providers/dns/httpnet/httpnet_test.go b/providers/dns/httpnet/httpnet_test.go index a9bc527ad..64a94f80c 100644 --- a/providers/dns/httpnet/httpnet_test.go +++ b/providers/dns/httpnet/httpnet_test.go @@ -49,6 +49,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -116,6 +117,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -129,6 +131,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/httpreq/httpreq.go b/providers/dns/httpreq/httpreq.go index 12eef7b8e..591e9b5e1 100644 --- a/providers/dns/httpreq/httpreq.go +++ b/providers/dns/httpreq/httpreq.go @@ -129,6 +129,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("httpreq: %w", err) } + return nil } @@ -142,6 +143,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("httpreq: %w", err) } + return nil } @@ -160,6 +162,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("httpreq: %w", err) } + return nil } @@ -173,11 +176,13 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("httpreq: %w", err) } + return nil } func (d *DNSProvider) doPost(ctx context.Context, uri string, msg any) error { reqBody := new(bytes.Buffer) + err := json.NewEncoder(reqBody).Encode(msg) if err != nil { return fmt.Errorf("failed to create request JSON body: %w", err) diff --git a/providers/dns/httpreq/httpreq_test.go b/providers/dns/httpreq/httpreq_test.go index a7571de22..108d6a565 100644 --- a/providers/dns/httpreq/httpreq_test.go +++ b/providers/dns/httpreq/httpreq_test.go @@ -43,6 +43,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -266,5 +267,6 @@ func mustParse(rawURL string) *url.URL { if err != nil { panic(err) } + return uri } diff --git a/providers/dns/huaweicloud/huaweicloud.go b/providers/dns/huaweicloud/huaweicloud.go index 430abce74..5a2773ab2 100644 --- a/providers/dns/huaweicloud/huaweicloud.go +++ b/providers/dns/huaweicloud/huaweicloud.go @@ -184,6 +184,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("huaweicloud: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/huaweicloud/huaweicloud_test.go b/providers/dns/huaweicloud/huaweicloud_test.go index 6787650ca..25e295da7 100644 --- a/providers/dns/huaweicloud/huaweicloud_test.go +++ b/providers/dns/huaweicloud/huaweicloud_test.go @@ -62,6 +62,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -140,6 +141,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -153,6 +155,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/hurricane/hurricane.go b/providers/dns/hurricane/hurricane.go index c8b05731a..b23528bb0 100644 --- a/providers/dns/hurricane/hurricane.go +++ b/providers/dns/hurricane/hurricane.go @@ -58,6 +58,7 @@ type DNSProvider struct { // NewDNSProvider returns a DNSProvider instance configured for Hurricane Electric. func NewDNSProvider() (*DNSProvider, error) { config := NewDefaultConfig() + values, err := env.Get(EnvTokens) if err != nil { return nil, fmt.Errorf("hurricane: %w", err) diff --git a/providers/dns/hurricane/hurricane_test.go b/providers/dns/hurricane/hurricane_test.go index f8a1f185c..2bbd638fa 100644 --- a/providers/dns/hurricane/hurricane_test.go +++ b/providers/dns/hurricane/hurricane_test.go @@ -55,6 +55,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -120,6 +121,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -133,6 +135,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/hyperone/hyperone.go b/providers/dns/hyperone/hyperone.go index 33716cfdb..3cdad8e68 100644 --- a/providers/dns/hyperone/hyperone.go +++ b/providers/dns/hyperone/hyperone.go @@ -77,6 +77,7 @@ func NewDNSProvider() (*DNSProvider, error) { func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if config.PassportLocation == "" { var err error + config.PassportLocation, err = GetDefaultPassportLocation() if err != nil { return nil, fmt.Errorf("hyperone: %w", err) @@ -166,6 +167,7 @@ func (d *DNSProvider) CleanUp(domain, _, keyAuth string) error { if err != nil { return fmt.Errorf("hyperone: %w", err) } + if len(records) == 1 { if records[0].Content != info.Value { return fmt.Errorf("hyperone: record with content %s not found: fqdn=%s", info.Value, info.EffectiveFQDN) diff --git a/providers/dns/hyperone/hyperone_test.go b/providers/dns/hyperone/hyperone_test.go index 1222d1c74..675a1fe19 100644 --- a/providers/dns/hyperone/hyperone_test.go +++ b/providers/dns/hyperone/hyperone_test.go @@ -49,6 +49,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -124,6 +125,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -137,6 +139,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/hyperone/internal/passport.go b/providers/dns/hyperone/internal/passport.go index b63236c3b..d1503d893 100644 --- a/providers/dns/hyperone/internal/passport.go +++ b/providers/dns/hyperone/internal/passport.go @@ -25,6 +25,7 @@ func LoadPassportFile(location string) (*Passport, error) { defer func() { _ = file.Close() }() var passport Passport + err = json.NewDecoder(file).Decode(&passport) if err != nil { return nil, fmt.Errorf("failed to parse passport file: %w", err) diff --git a/providers/dns/hyperone/internal/token_test.go b/providers/dns/hyperone/internal/token_test.go index 315d0896f..34b4cc573 100644 --- a/providers/dns/hyperone/internal/token_test.go +++ b/providers/dns/hyperone/internal/token_test.go @@ -38,6 +38,7 @@ func TestPayload_buildToken(t *testing.T) { require.NoError(t, err) var headerStruct Header + err = json.Unmarshal(headerString, &headerStruct) require.NoError(t, err) @@ -45,6 +46,7 @@ func TestPayload_buildToken(t *testing.T) { require.NoError(t, err) var payloadStruct Payload + err = json.Unmarshal(payloadString, &payloadStruct) require.NoError(t, err) diff --git a/providers/dns/ibmcloud/ibmcloud_test.go b/providers/dns/ibmcloud/ibmcloud_test.go index a000e3e59..6ca7cd81b 100644 --- a/providers/dns/ibmcloud/ibmcloud_test.go +++ b/providers/dns/ibmcloud/ibmcloud_test.go @@ -55,6 +55,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -127,6 +128,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -140,6 +142,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/iij/iij.go b/providers/dns/iij/iij.go index 6bc7db21a..1d098bde2 100644 --- a/providers/dns/iij/iij.go +++ b/providers/dns/iij/iij.go @@ -98,6 +98,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("iij: %w", err) } + return nil } @@ -110,6 +111,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("iij: %w", err) } + return nil } diff --git a/providers/dns/iij/iij_test.go b/providers/dns/iij/iij_test.go index 2c7ec4217..bd8140532 100644 --- a/providers/dns/iij/iij_test.go +++ b/providers/dns/iij/iij_test.go @@ -71,6 +71,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -238,6 +239,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -251,6 +253,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/iijdpf/iijdpf_test.go b/providers/dns/iijdpf/iijdpf_test.go index a4fa8b8f6..fbcf3e1f5 100644 --- a/providers/dns/iijdpf/iijdpf_test.go +++ b/providers/dns/iijdpf/iijdpf_test.go @@ -43,6 +43,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -115,6 +116,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -128,6 +130,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/iijdpf/wrapper.go b/providers/dns/iijdpf/wrapper.go index 12b09a30c..0ab26cdcd 100644 --- a/providers/dns/iijdpf/wrapper.go +++ b/providers/dns/iijdpf/wrapper.go @@ -51,6 +51,7 @@ func (d *DNSProvider) deleteTxtRecord(ctx context.Context, zoneID, fqdn, rdata s // empty target rrset return nil } + return err } @@ -66,11 +67,13 @@ func (d *DNSProvider) deleteTxtRecord(ctx context.Context, zoneID, fqdn, rdata s // delete rdata rdataSlice := dpfzones.RecordRDATASlice{} + for _, v := range r.RData { if v.Value != rdata { rdataSlice = append(rdataSlice, v) } } + r.RData = rdataSlice _, _, err = dpfapiutils.SyncUpdate(ctx, d.client, r, nil) diff --git a/providers/dns/infoblox/infoblox.go b/providers/dns/infoblox/infoblox.go index 37e119e85..054f13679 100644 --- a/providers/dns/infoblox/infoblox.go +++ b/providers/dns/infoblox/infoblox.go @@ -198,6 +198,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordRefsMu.Lock() recordRef, ok := d.recordRefs[token] d.recordRefsMu.Unlock() + if !ok { return fmt.Errorf("infoblox: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/infoblox/infoblox_test.go b/providers/dns/infoblox/infoblox_test.go index 45434e0e3..68158cb0d 100644 --- a/providers/dns/infoblox/infoblox_test.go +++ b/providers/dns/infoblox/infoblox_test.go @@ -68,6 +68,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -149,6 +150,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -162,6 +164,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/infomaniak/infomaniak_test.go b/providers/dns/infomaniak/infomaniak_test.go index bc8fb7b58..980f3b959 100644 --- a/providers/dns/infomaniak/infomaniak_test.go +++ b/providers/dns/infomaniak/infomaniak_test.go @@ -39,6 +39,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -101,6 +102,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -114,6 +116,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/infomaniak/internal/client.go b/providers/dns/infomaniak/internal/client.go index 886a8966f..40b56c707 100644 --- a/providers/dns/infomaniak/internal/client.go +++ b/providers/dns/infomaniak/internal/client.go @@ -50,6 +50,7 @@ func (c *Client) CreateDNSRecord(ctx context.Context, domain *DNSDomain, record } result := APIResponse[string]{} + err = c.do(req, &result) if err != nil { return "", err @@ -112,6 +113,7 @@ func (c *Client) getDomainByName(ctx context.Context, name string) (*DNSDomain, } result := APIResponse[[]DNSDomain]{} + err = c.do(req, &result) if err != nil { return nil, err diff --git a/providers/dns/internal/active24/client.go b/providers/dns/internal/active24/client.go index 32ecc2186..10aaa4666 100644 --- a/providers/dns/internal/active24/client.go +++ b/providers/dns/internal/active24/client.go @@ -55,6 +55,7 @@ func (c *Client) GetServices(ctx context.Context) ([]Service, error) { } var result OldAPIResponse + err = c.do(req, &result) if err != nil { return nil, err @@ -82,6 +83,7 @@ func (c *Client) GetRecords(ctx context.Context, service string, filter RecordFi } var result APIResponse + err = c.do(req, &result) if err != nil { return nil, err @@ -180,6 +182,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) @@ -198,6 +201,7 @@ func (c *Client) sign(req *http.Request, now time.Time) error { canonicalRequest := fmt.Sprintf("%s %s %d", req.Method, req.URL.Path, now.Unix()) mac := hmac.New(sha1.New, []byte(c.secret)) + _, err := mac.Write([]byte(canonicalRequest)) if err != nil { return err diff --git a/providers/dns/internal/hostingde/types.go b/providers/dns/internal/hostingde/types.go index 4f3347190..86b69ec42 100644 --- a/providers/dns/internal/hostingde/types.go +++ b/providers/dns/internal/hostingde/types.go @@ -88,7 +88,8 @@ type Zone struct { // https://www.hosting.de/api/?json#updating-zones type ZoneUpdateRequest struct { BaseRequest - ZoneConfig `json:"zoneConfig"` + ZoneConfig `json:"zoneConfig"` + RecordsToAdd []DNSRecord `json:"recordsToAdd"` RecordsToDelete []DNSRecord `json:"recordsToDelete"` } @@ -97,6 +98,7 @@ type ZoneUpdateRequest struct { // https://www.hosting.de/api/?json#list-zoneconfigs type ZoneConfigsFindRequest struct { BaseRequest + Filter Filter `json:"filter"` Limit int `json:"limit"` Page int `json:"page"` diff --git a/providers/dns/internal/rimuhosting/client.go b/providers/dns/internal/rimuhosting/client.go index 06292453a..c46afc544 100644 --- a/providers/dns/internal/rimuhosting/client.go +++ b/providers/dns/internal/rimuhosting/client.go @@ -82,14 +82,17 @@ func (c *Client) DoActions(ctx context.Context, actions ...ActionParameter) (*DN if err != nil { return nil, err } + return resp, nil } multi := c.toMultiParameters(actions) + err := c.do(ctx, multi, resp) if err != nil { return nil, err } + return resp, nil } @@ -160,6 +163,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errAPI := APIError{} + err := xml.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/internal/selectel/client.go b/providers/dns/internal/selectel/client.go index 1e1e4a215..fe810ebc5 100644 --- a/providers/dns/internal/selectel/client.go +++ b/providers/dns/internal/selectel/client.go @@ -52,6 +52,7 @@ func (c *Client) GetDomainByName(ctx context.Context, domainName string) (*Domai } domain := &Domain{} + statusCode, err := c.do(req, domain) if err != nil { if statusCode == http.StatusNotFound && strings.Count(domainName, ".") > 1 { @@ -74,6 +75,7 @@ func (c *Client) AddRecord(ctx context.Context, domainID int, body Record) (*Rec } record := &Record{} + _, err = c.do(req, record) if err != nil { return nil, err @@ -90,6 +92,7 @@ func (c *Client) ListRecords(ctx context.Context, domainID int) ([]Record, error } var records []Record + _, err = c.do(req, &records) if err != nil { return nil, err @@ -108,6 +111,7 @@ func (c *Client) DeleteRecord(ctx context.Context, domainID, recordID int) error } _, err = c.do(req, nil) + return err } @@ -170,6 +174,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errAPI := &APIError{} + err := json.Unmarshal(raw, errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/internetbs/internal/client.go b/providers/dns/internetbs/internal/client.go index 4de57dc9a..cf9e90dc5 100644 --- a/providers/dns/internetbs/internal/client.go +++ b/providers/dns/internetbs/internal/client.go @@ -48,6 +48,7 @@ func NewClient(apiKey, password string) *Client { // AddRecord The command is intended to add a new DNS record to a specific zone (domain). func (c *Client) AddRecord(ctx context.Context, query RecordQuery) error { var r APIResponse + err := c.doRequest(ctx, "Add", query, &r) if err != nil { return err @@ -63,6 +64,7 @@ func (c *Client) AddRecord(ctx context.Context, query RecordQuery) error { // RemoveRecord The command is intended to remove a DNS record from a specific zone. func (c *Client) RemoveRecord(ctx context.Context, query RecordQuery) error { var r APIResponse + err := c.doRequest(ctx, "Remove", query, &r) if err != nil { return err @@ -78,6 +80,7 @@ func (c *Client) RemoveRecord(ctx context.Context, query RecordQuery) error { // ListRecords The command is intended to retrieve the list of DNS records for a specific domain. func (c *Client) ListRecords(ctx context.Context, query ListRecordQuery) ([]Record, error) { var l ListResponse + err := c.doRequest(ctx, "List", query, &l) if err != nil { return nil, err diff --git a/providers/dns/internetbs/internetbs_test.go b/providers/dns/internetbs/internetbs_test.go index ea328d506..be436d6e7 100644 --- a/providers/dns/internetbs/internetbs_test.go +++ b/providers/dns/internetbs/internetbs_test.go @@ -49,6 +49,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -121,6 +122,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -134,6 +136,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/inwx/inwx.go b/providers/dns/inwx/inwx.go index 9945d904c..794db84b3 100644 --- a/providers/dns/inwx/inwx.go +++ b/providers/dns/inwx/inwx.go @@ -178,12 +178,14 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var recordID int + for _, record := range response.Records { if record.Content != info.Value { continue } recordID = record.ID + break } diff --git a/providers/dns/inwx/inwx_test.go b/providers/dns/inwx/inwx_test.go index 39ce7d70e..47b12e228 100644 --- a/providers/dns/inwx/inwx_test.go +++ b/providers/dns/inwx/inwx_test.go @@ -62,6 +62,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -124,6 +125,7 @@ func TestLivePresentAndCleanup(t *testing.T) { } envTest.RestoreEnv() + envTest.Apply(map[string]string{ EnvSandbox: "true", EnvTTL: "3600", // In sandbox mode, the minimum allowed TTL is 3600 diff --git a/providers/dns/ionos/internal/client.go b/providers/dns/ionos/internal/client.go index b51e003f7..935b6bbad 100644 --- a/providers/dns/ionos/internal/client.go +++ b/providers/dns/ionos/internal/client.go @@ -52,6 +52,7 @@ func (c *Client) ListZones(ctx context.Context) ([]Zone, error) { } var zones []Zone + err = c.do(req, &zones) if err != nil { return nil, fmt.Errorf("failed to call API: %w", err) @@ -96,6 +97,7 @@ func (c *Client) GetRecords(ctx context.Context, zoneID string, filter *RecordsF } var zone CustomerZone + err = c.do(req, &zone) if err != nil { return nil, fmt.Errorf("failed to call API: %w", err) @@ -180,6 +182,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errClient := &ClientError{StatusCode: resp.StatusCode} + err := json.Unmarshal(raw, &errClient.errors) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/ionos/internal/types.go b/providers/dns/ionos/internal/types.go index 3b7acbec2..35bfe0966 100644 --- a/providers/dns/ionos/internal/types.go +++ b/providers/dns/ionos/internal/types.go @@ -3,6 +3,7 @@ package internal import ( "fmt" "strconv" + "strings" ) // ClientError a detailed error. @@ -13,21 +14,23 @@ type ClientError struct { } func (f ClientError) Error() string { - msg := strconv.Itoa(f.StatusCode) + ": " + var msg strings.Builder + + msg.WriteString(strconv.Itoa(f.StatusCode) + ": ") if f.message != "" { - msg += f.message + ": " + msg.WriteString(f.message + ": ") } for i, e := range f.errors { if i != 0 { - msg += ", " + msg.WriteString(", ") } - msg += e.Error() + msg.WriteString(e.Error()) } - return msg + return msg.String() } func (f ClientError) Unwrap() error { diff --git a/providers/dns/ionos/ionos.go b/providers/dns/ionos/ionos.go index 1c2bf118d..a512e8bfd 100644 --- a/providers/dns/ionos/ionos.go +++ b/providers/dns/ionos/ionos.go @@ -185,6 +185,7 @@ func (d *DNSProvider) CleanUp(domain, _, keyAuth string) error { if err != nil { return fmt.Errorf("ionos: failed to remove record (zone=%s, record=%s): %w", zone.ID, record.ID, err) } + return nil } } diff --git a/providers/dns/ionos/ionos_test.go b/providers/dns/ionos/ionos_test.go index 5aef6ad14..7b1f5af11 100644 --- a/providers/dns/ionos/ionos_test.go +++ b/providers/dns/ionos/ionos_test.go @@ -37,6 +37,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -106,6 +107,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -119,6 +121,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/ipv64/internal/client.go b/providers/dns/ipv64/internal/client.go index 1cb9c532f..0dfd94374 100644 --- a/providers/dns/ipv64/internal/client.go +++ b/providers/dns/ipv64/internal/client.go @@ -131,6 +131,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errAPI := &APIError{} + err := json.Unmarshal(raw, errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/ipv64/internal/types.go b/providers/dns/ipv64/internal/types.go index e9e357ecc..6ef31a3cc 100644 --- a/providers/dns/ipv64/internal/types.go +++ b/providers/dns/ipv64/internal/types.go @@ -11,6 +11,7 @@ type APIResponse struct { type APIError struct { APIResponse + AddRecordMessage string `json:"add_record"` DelRecordMessage string `json:"del_record"` AddDomainMessage string `json:"add_domain"` @@ -41,6 +42,7 @@ func (a APIError) Error() string { type Domains struct { APIResponse + APICall string `json:"add_domain"` Subdomains map[string]Subdomain `json:"subdomains"` } diff --git a/providers/dns/ipv64/ipv64_test.go b/providers/dns/ipv64/ipv64_test.go index b3fe142e9..6dc7d1cfc 100644 --- a/providers/dns/ipv64/ipv64_test.go +++ b/providers/dns/ipv64/ipv64_test.go @@ -114,6 +114,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -171,6 +172,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -184,6 +186,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/joker/internal/dmapi/client.go b/providers/dns/joker/internal/dmapi/client.go index 6496abe2e..576410723 100644 --- a/providers/dns/joker/internal/dmapi/client.go +++ b/providers/dns/joker/internal/dmapi/client.go @@ -176,12 +176,15 @@ func RemoveTxtEntryFromZone(zone, relative string) (string, bool) { prefix := fmt.Sprintf("%s TXT 0 ", relative) modified := false + var zoneEntries []string + for line := range strings.Lines(zone) { if strings.HasPrefix(line, prefix) { modified = true continue } + zoneEntries = append(zoneEntries, line) } diff --git a/providers/dns/joker/internal/dmapi/identity.go b/providers/dns/joker/internal/dmapi/identity.go index 351d987e9..63c0b2ea1 100644 --- a/providers/dns/joker/internal/dmapi/identity.go +++ b/providers/dns/joker/internal/dmapi/identity.go @@ -24,6 +24,7 @@ type Token struct { // login performs a log in to Joker's DMAPI. func (c *Client) login(ctx context.Context) (*Response, error) { var values url.Values + switch { case c.username != "" && c.password != "": values = url.Values{ @@ -106,5 +107,6 @@ func formatResponseError(response *Response, err error) error { if response != nil { return fmt.Errorf("joker: DMAPI error: %w Response: %v", err, response.Headers) } + return fmt.Errorf("joker: DMAPI error: %w", err) } diff --git a/providers/dns/joker/joker_test.go b/providers/dns/joker/joker_test.go index 20e3fc7a5..bc21ccbbc 100644 --- a/providers/dns/joker/joker_test.go +++ b/providers/dns/joker/joker_test.go @@ -53,6 +53,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -112,6 +113,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -125,6 +127,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/joker/provider_dmapi.go b/providers/dns/joker/provider_dmapi.go index 7b32ce804..11f850136 100644 --- a/providers/dns/joker/provider_dmapi.go +++ b/providers/dns/joker/provider_dmapi.go @@ -28,6 +28,7 @@ func newDmapiProvider() (*dmapiProvider, error) { values, err := env.Get(EnvAPIKey) if err != nil { var errU error + values, errU = env.Get(EnvUsername, EnvPassword) if errU != nil { //nolint:errorlint // false-positive @@ -161,6 +162,7 @@ func (d *dmapiProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return formatResponseError(response, err) } + return nil } @@ -169,5 +171,6 @@ func formatResponseError(response *dmapi.Response, err error) error { if response != nil { return fmt.Errorf("joker: DMAPI error: %w Response: %v", err, response.Headers) } + return fmt.Errorf("joker: DMAPI error: %w", err) } diff --git a/providers/dns/joker/provider_dmapi_test.go b/providers/dns/joker/provider_dmapi_test.go index 4704f2b80..06f283872 100644 --- a/providers/dns/joker/provider_dmapi_test.go +++ b/providers/dns/joker/provider_dmapi_test.go @@ -58,6 +58,7 @@ func Test_newDmapiProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) diff --git a/providers/dns/joker/provider_svc_test.go b/providers/dns/joker/provider_svc_test.go index ad6c74c87..dc981b6b4 100644 --- a/providers/dns/joker/provider_svc_test.go +++ b/providers/dns/joker/provider_svc_test.go @@ -49,6 +49,7 @@ func Test_newSvcProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) diff --git a/providers/dns/keyhelp/internal/client.go b/providers/dns/keyhelp/internal/client.go index 3c731fc49..a5a80db5c 100644 --- a/providers/dns/keyhelp/internal/client.go +++ b/providers/dns/keyhelp/internal/client.go @@ -165,6 +165,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/keyhelp/keyhelp.go b/providers/dns/keyhelp/keyhelp.go index cbf641cfe..67ceaaa63 100644 --- a/providers/dns/keyhelp/keyhelp.go +++ b/providers/dns/keyhelp/keyhelp.go @@ -162,6 +162,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.domainIDsMu.Lock() domainID, ok := d.domainIDs[token] d.domainIDsMu.Unlock() + if !ok { return fmt.Errorf("keyhelp: unknown record ID for '%s'", info.EffectiveFQDN) } @@ -172,6 +173,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var records []internal.Record + for _, record := range domainRecords.Records.Other { if record.Type == "TXT" && record.Value == info.Value { continue diff --git a/providers/dns/keyhelp/keyhelp_test.go b/providers/dns/keyhelp/keyhelp_test.go index bdcf26ad4..8d8ac821d 100644 --- a/providers/dns/keyhelp/keyhelp_test.go +++ b/providers/dns/keyhelp/keyhelp_test.go @@ -53,6 +53,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -125,6 +126,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -138,6 +140,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/liara/internal/client.go b/providers/dns/liara/internal/client.go index 3d4af1d3b..93cdcf7c8 100644 --- a/providers/dns/liara/internal/client.go +++ b/providers/dns/liara/internal/client.go @@ -60,6 +60,7 @@ func (c *Client) GetRecords(ctx context.Context, domainName string) ([]Record, e } var response Response[[]Record] + err = json.Unmarshal(raw, &response) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -94,6 +95,7 @@ func (c *Client) CreateRecord(ctx context.Context, domainName string, record Rec } var response Response[*Record] + err = json.Unmarshal(raw, &response) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -128,6 +130,7 @@ func (c *Client) GetRecord(ctx context.Context, domainName, recordID string) (*R } var response Response[*Record] + err = json.Unmarshal(raw, &response) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -187,6 +190,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/liara/liara.go b/providers/dns/liara/liara.go index 7894afc98..b91b004cc 100644 --- a/providers/dns/liara/liara.go +++ b/providers/dns/liara/liara.go @@ -100,10 +100,12 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { } retryClient := retryablehttp.NewClient() + retryClient.RetryMax = 5 if config.HTTPClient != nil { retryClient.HTTPClient = config.HTTPClient } + retryClient.Logger = log.Logger client := internal.NewClient( @@ -145,6 +147,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { Contents: []internal.Content{{Text: info.Value}}, TTL: d.config.TTL, } + newRecord, err := d.client.CreateRecord(context.Background(), dns01.UnFqdn(authZone), record) if err != nil { return fmt.Errorf("liara: failed to create TXT record, fqdn=%s: %w", info.EffectiveFQDN, err) @@ -170,6 +173,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("liara: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/liara/liara_test.go b/providers/dns/liara/liara_test.go index 4256be55e..b1f3f77c9 100644 --- a/providers/dns/liara/liara_test.go +++ b/providers/dns/liara/liara_test.go @@ -38,6 +38,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -113,6 +114,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -126,6 +128,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/lightsail/lightsail.go b/providers/dns/lightsail/lightsail.go index ddaf7baca..95b07c503 100644 --- a/providers/dns/lightsail/lightsail.go +++ b/providers/dns/lightsail/lightsail.go @@ -99,6 +99,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { retryCount := min(attempt, 7) delay := (1 << uint(retryCount)) * (rand.Intn(50) + 200) + return time.Duration(delay) * time.Millisecond, nil }) }) diff --git a/providers/dns/lightsail/lightsail_integration_test.go b/providers/dns/lightsail/lightsail_integration_test.go index 718e57460..dc86bf079 100644 --- a/providers/dns/lightsail/lightsail_integration_test.go +++ b/providers/dns/lightsail/lightsail_integration_test.go @@ -34,6 +34,7 @@ func TestLiveTTL(t *testing.T) { require.NoError(t, err) svc := lightsail.NewFromConfig(cfg) + require.NoError(t, err) defer func() { diff --git a/providers/dns/lightsail/lightsail_test.go b/providers/dns/lightsail/lightsail_test.go index db69738fd..a6b46045e 100644 --- a/providers/dns/lightsail/lightsail_test.go +++ b/providers/dns/lightsail/lightsail_test.go @@ -34,6 +34,7 @@ var envTest = tester.NewEnvTest( func TestCredentialsFromEnv(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() _ = os.Setenv(envAwsAccessKeyID, "123") diff --git a/providers/dns/limacity/internal/client.go b/providers/dns/limacity/internal/client.go index 07622e121..ae6ab87eb 100644 --- a/providers/dns/limacity/internal/client.go +++ b/providers/dns/limacity/internal/client.go @@ -41,6 +41,7 @@ func (c *Client) GetDomains(ctx context.Context) ([]Domain, error) { } var results DomainsResponse + err = c.do(req, &results) if err != nil { return nil, err @@ -58,6 +59,7 @@ func (c *Client) GetRecords(ctx context.Context, domainID int) ([]Record, error) } var results RecordsResponse + err = c.do(req, &results) if err != nil { return nil, err @@ -75,6 +77,7 @@ func (c *Client) AddRecord(ctx context.Context, domainID int, record Record) err } var results APIResponse + err = c.do(req, &results) if err != nil { return err @@ -92,6 +95,7 @@ func (c *Client) UpdateRecord(ctx context.Context, domainID, recordID int, recor } var results APIResponse + err = c.do(req, &results) if err != nil { return err @@ -110,6 +114,7 @@ func (c *Client) DeleteRecord(ctx context.Context, domainID, recordID int) error } var results APIResponse + err = c.do(req, &results) if err != nil { return err @@ -177,6 +182,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIResponse + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/limacity/internal/types.go b/providers/dns/limacity/internal/types.go index 5fdbacef9..7411632ea 100644 --- a/providers/dns/limacity/internal/types.go +++ b/providers/dns/limacity/internal/types.go @@ -10,7 +10,7 @@ type RecordsResponse struct { } type NameserverRecordPayload struct { - Data Record `json:"nameserver_record,omitempty"` + Data Record `json:"nameserver_record"` } type DomainsResponse struct { diff --git a/providers/dns/limacity/limacity.go b/providers/dns/limacity/limacity.go index 502208f2a..9e1f58f1a 100644 --- a/providers/dns/limacity/limacity.go +++ b/providers/dns/limacity/limacity.go @@ -165,6 +165,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.domainIDsMu.Lock() domainID, ok := d.domainIDs[token] d.domainIDsMu.Unlock() + if !ok { return fmt.Errorf("limacity: unknown domain ID for '%s' '%s'", info.EffectiveFQDN, token) } @@ -175,6 +176,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var recordID int + for _, record := range records { if record.Type == "TXT" && record.Content == strconv.Quote(info.Value) { recordID = record.ID diff --git a/providers/dns/limacity/limacity_test.go b/providers/dns/limacity/limacity_test.go index 2834a5f1f..3301fcb2e 100644 --- a/providers/dns/limacity/limacity_test.go +++ b/providers/dns/limacity/limacity_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -92,6 +93,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -105,6 +107,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/linode/linode.go b/providers/dns/linode/linode.go index 449c84a1a..b03dee4f5 100644 --- a/providers/dns/linode/linode.go +++ b/providers/dns/linode/linode.go @@ -148,6 +148,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { } _, err = d.client.CreateDomainRecord(ctx, zone.domainID, createOpts) + return err } @@ -164,6 +165,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { // Get all TXT records for the specified domain. listOpts := linodego.NewListOptions(0, `{"type":"TXT"}`) + resources, err := d.client.ListDomainRecords(ctx, zone.domainID, listOpts) if err != nil { return err @@ -196,6 +198,7 @@ func (d *DNSProvider) getHostedZoneInfo(ctx context.Context, fqdn string) (*host } listOpts := linodego.NewListOptions(0, string(filter)) + domains, err := d.client.ListDomains(ctx, listOpts) if err != nil { return nil, err diff --git a/providers/dns/linode/linode_test.go b/providers/dns/linode/linode_test.go index 08549ab7e..1c4903aca 100644 --- a/providers/dns/linode/linode_test.go +++ b/providers/dns/linode/linode_test.go @@ -39,6 +39,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -94,6 +95,7 @@ func TestNewDNSProviderConfig(t *testing.T) { func TestDNSProvider_Present(t *testing.T) { defer envTest.RestoreEnv() + os.Setenv(EnvToken, "testing") domain := "example.com" @@ -178,6 +180,7 @@ func TestDNSProvider_Present(t *testing.T) { func TestDNSProvider_CleanUp(t *testing.T) { defer envTest.RestoreEnv() + os.Setenv(EnvToken, "testing") domain := "example.com" diff --git a/providers/dns/liquidweb/liquidweb.go b/providers/dns/liquidweb/liquidweb.go index 2d0a46142..b56968fe3 100644 --- a/providers/dns/liquidweb/liquidweb.go +++ b/providers/dns/liquidweb/liquidweb.go @@ -159,6 +159,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } params := &network.DNSRecordParams{ID: recordID} + _, err := d.client.NetworkDNS.Delete(params) if err != nil { return fmt.Errorf("liquidweb: could not remove TXT record: %w", err) @@ -179,6 +180,7 @@ func (d *DNSProvider) findZone(domain string) (string, error) { // filter the zones on the account to only ones that match var zs []network.DNSZone + for _, item := range zones.Items { if strings.HasSuffix(domain, item.Name) { zs = append(zs, item) diff --git a/providers/dns/liquidweb/liquidweb_test.go b/providers/dns/liquidweb/liquidweb_test.go index b0788c7f5..26dc5bdc0 100644 --- a/providers/dns/liquidweb/liquidweb_test.go +++ b/providers/dns/liquidweb/liquidweb_test.go @@ -66,6 +66,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -248,6 +249,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/liquidweb/servermock_test.go b/providers/dns/liquidweb/servermock_test.go index 9cb434761..f211e7253 100644 --- a/providers/dns/liquidweb/servermock_test.go +++ b/providers/dns/liquidweb/servermock_test.go @@ -62,6 +62,7 @@ func mockAPICreate(recs map[int]network.DNSRecord) http.HandlerFunc { http.Error(rw, makeEncodingError(body), http.StatusBadRequest) return } + payload.Params.ID = types.FlexInt(rand.Intn(10000000)) payload.Params.ZoneID = types.FlexInt(mockAPIServerZones[payload.Params.Name]) @@ -69,6 +70,7 @@ func mockAPICreate(recs map[int]network.DNSRecord) http.HandlerFunc { http.Error(rw, "dns record already exists", http.StatusTeapot) return } + recs[int(payload.Params.ID)] = payload.Params resp, err := json.Marshal(payload.Params) @@ -76,6 +78,7 @@ func mockAPICreate(recs map[int]network.DNSRecord) http.HandlerFunc { http.Error(rw, "", http.StatusInternalServerError) return } + http.Error(rw, string(resp), http.StatusOK) } } @@ -109,6 +112,7 @@ func mockAPIDelete(recs map[int]network.DNSRecord) http.HandlerFunc { http.Error(rw, fmt.Sprintf(`{"error":"","error_class":"LW::Exception::RecordNotFound","field":"network_dns_rr","full_message":"Record 'network_dns_rr: %d' not found","input":"%d","public_message":null}`, payload.Params.ID, payload.Params.ID), http.StatusOK) return } + delete(recs, payload.Params.ID) http.Error(rw, fmt.Sprintf("{\"deleted\":%d}", payload.Params.ID), http.StatusOK) } @@ -141,6 +145,7 @@ func mockAPIListZones() http.HandlerFunc { case payload.Params.PageNum > len(mockZones): payload.Params.PageNum = len(mockZones) } + resp := mockZones[payload.Params.PageNum] resp.ItemTotal = types.FlexInt(len(mockAPIServerZones)) resp.PageNum = types.FlexInt(payload.Params.PageNum) @@ -276,10 +281,12 @@ func makeMockZones() (map[int]network.DNSZoneList, map[string]int) { } mockAPIServerZones := make(map[string]int) + for _, page := range mockZones { for _, zone := range page.Items { mockAPIServerZones[zone.Name] = int(zone.ID) } } + return mockZones, mockAPIServerZones } diff --git a/providers/dns/loopia/internal/types.go b/providers/dns/loopia/internal/types.go index c286c01fd..c3425c8b1 100644 --- a/providers/dns/loopia/internal/types.go +++ b/providers/dns/loopia/internal/types.go @@ -66,6 +66,7 @@ type response interface { type responseString struct { responseFault + Value string `xml:"params>param>value>string"` } @@ -88,6 +89,7 @@ func (e RPCError) Error() string { type recordObjectsResponse struct { responseFault + XMLName xml.Name `xml:"methodResponse"` Params []RecordObj `xml:"params>param>value>array>data>value>struct"` } @@ -102,6 +104,7 @@ type RecordObj struct { func (r *RecordObj) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { var name string + for { t, err := d.Token() if err != nil { @@ -144,6 +147,7 @@ func (r *RecordObj) decodeValueString(name string, d *xml.Decoder, start xml.Sta } s = strings.TrimSpace(s) + switch name { case "type": r.Type = s diff --git a/providers/dns/loopia/loopia_test.go b/providers/dns/loopia/loopia_test.go index e397c9639..b3163fc77 100644 --- a/providers/dns/loopia/loopia_test.go +++ b/providers/dns/loopia/loopia_test.go @@ -103,6 +103,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -192,6 +193,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -205,6 +207,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/luadns/internal/client.go b/providers/dns/luadns/internal/client.go index 8e46418f2..5ce9cca86 100644 --- a/providers/dns/luadns/internal/client.go +++ b/providers/dns/luadns/internal/client.go @@ -49,6 +49,7 @@ func (c *Client) ListZones(ctx context.Context) ([]DNSZone, error) { } var zones []DNSZone + err = c.do(req, &zones) if err != nil { return nil, fmt.Errorf("could not list zones: %w", err) @@ -68,6 +69,7 @@ func (c *Client) CreateRecord(ctx context.Context, zone DNSZone, newRecord DNSRe } var record *DNSRecord + err = c.do(req, &record) if err != nil { return nil, fmt.Errorf("could not create record %#v: %w", record, err) @@ -153,6 +155,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errResp errorResponse + err := json.Unmarshal(raw, &errResp) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/luadns/luadns_test.go b/providers/dns/luadns/luadns_test.go index ea4d06ae1..a1aa36872 100644 --- a/providers/dns/luadns/luadns_test.go +++ b/providers/dns/luadns/luadns_test.go @@ -58,6 +58,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -199,6 +200,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -212,6 +214,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/mailinabox/mailinabox_test.go b/providers/dns/mailinabox/mailinabox_test.go index 1b95c220d..11143a11f 100644 --- a/providers/dns/mailinabox/mailinabox_test.go +++ b/providers/dns/mailinabox/mailinabox_test.go @@ -59,6 +59,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -136,6 +137,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -149,6 +151,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/manageengine/internal/client.go b/providers/dns/manageengine/internal/client.go index debb62812..b5a7dbae7 100644 --- a/providers/dns/manageengine/internal/client.go +++ b/providers/dns/manageengine/internal/client.go @@ -109,6 +109,7 @@ func (c *Client) UpdateZoneRecord(ctx context.Context, record ZoneRecord) error if record.SpfTxtDomainID == 0 { return errors.New("SpfTxtDomainID is empty") } + if record.ZoneID == 0 { return errors.New("ZoneID is empty") } @@ -188,6 +189,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/manageengine/manageengine.go b/providers/dns/manageengine/manageengine.go index 3863a6597..76b6644c0 100644 --- a/providers/dns/manageengine/manageengine.go +++ b/providers/dns/manageengine/manageengine.go @@ -195,6 +195,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { // Update the zone record. var values []string + for _, value := range record.Values { if value != info.Value { values = append(values, value) diff --git a/providers/dns/manageengine/manageengine_test.go b/providers/dns/manageengine/manageengine_test.go index 624459be9..215de68dd 100644 --- a/providers/dns/manageengine/manageengine_test.go +++ b/providers/dns/manageengine/manageengine_test.go @@ -50,6 +50,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -122,6 +123,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -135,6 +137,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/metaname/metaname.go b/providers/dns/metaname/metaname.go index 9b8c41def..d5d87dc4d 100644 --- a/providers/dns/metaname/metaname.go +++ b/providers/dns/metaname/metaname.go @@ -79,6 +79,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if config.AccountReference == "" { return nil, errors.New("metaname: missing account reference") } + if config.APIKey == "" { return nil, errors.New("metaname: missing api key") } diff --git a/providers/dns/metaname/metaname_test.go b/providers/dns/metaname/metaname_test.go index 174af4014..855fc493d 100644 --- a/providers/dns/metaname/metaname_test.go +++ b/providers/dns/metaname/metaname_test.go @@ -51,6 +51,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -122,6 +123,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -135,6 +137,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/metaregistrar/internal/client.go b/providers/dns/metaregistrar/internal/client.go index 711a1e94c..df99d81ba 100644 --- a/providers/dns/metaregistrar/internal/client.go +++ b/providers/dns/metaregistrar/internal/client.go @@ -121,6 +121,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/metaregistrar/metaregistrar_test.go b/providers/dns/metaregistrar/metaregistrar_test.go index ffd7965d9..aa9bbbb58 100644 --- a/providers/dns/metaregistrar/metaregistrar_test.go +++ b/providers/dns/metaregistrar/metaregistrar_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -92,6 +93,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -105,6 +107,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/mijnhost/internal/client.go b/providers/dns/mijnhost/internal/client.go index 1a67a73b1..a51233211 100644 --- a/providers/dns/mijnhost/internal/client.go +++ b/providers/dns/mijnhost/internal/client.go @@ -47,6 +47,7 @@ func (c *Client) ListDomains(ctx context.Context) ([]Domain, error) { } var results Response[DomainData] + err = c.do(req, &results) if err != nil { return nil, err @@ -66,6 +67,7 @@ func (c *Client) GetRecords(ctx context.Context, domain string) ([]Record, error } var results Response[RecordData] + err = c.do(req, &results) if err != nil { return nil, err @@ -151,6 +153,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/mijnhost/mijnhost_test.go b/providers/dns/mijnhost/mijnhost_test.go index a48f84ca8..c87ae0a40 100644 --- a/providers/dns/mijnhost/mijnhost_test.go +++ b/providers/dns/mijnhost/mijnhost_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -94,6 +95,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -107,6 +109,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/mittwald/internal/client.go b/providers/dns/mittwald/internal/client.go index 69222903d..2b1564dc1 100644 --- a/providers/dns/mittwald/internal/client.go +++ b/providers/dns/mittwald/internal/client.go @@ -47,6 +47,7 @@ func (c *Client) ListDomains(ctx context.Context) ([]Domain, error) { } var result []Domain + err = c.do(req, &result) if err != nil { return nil, err @@ -66,6 +67,7 @@ func (c *Client) GetDNSZone(ctx context.Context, zoneID string) (*DNSZone, error } result := &DNSZone{} + err = c.do(req, result) if err != nil { return nil, err @@ -85,6 +87,7 @@ func (c *Client) ListDNSZones(ctx context.Context, projectID string) ([]DNSZone, } var result []DNSZone + err = c.do(req, &result) if err != nil { return nil, err @@ -104,6 +107,7 @@ func (c *Client) CreateDNSZone(ctx context.Context, zone CreateDNSZoneRequest) ( } result := &DNSZone{} + err = c.do(req, result) if err != nil { return nil, err @@ -197,6 +201,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var response APIError + err := json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/mittwald/internal/types.go b/providers/dns/mittwald/internal/types.go index df10ab293..ce49cb820 100644 --- a/providers/dns/mittwald/internal/types.go +++ b/providers/dns/mittwald/internal/types.go @@ -1,6 +1,9 @@ package internal -import "fmt" +import ( + "fmt" + "strings" +) // https://api.mittwald.de/v2/docs/#/Domain/domain-list-domains @@ -36,7 +39,7 @@ type NewDNSZone struct { // https://api.mittwald.de/v2/docs/#/Domain/dns-update-record-set type TXTRecord struct { - Settings Settings `json:"settings,omitempty"` + Settings Settings `json:"settings"` Entries []string `json:"entries,omitempty"` } @@ -58,23 +61,25 @@ type APIError struct { } func (a APIError) Error() string { - msg := fmt.Sprintf("%s: %s", a.Type, a.Message) + var msg strings.Builder + + msg.WriteString(fmt.Sprintf("%s: %s", a.Type, a.Message)) if len(a.ValidationErrors) > 0 { for _, validationError := range a.ValidationErrors { - msg += fmt.Sprintf(" [%s: %s (%s, %s)]", - validationError.Type, validationError.Message, validationError.Path, validationError.Context.Format) + msg.WriteString(fmt.Sprintf(" [%s: %s (%s, %s)]", + validationError.Type, validationError.Message, validationError.Path, validationError.Context.Format)) } } - return msg + return msg.String() } type ValidationError struct { Message string `json:"message,omitempty"` Path string `json:"path,omitempty"` Type string `json:"type,omitempty"` - Context ValidationErrorContext `json:"context,omitempty"` + Context ValidationErrorContext `json:"context"` } type ValidationErrorContext struct { diff --git a/providers/dns/mittwald/mittwald.go b/providers/dns/mittwald/mittwald.go index f60745659..6292dd787 100644 --- a/providers/dns/mittwald/mittwald.go +++ b/providers/dns/mittwald/mittwald.go @@ -158,6 +158,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.zoneIDsMu.Lock() zoneID, ok := d.zoneIDs[token] d.zoneIDsMu.Unlock() + if !ok { return fmt.Errorf("mittwald: unknown zone ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/mittwald/mittwald_test.go b/providers/dns/mittwald/mittwald_test.go index d8cbdb263..6a6599536 100644 --- a/providers/dns/mittwald/mittwald_test.go +++ b/providers/dns/mittwald/mittwald_test.go @@ -38,6 +38,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -104,6 +105,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -117,6 +119,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/myaddr/myaddr_test.go b/providers/dns/myaddr/myaddr_test.go index d95a0cf5c..8e555ecfd 100644 --- a/providers/dns/myaddr/myaddr_test.go +++ b/providers/dns/myaddr/myaddr_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -92,6 +93,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -105,6 +107,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/mydnsjp/mydnsjp.go b/providers/dns/mydnsjp/mydnsjp.go index 934fe764a..8a790c88e 100644 --- a/providers/dns/mydnsjp/mydnsjp.go +++ b/providers/dns/mydnsjp/mydnsjp.go @@ -109,6 +109,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("mydnsjp: %w", err) } + return nil } @@ -121,5 +122,6 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("mydnsjp: %w", err) } + return nil } diff --git a/providers/dns/mydnsjp/mydnsjp_test.go b/providers/dns/mydnsjp/mydnsjp_test.go index 96eb95865..c82bd2264 100644 --- a/providers/dns/mydnsjp/mydnsjp_test.go +++ b/providers/dns/mydnsjp/mydnsjp_test.go @@ -56,6 +56,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -124,6 +125,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -137,6 +139,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/mythicbeasts/internal/client.go b/providers/dns/mythicbeasts/internal/client.go index 87464553c..82c51dbf3 100644 --- a/providers/dns/mythicbeasts/internal/client.go +++ b/providers/dns/mythicbeasts/internal/client.go @@ -99,6 +99,7 @@ func (c *Client) createTXTRecord(ctx context.Context, zone, leaf, recordType, va } resp := &createTXTResponse{} + err = c.do(req, resp) if err != nil { return nil, err diff --git a/providers/dns/mythicbeasts/internal/identity.go b/providers/dns/mythicbeasts/internal/identity.go index 417f1c759..15e35ba69 100644 --- a/providers/dns/mythicbeasts/internal/identity.go +++ b/providers/dns/mythicbeasts/internal/identity.go @@ -44,6 +44,7 @@ func (c *Client) obtainToken(ctx context.Context) (*Token, error) { } tok := Token{} + err = json.Unmarshal(raw, &tok) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -83,6 +84,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errResp := &authResponseError{} + err := json.Unmarshal(raw, errResp) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/mythicbeasts/mythicbeasts.go b/providers/dns/mythicbeasts/mythicbeasts.go index 30d1eaa3e..e8f5081f7 100644 --- a/providers/dns/mythicbeasts/mythicbeasts.go +++ b/providers/dns/mythicbeasts/mythicbeasts.go @@ -88,6 +88,7 @@ func NewDNSProvider() (*DNSProvider, error) { if err != nil { return nil, fmt.Errorf("mythicbeasts: %w", err) } + config.UserName = values[EnvUserName] config.Password = values[EnvPassword] diff --git a/providers/dns/mythicbeasts/mythicbeasts_test.go b/providers/dns/mythicbeasts/mythicbeasts_test.go index 5a8a9d4bb..c684725b7 100644 --- a/providers/dns/mythicbeasts/mythicbeasts_test.go +++ b/providers/dns/mythicbeasts/mythicbeasts_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -108,6 +109,7 @@ func TestNewDNSProviderConfig(t *testing.T) { t.Run(test.desc, func(t *testing.T) { config, err := NewDefaultConfig() require.NoError(t, err) + config.UserName = test.username config.Password = test.password @@ -130,6 +132,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -143,6 +146,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/namecheap/internal/client.go b/providers/dns/namecheap/internal/client.go index 0fb32b1be..6fb737b95 100644 --- a/providers/dns/namecheap/internal/client.go +++ b/providers/dns/namecheap/internal/client.go @@ -54,6 +54,7 @@ func (c *Client) GetHosts(ctx context.Context, sld, tld string) ([]Record, error } var ghr getHostsResponse + err = c.do(request, &ghr) if err != nil { return nil, err @@ -88,6 +89,7 @@ func (c *Client) SetHosts(ctx context.Context, sld, tld string, hosts []Record) } var shr setHostsResponse + err = c.do(req, &shr) if err != nil { return err @@ -96,6 +98,7 @@ func (c *Client) SetHosts(ctx context.Context, sld, tld string, hosts []Record) if len(shr.Errors) > 0 { return shr.Errors[0] } + if shr.Result.IsSuccess != "true" { return errors.New("setHosts failed") } diff --git a/providers/dns/namecheap/namecheap.go b/providers/dns/namecheap/namecheap.go index e21ddf556..cf8520546 100644 --- a/providers/dns/namecheap/namecheap.go +++ b/providers/dns/namecheap/namecheap.go @@ -118,6 +118,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if err != nil { return nil, fmt.Errorf("namecheap: %w", err) } + config.ClientIP = clientIP } @@ -174,6 +175,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("namecheap: %w", err) } + return nil } @@ -193,8 +195,11 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } // Find the challenge TXT record and remove it if found. - var found bool - var newRecords []internal.Record + var ( + found bool + newRecords []internal.Record + ) + for _, h := range records { if h.Name == pr.key && h.Type == "TXT" { found = true @@ -211,6 +216,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("namecheap: %w", err) } + return nil } diff --git a/providers/dns/namecheap/namecheap_test.go b/providers/dns/namecheap/namecheap_test.go index e0c947095..e55a4a6bc 100644 --- a/providers/dns/namecheap/namecheap_test.go +++ b/providers/dns/namecheap/namecheap_test.go @@ -152,6 +152,7 @@ func Test_newPseudoRecord_domainSplit(t *testing.T) { for _, test := range tests { t.Run(test.domain, func(t *testing.T) { valid := true + ch, err := newPseudoRecord(test.domain, "") if err != nil { valid = false diff --git a/providers/dns/namedotcom/namedotcom.go b/providers/dns/namedotcom/namedotcom.go index 1c0f162de..3d1f33af1 100644 --- a/providers/dns/namedotcom/namedotcom.go +++ b/providers/dns/namedotcom/namedotcom.go @@ -161,6 +161,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { DomainName: domain, ID: rec.ID, } + _, err := d.client.DeleteRecord(request) if err != nil { return fmt.Errorf("namedotcom: %w", err) @@ -184,6 +185,7 @@ func (d *DNSProvider) getRecords(domain string) ([]*namecom.Record, error) { } var records []*namecom.Record + for request.Page > 0 { response, err := d.client.ListRecords(request) if err != nil { diff --git a/providers/dns/namedotcom/namedotcom_test.go b/providers/dns/namedotcom/namedotcom_test.go index c7d4deaa1..da9878bdc 100644 --- a/providers/dns/namedotcom/namedotcom_test.go +++ b/providers/dns/namedotcom/namedotcom_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -131,6 +132,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -144,6 +146,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/namesilo/namesilo.go b/providers/dns/namesilo/namesilo.go index e2f66f8c9..0297b4e1c 100644 --- a/providers/dns/namesilo/namesilo.go +++ b/providers/dns/namesilo/namesilo.go @@ -118,6 +118,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("namesilo: failed to add record %w", err) } + return nil } diff --git a/providers/dns/namesilo/namesilo_test.go b/providers/dns/namesilo/namesilo_test.go index e3ef956bf..09eacd035 100644 --- a/providers/dns/namesilo/namesilo_test.go +++ b/providers/dns/namesilo/namesilo_test.go @@ -45,6 +45,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -112,6 +113,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/nearlyfreespeech/internal/client.go b/providers/dns/nearlyfreespeech/internal/client.go index fcfe4e9b7..5d7e79fbe 100644 --- a/providers/dns/nearlyfreespeech/internal/client.go +++ b/providers/dns/nearlyfreespeech/internal/client.go @@ -97,6 +97,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errAPI := &APIError{} + err := json.Unmarshal(raw, errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) @@ -118,7 +119,6 @@ func (c Signer) Sign(uri, body, login, apiKey string) string { // Header is "login;timestamp;salt;hash". // hash is SHA1("login;timestamp;salt;api-key;request-uri;body-hash") // and body-hash is SHA1(body). - bodyHash := sha1.Sum([]byte(body)) timestamp := strconv.FormatInt(c.clock().Unix(), 10) diff --git a/providers/dns/nearlyfreespeech/internal/client_test.go b/providers/dns/nearlyfreespeech/internal/client_test.go index 1445286c3..26e4552be 100644 --- a/providers/dns/nearlyfreespeech/internal/client_test.go +++ b/providers/dns/nearlyfreespeech/internal/client_test.go @@ -163,6 +163,7 @@ func TestSigner_Sign(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { t.Parallel() + signer := NewSigner() signer.saltShaker = func() []byte { return []byte(test.salt) } signer.clock = func() time.Time { return time.Unix(test.now, 0) } diff --git a/providers/dns/nearlyfreespeech/nearlyfreespeech_test.go b/providers/dns/nearlyfreespeech/nearlyfreespeech_test.go index adc7efe1e..b67b350e9 100644 --- a/providers/dns/nearlyfreespeech/nearlyfreespeech_test.go +++ b/providers/dns/nearlyfreespeech/nearlyfreespeech_test.go @@ -54,6 +54,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -126,6 +127,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -139,6 +141,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/netcup/internal/client.go b/providers/dns/netcup/internal/client.go index 553733175..1287a8d7a 100644 --- a/providers/dns/netcup/internal/client.go +++ b/providers/dns/netcup/internal/client.go @@ -80,6 +80,7 @@ func (c *Client) GetDNSRecords(ctx context.Context, hostname string) ([]DNSRecor } var responseData InfoDNSRecordsResponse + err := c.doRequest(ctx, payload, &responseData) if err != nil { return nil, fmt.Errorf("error when sending the request: %w", err) @@ -139,6 +140,7 @@ func GetDNSRecordIdx(records []DNSRecord, record DNSRecord) (int, error) { return index, nil } } + return -1, errors.New("no DNS Record found") } @@ -173,6 +175,7 @@ func unmarshalResponseMsg(req *http.Request, resp *http.Response) (*ResponseMsg, } var respMsg ResponseMsg + err = json.Unmarshal(raw, &respMsg) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/netcup/internal/session.go b/providers/dns/netcup/internal/session.go index 6627d74e1..b53751edf 100644 --- a/providers/dns/netcup/internal/session.go +++ b/providers/dns/netcup/internal/session.go @@ -24,6 +24,7 @@ func (c *Client) login(ctx context.Context) (string, error) { } var responseData LoginResponse + err := c.doRequest(ctx, payload, &responseData) if err != nil { return "", fmt.Errorf("loging error: %w", err) diff --git a/providers/dns/netcup/netcup_test.go b/providers/dns/netcup/netcup_test.go index a0c631f46..fedc56ba9 100644 --- a/providers/dns/netcup/netcup_test.go +++ b/providers/dns/netcup/netcup_test.go @@ -72,6 +72,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -158,6 +159,7 @@ func TestLivePresentAndCleanup(t *testing.T) { } envTest.RestoreEnv() + p, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/netlify/internal/client.go b/providers/dns/netlify/internal/client.go index a8e3b35c3..3b6b681fe 100644 --- a/providers/dns/netlify/internal/client.go +++ b/providers/dns/netlify/internal/client.go @@ -59,6 +59,7 @@ func (c *Client) GetRecords(ctx context.Context, zoneID string) ([]DNSRecord, er } var records []DNSRecord + err = json.Unmarshal(raw, &records) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -93,6 +94,7 @@ func (c *Client) CreateRecord(ctx context.Context, zoneID string, record DNSReco } var recordResp DNSRecord + err = json.Unmarshal(raw, &recordResp) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/netlify/netlify.go b/providers/dns/netlify/netlify.go index b95a1a128..5b2980d24 100644 --- a/providers/dns/netlify/netlify.go +++ b/providers/dns/netlify/netlify.go @@ -149,6 +149,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("netlify: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/netlify/netlify_test.go b/providers/dns/netlify/netlify_test.go index f351802da..1e84517be 100644 --- a/providers/dns/netlify/netlify_test.go +++ b/providers/dns/netlify/netlify_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -93,6 +94,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -106,6 +108,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/nicmanager/internal/client.go b/providers/dns/nicmanager/internal/client.go index eb84e29ec..16bfe497b 100644 --- a/providers/dns/nicmanager/internal/client.go +++ b/providers/dns/nicmanager/internal/client.go @@ -83,6 +83,7 @@ func (c *Client) GetZone(ctx context.Context, name string) (*Zone, error) { } var zone Zone + err = c.do(req, http.StatusOK, &zone) if err != nil { return nil, err diff --git a/providers/dns/nicmanager/nicmanager.go b/providers/dns/nicmanager/nicmanager.go index ff9a20125..9b27df64e 100644 --- a/providers/dns/nicmanager/nicmanager.go +++ b/providers/dns/nicmanager/nicmanager.go @@ -191,8 +191,11 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { name := dns01.UnFqdn(info.EffectiveFQDN) - var existingRecord internal.Record - var existingRecordFound bool + var ( + existingRecord internal.Record + existingRecordFound bool + ) + for _, record := range zone.Records { if strings.EqualFold(record.Type, "TXT") && strings.EqualFold(record.Name, name) && record.Content == info.Value { existingRecord = record diff --git a/providers/dns/nicmanager/nicmanager_test.go b/providers/dns/nicmanager/nicmanager_test.go index bc2f50cc3..114cdb7ca 100644 --- a/providers/dns/nicmanager/nicmanager_test.go +++ b/providers/dns/nicmanager/nicmanager_test.go @@ -66,6 +66,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -159,6 +160,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -172,6 +174,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/nicru/internal/client.go b/providers/dns/nicru/internal/client.go index 37acd68f1..5d851fc76 100644 --- a/providers/dns/nicru/internal/client.go +++ b/providers/dns/nicru/internal/client.go @@ -30,6 +30,7 @@ func (tr Trimmer) Token() (xml.Token, error) { if cd, ok := t.(xml.CharData); ok { t = xml.CharData(bytes.TrimSpace(cd)) } + return t, err } diff --git a/providers/dns/nicru/nicru_test.go b/providers/dns/nicru/nicru_test.go index 12db3a4ff..7e71f9d2c 100644 --- a/providers/dns/nicru/nicru_test.go +++ b/providers/dns/nicru/nicru_test.go @@ -75,6 +75,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -171,6 +172,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -184,6 +186,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/nifcloud/internal/client.go b/providers/dns/nifcloud/internal/client.go index 4469a1f78..0f3851883 100644 --- a/providers/dns/nifcloud/internal/client.go +++ b/providers/dns/nifcloud/internal/client.go @@ -59,6 +59,7 @@ func (c *Client) ChangeResourceRecordSets(ctx context.Context, hostedZoneID stri } output := &ChangeResourceRecordSetsResponse{} + err = c.do(req, output) if err != nil { return nil, err @@ -77,6 +78,7 @@ func (c *Client) GetChange(ctx context.Context, statusID string) (*GetChangeResp } output := &GetChangeResponse{} + err = c.do(req, output) if err != nil { return nil, err @@ -129,6 +131,7 @@ func (c *Client) sign(req *http.Request) error { } mac := hmac.New(sha1.New, []byte(c.secretKey)) + _, err := mac.Write([]byte(req.Header.Get("Date"))) if err != nil { return err @@ -148,6 +151,7 @@ func newXMLRequest(ctx context.Context, method string, endpoint *url.URL, payloa if payload != nil { body.WriteString(xml.Header) + err := xml.NewEncoder(body).Encode(payload) if err != nil { return nil, fmt.Errorf("failed to create request XML body: %w", err) @@ -170,6 +174,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errResp := &ErrorResponse{} + err := xml.Unmarshal(raw, errResp) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/nifcloud/nifcloud.go b/providers/dns/nifcloud/nifcloud.go index 2310d3805..ced7eff09 100644 --- a/providers/dns/nifcloud/nifcloud.go +++ b/providers/dns/nifcloud/nifcloud.go @@ -119,6 +119,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("nifcloud: %w", err) } + return err } @@ -132,6 +133,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("nifcloud: %w", err) } + return err } diff --git a/providers/dns/nifcloud/nifcloud_test.go b/providers/dns/nifcloud/nifcloud_test.go index 9b635edfc..0eff98a71 100644 --- a/providers/dns/nifcloud/nifcloud_test.go +++ b/providers/dns/nifcloud/nifcloud_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -129,6 +130,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -142,6 +144,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/njalla/internal/client.go b/providers/dns/njalla/internal/client.go index f64db3c80..d2893253f 100644 --- a/providers/dns/njalla/internal/client.go +++ b/providers/dns/njalla/internal/client.go @@ -46,6 +46,7 @@ func (c *Client) AddRecord(ctx context.Context, record Record) (*Record, error) } var result APIResponse[*Record] + err = c.do(req, &result) if err != nil { return nil, err @@ -92,6 +93,7 @@ func (c *Client) ListRecords(ctx context.Context, domain string) ([]Record, erro } var result APIResponse[Records] + err = c.do(req, &result) if err != nil { return nil, err diff --git a/providers/dns/njalla/njalla.go b/providers/dns/njalla/njalla.go index f35e32f37..2f9aef8ea 100644 --- a/providers/dns/njalla/njalla.go +++ b/providers/dns/njalla/njalla.go @@ -148,6 +148,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("njalla: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/njalla/njalla_test.go b/providers/dns/njalla/njalla_test.go index f1489257b..61f106d75 100644 --- a/providers/dns/njalla/njalla_test.go +++ b/providers/dns/njalla/njalla_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -95,6 +96,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -108,6 +110,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/nodion/nodion.go b/providers/dns/nodion/nodion.go index 55af3a847..e34d7db28 100644 --- a/providers/dns/nodion/nodion.go +++ b/providers/dns/nodion/nodion.go @@ -172,6 +172,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.zoneIDsMu.Lock() zoneID, ok := d.zoneIDs[token] d.zoneIDsMu.Unlock() + if !ok { return fmt.Errorf("nodion: unknown zone ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/nodion/nodion_test.go b/providers/dns/nodion/nodion_test.go index fbf4b89eb..0ec5c1627 100644 --- a/providers/dns/nodion/nodion_test.go +++ b/providers/dns/nodion/nodion_test.go @@ -34,6 +34,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -91,6 +92,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -104,6 +106,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/ns1/ns1.go b/providers/dns/ns1/ns1.go index 83faf7e5e..6a7846e85 100644 --- a/providers/dns/ns1/ns1.go +++ b/providers/dns/ns1/ns1.go @@ -147,10 +147,12 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } name := dns01.UnFqdn(info.EffectiveFQDN) + _, err = d.client.Records.Delete(zone.Zone, name, "TXT") if err != nil { return fmt.Errorf("ns1: failed to delete record [zone: %q, domain: %q]: %w", zone.Zone, name, err) } + return nil } diff --git a/providers/dns/ns1/ns1_test.go b/providers/dns/ns1/ns1_test.go index 6df6b4afb..82fa70c52 100644 --- a/providers/dns/ns1/ns1_test.go +++ b/providers/dns/ns1/ns1_test.go @@ -37,6 +37,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -96,6 +97,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -109,6 +111,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/octenium/octenium.go b/providers/dns/octenium/octenium.go index 383523575..af469f5ed 100644 --- a/providers/dns/octenium/octenium.go +++ b/providers/dns/octenium/octenium.go @@ -146,6 +146,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.domainIDsMu.Lock() domainID, ok := d.domainIDs[token] d.domainIDsMu.Unlock() + if !ok { return fmt.Errorf("octenium: unknown domain ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/octenium/octenium_test.go b/providers/dns/octenium/octenium_test.go index a6c801bad..dbb8d64b3 100644 --- a/providers/dns/octenium/octenium_test.go +++ b/providers/dns/octenium/octenium_test.go @@ -43,6 +43,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -106,6 +107,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -119,6 +121,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/oraclecloud/oraclecloud.go b/providers/dns/oraclecloud/oraclecloud.go index 4ef891322..730b3f212 100644 --- a/providers/dns/oraclecloud/oraclecloud.go +++ b/providers/dns/oraclecloud/oraclecloud.go @@ -218,6 +218,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var deleteHash *string + for _, record := range domainRecords.Items { if record.Rdata != nil && *record.Rdata == `"`+info.Value+`"` { deleteHash = record.RecordHash diff --git a/providers/dns/oraclecloud/oraclecloud_test.go b/providers/dns/oraclecloud/oraclecloud_test.go index 058566504..c646e90f2 100644 --- a/providers/dns/oraclecloud/oraclecloud_test.go +++ b/providers/dns/oraclecloud/oraclecloud_test.go @@ -6,6 +6,7 @@ import ( "crypto/x509" "encoding/base64" "encoding/pem" + "maps" "net/http/httptest" "os" "testing" @@ -187,8 +188,10 @@ func TestNewDNSProvider(t *testing.T) { if privKeyFile != "" { _ = os.Remove(privKeyFile) } + envTest.RestoreEnv() }() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -257,9 +260,7 @@ func TestNewDNSProvider_instance_principal(t *testing.T) { envSDKAuthClientRegionURL: serverURL, } - for k, v := range test.envVars { - envVars[k] = v - } + maps.Copy(envVars, test.envVars) envTest.Apply(envVars) @@ -332,6 +333,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -345,6 +347,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/otc/internal/client.go b/providers/dns/otc/internal/client.go index 0bb4dd323..adb0682e1 100644 --- a/providers/dns/otc/internal/client.go +++ b/providers/dns/otc/internal/client.go @@ -69,9 +69,11 @@ func (c *Client) getZones(ctx context.Context, zone string, privateZone bool) (* query := endpoint.Query() query.Set("name", zone) + if privateZone { query.Set("type", "private") } + endpoint.RawQuery = query.Encode() req, err := newJSONRequest(ctx, http.MethodGet, endpoint, nil) @@ -80,6 +82,7 @@ func (c *Client) getZones(ctx context.Context, zone string, privateZone bool) (* } var zones ZonesResponse + err = c.do(req, &zones) if err != nil { return nil, err @@ -126,6 +129,7 @@ func (c *Client) getRecordSet(ctx context.Context, zoneID, fqdn string) (*Record } var recordSetsRes RecordSetsResponse + err = c.do(req, &recordSetsRes) if err != nil { return nil, err @@ -166,9 +170,11 @@ func (c *Client) DeleteRecordSet(ctx context.Context, zoneID, recordID string) e func (c *Client) do(req *http.Request, result any) error { c.muToken.Lock() + if c.token != "" { req.Header.Set("X-Auth-Token", c.token) } + c.muToken.Unlock() resp, err := c.HTTPClient.Do(req) diff --git a/providers/dns/otc/internal/identity.go b/providers/dns/otc/internal/identity.go index f9e7cb08f..154ec65e2 100644 --- a/providers/dns/otc/internal/identity.go +++ b/providers/dns/otc/internal/identity.go @@ -46,6 +46,7 @@ func (c *Client) Login(ctx context.Context) error { c.muToken.Lock() defer c.muToken.Unlock() + c.token = token if c.token == "" { @@ -96,6 +97,7 @@ func (c *Client) obtainUserToken(ctx context.Context, payload LoginRequest) (*To } var newToken TokenResponse + err = json.Unmarshal(raw, &newToken) if err != nil { return nil, "", errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -106,6 +108,7 @@ func (c *Client) obtainUserToken(ctx context.Context, payload LoginRequest) (*To func getBaseURL(tokenResp *TokenResponse) (*url.URL, error) { var endpoints []Endpoint + for _, v := range tokenResp.Token.Catalog { if v.Type == "dns" { endpoints = append(endpoints, v.Endpoints...) diff --git a/providers/dns/otc/internal/types.go b/providers/dns/otc/internal/types.go index 38da4f110..e7bfe8fcb 100644 --- a/providers/dns/otc/internal/types.go +++ b/providers/dns/otc/internal/types.go @@ -41,8 +41,8 @@ type TokenResponse struct { } type Token struct { - User UserR `json:"user,omitempty"` - Domain Domain `json:"domain,omitempty"` + User UserR `json:"user"` + Domain Domain `json:"domain"` Catalog []Catalog `json:"catalog,omitempty"` Methods []string `json:"methods,omitempty"` Roles []Role `json:"roles,omitempty"` @@ -59,7 +59,7 @@ type Catalog struct { type UserR struct { ID string `json:"id,omitempty"` - Domain Domain `json:"domain,omitempty"` + Domain Domain `json:"domain"` Name string `json:"name,omitempty"` PasswordExpiresAt string `json:"password_expires_at,omitempty"` } @@ -106,7 +106,7 @@ type RecordSets struct { // ZonesResponse type ZonesResponse struct { - Links Links `json:"links,omitempty"` + Links Links `json:"links"` Zones []Zone `json:"zones"` Metadata Metadata `json:"metadata"` } diff --git a/providers/dns/otc/otc_test.go b/providers/dns/otc/otc_test.go index 0b59e02ac..518ce0f19 100644 --- a/providers/dns/otc/otc_test.go +++ b/providers/dns/otc/otc_test.go @@ -93,6 +93,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -191,6 +192,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -204,6 +206,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/ovh/ovh.go b/providers/dns/ovh/ovh.go index 7ef89eff2..b7e522540 100644 --- a/providers/dns/ovh/ovh.go +++ b/providers/dns/ovh/ovh.go @@ -191,6 +191,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { // Create TXT record var respData Record + err = d.client.Post(reqURL, reqData, &respData) if err != nil { return fmt.Errorf("ovh: error when call api to add record (%s): %w", reqURL, err) @@ -198,6 +199,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { // Apply the change reqURL = fmt.Sprintf("/domain/zone/%s/refresh", authZone) + err = d.client.Post(reqURL, nil, nil) if err != nil { return fmt.Errorf("ovh: error when call api to refresh zone (%s): %w", reqURL, err) @@ -218,6 +220,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("ovh: unknown record ID for '%s'", info.EffectiveFQDN) } @@ -238,6 +241,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { // Apply the change reqURL = fmt.Sprintf("/domain/zone/%s/refresh", authZone) + err = d.client.Post(reqURL, nil, nil) if err != nil { return fmt.Errorf("ovh: error when call api to refresh zone (%s): %w", reqURL, err) @@ -258,8 +262,10 @@ func (d *DNSProvider) Timeout() (timeout, interval time.Duration) { } func newClient(config *Config) (*ovh.Client, error) { - var client *ovh.Client - var err error + var ( + client *ovh.Client + err error + ) switch { case config.hasAppKeyAuth(): diff --git a/providers/dns/ovh/ovh_test.go b/providers/dns/ovh/ovh_test.go index fcb2300b6..332e7f192 100644 --- a/providers/dns/ovh/ovh_test.go +++ b/providers/dns/ovh/ovh_test.go @@ -162,6 +162,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -315,6 +316,7 @@ func TestNewDNSProviderConfig(t *testing.T) { // The OVH client use the same env vars than lego, so it requires to clean them. defer envTest.RestoreEnv() + envTest.ClearEnv() for _, test := range testCases { @@ -354,6 +356,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -367,6 +370,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/pdns/internal/client.go b/providers/dns/pdns/internal/client.go index f6b55d5de..f72dd4d78 100644 --- a/providers/dns/pdns/internal/client.go +++ b/providers/dns/pdns/internal/client.go @@ -69,6 +69,7 @@ func (c *Client) getAPIVersion(ctx context.Context) (int, error) { } var versions []apiVersion + err = json.Unmarshal(result, &versions) if err != nil { return 0, err @@ -98,6 +99,7 @@ func (c *Client) GetHostedZone(ctx context.Context, authZone string) (*HostedZon } var zone HostedZone + err = json.Unmarshal(result, &zone) if err != nil { return nil, err @@ -180,6 +182,7 @@ func (c *Client) do(req *http.Request) (json.RawMessage, error) { } var msg json.RawMessage + err = json.NewDecoder(resp.Body).Decode(&msg) if err != nil { if errors.Is(err, io.EOF) { @@ -193,10 +196,12 @@ func (c *Client) do(req *http.Request) (json.RawMessage, error) { // check for PowerDNS error message if len(msg) > 0 && msg[0] == '{' { var errInfo apiError + err = json.Unmarshal(msg, &errInfo) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, msg, err) } + if errInfo.ShortMsg != "" { return nil, fmt.Errorf("error talking to PDNS API: %w", errInfo) } diff --git a/providers/dns/pdns/pdns.go b/providers/dns/pdns/pdns.go index 0d3c6fdea..e7ead7078 100644 --- a/providers/dns/pdns/pdns.go +++ b/providers/dns/pdns/pdns.go @@ -213,6 +213,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var records []internal.Record + for _, r := range set.Records { if r.Content != strconv.Quote(info.Value) { records = append(records, r) diff --git a/providers/dns/pdns/pdns_test.go b/providers/dns/pdns/pdns_test.go index 6762e892e..0213ba17c 100644 --- a/providers/dns/pdns/pdns_test.go +++ b/providers/dns/pdns/pdns_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -136,6 +137,7 @@ func TestLivePresentAndCleanup(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -155,5 +157,6 @@ func mustParse(rawURL string) *url.URL { if err != nil { panic(err) } + return u } diff --git a/providers/dns/plesk/internal/client.go b/providers/dns/plesk/internal/client.go index 88a7fdd9f..47abba805 100644 --- a/providers/dns/plesk/internal/client.go +++ b/providers/dns/plesk/internal/client.go @@ -121,6 +121,7 @@ func (c *Client) doRequest(ctx context.Context, payload RequestPacketType) (*Res endpoint := c.baseURL.JoinPath("/enterprise/control/agent.php") body := new(bytes.Buffer) + err := xml.NewEncoder(body).Encode(payload) if err != nil { return nil, err @@ -153,6 +154,7 @@ func (c *Client) doRequest(ctx context.Context, payload RequestPacketType) (*Res } var response ResponsePacketType + err = xml.Unmarshal(raw, &response) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/plesk/plesk.go b/providers/dns/plesk/plesk.go index f377cb8ac..b764dff33 100644 --- a/providers/dns/plesk/plesk.go +++ b/providers/dns/plesk/plesk.go @@ -163,6 +163,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("plesk: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/plesk/plesk_test.go b/providers/dns/plesk/plesk_test.go index 417e2c1da..506a26a2a 100644 --- a/providers/dns/plesk/plesk_test.go +++ b/providers/dns/plesk/plesk_test.go @@ -67,6 +67,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -149,6 +150,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -162,6 +164,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/porkbun/porkbun.go b/providers/dns/porkbun/porkbun.go index 4805418ee..dc9efb013 100644 --- a/providers/dns/porkbun/porkbun.go +++ b/providers/dns/porkbun/porkbun.go @@ -154,6 +154,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("porkbun: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/porkbun/porkbun_test.go b/providers/dns/porkbun/porkbun_test.go index cdf022b5d..7c69edfdb 100644 --- a/providers/dns/porkbun/porkbun_test.go +++ b/providers/dns/porkbun/porkbun_test.go @@ -54,6 +54,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -124,6 +125,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -137,6 +139,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/rackspace/internal/client.go b/providers/dns/rackspace/internal/client.go index 076409ebd..4a1872484 100644 --- a/providers/dns/rackspace/internal/client.go +++ b/providers/dns/rackspace/internal/client.go @@ -113,6 +113,7 @@ func (c *Client) listDomainsByName(ctx context.Context, domain string) (*ZoneSea } var zoneSearchResponse ZoneSearchResponse + err = c.do(req, &zoneSearchResponse) if err != nil { return nil, err @@ -154,6 +155,7 @@ func (c *Client) searchRecords(ctx context.Context, zoneID, recordName, recordTy } var records Records + err = c.do(req, &records) if err != nil { return nil, err diff --git a/providers/dns/rackspace/internal/identity.go b/providers/dns/rackspace/internal/identity.go index 062350df5..3ff667fb8 100644 --- a/providers/dns/rackspace/internal/identity.go +++ b/providers/dns/rackspace/internal/identity.go @@ -65,6 +65,7 @@ func (a *Identifier) Login(ctx context.Context, apiUser, apiKey string) (*Identi } var identity Identity + err = json.Unmarshal(raw, &identity) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/rackspace/rackspace.go b/providers/dns/rackspace/rackspace.go index f796a494d..b4c7b4a0f 100644 --- a/providers/dns/rackspace/rackspace.go +++ b/providers/dns/rackspace/rackspace.go @@ -99,6 +99,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { // Iterate through the Service Catalog to get the DNS Endpoint var dnsEndpoint string + for _, service := range identity.Access.ServiceCatalog { if service.Name == "cloudDNS" { dnsEndpoint = service.Endpoints[0].PublicURL diff --git a/providers/dns/rackspace/rackspace_test.go b/providers/dns/rackspace/rackspace_test.go index 4f270ee6c..de0749fd3 100644 --- a/providers/dns/rackspace/rackspace_test.go +++ b/providers/dns/rackspace/rackspace_test.go @@ -75,6 +75,7 @@ func TestLiveNewDNSProvider_ValidEnv(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -87,6 +88,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -100,6 +102,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/rainyun/internal/client.go b/providers/dns/rainyun/internal/client.go index 3d99bd9be..595b39f29 100644 --- a/providers/dns/rainyun/internal/client.go +++ b/providers/dns/rainyun/internal/client.go @@ -84,6 +84,7 @@ func (c *Client) ListRecords(ctx context.Context, domainID int) ([]Record, error } var recordData APIResponse[Record] + err = c.do(req, &recordData) if err != nil { return nil, err @@ -173,6 +174,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/rainyun/rainyun_test.go b/providers/dns/rainyun/rainyun_test.go index d0048e5d0..d27d47e81 100644 --- a/providers/dns/rainyun/rainyun_test.go +++ b/providers/dns/rainyun/rainyun_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -92,6 +93,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -105,6 +107,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/rcodezero/internal/client.go b/providers/dns/rcodezero/internal/client.go index d37fec2dd..5cf39907e 100644 --- a/providers/dns/rcodezero/internal/client.go +++ b/providers/dns/rcodezero/internal/client.go @@ -64,6 +64,7 @@ func (c *Client) do(req *http.Request) (*APIResponse, error) { } result := &APIResponse{} + raw, err := io.ReadAll(resp.Body) if err != nil { return nil, errutils.NewReadResponseError(req, resp.StatusCode, err) @@ -105,6 +106,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errAPI := &APIResponse{} + err := json.Unmarshal(raw, errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/rcodezero/rcodezero_test.go b/providers/dns/rcodezero/rcodezero_test.go index 1f0946072..a4a242c30 100644 --- a/providers/dns/rcodezero/rcodezero_test.go +++ b/providers/dns/rcodezero/rcodezero_test.go @@ -37,6 +37,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -94,6 +95,7 @@ func TestLivePresentAndCleanup(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/regfish/regfish.go b/providers/dns/regfish/regfish.go index fb2ffaeb6..85aac92e5 100644 --- a/providers/dns/regfish/regfish.go +++ b/providers/dns/regfish/regfish.go @@ -132,6 +132,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("regfish: unknown record ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/regfish/regfish_test.go b/providers/dns/regfish/regfish_test.go index 80928048f..6613bd508 100644 --- a/providers/dns/regfish/regfish_test.go +++ b/providers/dns/regfish/regfish_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -92,6 +93,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -105,6 +107,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/regru/internal/client.go b/providers/dns/regru/internal/client.go index 4b0205b0f..b0b86d567 100644 --- a/providers/dns/regru/internal/client.go +++ b/providers/dns/regru/internal/client.go @@ -111,6 +111,7 @@ func (c *Client) doRequest(ctx context.Context, request any, fragments ...string } var apiResp APIResponse + err = json.Unmarshal(raw, &apiResp) if err != nil { return nil, errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) @@ -123,6 +124,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIResponse + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/regru/regru_test.go b/providers/dns/regru/regru_test.go index 15d86d75c..762eeb4d3 100644 --- a/providers/dns/regru/regru_test.go +++ b/providers/dns/regru/regru_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -129,6 +130,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -142,6 +144,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/rfc2136/rfc2136.go b/providers/dns/rfc2136/rfc2136.go index 84655b450..2c4fe7aeb 100644 --- a/providers/dns/rfc2136/rfc2136.go +++ b/providers/dns/rfc2136/rfc2136.go @@ -171,6 +171,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("rfc2136: failed to insert: %w", err) } + return nil } @@ -182,6 +183,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("rfc2136: failed to remove: %w", err) } + return nil } @@ -228,6 +230,7 @@ func (d *DNSProvider) changeRecord(action, fqdn, value string, ttl int) error { if err != nil { return fmt.Errorf("DNS update failed: %w", err) } + if reply != nil && reply.Rcode != dns.RcodeSuccess { return fmt.Errorf("DNS update failed: server replied: %s", dns.RcodeToString[reply.Rcode]) } diff --git a/providers/dns/rfc2136/rfc2136_test.go b/providers/dns/rfc2136/rfc2136_test.go index 1dc7270d2..ce4859e84 100644 --- a/providers/dns/rfc2136/rfc2136_test.go +++ b/providers/dns/rfc2136/rfc2136_test.go @@ -84,6 +84,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -250,6 +251,7 @@ func TestDNSProvider_Present_error(t *testing.T) { err = provider.Present(fakeDomain, "", fakeKeyAuth) require.Error(t, err) + if !strings.Contains(err.Error(), "NOTZONE") { t.Errorf("Expected Present() to return an error with the 'NOTZONE' rcode string, but it did not: %v", err) } diff --git a/providers/dns/rimuhosting/rimuhosting_test.go b/providers/dns/rimuhosting/rimuhosting_test.go index cbdacedc4..d8b086e25 100644 --- a/providers/dns/rimuhosting/rimuhosting_test.go +++ b/providers/dns/rimuhosting/rimuhosting_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -97,6 +98,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -110,6 +112,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/route53/route53.go b/providers/dns/route53/route53.go index 6e66149da..b41c95dac 100644 --- a/providers/dns/route53/route53.go +++ b/providers/dns/route53/route53.go @@ -155,6 +155,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { realValue := `"` + info.Value + `"` var found bool + for _, record := range records { if ptr.Deref(record.Value) == realValue { found = true @@ -200,6 +201,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var nonLegoRecords []awstypes.ResourceRecord + for _, record := range existingRecords { if ptr.Deref(record.Value) != `"`+info.Value+`"` { nonLegoRecords = append(nonLegoRecords, record) @@ -312,12 +314,14 @@ func (d *DNSProvider) getHostedZoneID(ctx context.Context, fqdn string) (string, reqParams := &route53.ListHostedZonesByNameInput{ DNSName: aws.String(dns01.UnFqdn(authZone)), } + resp, err := d.client.ListHostedZonesByName(ctx, reqParams) if err != nil { return "", err } var hostedZoneID string + for _, hostedZone := range resp.HostedZones { // .Name has a trailing dot if ptr.Deref(hostedZone.Name) == authZone && d.config.PrivateZone == hostedZone.Config.PrivateZone { @@ -353,6 +357,7 @@ func createAWSConfig(ctx context.Context, config *Config) (aws.Config, error) { retryCount := min(attempt, 7) delay := (1 << uint(retryCount)) * (rand.Intn(50) + 200) + return time.Duration(delay) * time.Millisecond, nil }) }) diff --git a/providers/dns/route53/route53_test.go b/providers/dns/route53/route53_test.go index f9f3b6293..41ed824bc 100644 --- a/providers/dns/route53/route53_test.go +++ b/providers/dns/route53/route53_test.go @@ -34,6 +34,7 @@ var envTest = tester.NewEnvTest( func Test_loadCredentials_FromEnv(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() _ = os.Setenv(EnvAccessKeyID, "123") @@ -60,6 +61,7 @@ func Test_loadCredentials_FromEnv(t *testing.T) { func Test_loadRegion_FromEnv(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() _ = os.Setenv(EnvRegion, "foo") @@ -72,6 +74,7 @@ func Test_loadRegion_FromEnv(t *testing.T) { func Test_getHostedZoneID_FromEnv(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() expectedZoneID := "zoneID" @@ -128,6 +131,7 @@ func TestNewDefaultConfig(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { envTest.ClearEnv() + for key, value := range test.envVars { _ = os.Setenv(key, value) } @@ -141,6 +145,7 @@ func TestNewDefaultConfig(t *testing.T) { func TestDNSProvider_Present(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() provider := servermock.NewBuilder( @@ -271,6 +276,7 @@ func Test_createAWSConfig(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.env) diff --git a/providers/dns/safedns/internal/client.go b/providers/dns/safedns/internal/client.go index 3e6f99919..51b12e99d 100644 --- a/providers/dns/safedns/internal/client.go +++ b/providers/dns/safedns/internal/client.go @@ -48,6 +48,7 @@ func (c *Client) AddRecord(ctx context.Context, zone string, record Record) (*Ad } respData := &AddRecordResponse{} + err = c.do(req, respData) if err != nil { return nil, fmt.Errorf("add record: %w", err) @@ -132,6 +133,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/safedns/safedns.go b/providers/dns/safedns/safedns.go index ce5c27672..be8ca4fe6 100644 --- a/providers/dns/safedns/safedns.go +++ b/providers/dns/safedns/safedns.go @@ -146,6 +146,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("safedns: unknown record ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/safedns/safedns_test.go b/providers/dns/safedns/safedns_test.go index dcb374718..ce7568056 100644 --- a/providers/dns/safedns/safedns_test.go +++ b/providers/dns/safedns/safedns_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -95,6 +96,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -108,6 +110,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/sakuracloud/sakuracloud.go b/providers/dns/sakuracloud/sakuracloud.go index fad675611..1adbe3a88 100644 --- a/providers/dns/sakuracloud/sakuracloud.go +++ b/providers/dns/sakuracloud/sakuracloud.go @@ -171,6 +171,7 @@ func newCaller(opts *api.CallerOptions) iaas.APICaller { if strings.HasSuffix(opts.APIRootURL, "/") { opts.APIRootURL = strings.TrimRight(opts.APIRootURL, "/") } + iaas.SakuraCloudAPIRoot = opts.APIRootURL } diff --git a/providers/dns/sakuracloud/sakuracloud_test.go b/providers/dns/sakuracloud/sakuracloud_test.go index 93cf20ea1..789a27544 100644 --- a/providers/dns/sakuracloud/sakuracloud_test.go +++ b/providers/dns/sakuracloud/sakuracloud_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -129,6 +130,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -142,6 +144,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/sakuracloud/wrapper.go b/providers/dns/sakuracloud/wrapper.go index c23a8b590..ff0b78e09 100644 --- a/providers/dns/sakuracloud/wrapper.go +++ b/providers/dns/sakuracloud/wrapper.go @@ -61,6 +61,7 @@ func (d *DNSProvider) cleanupTXTRecord(ctx context.Context, fqdn, value string) } var updRecords iaas.DNSRecords + for _, r := range zone.Records { if !(r.Name == subDomain && r.Type == "TXT" && r.RData == value) { //nolint:staticcheck // Clearer without De Morgan's law. updRecords = append(updRecords, r) @@ -71,6 +72,7 @@ func (d *DNSProvider) cleanupTXTRecord(ctx context.Context, fqdn, value string) Records: updRecords, SettingsHash: zone.SettingsHash, } + _, err = d.client.UpdateSettings(ctx, zone.ID, settings) if err != nil { return fmt.Errorf("API call failed: %w", err) diff --git a/providers/dns/sakuracloud/wrapper_test.go b/providers/dns/sakuracloud/wrapper_test.go index 958ef1b88..7432c67a6 100644 --- a/providers/dns/sakuracloud/wrapper_test.go +++ b/providers/dns/sakuracloud/wrapper_test.go @@ -44,6 +44,7 @@ func createDummyZone(t *testing.T, caller iaas.APICaller) { if zone.Name == "example.com" { err = dnsOp.Delete(ctx, zone.ID) require.NoError(t, err) + break } } @@ -96,6 +97,7 @@ func TestDNSProvider_concurrentAddAndCleanupRecords(t *testing.T) { dummyRecordCount := 10 var providers []*DNSProvider + for range dummyRecordCount { config := NewDefaultConfig() config.Token = "token3" diff --git a/providers/dns/scaleway/scaleway_test.go b/providers/dns/scaleway/scaleway_test.go index bf950e84e..b683d751a 100644 --- a/providers/dns/scaleway/scaleway_test.go +++ b/providers/dns/scaleway/scaleway_test.go @@ -41,6 +41,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -105,6 +106,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -118,6 +120,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/selectel/selectel.go b/providers/dns/selectel/selectel.go index a7fb97cac..804ef04d5 100644 --- a/providers/dns/selectel/selectel.go +++ b/providers/dns/selectel/selectel.go @@ -101,6 +101,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { client.HTTPClient = clientdebug.Wrap(client.HTTPClient) var err error + client.BaseURL, err = url.Parse(config.BaseURL) if err != nil { return nil, fmt.Errorf("selectel: %w", err) @@ -133,6 +134,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { Name: info.EffectiveFQDN, Content: info.Value, } + _, err = d.client.AddRecord(ctx, domainObj.ID, txtRecord) if err != nil { return fmt.Errorf("selectel: %w", err) @@ -162,6 +164,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { // Delete records with specific FQDN var lastErr error + for _, record := range records { if record.Name == recordName { err = d.client.DeleteRecord(ctx, domainObj.ID, record.ID) diff --git a/providers/dns/selectel/selectel_test.go b/providers/dns/selectel/selectel_test.go index 0e2de2dbe..e3c36e226 100644 --- a/providers/dns/selectel/selectel_test.go +++ b/providers/dns/selectel/selectel_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -106,6 +107,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -119,6 +121,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/selectelv2/selectelv2_test.go b/providers/dns/selectelv2/selectelv2_test.go index 265c17e90..2627fa023 100644 --- a/providers/dns/selectelv2/selectelv2_test.go +++ b/providers/dns/selectelv2/selectelv2_test.go @@ -78,6 +78,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -170,6 +171,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -183,6 +185,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/selfhostde/mapping.go b/providers/dns/selfhostde/mapping.go index 0984419ef..fe11ceda1 100644 --- a/providers/dns/selfhostde/mapping.go +++ b/providers/dns/selfhostde/mapping.go @@ -88,8 +88,10 @@ func parseLine(line string) (string, *Seq, error) { name, rawIDs := line[:idx], line[idx+1:] - var ids []string - var count int + var ( + ids []string + count int + ) for { idx, err = safeIndex(rawIDs, recordSep) diff --git a/providers/dns/selfhostde/selfhostde.go b/providers/dns/selfhostde/selfhostde.go index ccaba4647..bb475deea 100644 --- a/providers/dns/selfhostde/selfhostde.go +++ b/providers/dns/selfhostde/selfhostde.go @@ -176,6 +176,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("selfhostde: unknown record ID for %q", dns01.UnFqdn(info.EffectiveFQDN)) } diff --git a/providers/dns/selfhostde/selfhostde_test.go b/providers/dns/selfhostde/selfhostde_test.go index 1161049b0..7c12195fa 100644 --- a/providers/dns/selfhostde/selfhostde_test.go +++ b/providers/dns/selfhostde/selfhostde_test.go @@ -71,6 +71,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -185,6 +186,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -198,6 +200,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/servercow/internal/client.go b/providers/dns/servercow/internal/client.go index 3695b0979..e15237201 100644 --- a/providers/dns/servercow/internal/client.go +++ b/providers/dns/servercow/internal/client.go @@ -47,6 +47,7 @@ func (c *Client) GetRecords(ctx context.Context, domain string) ([]Record, error } var records []Record + err = c.do(req, &records) if err != nil { return nil, err @@ -65,6 +66,7 @@ func (c *Client) CreateUpdateRecord(ctx context.Context, domain string, data Rec } var msg Message + err = c.do(req, &msg) if err != nil { return nil, err @@ -87,6 +89,7 @@ func (c *Client) DeleteRecord(ctx context.Context, domain string, data Record) ( } var msg Message + err = c.do(req, &msg) if err != nil { return nil, err @@ -168,6 +171,7 @@ func unmarshal(raw []byte, v any) error { } var apiErr Message + errU := json.Unmarshal(raw, &apiErr) if errU != nil { return fmt.Errorf("unmarshaling %T error: %w: %s", v, err, string(raw)) diff --git a/providers/dns/servercow/internal/types.go b/providers/dns/servercow/internal/types.go index 5a8fb6ff8..9a951e806 100644 --- a/providers/dns/servercow/internal/types.go +++ b/providers/dns/servercow/internal/types.go @@ -43,6 +43,7 @@ func (v *Value) UnmarshalJSON(b []byte) error { } *v = append(*v, s) + return nil } diff --git a/providers/dns/servercow/servercow.go b/providers/dns/servercow/servercow.go index 8583e7d9e..557c6b1ec 100644 --- a/providers/dns/servercow/servercow.go +++ b/providers/dns/servercow/servercow.go @@ -140,6 +140,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("servercow: failed to update TXT records: %w", err) } + return nil } @@ -194,6 +195,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("servercow: failed to delete TXT records: %w", err) } + return nil } diff --git a/providers/dns/servercow/servercow_test.go b/providers/dns/servercow/servercow_test.go index 1c3facad9..f2328fe1a 100644 --- a/providers/dns/servercow/servercow_test.go +++ b/providers/dns/servercow/servercow_test.go @@ -57,6 +57,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -129,6 +130,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -142,6 +144,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/shellrent/internal/client.go b/providers/dns/shellrent/internal/client.go index 8ec02bfc0..a70ff5452 100644 --- a/providers/dns/shellrent/internal/client.go +++ b/providers/dns/shellrent/internal/client.go @@ -114,6 +114,7 @@ func (c *Client) GetDomainDetails(ctx context.Context, domainID int) (*DomainDet if result.Code != 0 { return nil, result.Base } + return result.Data, nil } @@ -137,6 +138,7 @@ func (c *Client) CreateRecord(ctx context.Context, domainID int, record Record) if result.Code != 0 { return 0, result.Base } + return result.Data.ID.Value(), nil } @@ -219,6 +221,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var response Base + err := json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/shellrent/internal/types.go b/providers/dns/shellrent/internal/types.go index a27b06347..6bdd82330 100644 --- a/providers/dns/shellrent/internal/types.go +++ b/providers/dns/shellrent/internal/types.go @@ -7,6 +7,7 @@ import ( type Response[T any] struct { Base + Data T `json:"data"` } @@ -57,6 +58,7 @@ func (m *IntOrString) UnmarshalJSON(data []byte) error { raw := string(data) if data[0] == '"' { var err error + raw, err = strconv.Unquote(string(data)) if err != nil { return err diff --git a/providers/dns/shellrent/shellrent.go b/providers/dns/shellrent/shellrent.go index bc8809943..5a3a1f6de 100644 --- a/providers/dns/shellrent/shellrent.go +++ b/providers/dns/shellrent/shellrent.go @@ -162,6 +162,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() key, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("shellrent: unknown request key for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/shellrent/shellrent_test.go b/providers/dns/shellrent/shellrent_test.go index e5d529917..8c4e3f6bf 100644 --- a/providers/dns/shellrent/shellrent_test.go +++ b/providers/dns/shellrent/shellrent_test.go @@ -47,6 +47,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -117,6 +118,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -130,6 +132,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/simply/internal/client.go b/providers/dns/simply/internal/client.go index 47e602d92..0c0655463 100644 --- a/providers/dns/simply/internal/client.go +++ b/providers/dns/simply/internal/client.go @@ -60,6 +60,7 @@ func (c *Client) GetRecords(ctx context.Context, zoneName string) ([]Record, err } result := &apiResponse[[]Record, json.RawMessage]{} + err = c.do(req, result) if err != nil { return nil, err @@ -78,6 +79,7 @@ func (c *Client) AddRecord(ctx context.Context, zoneName string, record Record) } result := &apiResponse[json.RawMessage, recordHeader]{} + err = c.do(req, result) if err != nil { return 0, err diff --git a/providers/dns/simply/simply.go b/providers/dns/simply/simply.go index 434bb0d30..fc3afd310 100644 --- a/providers/dns/simply/simply.go +++ b/providers/dns/simply/simply.go @@ -165,6 +165,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("simply: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/simply/simply_test.go b/providers/dns/simply/simply_test.go index ace8e0b72..e6de60d43 100644 --- a/providers/dns/simply/simply_test.go +++ b/providers/dns/simply/simply_test.go @@ -53,6 +53,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -121,6 +122,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -134,6 +136,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/sonic/internal/client.go b/providers/dns/sonic/internal/client.go index 3007a8248..cf8f7f067 100644 --- a/providers/dns/sonic/internal/client.go +++ b/providers/dns/sonic/internal/client.go @@ -83,6 +83,7 @@ func (c *Client) SetRecord(ctx context.Context, hostname, value string, ttl int) } r := APIResponse{} + err = json.Unmarshal(raw, &r) if err != nil { return errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/sonic/sonic_test.go b/providers/dns/sonic/sonic_test.go index f9087f8e3..7dc7fc586 100644 --- a/providers/dns/sonic/sonic_test.go +++ b/providers/dns/sonic/sonic_test.go @@ -49,6 +49,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -119,6 +120,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -132,6 +134,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/spaceship/internal/client.go b/providers/dns/spaceship/internal/client.go index f739e01ba..e690fa467 100644 --- a/providers/dns/spaceship/internal/client.go +++ b/providers/dns/spaceship/internal/client.go @@ -114,6 +114,7 @@ func (c *Client) GetRecords(ctx context.Context, domain string) ([]Record, error } var result GetRecordsResponse + err = c.do(req, &result) if err != nil { return nil, err @@ -150,6 +151,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/spaceship/spaceship_test.go b/providers/dns/spaceship/spaceship_test.go index ba60cfa5e..d4eb37d88 100644 --- a/providers/dns/spaceship/spaceship_test.go +++ b/providers/dns/spaceship/spaceship_test.go @@ -50,6 +50,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -122,6 +123,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -135,6 +137,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/stackpath/internal/client.go b/providers/dns/stackpath/internal/client.go index f06feb807..8a40a4093 100644 --- a/providers/dns/stackpath/internal/client.go +++ b/providers/dns/stackpath/internal/client.go @@ -55,6 +55,7 @@ func (c *Client) GetZones(ctx context.Context, domain string) (*Zone, error) { req.URL.RawQuery = query.Encode() var zones Zones + err = c.do(req, &zones) if err != nil { return nil, err @@ -82,6 +83,7 @@ func (c *Client) GetZoneRecords(ctx context.Context, name string, zone *Zone) ([ req.URL.RawQuery = query.Encode() var records Records + err = c.do(req, &records) if err != nil { return nil, err @@ -177,6 +179,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) errResp := &ErrorResponse{} + err := json.Unmarshal(raw, errResp) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/stackpath/stackpath_test.go b/providers/dns/stackpath/stackpath_test.go index f8b83140f..a4b959222 100644 --- a/providers/dns/stackpath/stackpath_test.go +++ b/providers/dns/stackpath/stackpath_test.go @@ -72,6 +72,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -137,6 +138,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -150,6 +152,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/technitium/internal/client.go b/providers/dns/technitium/internal/client.go index a68008d34..965638b1d 100644 --- a/providers/dns/technitium/internal/client.go +++ b/providers/dns/technitium/internal/client.go @@ -125,6 +125,7 @@ func (c *Client) newFormRequest(ctx context.Context, endpoint *url.URL, payload if payload != nil { var err error + values, err = querystring.Values(payload) if err != nil { return nil, fmt.Errorf("failed to create request body: %w", err) @@ -149,6 +150,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIResponse[any] + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/technitium/technitium_test.go b/providers/dns/technitium/technitium_test.go index da50b6fe6..4eee530fd 100644 --- a/providers/dns/technitium/technitium_test.go +++ b/providers/dns/technitium/technitium_test.go @@ -50,6 +50,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -122,6 +123,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -135,6 +137,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/tencentcloud/tencentcloud_test.go b/providers/dns/tencentcloud/tencentcloud_test.go index c5a2fd974..ce6358174 100644 --- a/providers/dns/tencentcloud/tencentcloud_test.go +++ b/providers/dns/tencentcloud/tencentcloud_test.go @@ -55,6 +55,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -127,6 +128,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -140,6 +142,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/tencentcloud/wrapper.go b/providers/dns/tencentcloud/wrapper.go index 6fdb7f899..6a66bc1c6 100644 --- a/providers/dns/tencentcloud/wrapper.go +++ b/providers/dns/tencentcloud/wrapper.go @@ -38,6 +38,7 @@ func (d *DNSProvider) getHostedZone(ctx context.Context, domain string) (*dnspod } var hostedZone *dnspod.DomainListItem + for _, zone := range domains { unfqdn := dns01.UnFqdn(authZone) if *zone.Name == unfqdn || *zone.Punycode == unfqdn { @@ -73,6 +74,7 @@ func (d *DNSProvider) findTxtRecords(ctx context.Context, zone *dnspod.DomainLis return nil, nil } } + return nil, err } diff --git a/providers/dns/timewebcloud/internal/client.go b/providers/dns/timewebcloud/internal/client.go index b3030861e..ec3c8703d 100644 --- a/providers/dns/timewebcloud/internal/client.go +++ b/providers/dns/timewebcloud/internal/client.go @@ -49,6 +49,7 @@ func (c *Client) CreateRecord(ctx context.Context, zone string, record DNSRecord } respData := &CreateRecordResponse{} + err = c.do(req, respData) if err != nil { return nil, err @@ -127,6 +128,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var response ErrorResponse + err := json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/timewebcloud/timewebcloud.go b/providers/dns/timewebcloud/timewebcloud.go index 0d3a36b46..d71beea4b 100644 --- a/providers/dns/timewebcloud/timewebcloud.go +++ b/providers/dns/timewebcloud/timewebcloud.go @@ -145,6 +145,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("timewebcloud: unknown record ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/timewebcloud/timewebcloud_test.go b/providers/dns/timewebcloud/timewebcloud_test.go index cd3e2e26f..26e107578 100644 --- a/providers/dns/timewebcloud/timewebcloud_test.go +++ b/providers/dns/timewebcloud/timewebcloud_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -97,6 +98,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -110,6 +112,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/transip/transip.go b/providers/dns/transip/transip.go index a58a1bfe0..bc2913aa4 100644 --- a/providers/dns/transip/transip.go +++ b/providers/dns/transip/transip.go @@ -168,6 +168,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err = d.repository.RemoveDNSEntry(domainName, entry); err != nil { return fmt.Errorf("transip: couldn't get Record ID in CleanUp: %w", err) } + return nil } } diff --git a/providers/dns/transip/transip_test.go b/providers/dns/transip/transip_test.go index b42753680..3c6e86657 100644 --- a/providers/dns/transip/transip_test.go +++ b/providers/dns/transip/transip_test.go @@ -58,6 +58,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -79,6 +80,7 @@ func TestNewDNSProvider(t *testing.T) { // Therefore, we test if the error type is the same. t.Run("could not open private key path", func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(map[string]string{ @@ -156,6 +158,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -169,6 +172,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/ultradns/ultradns.go b/providers/dns/ultradns/ultradns.go index 0515cbaae..da76c56f4 100644 --- a/providers/dns/ultradns/ultradns.go +++ b/providers/dns/ultradns/ultradns.go @@ -4,6 +4,7 @@ package ultradns import ( "errors" "fmt" + "net/http" "time" "github.com/go-acme/lego/v4/challenge" @@ -121,7 +122,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { RecordType: "TXT", } - res, _, _ := recordService.Read(rrSetKeyData) + resp, _, _ := recordService.Read(rrSetKeyData) rrSetData := &rrset.RRSet{ OwnerName: info.EffectiveFQDN, @@ -130,11 +131,12 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { RData: []string{info.Value}, } - if res != nil && res.StatusCode == 200 { + if resp != nil && resp.StatusCode == http.StatusOK { _, err = recordService.Update(rrSetKeyData, rrSetData) } else { _, err = recordService.Create(rrSetKeyData, rrSetData) } + if err != nil { return fmt.Errorf("ultradns: %w", err) } diff --git a/providers/dns/ultradns/ultradns_test.go b/providers/dns/ultradns/ultradns_test.go index eefa63ec3..464bc51cd 100644 --- a/providers/dns/ultradns/ultradns_test.go +++ b/providers/dns/ultradns/ultradns_test.go @@ -177,6 +177,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/variomedia/internal/client.go b/providers/dns/variomedia/internal/client.go index 8c2a124cc..0e4ef9518 100644 --- a/providers/dns/variomedia/internal/client.go +++ b/providers/dns/variomedia/internal/client.go @@ -52,6 +52,7 @@ func (c *Client) CreateDNSRecord(ctx context.Context, record DNSRecord) (*Create } var result CreateDNSRecordResponse + err = c.do(req, &result) if err != nil { return nil, err @@ -71,6 +72,7 @@ func (c *Client) DeleteDNSRecord(ctx context.Context, id string) (*DeleteRecordR } var result DeleteRecordResponse + err = c.do(req, &result) if err != nil { return nil, err @@ -90,6 +92,7 @@ func (c *Client) GetJob(ctx context.Context, id string) (*GetJobResponse, error) } var result GetJobResponse + err = c.do(req, &result) if err != nil { return nil, err @@ -153,6 +156,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var errAPI APIError + err := json.Unmarshal(raw, &errAPI) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/variomedia/variomedia.go b/providers/dns/variomedia/variomedia.go index 2dbf546b1..90ac70a05 100644 --- a/providers/dns/variomedia/variomedia.go +++ b/providers/dns/variomedia/variomedia.go @@ -165,6 +165,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("variomedia: unknown record ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/variomedia/variomedia_test.go b/providers/dns/variomedia/variomedia_test.go index 305646070..552419fd0 100644 --- a/providers/dns/variomedia/variomedia_test.go +++ b/providers/dns/variomedia/variomedia_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -91,6 +92,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -104,6 +106,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/vegadns/vegadns_test.go b/providers/dns/vegadns/vegadns_test.go index fe40057c4..988326670 100644 --- a/providers/dns/vegadns/vegadns_test.go +++ b/providers/dns/vegadns/vegadns_test.go @@ -19,6 +19,7 @@ var envTest = tester.NewEnvTest(EnvKey, EnvSecret, EnvURL) func TestNewDNSProvider_Fail(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() _, err := NewDNSProvider() @@ -27,6 +28,7 @@ func TestNewDNSProvider_Fail(t *testing.T) { func TestDNSProvider_TimeoutSuccess(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() provider := mockBuilder().Build(t) @@ -79,6 +81,7 @@ func TestDNSProvider_Present(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() provider := test.builder.Build(t) @@ -138,6 +141,7 @@ func TestDNSProvider_CleanUp(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() provider := test.builder.Build(t) @@ -167,6 +171,7 @@ func getDomainHandler() http.HandlerFunc { ] } `) + return } diff --git a/providers/dns/vercel/internal/client.go b/providers/dns/vercel/internal/client.go index d852689ae..930f3543e 100644 --- a/providers/dns/vercel/internal/client.go +++ b/providers/dns/vercel/internal/client.go @@ -51,6 +51,7 @@ func (c *Client) CreateRecord(ctx context.Context, zone string, record Record) ( } respData := &CreateRecordResponse{} + err = c.do(req, respData) if err != nil { return nil, err @@ -135,6 +136,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var response APIErrorResponse + err := json.Unmarshal(raw, &response) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/vercel/vercel.go b/providers/dns/vercel/vercel.go index 447165262..965e3de12 100644 --- a/providers/dns/vercel/vercel.go +++ b/providers/dns/vercel/vercel.go @@ -148,6 +148,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("vercel: unknown record ID for '%s'", info.EffectiveFQDN) } diff --git a/providers/dns/vercel/vercel_test.go b/providers/dns/vercel/vercel_test.go index 6c19a4db5..d4cf37904 100644 --- a/providers/dns/vercel/vercel_test.go +++ b/providers/dns/vercel/vercel_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -95,6 +96,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -108,6 +110,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/versio/internal/client.go b/providers/dns/versio/internal/client.go index e91913556..6a92cc958 100644 --- a/providers/dns/versio/internal/client.go +++ b/providers/dns/versio/internal/client.go @@ -48,6 +48,7 @@ func (c *Client) UpdateDomain(ctx context.Context, domain string, msg *DomainInf } respData := &DomainInfoResponse{} + err = c.do(req, respData) if err != nil { return nil, err @@ -71,6 +72,7 @@ func (c *Client) GetDomain(ctx context.Context, domain string) (*DomainInfoRespo } respData := &DomainInfoResponse{} + err = c.do(req, respData) if err != nil { return nil, err @@ -88,6 +90,7 @@ func (c *Client) do(req *http.Request, result any) error { if resp != nil { defer func() { _ = resp.Body.Close() }() } + if err != nil { return errutils.NewHTTPDoError(req, err) } @@ -140,6 +143,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) response := &ErrorResponse{} + err := json.Unmarshal(raw, response) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/versio/versio.go b/providers/dns/versio/versio.go index bc999a674..05a7263c4 100644 --- a/providers/dns/versio/versio.go +++ b/providers/dns/versio/versio.go @@ -92,9 +92,11 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { if config == nil { return nil, errors.New("versio: the configuration of the DNS provider is nil") } + if config.Username == "" { return nil, errors.New("versio: the versio username is missing") } + if config.Password == "" { return nil, errors.New("versio: the versio password is missing") } @@ -158,6 +160,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("versio: %w", err) } + return nil } @@ -185,6 +188,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { // loop through the existing entries and remove the specific record msg := &internal.DomainInfo{} + for _, e := range domains.DomainInfo.DNSRecords { if e.Name != info.EffectiveFQDN { msg.DNSRecords = append(msg.DNSRecords, e) @@ -195,5 +199,6 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("versio: %w", err) } + return nil } diff --git a/providers/dns/versio/versio_test.go b/providers/dns/versio/versio_test.go index 9e3db8b0d..563e70d05 100644 --- a/providers/dns/versio/versio_test.go +++ b/providers/dns/versio/versio_test.go @@ -54,6 +54,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -161,6 +162,7 @@ func TestDNSProvider_Present(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() provider := test.builder.Build(t) @@ -204,6 +206,7 @@ func TestDNSProvider_CleanUp(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() provider := test.builder.Build(t) @@ -224,6 +227,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -237,6 +241,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/vinyldns/vinyldns.go b/providers/dns/vinyldns/vinyldns.go index 62d7c3442..65a024513 100644 --- a/providers/dns/vinyldns/vinyldns.go +++ b/providers/dns/vinyldns/vinyldns.go @@ -175,6 +175,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { value := d.formatValue(info.Value) var records []vinyldns.Record + for _, i := range existingRecord.Records { if i.Text != value { records = append(records, i) diff --git a/providers/dns/vinyldns/vinyldns_test.go b/providers/dns/vinyldns/vinyldns_test.go index c4741ea1c..7dfe2c13f 100644 --- a/providers/dns/vinyldns/vinyldns_test.go +++ b/providers/dns/vinyldns/vinyldns_test.go @@ -78,6 +78,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -246,6 +247,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -259,6 +261,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/vinyldns/wrapper.go b/providers/dns/vinyldns/wrapper.go index e247fd265..e7b59a82b 100644 --- a/providers/dns/vinyldns/wrapper.go +++ b/providers/dns/vinyldns/wrapper.go @@ -27,6 +27,7 @@ func (d *DNSProvider) getRecordSet(fqdn string) (*vinyldns.RecordSet, error) { } var recordSets []vinyldns.RecordSet + for _, i := range allRecordSets { if i.Type == "TXT" { recordSets = append(recordSets, i) diff --git a/providers/dns/vkcloud/internal/client.go b/providers/dns/vkcloud/internal/client.go index 5ced88d2d..2b03518db 100644 --- a/providers/dns/vkcloud/internal/client.go +++ b/providers/dns/vkcloud/internal/client.go @@ -46,6 +46,7 @@ func (c *Client) ListZones() ([]DNSZone, error) { endpoint := c.baseURL.JoinPath("/") var zones []DNSZone + opts := &gophercloud.RequestOpts{JSONResponse: &zones} err := c.request(http.MethodGet, endpoint, opts) @@ -60,6 +61,7 @@ func (c *Client) ListTXTRecords(zoneUUID string) ([]DNSTXTRecord, error) { endpoint := c.baseURL.JoinPath(zoneUUID, "txt", "/") var records []DNSTXTRecord + opts := &gophercloud.RequestOpts{JSONResponse: &records} err := c.request(http.MethodGet, endpoint, opts) diff --git a/providers/dns/vkcloud/vkcloud.go b/providers/dns/vkcloud/vkcloud.go index 2aea7838c..ffacdbe52 100644 --- a/providers/dns/vkcloud/vkcloud.go +++ b/providers/dns/vkcloud/vkcloud.go @@ -135,6 +135,7 @@ func (d *DNSProvider) Present(domain, _, keyAuth string) error { } var zoneUUID string + for _, zone := range zones { if zone.Zone == authZone { zoneUUID = zone.UUID diff --git a/providers/dns/vkcloud/vkcloud_test.go b/providers/dns/vkcloud/vkcloud_test.go index edc32363a..e7883b486 100644 --- a/providers/dns/vkcloud/vkcloud_test.go +++ b/providers/dns/vkcloud/vkcloud_test.go @@ -60,6 +60,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -188,6 +189,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -201,6 +203,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/volcengine/volcengine.go b/providers/dns/volcengine/volcengine.go index a271e0f26..9a5886e6d 100644 --- a/providers/dns/volcengine/volcengine.go +++ b/providers/dns/volcengine/volcengine.go @@ -159,6 +159,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("volcengine: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/volcengine/volcengine_test.go b/providers/dns/volcengine/volcengine_test.go index 5e9167612..0f79ed83a 100644 --- a/providers/dns/volcengine/volcengine_test.go +++ b/providers/dns/volcengine/volcengine_test.go @@ -55,6 +55,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -125,6 +126,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -138,6 +140,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/vscale/vscale.go b/providers/dns/vscale/vscale.go index 1ecff3a60..01fae946d 100644 --- a/providers/dns/vscale/vscale.go +++ b/providers/dns/vscale/vscale.go @@ -101,6 +101,7 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { client.HTTPClient = clientdebug.Wrap(client.HTTPClient) var err error + client.BaseURL, err = url.Parse(config.BaseURL) if err != nil { return nil, fmt.Errorf("vscale: %w", err) @@ -133,6 +134,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { Name: info.EffectiveFQDN, Content: info.Value, } + _, err = d.client.AddRecord(ctx, domainObj.ID, txtRecord) if err != nil { return fmt.Errorf("vscale: %w", err) @@ -162,6 +164,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { // Delete records with specific FQDN var lastErr error + for _, record := range records { if record.Name == recordName { err = d.client.DeleteRecord(ctx, domainObj.ID, record.ID) diff --git a/providers/dns/vscale/vscale_test.go b/providers/dns/vscale/vscale_test.go index 6a9b25583..f3bc15531 100644 --- a/providers/dns/vscale/vscale_test.go +++ b/providers/dns/vscale/vscale_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -106,6 +107,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -119,6 +121,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/vultr/vultr.go b/providers/dns/vultr/vultr.go index 73e3480a2..2064cee19 100644 --- a/providers/dns/vultr/vultr.go +++ b/providers/dns/vultr/vultr.go @@ -136,6 +136,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var allErr []string + for _, rec := range records { err := d.client.DomainRecord.Delete(ctx, zoneDomain, rec.ID) if err != nil { @@ -205,6 +206,7 @@ func (d *DNSProvider) findTxtRecords(ctx context.Context, domain, fqdn string) ( listOptions := &govultr.ListOptions{PerPage: 25} var records []govultr.DomainRecord + for { result, meta, resp, err := d.client.DomainRecord.List(ctx, zoneDomain, listOptions) if err != nil { diff --git a/providers/dns/vultr/vultr_test.go b/providers/dns/vultr/vultr_test.go index f8b8fcd1f..17d962b2a 100644 --- a/providers/dns/vultr/vultr_test.go +++ b/providers/dns/vultr/vultr_test.go @@ -45,6 +45,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -221,6 +222,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -234,6 +236,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/webnames/internal/client.go b/providers/dns/webnames/internal/client.go index 5b1a8b357..985503d2a 100644 --- a/providers/dns/webnames/internal/client.go +++ b/providers/dns/webnames/internal/client.go @@ -83,6 +83,7 @@ func (c *Client) doRequest(ctx context.Context, data url.Values) error { } var r APIResponse + err = json.Unmarshal(raw, &r) if err != nil { return errutils.NewUnmarshalError(req, resp.StatusCode, raw, err) diff --git a/providers/dns/webnames/webnames_test.go b/providers/dns/webnames/webnames_test.go index 3ec69501f..553841e32 100644 --- a/providers/dns/webnames/webnames_test.go +++ b/providers/dns/webnames/webnames_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -93,6 +94,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -106,6 +108,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/websupport/websupport_test.go b/providers/dns/websupport/websupport_test.go index 051fdb837..c7b8572b5 100644 --- a/providers/dns/websupport/websupport_test.go +++ b/providers/dns/websupport/websupport_test.go @@ -50,6 +50,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -124,6 +125,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -137,6 +139,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/wedos/internal/client.go b/providers/dns/wedos/internal/client.go index 1f573e397..48c89d189 100644 --- a/providers/dns/wedos/internal/client.go +++ b/providers/dns/wedos/internal/client.go @@ -69,6 +69,7 @@ func (c *Client) AddRecord(ctx context.Context, zone string, record DNSRow) erro } cmd := commandDNSRowAdd + if record.ID == "" { payload.Name = record.Name } else { diff --git a/providers/dns/wedos/internal/token.go b/providers/dns/wedos/internal/token.go index dd126b442..11e680cb8 100644 --- a/providers/dns/wedos/internal/token.go +++ b/providers/dns/wedos/internal/token.go @@ -15,6 +15,7 @@ func authToken(userName, wapiPass string) string { func sha1string(txt string) string { h := sha1.New() _, _ = io.WriteString(h, txt) + return hex.EncodeToString(h.Sum(nil)) } @@ -46,11 +47,13 @@ func utcToCet(utc time.Time) time.Time { if utcMonth < time.March || utcMonth > time.October { return utc.Add(time.Hour) } + if utcMonth > time.March && utcMonth < time.October { return utc.Add(time.Hour * 2) } dayOff := 0 + breaking := time.Date(utc.Year(), utcMonth+1, dayOff, 1, 0, 0, 0, time.UTC) for breaking.Weekday() != time.Sunday { dayOff-- @@ -65,6 +68,7 @@ func utcToCet(utc time.Time) time.Time { if (utcMonth == time.March && utc.Before(breaking)) || (utcMonth == time.October && utc.After(breaking)) { return utc.Add(time.Hour) } + return utc.Add(time.Hour * 2) } diff --git a/providers/dns/wedos/wedos_test.go b/providers/dns/wedos/wedos_test.go index 9363002b5..25f70d0fc 100644 --- a/providers/dns/wedos/wedos_test.go +++ b/providers/dns/wedos/wedos_test.go @@ -54,6 +54,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -120,6 +121,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -133,6 +135,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/westcn/westcn.go b/providers/dns/westcn/westcn.go index 7efcfab21..c641f661d 100644 --- a/providers/dns/westcn/westcn.go +++ b/providers/dns/westcn/westcn.go @@ -148,6 +148,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { d.recordIDsMu.Lock() recordID, ok := d.recordIDs[token] d.recordIDsMu.Unlock() + if !ok { return fmt.Errorf("westcn: unknown record ID for '%s' '%s'", info.EffectiveFQDN, token) } diff --git a/providers/dns/westcn/westcn_test.go b/providers/dns/westcn/westcn_test.go index 71632d99f..36827fd06 100644 --- a/providers/dns/westcn/westcn_test.go +++ b/providers/dns/westcn/westcn_test.go @@ -50,6 +50,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -122,6 +123,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -135,6 +137,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/yandex/internal/client.go b/providers/dns/yandex/internal/client.go index 98480a793..4b0421f49 100644 --- a/providers/dns/yandex/internal/client.go +++ b/providers/dns/yandex/internal/client.go @@ -51,6 +51,7 @@ func (c *Client) AddRecord(ctx context.Context, payload Record) (*Record, error) } r := AddResponse{} + err = c.do(req, &r) if err != nil { return nil, err @@ -68,6 +69,7 @@ func (c *Client) RemoveRecord(ctx context.Context, payload Record) (int, error) } r := RemoveResponse{} + err = c.do(req, &r) if err != nil { return 0, err @@ -89,6 +91,7 @@ func (c *Client) GetRecords(ctx context.Context, domain string) ([]Record, error } r := ListResponse{} + err = c.do(req, &r) if err != nil { return nil, err diff --git a/providers/dns/yandex/internal/types.go b/providers/dns/yandex/internal/types.go index ed1873cef..48a85042c 100644 --- a/providers/dns/yandex/internal/types.go +++ b/providers/dns/yandex/internal/types.go @@ -30,18 +30,21 @@ func (r BaseResponse) GetError() string { type AddResponse struct { BaseResponse + Domain string `json:"domain,omitempty"` Record *Record `json:"record,omitempty"` } type RemoveResponse struct { BaseResponse + Domain string `json:"domain,omitempty"` RecordID int `json:"record_id,omitempty"` } type ListResponse struct { BaseResponse + Domain string `json:"domain,omitempty"` Records []Record `json:"records,omitempty"` } diff --git a/providers/dns/yandex/yandex.go b/providers/dns/yandex/yandex.go index d832f8859..7ae505ec0 100644 --- a/providers/dns/yandex/yandex.go +++ b/providers/dns/yandex/yandex.go @@ -136,6 +136,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var record *internal.Record + for _, rcd := range records { if rcd.Type == "TXT" && rcd.SubDomain == subDomain && rcd.Content == info.Value { record = &rcd @@ -156,6 +157,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("yandex: %w", err) } + return nil } diff --git a/providers/dns/yandex/yandex_test.go b/providers/dns/yandex/yandex_test.go index 144a24126..8a0a7534a 100644 --- a/providers/dns/yandex/yandex_test.go +++ b/providers/dns/yandex/yandex_test.go @@ -33,6 +33,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -95,6 +96,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -108,6 +110,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/yandex360/internal/client.go b/providers/dns/yandex360/internal/client.go index 9ffececaf..33aeb0daa 100644 --- a/providers/dns/yandex360/internal/client.go +++ b/providers/dns/yandex360/internal/client.go @@ -138,6 +138,7 @@ func parseError(req *http.Request, resp *http.Response) error { raw, _ := io.ReadAll(resp.Body) var apiErr APIError + err := json.Unmarshal(raw, &apiErr) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/yandex360/yandex360_test.go b/providers/dns/yandex360/yandex360_test.go index 545c90985..c1d37ad12 100644 --- a/providers/dns/yandex360/yandex360_test.go +++ b/providers/dns/yandex360/yandex360_test.go @@ -43,6 +43,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -109,6 +110,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -122,6 +124,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/yandexcloud/yandexcloud.go b/providers/dns/yandexcloud/yandexcloud.go index 346b6d952..f9c64def1 100644 --- a/providers/dns/yandexcloud/yandexcloud.go +++ b/providers/dns/yandexcloud/yandexcloud.go @@ -229,6 +229,7 @@ func (d *DNSProvider) upsertRecordSetData(ctx context.Context, zoneID, name, val } var deletions []*ycdnsproto.RecordSet + if exist != nil { record.SetData(append(record.GetData(), exist.GetData()...)) deletions = append(deletions, exist) @@ -307,6 +308,7 @@ func decodeCredentials(accountB64 string) (credentials.Credentials, error) { } key := &iamkey.Key{} + err = json.Unmarshal(account, key) if err != nil { return nil, err diff --git a/providers/dns/yandexcloud/yandexcloud_test.go b/providers/dns/yandexcloud/yandexcloud_test.go index 48f75d134..52dad574d 100644 --- a/providers/dns/yandexcloud/yandexcloud_test.go +++ b/providers/dns/yandexcloud/yandexcloud_test.go @@ -71,6 +71,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -143,6 +144,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -156,6 +158,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/zoneedit/internal/client.go b/providers/dns/zoneedit/internal/client.go index e97f4beb9..c8b99e173 100644 --- a/providers/dns/zoneedit/internal/client.go +++ b/providers/dns/zoneedit/internal/client.go @@ -98,6 +98,7 @@ func (c *Client) do(req *http.Request) error { } var apiErr APIError + err = xml.Unmarshal(raw, &apiErr) if err != nil { return errutils.NewUnexpectedStatusCodeError(req, resp.StatusCode, raw) diff --git a/providers/dns/zoneedit/zoneedit_test.go b/providers/dns/zoneedit/zoneedit_test.go index 2a9b1754d..0b251fddf 100644 --- a/providers/dns/zoneedit/zoneedit_test.go +++ b/providers/dns/zoneedit/zoneedit_test.go @@ -50,6 +50,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -122,6 +123,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -135,6 +137,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/dns/zoneee/zoneee.go b/providers/dns/zoneee/zoneee.go index 82e8effaf..5c34ea1c9 100644 --- a/providers/dns/zoneee/zoneee.go +++ b/providers/dns/zoneee/zoneee.go @@ -70,6 +70,7 @@ func NewDNSProvider() (*DNSProvider, error) { } rawEndpoint := env.GetOrDefaultString(EnvEndpoint, internal.DefaultEndpoint) + endpoint, err := url.Parse(rawEndpoint) if err != nil { return nil, fmt.Errorf("zoneee: %w", err) @@ -142,6 +143,7 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("zoneee: %w", err) } + return nil } @@ -164,6 +166,7 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } var id string + for _, record := range records { if record.Destination == info.Value { id = record.ID diff --git a/providers/dns/zoneee/zoneee_test.go b/providers/dns/zoneee/zoneee_test.go index 32090a41b..9ad87c02a 100644 --- a/providers/dns/zoneee/zoneee_test.go +++ b/providers/dns/zoneee/zoneee_test.go @@ -77,6 +77,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -247,6 +248,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -260,6 +262,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -286,6 +289,7 @@ func mockBuilder(username, apiKey string) *servermock.Builder[*DNSProvider] { func mockHandlerCreateRecord() http.HandlerFunc { return encodeJSONHandler(func(req *http.Request, rw http.ResponseWriter) (any, error) { record := internal.TXTRecord{} + err := json.NewDecoder(req.Body).Decode(&record) if err != nil { return nil, err @@ -340,6 +344,7 @@ func checkBasicAuth() servermock.LinkFunc { if username != fakeUsername || apiKey != fakeAPIKey || !ok { rw.Header().Set("WWW-Authenticate", fmt.Sprintf(`Basic realm=%q`, "Please enter your username and API key.")) http.Error(rw, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized) + return } diff --git a/providers/dns/zonomi/zonomi_test.go b/providers/dns/zonomi/zonomi_test.go index fb1b68773..0583f4a1c 100644 --- a/providers/dns/zonomi/zonomi_test.go +++ b/providers/dns/zonomi/zonomi_test.go @@ -36,6 +36,7 @@ func TestNewDNSProvider(t *testing.T) { for _, test := range testCases { t.Run(test.desc, func(t *testing.T) { defer envTest.RestoreEnv() + envTest.ClearEnv() envTest.Apply(test.envVars) @@ -97,6 +98,7 @@ func TestLivePresent(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) @@ -110,6 +112,7 @@ func TestLiveCleanUp(t *testing.T) { } envTest.RestoreEnv() + provider, err := NewDNSProvider() require.NoError(t, err) diff --git a/providers/http/memcached/memcached.go b/providers/http/memcached/memcached.go index b26def2c4..376ae8c16 100644 --- a/providers/http/memcached/memcached.go +++ b/providers/http/memcached/memcached.go @@ -33,12 +33,14 @@ func (w *HTTPProvider) Present(domain, token, keyAuth string) error { var errs []error challengePath := path.Join("/", http01.ChallengePath(token)) + for _, host := range w.hosts { mc, err := memcache.New(host) if err != nil { errs = append(errs, err) continue } + _ = mc.Add(&memcache.Item{ Key: challengePath, Value: []byte(keyAuth), diff --git a/providers/http/memcached/memcached_test.go b/providers/http/memcached/memcached_test.go index fb450f988..5862efbc6 100644 --- a/providers/http/memcached/memcached_test.go +++ b/providers/http/memcached/memcached_test.go @@ -25,6 +25,7 @@ func loadMemcachedHosts() []string { if memcachedHostsStr != "" { return strings.Split(memcachedHostsStr, ",") } + return nil } @@ -38,6 +39,7 @@ func TestNewMemcachedProviderValid(t *testing.T) { if len(memcachedHosts) == 0 { t.Skip("Skipping memcached tests") } + _, err := NewMemcachedProvider(memcachedHosts) require.NoError(t, err) } @@ -46,6 +48,7 @@ func TestMemcachedPresentSingleHost(t *testing.T) { if len(memcachedHosts) == 0 { t.Skip("Skipping memcached tests") } + p, err := NewMemcachedProvider(memcachedHosts[0:1]) require.NoError(t, err) @@ -64,6 +67,7 @@ func TestMemcachedPresentMultiHost(t *testing.T) { if len(memcachedHosts) <= 1 { t.Skip("Skipping memcached multi-host tests") } + p, err := NewMemcachedProvider(memcachedHosts) require.NoError(t, err) @@ -71,6 +75,7 @@ func TestMemcachedPresentMultiHost(t *testing.T) { err = p.Present(domain, token, keyAuth) require.NoError(t, err) + for _, host := range memcachedHosts { mc, err := memcache.New(host) require.NoError(t, err) @@ -84,6 +89,7 @@ func TestMemcachedPresentPartialFailureMultiHost(t *testing.T) { if len(memcachedHosts) == 0 { t.Skip("Skipping memcached tests") } + hosts := append(memcachedHosts, "5.5.5.5:11211") p, err := NewMemcachedProvider(hosts) require.NoError(t, err) @@ -92,6 +98,7 @@ func TestMemcachedPresentPartialFailureMultiHost(t *testing.T) { err = p.Present(domain, token, keyAuth) require.NoError(t, err) + for _, host := range memcachedHosts { mc, err := memcache.New(host) require.NoError(t, err) @@ -105,6 +112,7 @@ func TestMemcachedCleanup(t *testing.T) { if len(memcachedHosts) == 0 { t.Skip("Skipping memcached tests") } + p, err := NewMemcachedProvider(memcachedHosts) require.NoError(t, err) require.NoError(t, p.CleanUp(domain, token, keyAuth)) diff --git a/providers/http/s3/s3.go b/providers/http/s3/s3.go index 07e1eed63..e277deeea 100644 --- a/providers/http/s3/s3.go +++ b/providers/http/s3/s3.go @@ -57,6 +57,7 @@ func (s *HTTPProvider) Present(domain, token, keyAuth string) error { if err != nil { return fmt.Errorf("s3: failed to upload token to s3: %w", err) } + return nil } diff --git a/providers/http/webroot/webroot.go b/providers/http/webroot/webroot.go index c5b49caee..c94c4579c 100644 --- a/providers/http/webroot/webroot.go +++ b/providers/http/webroot/webroot.go @@ -29,6 +29,7 @@ func (w *HTTPProvider) Present(domain, token, keyAuth string) error { var err error challengeFilePath := filepath.Join(w.path, http01.ChallengePath(token)) + err = os.MkdirAll(filepath.Dir(challengeFilePath), 0o755) if err != nil { return fmt.Errorf("could not create required directories in webroot for HTTP challenge: %w", err) diff --git a/providers/http/webroot/webroot_test.go b/providers/http/webroot/webroot_test.go index 124b324a3..4c55e2b90 100644 --- a/providers/http/webroot/webroot_test.go +++ b/providers/http/webroot/webroot_test.go @@ -29,6 +29,7 @@ func TestHTTPProvider(t *testing.T) { } var data []byte + data, err = os.ReadFile(challengeFilePath) require.NoError(t, err) diff --git a/registration/registar.go b/registration/registar.go index 15c28bad6..5d3ea250b 100644 --- a/registration/registar.go +++ b/registration/registar.go @@ -15,7 +15,7 @@ const mailTo = "mailto:" // of which the client needs to keep track itself. // WARNING: will be removed in the future (acme.ExtendedAccount), https://github.com/go-acme/lego/issues/855. type Resource struct { - Body acme.Account `json:"body,omitempty"` + Body acme.Account `json:"body"` URI string `json:"uri,omitempty"` } @@ -160,6 +160,7 @@ func (r *Registrar) ResolveAccountByKey() (*Resource, error) { log.Infof("acme: Trying to resolve account by key") accMsg := acme.Account{OnlyReturnExisting: true} + account, err := r.core.Accounts.New(accMsg) if err != nil { return nil, err