From db972bd0ded7154c5f0f30149c6af87dafc609b6 Mon Sep 17 00:00:00 2001 From: Oana Tanasoiu Date: Wed, 6 May 2020 09:31:36 +0300 Subject: [PATCH] (FACT-2247) Add networking fact for linux --- .rubocop_todo.yml | 17 ++---- lib/facts/linux/dhcp_servers.rb | 26 +++++++++ lib/facts/linux/ipaddress6_interfaces.rb | 20 +++++++ lib/facts/linux/ipaddress_interfaces.rb | 20 +++++++ lib/facts/linux/macaddress_interfaces.rb | 20 +++++++ lib/facts/linux/mtu_interfaces.rb | 20 +++++++ lib/facts/linux/netmask6_interfaces.rb | 20 +++++++ lib/facts/linux/netmask_interfaces.rb | 20 +++++++ lib/facts/linux/network6_interfaces.rb | 20 +++++++ lib/facts/linux/network_interfaces.rb | 20 +++++++ lib/facts/linux/networking/dhcp.rb | 20 +++++++ lib/facts/linux/networking/ip.rb | 5 +- lib/facts/linux/networking/ip6.rb | 21 ++++++++ lib/facts/linux/networking/mac.rb | 5 +- lib/facts/linux/networking/mtu.rb | 20 +++++++ lib/facts/linux/networking/netmask.rb | 21 ++++++++ lib/facts/linux/networking/netmask6.rb | 21 ++++++++ lib/facts/linux/networking/network.rb | 21 ++++++++ lib/facts/linux/networking/network6.rb | 21 ++++++++ lib/facts/linux/networking/scope6.rb | 20 +++++++ lib/facts/linux/scope6_interfaces.rb | 20 +++++++ lib/facts/windows/dhcp_servers.rb | 6 ++- lib/resolvers/networking_linux_resolver.rb | 54 +++++++++++++------ spec/facter/facts/linux/dhcp_servers_spec.rb | 41 ++++++++++++++ .../facts/linux/ipaddress6_interfaces_spec.rb | 34 ++++++++++++ .../facts/linux/ipaddress_interfaces_spec.rb | 34 ++++++++++++ .../facts/linux/macaddress_interfaces_spec.rb | 34 ++++++++++++ .../facter/facts/linux/mtu_interfaces_spec.rb | 32 +++++++++++ .../facts/linux/netmask6_interfaces_spec.rb | 37 +++++++++++++ .../facts/linux/netmask_interfaces_spec.rb | 34 ++++++++++++ .../facts/linux/network6_interfaces_spec.rb | 34 ++++++++++++ .../facts/linux/network_interfaces_spec.rb | 34 ++++++++++++ .../facts/linux/networking/dhcp_spec.rb | 32 +++++++++++ .../facter/facts/linux/networking/ip6_spec.rb | 32 +++++++++++ spec/facter/facts/linux/networking/ip_spec.rb | 14 +++-- .../facter/facts/linux/networking/mac_spec.rb | 14 +++-- .../facter/facts/linux/networking/mtu_spec.rb | 32 +++++++++++ .../facts/linux/networking/netmask6_spec.rb | 32 +++++++++++ .../facts/linux/networking/netmask_spec.rb | 32 +++++++++++ .../facts/linux/networking/network6_spec.rb | 32 +++++++++++ .../facts/linux/networking/network_spec.rb | 32 +++++++++++ .../facts/linux/networking/scope6_spec.rb | 32 +++++++++++ .../facts/linux/scope6_interfaces_spec.rb | 34 ++++++++++++ .../facter/facts/windows/dhcp_servers_spec.rb | 41 ++++++++++++++ .../windows/ipaddress6_interfaces_spec.rb | 2 +- .../windows/ipaddress_interfaces_spec.rb | 2 +- .../windows/macaddress_interfaces_spec.rb | 2 +- .../facts/windows/mtu_interfaces_spec.rb | 2 +- .../facts/windows/netmask6_interfaces_spec.rb | 2 +- .../facts/windows/netmask_interfaces_spec.rb | 2 +- .../facts/windows/network6_interfaces_spec.rb | 2 +- .../facts/windows/network_interfaces_spec.rb | 2 +- .../facts/windows/networking/dhcp_spec.rb | 22 +++++--- .../facts/windows/scope6_interfaces_spec.rb | 2 +- 54 files changed, 1115 insertions(+), 56 deletions(-) create mode 100644 lib/facts/linux/dhcp_servers.rb create mode 100644 lib/facts/linux/ipaddress6_interfaces.rb create mode 100644 lib/facts/linux/ipaddress_interfaces.rb create mode 100644 lib/facts/linux/macaddress_interfaces.rb create mode 100644 lib/facts/linux/mtu_interfaces.rb create mode 100644 lib/facts/linux/netmask6_interfaces.rb create mode 100644 lib/facts/linux/netmask_interfaces.rb create mode 100644 lib/facts/linux/network6_interfaces.rb create mode 100644 lib/facts/linux/network_interfaces.rb create mode 100644 lib/facts/linux/networking/dhcp.rb create mode 100644 lib/facts/linux/networking/ip6.rb create mode 100644 lib/facts/linux/networking/mtu.rb create mode 100644 lib/facts/linux/networking/netmask.rb create mode 100644 lib/facts/linux/networking/netmask6.rb create mode 100644 lib/facts/linux/networking/network.rb create mode 100644 lib/facts/linux/networking/network6.rb create mode 100644 lib/facts/linux/networking/scope6.rb create mode 100644 lib/facts/linux/scope6_interfaces.rb create mode 100644 spec/facter/facts/linux/dhcp_servers_spec.rb create mode 100644 spec/facter/facts/linux/ipaddress6_interfaces_spec.rb create mode 100644 spec/facter/facts/linux/ipaddress_interfaces_spec.rb create mode 100644 spec/facter/facts/linux/macaddress_interfaces_spec.rb create mode 100644 spec/facter/facts/linux/mtu_interfaces_spec.rb create mode 100644 spec/facter/facts/linux/netmask6_interfaces_spec.rb create mode 100644 spec/facter/facts/linux/netmask_interfaces_spec.rb create mode 100644 spec/facter/facts/linux/network6_interfaces_spec.rb create mode 100644 spec/facter/facts/linux/network_interfaces_spec.rb create mode 100644 spec/facter/facts/linux/networking/dhcp_spec.rb create mode 100644 spec/facter/facts/linux/networking/ip6_spec.rb create mode 100644 spec/facter/facts/linux/networking/mtu_spec.rb create mode 100644 spec/facter/facts/linux/networking/netmask6_spec.rb create mode 100644 spec/facter/facts/linux/networking/netmask_spec.rb create mode 100644 spec/facter/facts/linux/networking/network6_spec.rb create mode 100644 spec/facter/facts/linux/networking/network_spec.rb create mode 100644 spec/facter/facts/linux/networking/scope6_spec.rb create mode 100644 spec/facter/facts/linux/scope6_interfaces_spec.rb create mode 100644 spec/facter/facts/windows/dhcp_servers_spec.rb diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml index 3d337cbbc..7a1dd1833 100644 --- a/.rubocop_todo.yml +++ b/.rubocop_todo.yml @@ -1,6 +1,6 @@ # This configuration was generated by # `rubocop --auto-gen-config --exclude-limit 1000` -# on 2020-05-06 13:07:31 +0300 using RuboCop version 0.74.0. +# on 2020-05-07 16:15:01 +0300 using RuboCop version 0.74.0. # The point is for the user to remove these configuration records # one by one as the offenses are removed from the code base. # Note that changes in the inspected code, or installation of new @@ -110,7 +110,7 @@ RSpec/LeakyConstantDeclaration: - 'spec/facter/resolvers/macosx/mountpoints_resolver_spec.rb' - 'spec/facter/resolvers/utils/windows/network_utils_spec.rb' -# Offense count: 114 +# Offense count: 100 # Configuration parameters: EnforcedStyle. # SupportedStyles: have_received, receive RSpec/MessageSpies: @@ -148,18 +148,10 @@ RSpec/MessageSpies: - 'spec/facter/facts/windows/dmi/product/uuid_spec.rb' - 'spec/facter/facts/windows/fips_enabled_spec.rb' - 'spec/facter/facts/windows/identity/user_spec.rb' - - 'spec/facter/facts/windows/ipaddress6_interfaces_spec.rb' - - 'spec/facter/facts/windows/ipaddress_interfaces_spec.rb' - - 'spec/facter/facts/windows/macaddress_interfaces_spec.rb' - 'spec/facter/facts/windows/memory/system/available_bytes_spec.rb' - 'spec/facter/facts/windows/memory/system/available_spec.rb' - 'spec/facter/facts/windows/memory/system/total_bytes_spec.rb' - 'spec/facter/facts/windows/memory/system/total_spec.rb' - - 'spec/facter/facts/windows/mtu_interfaces_spec.rb' - - 'spec/facter/facts/windows/netmask6_interfaces_spec.rb' - - 'spec/facter/facts/windows/netmask_interfaces_spec.rb' - - 'spec/facter/facts/windows/network6_interfaces_spec.rb' - - 'spec/facter/facts/windows/network_interfaces_spec.rb' - 'spec/facter/facts/windows/os/architecture_spec.rb' - 'spec/facter/facts/windows/os/family_spec.rb' - 'spec/facter/facts/windows/os/hardware_spec.rb' @@ -174,9 +166,7 @@ RSpec/MessageSpies: - 'spec/facter/facts/windows/processors/physicalcount_spec.rb' - 'spec/facter/facts/windows/ruby/platform_spec.rb' - 'spec/facter/facts/windows/ruby/sitedir_spec.rb' - - 'spec/facter/facts/windows/scope6_interfaces_spec.rb' - 'spec/facter/resolvers/utils/aix/odm_query_spec.rb' - - 'spec/framework/core/fact_loaders/external_fact_loader_spec.rb' # Offense count: 26 RSpec/SubjectStub: @@ -189,7 +179,7 @@ RSpec/SubjectStub: - 'spec/custom_facts/util/fact_spec.rb' - 'spec/custom_facts/util/resolution_spec.rb' -# Offense count: 162 +# Offense count: 161 # Configuration parameters: IgnoreNameless, IgnoreSymbolicNames. RSpec/VerifiedDoubles: Exclude: @@ -214,7 +204,6 @@ RSpec/VerifiedDoubles: - 'spec/facter/facts/windows/identity/privileged_spec.rb' - 'spec/facter/facts/windows/memory/system/capacity_spec.rb' - 'spec/facter/facts/windows/memory/system/used_bytes_spec.rb' - - 'spec/facter/facts/windows/networking/dhcp_spec.rb' - 'spec/facter/facts/windows/networking/interfaces_spec.rb' - 'spec/facter/facts/windows/networking/mtu_spec.rb' - 'spec/facter/facts/windows/networking/primary_spec.rb' diff --git a/lib/facts/linux/dhcp_servers.rb b/lib/facts/linux/dhcp_servers.rb new file mode 100644 index 000000000..5a8edf9fb --- /dev/null +++ b/lib/facts/linux/dhcp_servers.rb @@ -0,0 +1,26 @@ +# frozen_string_literal: true + +module Facts + module Linux + class DhcpServers + FACT_NAME = 'dhcp_servers' + + def call_the_resolver + fact_value = construct_addresses_hash + Facter::ResolvedFact.new(FACT_NAME, !fact_value || fact_value.empty? ? nil : fact_value, :legacy) + end + + private + + def construct_addresses_hash + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + return unless interfaces + + servers = { system: interfaces[primary][:dhcp] } + interfaces&.each { |interface_name, info| servers[interface_name] = info[:dhcp] if info[:dhcp] } + servers + end + end + end +end diff --git a/lib/facts/linux/ipaddress6_interfaces.rb b/lib/facts/linux/ipaddress6_interfaces.rb new file mode 100644 index 000000000..da6ce1b25 --- /dev/null +++ b/lib/facts/linux/ipaddress6_interfaces.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + class Ipaddress6Interfaces + FACT_NAME = 'ipaddress6_.*' + TYPE = :legacy + + def call_the_resolver + arr = [] + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + interfaces&.each do |interface_name, info| + arr << Facter::ResolvedFact.new("ipaddress6_#{interface_name}", info[:ip6], :legacy) if info[:ip6] + end + + arr + end + end + end +end diff --git a/lib/facts/linux/ipaddress_interfaces.rb b/lib/facts/linux/ipaddress_interfaces.rb new file mode 100644 index 000000000..cc55846af --- /dev/null +++ b/lib/facts/linux/ipaddress_interfaces.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + class IpaddressInterfaces + FACT_NAME = 'ipaddress_.*' + TYPE = :legacy + + def call_the_resolver + arr = [] + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + interfaces&.each do |interface_name, info| + arr << Facter::ResolvedFact.new("ipaddress_#{interface_name}", info[:ip], :legacy) if info[:ip] + end + + arr + end + end + end +end diff --git a/lib/facts/linux/macaddress_interfaces.rb b/lib/facts/linux/macaddress_interfaces.rb new file mode 100644 index 000000000..37bd50433 --- /dev/null +++ b/lib/facts/linux/macaddress_interfaces.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + class MacaddressInterfaces + FACT_NAME = 'macaddress_.*' + TYPE = :legacy + + def call_the_resolver + arr = [] + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + interfaces&.each do |interface_name, info| + arr << Facter::ResolvedFact.new("macaddress_#{interface_name}", info[:mac], :legacy) if info[:mac] + end + + arr + end + end + end +end diff --git a/lib/facts/linux/mtu_interfaces.rb b/lib/facts/linux/mtu_interfaces.rb new file mode 100644 index 000000000..d98f0f1c2 --- /dev/null +++ b/lib/facts/linux/mtu_interfaces.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + class MtuInterfaces + FACT_NAME = 'mtu_.*' + TYPE = :legacy + + def call_the_resolver + arr = [] + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + interfaces&.each do |interface_name, info| + arr << Facter::ResolvedFact.new("mtu_#{interface_name}", info[:mtu], :legacy) if info[:mtu] + end + + arr + end + end + end +end diff --git a/lib/facts/linux/netmask6_interfaces.rb b/lib/facts/linux/netmask6_interfaces.rb new file mode 100644 index 000000000..71ab09fe6 --- /dev/null +++ b/lib/facts/linux/netmask6_interfaces.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + class Netmask6Interfaces + FACT_NAME = 'netmask6_.*' + TYPE = :legacy + + def call_the_resolver + arr = [] + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + interfaces&.each do |interface_name, info| + arr << Facter::ResolvedFact.new("netmask6_#{interface_name}", info[:netmask6], :legacy) if info[:netmask6] + end + + arr + end + end + end +end diff --git a/lib/facts/linux/netmask_interfaces.rb b/lib/facts/linux/netmask_interfaces.rb new file mode 100644 index 000000000..4834e6def --- /dev/null +++ b/lib/facts/linux/netmask_interfaces.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + class NetmaskInterfaces + FACT_NAME = 'netmask_.*' + TYPE = :legacy + + def call_the_resolver + arr = [] + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + interfaces&.each do |interface_name, info| + arr << Facter::ResolvedFact.new("netmask_#{interface_name}", info[:netmask], :legacy) if info[:netmask] + end + + arr + end + end + end +end diff --git a/lib/facts/linux/network6_interfaces.rb b/lib/facts/linux/network6_interfaces.rb new file mode 100644 index 000000000..bcb45a047 --- /dev/null +++ b/lib/facts/linux/network6_interfaces.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + class Network6Interfaces + FACT_NAME = 'network6_.*' + TYPE = :legacy + + def call_the_resolver + arr = [] + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + interfaces&.each do |interface_name, info| + arr << Facter::ResolvedFact.new("network6_#{interface_name}", info[:network6], :legacy) if info[:network6] + end + + arr + end + end + end +end diff --git a/lib/facts/linux/network_interfaces.rb b/lib/facts/linux/network_interfaces.rb new file mode 100644 index 000000000..b24a344e9 --- /dev/null +++ b/lib/facts/linux/network_interfaces.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + class NetworkInterfaces + FACT_NAME = 'network_.*' + TYPE = :legacy + + def call_the_resolver + arr = [] + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + interfaces&.each do |interface_name, info| + arr << Facter::ResolvedFact.new("network_#{interface_name}", info[:network], :legacy) if info[:network] + end + + arr + end + end + end +end diff --git a/lib/facts/linux/networking/dhcp.rb b/lib/facts/linux/networking/dhcp.rb new file mode 100644 index 000000000..f0f5b846c --- /dev/null +++ b/lib/facts/linux/networking/dhcp.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + module Networking + class Dhcp + FACT_NAME = 'networking.dhcp' + + def call_the_resolver + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + + fact_value = interfaces[primary][:dhcp] if interfaces && interfaces[primary] + + Facter::ResolvedFact.new(FACT_NAME, fact_value) + end + end + end + end +end diff --git a/lib/facts/linux/networking/ip.rb b/lib/facts/linux/networking/ip.rb index 96d853855..e02b200b3 100644 --- a/lib/facts/linux/networking/ip.rb +++ b/lib/facts/linux/networking/ip.rb @@ -8,7 +8,10 @@ class Ip ALIASES = 'ipaddress' def call_the_resolver - fact_value = Facter::Resolvers::NetworkingLinux.resolve(:ip) + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + + fact_value = interfaces[primary][:ip] if interfaces && interfaces[primary] [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)] end diff --git a/lib/facts/linux/networking/ip6.rb b/lib/facts/linux/networking/ip6.rb new file mode 100644 index 000000000..7e2d45fd8 --- /dev/null +++ b/lib/facts/linux/networking/ip6.rb @@ -0,0 +1,21 @@ +# frozen_string_literal: true + +module Facts + module Linux + module Networking + class Ip6 + FACT_NAME = 'networking.ip6' + ALIASES = 'ipaddress6' + + def call_the_resolver + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + + fact_value = interfaces[primary][:ip6] if interfaces && interfaces[primary] + + [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)] + end + end + end + end +end diff --git a/lib/facts/linux/networking/mac.rb b/lib/facts/linux/networking/mac.rb index 36a7b4f09..6ee6e62e9 100644 --- a/lib/facts/linux/networking/mac.rb +++ b/lib/facts/linux/networking/mac.rb @@ -8,7 +8,10 @@ class Mac ALIASES = 'macaddress' def call_the_resolver - fact_value = Facter::Resolvers::NetworkingLinux.resolve(:macaddress) + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + + fact_value = interfaces[primary][:mac] if interfaces && interfaces[primary] [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)] end diff --git a/lib/facts/linux/networking/mtu.rb b/lib/facts/linux/networking/mtu.rb new file mode 100644 index 000000000..7befa90df --- /dev/null +++ b/lib/facts/linux/networking/mtu.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + module Networking + class Mtu + FACT_NAME = 'networking.mtu' + + def call_the_resolver + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + + fact_value = interfaces[primary][:mtu] if interfaces && interfaces[primary] + + Facter::ResolvedFact.new(FACT_NAME, fact_value) + end + end + end + end +end diff --git a/lib/facts/linux/networking/netmask.rb b/lib/facts/linux/networking/netmask.rb new file mode 100644 index 000000000..1eaf2668a --- /dev/null +++ b/lib/facts/linux/networking/netmask.rb @@ -0,0 +1,21 @@ +# frozen_string_literal: true + +module Facts + module Linux + module Networking + class Netmask + FACT_NAME = 'networking.netmask' + ALIASES = 'netmask' + + def call_the_resolver + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + + fact_value = interfaces[primary][:netmask] if interfaces && interfaces[primary] + + [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)] + end + end + end + end +end diff --git a/lib/facts/linux/networking/netmask6.rb b/lib/facts/linux/networking/netmask6.rb new file mode 100644 index 000000000..30d480129 --- /dev/null +++ b/lib/facts/linux/networking/netmask6.rb @@ -0,0 +1,21 @@ +# frozen_string_literal: true + +module Facts + module Linux + module Networking + class Netmask6 + FACT_NAME = 'networking.netmask6' + ALIASES = 'netmask6' + + def call_the_resolver + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + + fact_value = interfaces[primary][:netmask6] if interfaces && interfaces[primary] + + [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)] + end + end + end + end +end diff --git a/lib/facts/linux/networking/network.rb b/lib/facts/linux/networking/network.rb new file mode 100644 index 000000000..4f3277c41 --- /dev/null +++ b/lib/facts/linux/networking/network.rb @@ -0,0 +1,21 @@ +# frozen_string_literal: true + +module Facts + module Linux + module Networking + class Network + FACT_NAME = 'networking.network' + ALIASES = 'network' + + def call_the_resolver + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + + fact_value = interfaces[primary][:network] if interfaces && interfaces[primary] + + [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)] + end + end + end + end +end diff --git a/lib/facts/linux/networking/network6.rb b/lib/facts/linux/networking/network6.rb new file mode 100644 index 000000000..b45b3b6a7 --- /dev/null +++ b/lib/facts/linux/networking/network6.rb @@ -0,0 +1,21 @@ +# frozen_string_literal: true + +module Facts + module Linux + module Networking + class Network6 + FACT_NAME = 'networking.network6' + ALIASES = 'network6' + + def call_the_resolver + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + + fact_value = interfaces[primary][:network6] if interfaces && interfaces[primary] + + [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)] + end + end + end + end +end diff --git a/lib/facts/linux/networking/scope6.rb b/lib/facts/linux/networking/scope6.rb new file mode 100644 index 000000000..aa85d55e4 --- /dev/null +++ b/lib/facts/linux/networking/scope6.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + module Networking + class Scope6 + FACT_NAME = 'networking.scope6' + + def call_the_resolver + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + primary = Facter::Resolvers::NetworkingLinux.resolve(:primary_interface) + + fact_value = interfaces[primary][:scope6] if interfaces && interfaces[primary] + + Facter::ResolvedFact.new(FACT_NAME, fact_value) + end + end + end + end +end diff --git a/lib/facts/linux/scope6_interfaces.rb b/lib/facts/linux/scope6_interfaces.rb new file mode 100644 index 000000000..d268b0550 --- /dev/null +++ b/lib/facts/linux/scope6_interfaces.rb @@ -0,0 +1,20 @@ +# frozen_string_literal: true + +module Facts + module Linux + class Scope6Interfaces + FACT_NAME = 'scope6_.*' + TYPE = :legacy + + def call_the_resolver + arr = [] + result = {} + interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces) + interfaces&.each { |interface_name, info| result["scope6_#{interface_name}"] = info[:scope6] if info[:scope6] } + + result.each { |fact, value| arr << Facter::ResolvedFact.new(fact, value, :legacy) } + arr + end + end + end +end diff --git a/lib/facts/windows/dhcp_servers.rb b/lib/facts/windows/dhcp_servers.rb index 70b5a2373..d90c69c50 100644 --- a/lib/facts/windows/dhcp_servers.rb +++ b/lib/facts/windows/dhcp_servers.rb @@ -7,14 +7,16 @@ class DhcpServers def call_the_resolver fact_value = construct_addresses_hash - Facter::ResolvedFact.new(FACT_NAME, fact_value.empty? ? nil : fact_value, :legacy) + Facter::ResolvedFact.new(FACT_NAME, !fact_value || fact_value.empty? ? nil : fact_value, :legacy) end private def construct_addresses_hash - servers = { system: Facter::Resolvers::Networking.resolve(:dhcp) } interfaces = Facter::Resolvers::Networking.resolve(:interfaces) + return unless interfaces + + servers = { system: Facter::Resolvers::Networking.resolve(:dhcp) } interfaces&.each { |interface_name, info| servers[interface_name] = info[:dhcp] if info[:dhcp] } servers end diff --git a/lib/resolvers/networking_linux_resolver.rb b/lib/resolvers/networking_linux_resolver.rb index f9bc00556..0512cf5d7 100644 --- a/lib/resolvers/networking_linux_resolver.rb +++ b/lib/resolvers/networking_linux_resolver.rb @@ -18,16 +18,19 @@ def post_resolve(fact_name) def retrieve_network_info(fact_name) @fact_list ||= {} - retrieve_default_interface_and_ip retrieve_interface_info - retrieve_macaddress + retrieve_interfaces_mac_and_mtu + retrieve_default_interface @fact_list[fact_name] end - def retrieve_macaddress - output = Facter::Core::Execution.execute("ip link show #{@fact_list[:primary_interface]}", logger: log) - macaddress = */ether ([^ ]*) /.match(output) - @fact_list[:macaddress] = macaddress[1] + def retrieve_interfaces_mac_and_mtu + @fact_list[:interfaces].map do |name, info| + macaddress = Util::FileHelper.safe_read("/sys/class/net/#{name}/address", nil) + info[:mac] = macaddress.strip if macaddress && !macaddress.include?('00:00:00:00:00:00') + mtu = Util::FileHelper.safe_read("/sys/class/net/#{name}/mtu", nil) + info[:mtu] = mtu.strip.to_i if mtu + end end def retrieve_interface_info @@ -39,48 +42,65 @@ def retrieve_interface_info fill_ip_v4_info!(ip_tokens, interfaces) fill_io_v6_info!(ip_tokens, interfaces) + find_dhcp(ip_tokens, interfaces) end @fact_list[:interfaces] = interfaces end + def find_dhcp(tokens, network_info) + return if network_info[tokens[1]][:dhcp] + + index = tokens[0].delete(':') + dhcp = Util::FileHelper.safe_read("/run/systemd/netif/leases/#{index}", nil) + network_info[tokens[1]][:dhcp] = dhcp.match(/SERVER_ADDRESS=(.*)/)[1] if dhcp + end + def fill_ip_v4_info!(ip_tokens, network_info) return unless ip_tokens[2].casecmp('inet').zero? - interface_name = ip_tokens[1] - ip4_info = ip_tokens[3].split('/') - ip4_address = ip4_info[0] - ip4_mask_length = ip4_info[1] + interface_name, ip4_address, ip4_mask_length = retrieve_name_and_ip_info(ip_tokens) binding = build_binding(ip4_address, ip4_mask_length) build_network_info_structure!(network_info, interface_name, 'bindings') network_info[interface_name]['bindings'] << binding + network_info[interface_name][:ip] ||= binding[:address] + network_info[interface_name][:network] ||= binding[:network] + network_info[interface_name][:netmask] ||= binding[:netmask] + end + + def retrieve_name_and_ip_info(tokens) + interface_name = tokens[1] + ip_info = tokens[3].split('/') + ip_address = ip_info[0] + ip_mask_length = ip_info[1] + + [interface_name, ip_address, ip_mask_length] end def fill_io_v6_info!(ip_tokens, network_info) return unless ip_tokens[2].casecmp('inet6').zero? - interface_name = ip_tokens[1] - ip6_info = ip_tokens[3].split('/') - ip6_address = ip6_info[0] - ip6_mask_length = ip6_info[1] + interface_name, ip6_address, ip6_mask_length = retrieve_name_and_ip_info(ip_tokens) binding = build_binding(ip6_address, ip6_mask_length) build_network_info_structure!(network_info, interface_name, 'bindings6') network_info[interface_name]['bindings6'] << binding + network_info[interface_name][:ip6] ||= binding[:address] + network_info[interface_name][:network6] ||= binding[:network] + network_info[interface_name][:netmask6] ||= binding[:netmask] + network_info[interface_name][:scope6] ||= ip_tokens[5] end - def retrieve_default_interface_and_ip + def retrieve_default_interface output = Facter::Core::Execution.execute('ip route get 1', logger: log) ip_route_tokens = output.each_line.first.strip.split(' ') default_interface = ip_route_tokens[4] - default_ip = ip_route_tokens[6] - @fact_list[:ip] = default_ip @fact_list[:primary_interface] = default_interface end diff --git a/spec/facter/facts/linux/dhcp_servers_spec.rb b/spec/facter/facts/linux/dhcp_servers_spec.rb new file mode 100644 index 000000000..d1a34df07 --- /dev/null +++ b/spec/facter/facts/linux/dhcp_servers_spec.rb @@ -0,0 +1,41 @@ +# frozen_string_literal: true + +describe Facts::Linux::DhcpServers do + subject(:fact) { Facts::Linux::DhcpServers.new } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) + end + + describe '#call_the_resolver' do + let(:value) { { 'system' => '10.16.122.163', 'eth0' => '10.16.122.163', 'en1' => '10.32.10.163' } } + let(:interfaces) { { 'eth0' => { dhcp: '10.16.122.163' }, 'en1' => { dhcp: '10.32.10.163' } } } + let(:primary) { 'eth0' } + + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) + end + + it 'returns dhcp_servers' do + expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \ + have_attributes(name: 'dhcp_servers', value: value, type: :legacy) + end + end + + describe '#call_the_resolver when resolver returns nil' do + let(:interfaces) { nil } + let(:primary) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \ + have_attributes(name: 'dhcp_servers', value: nil, type: :legacy) + end + end +end diff --git a/spec/facter/facts/linux/ipaddress6_interfaces_spec.rb b/spec/facter/facts/linux/ipaddress6_interfaces_spec.rb new file mode 100644 index 000000000..261b42dfe --- /dev/null +++ b/spec/facter/facts/linux/ipaddress6_interfaces_spec.rb @@ -0,0 +1,34 @@ +# frozen_string_literal: true + +describe Facts::Linux::Ipaddress6Interfaces do + subject(:fact) { Facts::Linux::Ipaddress6Interfaces.new } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + end + + describe '#call_the_resolver' do + let(:interfaces) { { 'eth0' => { ip6: 'fe80::99bf:da20:ad3:9bfe' }, 'en1' => { ip6: 'fe80::99bf:da20:ad3:9bfe' } } } + + it 'calls Facter::Resolvers::NetworkingLinux' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'returns legacy facts with names ipaddress6_' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'ipaddress6_eth0', + value: interfaces['eth0'][:ip6], type: :legacy), + an_object_having_attributes(name: 'ipaddress6_en1', + value: interfaces['en1'][:ip6], type: :legacy)) + end + end + + describe '#call_the_resolver when resolver returns nil' do + let(:interfaces) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly + end + end +end diff --git a/spec/facter/facts/linux/ipaddress_interfaces_spec.rb b/spec/facter/facts/linux/ipaddress_interfaces_spec.rb new file mode 100644 index 000000000..7fe2fe530 --- /dev/null +++ b/spec/facter/facts/linux/ipaddress_interfaces_spec.rb @@ -0,0 +1,34 @@ +# frozen_string_literal: true + +describe Facts::Linux::IpaddressInterfaces do + subject(:fact) { Facts::Linux::IpaddressInterfaces.new } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + end + + describe '#call_the_resolver' do + let(:interfaces) { { 'eth0' => { ip: '10.16.117.100' }, 'en1' => { ip: '10.16.117.255' } } } + + it 'calls Facter::Resolvers::NetworkingLinux' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'returns legacy facts with names ipaddress_' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'ipaddress_eth0', + value: interfaces['eth0'][:ip], type: :legacy), + an_object_having_attributes(name: 'ipaddress_en1', + value: interfaces['en1'][:ip], type: :legacy)) + end + end + + describe '#call_the_resolver when resolver returns nil' do + let(:interfaces) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly + end + end +end diff --git a/spec/facter/facts/linux/macaddress_interfaces_spec.rb b/spec/facter/facts/linux/macaddress_interfaces_spec.rb new file mode 100644 index 000000000..740cd94c3 --- /dev/null +++ b/spec/facter/facts/linux/macaddress_interfaces_spec.rb @@ -0,0 +1,34 @@ +# frozen_string_literal: true + +describe Facts::Linux::MacaddressInterfaces do + subject(:fact) { Facts::Linux::MacaddressInterfaces.new } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + end + + describe '#call_the_resolver' do + let(:interfaces) { { 'eth0' => { mac: '10.16.117.100' }, 'en1' => { mac: '10.16.117.255' } } } + + it 'calls Facter::Resolvers::NetworkingLinux' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'returns legacy facts with names macaddress_' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'macaddress_eth0', + value: interfaces['eth0'][:mac], type: :legacy), + an_object_having_attributes(name: 'macaddress_en1', + value: interfaces['en1'][:mac], type: :legacy)) + end + end + + describe '#call_the_resolver when resolver returns nil' do + let(:interfaces) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly + end + end +end diff --git a/spec/facter/facts/linux/mtu_interfaces_spec.rb b/spec/facter/facts/linux/mtu_interfaces_spec.rb new file mode 100644 index 000000000..921dd7774 --- /dev/null +++ b/spec/facter/facts/linux/mtu_interfaces_spec.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +describe Facts::Linux::MtuInterfaces do + subject(:fact) { Facts::Linux::MtuInterfaces.new } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + end + + describe '#call_the_resolver' do + let(:interfaces) { { 'eth0' => { mtu: 1500 }, 'en1' => { mtu: 1500 } } } + + it 'calls Facter::Resolvers::NetworkingLinux' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'returns legacy facts with names mtu_' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'mtu_eth0', value: interfaces['eth0'][:mtu], type: :legacy), + an_object_having_attributes(name: 'mtu_en1', value: interfaces['en1'][:mtu], type: :legacy)) + end + end + + describe '#call_the_resolver when resolver reeturns nil' do + let(:interfaces) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly + end + end +end diff --git a/spec/facter/facts/linux/netmask6_interfaces_spec.rb b/spec/facter/facts/linux/netmask6_interfaces_spec.rb new file mode 100644 index 000000000..ead226c1f --- /dev/null +++ b/spec/facter/facts/linux/netmask6_interfaces_spec.rb @@ -0,0 +1,37 @@ +# frozen_string_literal: true + +describe Facts::Linux::Netmask6Interfaces do + subject(:fact) { Facts::Linux::Netmask6Interfaces.new } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + end + + describe '#call_the_resolver' do + let(:interfaces) do + { 'eth0' => { netmask6: 'fe80::99bf:da20:ad3:9bfe' }, + 'en1' => { netmask6: 'fe80::99bf:da20:ad3:9bfe' } } + end + + it 'calls Facter::Resolvers::NetworkingLinux' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'returns legacy facts with names netmask6_' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'netmask6_eth0', + value: interfaces['eth0'][:netmask6], type: :legacy), + an_object_having_attributes(name: 'netmask6_en1', + value: interfaces['en1'][:netmask6], type: :legacy)) + end + end + + describe '#call_the_resolver when resolver return nil' do + let(:interfaces) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly + end + end +end diff --git a/spec/facter/facts/linux/netmask_interfaces_spec.rb b/spec/facter/facts/linux/netmask_interfaces_spec.rb new file mode 100644 index 000000000..ea0f26b70 --- /dev/null +++ b/spec/facter/facts/linux/netmask_interfaces_spec.rb @@ -0,0 +1,34 @@ +# frozen_string_literal: true + +describe Facts::Linux::NetmaskInterfaces do + subject(:fact) { Facts::Linux::NetmaskInterfaces.new } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + end + + describe '#call_the_resolver' do + let(:interfaces) { { 'eth0' => { netmask: '10.255.255.255' }, 'en1' => { netmask: '10.17.255.255' } } } + + it 'calls Facter::Resolvers::NetworkingLinux' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'returns legacy facts with names netmask_' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'netmask_eth0', + value: interfaces['eth0'][:netmask], type: :legacy), + an_object_having_attributes(name: 'netmask_en1', + value: interfaces['en1'][:netmask], type: :legacy)) + end + end + + describe '#call_the_resolver when resolver returns nil' do + let(:interfaces) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly + end + end +end diff --git a/spec/facter/facts/linux/network6_interfaces_spec.rb b/spec/facter/facts/linux/network6_interfaces_spec.rb new file mode 100644 index 000000000..7b777168e --- /dev/null +++ b/spec/facter/facts/linux/network6_interfaces_spec.rb @@ -0,0 +1,34 @@ +# frozen_string_literal: true + +describe Facts::Linux::Network6Interfaces do + subject(:fact) { Facts::Linux::Network6Interfaces.new } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + end + + describe '#call_the_resolver' do + let(:interfaces) { { 'eth0' => { network6: '::1' }, 'en1' => { network6: 'fe80::' } } } + + it 'calls Facter::Resolvers::NetworkingLinux' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'returns legacy facts with names network6_' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'network6_eth0', + value: interfaces['eth0'][:network6], type: :legacy), + an_object_having_attributes(name: 'network6_en1', + value: interfaces['en1'][:network6], type: :legacy)) + end + end + + describe '#call_the_resolver when resolver returns nil' do + let(:interfaces) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly + end + end +end diff --git a/spec/facter/facts/linux/network_interfaces_spec.rb b/spec/facter/facts/linux/network_interfaces_spec.rb new file mode 100644 index 000000000..444e5aa5a --- /dev/null +++ b/spec/facter/facts/linux/network_interfaces_spec.rb @@ -0,0 +1,34 @@ +# frozen_string_literal: true + +describe Facts::Linux::NetworkInterfaces do + subject(:fact) { Facts::Linux::NetworkInterfaces.new } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + end + + describe '#call_the_resolver' do + let(:interfaces) { { 'eth0' => { network: '10.255.255.255' }, 'en1' => { network: '10.17.255.255' } } } + + it 'calls Facter::Resolvers::NetworkingLinux' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'returns legacy facts with names network_' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'network_eth0', + value: interfaces['eth0'][:network], type: :legacy), + an_object_having_attributes(name: 'network_en1', + value: interfaces['en1'][:network], type: :legacy)) + end + end + + describe '#call_the_resolver when resolver returns nil' do + let(:interfaces) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly + end + end +end diff --git a/spec/facter/facts/linux/networking/dhcp_spec.rb b/spec/facter/facts/linux/networking/dhcp_spec.rb new file mode 100644 index 000000000..95ec6e24d --- /dev/null +++ b/spec/facter/facts/linux/networking/dhcp_spec.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +describe Facts::Linux::Networking::Dhcp do + describe '#call_the_resolver' do + subject(:fact) { Facts::Linux::Networking::Dhcp.new } + + let(:value) { '10.16.122.163' } + let(:interfaces) { { 'eth0' => { dhcp: value }, 'en1' => { ip6: 'fe80::99bf:da20:ad3:9bfe' } } } + let(:primary) { 'eth0' } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) + end + + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) + end + + it 'returns dhcp fact' do + expect(fact.call_the_resolver) + .to be_an_instance_of(Facter::ResolvedFact) + .and have_attributes(name: 'networking.dhcp', value: value) + end + end +end diff --git a/spec/facter/facts/linux/networking/ip6_spec.rb b/spec/facter/facts/linux/networking/ip6_spec.rb new file mode 100644 index 000000000..0370b6b03 --- /dev/null +++ b/spec/facter/facts/linux/networking/ip6_spec.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +describe Facts::Linux::Networking::Ip6 do + describe '#call_the_resolver' do + subject(:fact) { Facts::Linux::Networking::Ip6.new } + + let(:value) { 'fe80::5989:97ff:75ae:dae7' } + let(:interfaces) { { 'eth0' => { ip6: value }, 'en1' => { ip6: 'fe80::99bf:da20:ad3:9bfe' } } } + let(:primary) { 'eth0' } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) + end + + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) + end + + it 'returns ipv6 address fact' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'networking.ip6', value: value), + an_object_having_attributes(name: 'ipaddress6', value: value, type: :legacy)) + end + end +end diff --git a/spec/facter/facts/linux/networking/ip_spec.rb b/spec/facter/facts/linux/networking/ip_spec.rb index 76b28a1f6..56b76b748 100644 --- a/spec/facter/facts/linux/networking/ip_spec.rb +++ b/spec/facter/facts/linux/networking/ip_spec.rb @@ -5,14 +5,22 @@ subject(:fact) { Facts::Linux::Networking::Ip.new } let(:value) { '10.16.122.163' } + let(:interfaces) { { 'eth0' => { ip: value }, 'en1' => { ip6: 'fe80::99bf:da20:ad3:9bfe' } } } + let(:primary) { 'eth0' } before do - allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:ip).and_return(value) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) end - it 'calls Facter::Resolvers::NetworkingLinux' do + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do fact.call_the_resolver - expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:ip) + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) end it 'returns ipaddress fact' do diff --git a/spec/facter/facts/linux/networking/mac_spec.rb b/spec/facter/facts/linux/networking/mac_spec.rb index c16667e07..8b128b7b1 100644 --- a/spec/facter/facts/linux/networking/mac_spec.rb +++ b/spec/facter/facts/linux/networking/mac_spec.rb @@ -5,14 +5,22 @@ subject(:fact) { Facts::Linux::Networking::Mac.new } let(:value) { '64:5a:ed:ea:c3:25' } + let(:interfaces) { { 'eth0' => { ip: '10.16.122.163', mac: value } } } + let(:primary) { 'eth0' } before do - allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:macaddress).and_return(value) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) end - it 'calls Facter::Resolvers::NetworkingLinux' do + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do fact.call_the_resolver - expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:macaddress) + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) end it 'return macaddress fact' do diff --git a/spec/facter/facts/linux/networking/mtu_spec.rb b/spec/facter/facts/linux/networking/mtu_spec.rb new file mode 100644 index 000000000..a8a6345a8 --- /dev/null +++ b/spec/facter/facts/linux/networking/mtu_spec.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +describe Facts::Linux::Networking::Mtu do + describe '#call_the_resolver' do + subject(:fact) { Facts::Linux::Networking::Mtu.new } + + let(:value) { 1500 } + let(:interfaces) { { 'eth0' => { ip: '10.16.122.163', mtu: value } } } + let(:primary) { 'eth0' } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) + end + + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) + end + + it 'return mtu fact' do + expect(fact.call_the_resolver) + .to be_an_instance_of(Facter::ResolvedFact) + .and have_attributes(name: 'networking.mtu', value: value) + end + end +end diff --git a/spec/facter/facts/linux/networking/netmask6_spec.rb b/spec/facter/facts/linux/networking/netmask6_spec.rb new file mode 100644 index 000000000..b0d611e77 --- /dev/null +++ b/spec/facter/facts/linux/networking/netmask6_spec.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +describe Facts::Linux::Networking::Netmask6 do + describe '#call_the_resolver' do + subject(:fact) { Facts::Linux::Networking::Netmask6.new } + + let(:value) { 'fe80::5989:97ff:75ae:dae7' } + let(:interfaces) { { 'eth0' => { netmask6: value }, 'en1' => { ip6: 'fe80::99bf:da20:ad3:9bfe' } } } + let(:primary) { 'eth0' } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) + end + + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) + end + + it 'returns netmask6 fact' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'networking.netmask6', value: value), + an_object_having_attributes(name: 'netmask6', value: value, type: :legacy)) + end + end +end diff --git a/spec/facter/facts/linux/networking/netmask_spec.rb b/spec/facter/facts/linux/networking/netmask_spec.rb new file mode 100644 index 000000000..fb619ba65 --- /dev/null +++ b/spec/facter/facts/linux/networking/netmask_spec.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +describe Facts::Linux::Networking::Netmask do + describe '#call_the_resolver' do + subject(:fact) { Facts::Linux::Networking::Netmask.new } + + let(:value) { '10.16.122.163' } + let(:interfaces) { { 'eth0' => { netmask: value }, 'en1' => { ip6: 'fe80::99bf:da20:ad3:9bfe' } } } + let(:primary) { 'eth0' } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) + end + + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) + end + + it 'returns netmask fact' do + expect(fact.call_the_resolver).to be_an_instance_of(Array) + .and contain_exactly(an_object_having_attributes(name: 'networking.netmask', value: value), + an_object_having_attributes(name: 'netmask', value: value, type: :legacy)) + end + end +end diff --git a/spec/facter/facts/linux/networking/network6_spec.rb b/spec/facter/facts/linux/networking/network6_spec.rb new file mode 100644 index 000000000..318620138 --- /dev/null +++ b/spec/facter/facts/linux/networking/network6_spec.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +describe Facts::Linux::Networking::Network6 do + describe '#call_the_resolver' do + subject(:fact) { Facts::Linux::Networking::Network6.new } + + let(:value) { 'fe80::5989:97ff:75ae:dae7' } + let(:interfaces) { { 'eth0' => { network6: value }, 'en1' => { ip6: 'fe80::99bf:da20:ad3:9bfe' } } } + let(:primary) { 'eth0' } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) + end + + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) + end + + it 'returns network6 fact' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'networking.network6', value: value), + an_object_having_attributes(name: 'network6', value: value, type: :legacy)) + end + end +end diff --git a/spec/facter/facts/linux/networking/network_spec.rb b/spec/facter/facts/linux/networking/network_spec.rb new file mode 100644 index 000000000..411ec278e --- /dev/null +++ b/spec/facter/facts/linux/networking/network_spec.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +describe Facts::Linux::Networking::Network do + describe '#call_the_resolver' do + subject(:fact) { Facts::Linux::Networking::Network.new } + + let(:value) { '10.16.122.163' } + let(:interfaces) { { 'eth0' => { network: value }, 'en1' => { ip6: 'fe80::99bf:da20:ad3:9bfe' } } } + let(:primary) { 'eth0' } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) + end + + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) + end + + it 'returns network fact' do + expect(fact.call_the_resolver).to be_an_instance_of(Array) + .and contain_exactly(an_object_having_attributes(name: 'networking.network', value: value), + an_object_having_attributes(name: 'network', value: value, type: :legacy)) + end + end +end diff --git a/spec/facter/facts/linux/networking/scope6_spec.rb b/spec/facter/facts/linux/networking/scope6_spec.rb new file mode 100644 index 000000000..973403870 --- /dev/null +++ b/spec/facter/facts/linux/networking/scope6_spec.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +describe Facts::Linux::Networking::Scope6 do + describe '#call_the_resolver' do + subject(:fact) { Facts::Linux::Networking::Scope6.new } + + let(:value) { 'link' } + let(:interfaces) { { 'eth0' => { ip: '10.16.122.163', scope6: value } } } + let(:primary) { 'eth0' } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:primary_interface).and_return(primary) + end + + it 'calls Facter::Resolvers::NetworkingLinux with interfaces' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with primary_interface' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:primary_interface) + end + + it 'return scope6 fact' do + expect(fact.call_the_resolver) + .to be_an_instance_of(Facter::ResolvedFact) + .and have_attributes(name: 'networking.scope6', value: value) + end + end +end diff --git a/spec/facter/facts/linux/scope6_interfaces_spec.rb b/spec/facter/facts/linux/scope6_interfaces_spec.rb new file mode 100644 index 000000000..f910635d1 --- /dev/null +++ b/spec/facter/facts/linux/scope6_interfaces_spec.rb @@ -0,0 +1,34 @@ +# frozen_string_literal: true + +describe Facts::Linux::Scope6Interfaces do + subject(:fact) { Facts::Linux::Scope6Interfaces.new } + + before do + allow(Facter::Resolvers::NetworkingLinux).to receive(:resolve).with(:interfaces).and_return(interfaces) + end + + describe '#call_the_resolver' do + let(:interfaces) { { 'eth0' => { scope6: 'link' }, 'en1' => { scope6: 'global' } } } + + it 'calls Facter::Resolvers::NetworkingLinux' do + fact.call_the_resolver + expect(Facter::Resolvers::NetworkingLinux).to have_received(:resolve).with(:interfaces) + end + + it 'returns legacy facts with scope6_' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and \ + contain_exactly(an_object_having_attributes(name: 'scope6_eth0', + value: interfaces['eth0'][:scope6], type: :legacy), + an_object_having_attributes(name: 'scope6_en1', + value: interfaces['en1'][:scope6], type: :legacy)) + end + end + + describe '#call_the_resolver when resolver returns nil' do + let(:interfaces) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Array).and contain_exactly + end + end +end diff --git a/spec/facter/facts/windows/dhcp_servers_spec.rb b/spec/facter/facts/windows/dhcp_servers_spec.rb new file mode 100644 index 000000000..79241cd94 --- /dev/null +++ b/spec/facter/facts/windows/dhcp_servers_spec.rb @@ -0,0 +1,41 @@ +# frozen_string_literal: true + +describe Facts::Windows::DhcpServers do + subject(:fact) { Facts::Windows::DhcpServers.new } + + before do + allow(Facter::Resolvers::Networking).to receive(:resolve).with(:interfaces).and_return(interfaces) + allow(Facter::Resolvers::Networking).to receive(:resolve).with(:dhcp).and_return(dhcp) + end + + describe '#call_the_resolver' do + let(:value) { { 'system' => '10.16.122.163', 'eth0' => '10.16.122.163', 'en1' => '10.32.10.163' } } + let(:interfaces) { { 'eth0' => { dhcp: '10.16.122.163' }, 'en1' => { dhcp: '10.32.10.163' } } } + let(:dhcp) { '10.16.122.163' } + + it 'calls Facter::Resolvers::Networking with interfaces' do + fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:interfaces) + end + + it 'calls Facter::Resolvers::NetworkingLinux with dhcp' do + fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:dhcp) + end + + it 'returns dhcp_servers' do + expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \ + have_attributes(name: 'dhcp_servers', value: value, type: :legacy) + end + end + + describe '#call_the_resolver when resolver returns nil' do + let(:interfaces) { nil } + let(:dhcp) { nil } + + it 'returns nil' do + expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \ + have_attributes(name: 'dhcp_servers', value: nil, type: :legacy) + end + end +end diff --git a/spec/facter/facts/windows/ipaddress6_interfaces_spec.rb b/spec/facter/facts/windows/ipaddress6_interfaces_spec.rb index 9f62761f4..2eeba0555 100644 --- a/spec/facter/facts/windows/ipaddress6_interfaces_spec.rb +++ b/spec/facter/facts/windows/ipaddress6_interfaces_spec.rb @@ -11,8 +11,8 @@ let(:interfaces) { { 'eth0' => { ip6: 'fe80::99bf:da20:ad3:9bfe' }, 'en1' => { ip6: 'fe80::99bf:da20:ad3:9bfe' } } } it 'calls Facter::Resolvers::Networking' do - expect(Facter::Resolvers::Networking).to receive(:resolve).with(:interfaces) fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:interfaces) end it 'returns legacy facts with names ipaddress6_' do diff --git a/spec/facter/facts/windows/ipaddress_interfaces_spec.rb b/spec/facter/facts/windows/ipaddress_interfaces_spec.rb index 24d4b32f5..f7e9749c8 100644 --- a/spec/facter/facts/windows/ipaddress_interfaces_spec.rb +++ b/spec/facter/facts/windows/ipaddress_interfaces_spec.rb @@ -11,8 +11,8 @@ let(:interfaces) { { 'eth0' => { ip: '10.16.117.100' }, 'en1' => { ip: '10.16.117.255' } } } it 'calls Facter::Resolvers::Networking' do - expect(Facter::Resolvers::Networking).to receive(:resolve).with(:interfaces) fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:interfaces) end it 'returns legacy facts with names ipaddress_' do diff --git a/spec/facter/facts/windows/macaddress_interfaces_spec.rb b/spec/facter/facts/windows/macaddress_interfaces_spec.rb index 122831d25..ed0b8b095 100644 --- a/spec/facter/facts/windows/macaddress_interfaces_spec.rb +++ b/spec/facter/facts/windows/macaddress_interfaces_spec.rb @@ -11,8 +11,8 @@ let(:interfaces) { { 'eth0' => { mac: '10.16.117.100' }, 'en1' => { mac: '10.16.117.255' } } } it 'calls Facter::Resolvers::Networking' do - expect(Facter::Resolvers::Networking).to receive(:resolve).with(:interfaces) fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:interfaces) end it 'returns legacy facts with names macaddress_' do diff --git a/spec/facter/facts/windows/mtu_interfaces_spec.rb b/spec/facter/facts/windows/mtu_interfaces_spec.rb index 624c6fd3f..4b8694646 100644 --- a/spec/facter/facts/windows/mtu_interfaces_spec.rb +++ b/spec/facter/facts/windows/mtu_interfaces_spec.rb @@ -11,8 +11,8 @@ let(:interfaces) { { 'eth0' => { mtu: 1500 }, 'en1' => { mtu: 1500 } } } it 'calls Facter::Resolvers::Networking' do - expect(Facter::Resolvers::Networking).to receive(:resolve).with(:interfaces) fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:interfaces) end it 'returns legacy facts with names mtu_' do diff --git a/spec/facter/facts/windows/netmask6_interfaces_spec.rb b/spec/facter/facts/windows/netmask6_interfaces_spec.rb index 9dba688cd..15f05c9f1 100644 --- a/spec/facter/facts/windows/netmask6_interfaces_spec.rb +++ b/spec/facter/facts/windows/netmask6_interfaces_spec.rb @@ -14,8 +14,8 @@ end it 'calls Facter::Resolvers::Networking' do - expect(Facter::Resolvers::Networking).to receive(:resolve).with(:interfaces) fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:interfaces) end it 'returns legacy facts with names netmask6_' do diff --git a/spec/facter/facts/windows/netmask_interfaces_spec.rb b/spec/facter/facts/windows/netmask_interfaces_spec.rb index 9ed33c814..a44305df3 100644 --- a/spec/facter/facts/windows/netmask_interfaces_spec.rb +++ b/spec/facter/facts/windows/netmask_interfaces_spec.rb @@ -11,8 +11,8 @@ let(:interfaces) { { 'eth0' => { netmask: '10.255.255.255' }, 'en1' => { netmask: '10.17.255.255' } } } it 'calls Facter::Resolvers::Networking' do - expect(Facter::Resolvers::Networking).to receive(:resolve).with(:interfaces) fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:interfaces) end it 'returns legacy facts with names netmask_' do diff --git a/spec/facter/facts/windows/network6_interfaces_spec.rb b/spec/facter/facts/windows/network6_interfaces_spec.rb index 6b1296e57..d61c9f692 100644 --- a/spec/facter/facts/windows/network6_interfaces_spec.rb +++ b/spec/facter/facts/windows/network6_interfaces_spec.rb @@ -11,8 +11,8 @@ let(:interfaces) { { 'eth0' => { network6: '::1' }, 'en1' => { network6: 'fe80::' } } } it 'calls Facter::Resolvers::Networking' do - expect(Facter::Resolvers::Networking).to receive(:resolve).with(:interfaces) fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:interfaces) end it 'returns legacy facts with names network6_' do diff --git a/spec/facter/facts/windows/network_interfaces_spec.rb b/spec/facter/facts/windows/network_interfaces_spec.rb index 7291a4770..8639e4664 100644 --- a/spec/facter/facts/windows/network_interfaces_spec.rb +++ b/spec/facter/facts/windows/network_interfaces_spec.rb @@ -11,8 +11,8 @@ let(:interfaces) { { 'eth0' => { network: '10.255.255.255' }, 'en1' => { network: '10.17.255.255' } } } it 'calls Facter::Resolvers::Networking' do - expect(Facter::Resolvers::Networking).to receive(:resolve).with(:interfaces) fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:interfaces) end it 'returns legacy facts with names network_' do diff --git a/spec/facter/facts/windows/networking/dhcp_spec.rb b/spec/facter/facts/windows/networking/dhcp_spec.rb index 52795b850..01baae80b 100644 --- a/spec/facter/facts/windows/networking/dhcp_spec.rb +++ b/spec/facter/facts/windows/networking/dhcp_spec.rb @@ -2,13 +2,23 @@ describe Facts::Windows::Networking::Dhcp do describe '#call_the_resolver' do - it 'returns a fact' do - expected_fact = double(Facter::ResolvedFact, name: 'networking.dhcp', value: 'value') - allow(Facter::Resolvers::Networking).to receive(:resolve).with(:dhcp).and_return('value') - allow(Facter::ResolvedFact).to receive(:new).with('networking.dhcp', 'value').and_return(expected_fact) + subject(:fact) { Facts::Windows::Networking::Dhcp.new } - fact = Facts::Windows::Networking::Dhcp.new - expect(fact.call_the_resolver).to eq(expected_fact) + let(:value) { '10.16.122.163' } + + before do + allow(Facter::Resolvers::Networking).to receive(:resolve).with(:dhcp).and_return(value) + end + + it 'calls Facter::Resolvers::Networking' do + fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:dhcp) + end + + it 'returns ipaddress fact' do + expect(fact.call_the_resolver) + .to be_an_instance_of(Facter::ResolvedFact) + .and have_attributes(name: 'networking.dhcp', value: value) end end end diff --git a/spec/facter/facts/windows/scope6_interfaces_spec.rb b/spec/facter/facts/windows/scope6_interfaces_spec.rb index 92ca12c46..5836b016c 100644 --- a/spec/facter/facts/windows/scope6_interfaces_spec.rb +++ b/spec/facter/facts/windows/scope6_interfaces_spec.rb @@ -11,8 +11,8 @@ let(:interfaces) { { 'eth0' => { scope6: 'link' }, 'en1' => { scope6: 'global' } } } it 'calls Facter::Resolvers::Networking' do - expect(Facter::Resolvers::Networking).to receive(:resolve).with(:interfaces) fact.call_the_resolver + expect(Facter::Resolvers::Networking).to have_received(:resolve).with(:interfaces) end it 'returns legacy facts with scope6_' do