diff --git a/lib/facter/docker.rb b/lib/facter/docker.rb
index 543a006..63e276f 100644
--- a/lib/facter/docker.rb
+++ b/lib/facter/docker.rb
@@ -1,107 +1,107 @@
 # frozen_string_literal: true
 
 require 'facter'
 require 'json'
 
 Facter.add(:docker_systemroot) do
   confine osfamily: :windows
   setcode do
     Puppet::Util.get_env('SystemRoot')
   end
 end
 
 Facter.add(:docker_program_files_path) do
   confine osfamily: :windows
   setcode do
     Puppet::Util.get_env('ProgramFiles')
   end
 end
 
 Facter.add(:docker_program_data_path) do
   confine osfamily: :windows
   setcode do
     Puppet::Util.get_env('ProgramData')
   end
 end
 
 Facter.add(:docker_user_temp_path) do
   confine osfamily: :windows
   setcode do
     Puppet::Util.get_env('TEMP')
   end
 end
 
 docker_command = if Facter.value(:kernel) == 'windows'
                    'powershell -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -c docker'
                  else
                    'docker'
                  end
 
 def interfaces
   Facter.value(:interfaces).split(',')
 end
 
 Facter.add(:docker_client_version) do
   setcode do
     docker_version = Facter.value(:docker_version)
     docker_version['Client']['Version'] if docker_version
   end
 end
 
 Facter.add(:docker_server_version) do
   setcode do
     docker_version = Facter.value(:docker_version)
     if docker_version && docker_version['Server'].is_a?(Hash)
       docker_version['Server']['Version']
     else
       nil
     end
   end
 end
 
 Facter.add(:docker_version) do
   setcode do
     if Facter::Util::Resolution.which('docker')
       value = Facter::Core::Execution.execute(
         "#{docker_command} version --format '{{json .}}'",
       )
       val = JSON.parse(value)
     end
     val
   end
 end
 
 Facter.add(:docker) do
   setcode do
     docker_version = Facter.value(:docker_client_version)
     if docker_version !~ %r{1[.][0-9][0-2]?[.]\w+}
       if Facter::Util::Resolution.which('docker')
         docker_json_str = Facter::Util::Resolution.exec(
           "#{docker_command} info --format '{{json .}}'",
         )
         begin
           docker = JSON.parse(docker_json_str)
           docker['network'] = {}
 
           docker['network']['managed_interfaces'] = {}
-          network_list = Facter::Util::Resolution.exec('docker network ls | tail -n +2')
+          network_list = Facter::Util::Resolution.exec("#{docker_command} network ls | tail -n +2")
           docker_network_names = []
           network_list.each_line { |line| docker_network_names.push line.split[1] }
           docker_network_ids = []
           network_list.each_line { |line| docker_network_ids.push line.split[0] }
           docker_network_names.each do |network|
-            inspect = JSON.parse(Facter::Util::Resolution.exec("docker network inspect #{network}"))
+            inspect = JSON.parse(Facter::Util::Resolution.exec("#{docker_command} network inspect #{network}"))
             docker['network'][network] = inspect[0]
             network_id = docker['network'][network]['Id'][0..11]
             interfaces.each do |iface|
               docker['network']['managed_interfaces'][iface] = network if iface =~ %r{#{network_id}}
             end
           end
           docker
         rescue JSON::ParserError
           nil
         end
       end
     end
   end
 end
diff --git a/spec/unit/docker_facts_spec.rb b/spec/unit/docker_facts_spec.rb
index eb539c0..91ee847 100644
--- a/spec/unit/docker_facts_spec.rb
+++ b/spec/unit/docker_facts_spec.rb
@@ -1,90 +1,96 @@
 require 'spec_helper'
 require 'json'
 
 
 describe Facter::Util::Fact, type: :fact do
   before :each do
     Facter.clear
-    Facter::Util::Resolution.stubs(:which).with('docker').returns('/usr/bin/docker')
+    if Facter.value(:kernel) == 'windows'
+      docker_command = 'powershell -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -c docker'
+      Facter::Util::Resolution.stubs(:which).with('docker').returns('C:\Program Files\Docker\docker.exe')
+    else
+      docker_command = 'docker'
+      Facter::Util::Resolution.stubs(:which).with('docker').returns('/usr/bin/docker')
+    end
     docker_info = File.read(fixtures('facts', 'docker_info'))
-    Facter::Util::Resolution.stubs(:exec).with("docker info --format '{{json .}}'").returns(docker_info)
+    Facter::Util::Resolution.stubs(:exec).with("#{docker_command} info --format '{{json .}}'").returns(docker_info)
     processors = File.read(fixtures('facts', 'processors'))
     Facter.fact(:processors).stubs(:value).returns(JSON.parse(processors))
 
     docker_network_list = File.read(fixtures('facts', 'docker_network_list'))
-    Facter::Util::Resolution.stubs(:exec).with('docker network ls | tail -n +2').returns(docker_network_list)
+    Facter::Util::Resolution.stubs(:exec).with("#{docker_command} network ls | tail -n +2").returns(docker_network_list)
     docker_network_names = Array.new
     docker_network_list.each_line {|line| docker_network_names.push line.split[1] }
     docker_network_names.each do |network|
       inspect = File.read(fixtures('facts', "docker_network_inspect_#{network}"))
-      Facter::Util::Resolution.stubs(:exec).with("docker network inspect #{network}").returns(inspect)
+      Facter::Util::Resolution.stubs(:exec).with("#{docker_command} network inspect #{network}").returns(inspect)
     end
   end
   after { Facter.clear }
 
   describe 'docker fact with composer network' do
     before :each do
         docker_info = File.read(fixtures('facts', 'docker_info'))
       Facter.fact(:interfaces).stubs(:value).returns('br-c5810f1e3113,docker0,eth0,lo')
 
     end
     it do
       fact = File.read(fixtures('facts', 'facts_with_compose'))
       fact = JSON.parse(fact.to_json, {:quirks_mode => true})
       facts = eval(fact)
       expect(Facter.fact(:docker).value).to include(
         'network' => facts['network']
       )
     end
   end
 
   describe 'docker fact without composer network' do
     before :each do
       Facter.fact(:interfaces).stubs(:value).returns('br-19a6ebf6f5a5,docker0,eth0,lo')
     end
     it do
       fact = File.read(fixtures('facts', 'facts_without_compose')).chomp
       fact_json = fact.to_json
       facts = JSON.parse(fact_json, {:quirks_mode => true})
       facts = eval(facts)
       expect(Facter.fact(:docker).value).to include(
         'network' => facts['network']
       )
     end
   end
 
   describe'docker client version' do
     before do
       docker_version = File.read(fixtures('facts', 'docker_version'))
       Facter.fact(:docker_version).stubs(:value).returns(JSON.parse(docker_version))
       Facter.fact(:interfaces).stubs(:value).returns('br-19a6ebf6f5a5,docker0,eth0,lo')
 
     end
     it do
       expect(Facter.fact(:docker_client_version).value).to eq(
         '17.03.1-ce-client'
       )
     end
   end
 
   describe 'docker server version' do
     before do
       docker_version = File.read(fixtures('facts', 'docker_version'))
       Facter.fact(:docker_version).stubs(:value).returns(JSON.parse(docker_version))
       Facter.fact(:interfaces).stubs(:value).returns('br-19a6ebf6f5a5,docker0,eth0,lo')
     end
     it do
       expect(Facter.fact(:docker_server_version).value).to eq(
         '17.03.1-ce-server'
       )
     end
   end
 
   describe 'docker info' do
     it 'has valid entries' do
       expect(Facter.fact(:docker).value).to include(
         'Architecture' => 'x86_64'
       )
     end
   end
 end