puppetfile-resolver 0.4.0 → 0.6.1

data/lib/puppetfile-resolver/resolution_provider.rb

@@ -5,27 +5,34 @@ require 'puppetfile-resolver/cache/base'
 require 'puppetfile-resolver/spec_searchers/forge'
 require 'puppetfile-resolver/spec_searchers/git'
 require 'puppetfile-resolver/spec_searchers/local'
+require 'puppetfile-resolver/spec_searchers/configuration'
 
 module PuppetfileResolver
   class ResolutionProvider
     include Molinillo::SpecificationProvider
 
     # options
-    #   module_paths : Array of paths
-    #   strict_mode  : [Boolean] Whether missing dependencies throw an error (default: false)
+    #   module_paths                : Array of paths (Deprecated)
+    #   strict_mode                 : [Boolean] Whether missing dependencies throw an error (default: false)
+    #   spec_searcher_configuration : PuppetfileResolver::SpecSearchers::Configuration
     def initialize(puppetfile_document, puppet_version, resolver_ui, options = {})
       require 'semantic_puppet'
 
       @puppetfile_document = puppetfile_document
       raise 'The UI object must be of type Molinillo::UI' if resolver_ui.nil? || !resolver_ui.is_a?(Molinillo::UI)
       @resolver_ui = resolver_ui
-      # TODO: This default crap should move to the resolve class and we just validate (and raise) here
-      @puppet_module_paths = options[:module_paths].nil? ? [] : options[:module_paths]
+      @spec_searcher_configuration = options[:spec_searcher_configuration] || PuppetfileResolver::SpecSearchers::Configuration.new
       @allow_missing_modules = options[:allow_missing_modules].nil? ? true : options[:allow_missing_modules] == true
       # There can be only one puppet specification in existance so we pre-load here.
       @puppet_specification = Models::PuppetSpecification.new(puppet_version)
       @module_info = {}
       @cache = options[:cache].nil? ? Cache::Base.new : options[:cache]
+
+      # Check for deprecated options
+      unless options[:module_paths].nil? # rubocop:disable Style/GuardClause
+        Warning.warn 'The use of the module_paths option has been deprecated'
+        @spec_searcher_configuration.local.puppet_module_paths = options[:module_paths]
+      end
     end
 
     # Search for the specifications that match the given dependency.
@@ -137,9 +144,9 @@ module PuppetfileResolver
       unless mod.nil?
         case mod.module_type
         when Puppetfile::FORGE_MODULE
-          @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Forge.find_all(dependency, @cache, @resolver_ui) }
+          @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Forge.find_all(dependency, @cache, @resolver_ui, @spec_searcher_configuration.forge) }
         when Puppetfile::GIT_MODULE
-          @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Git.find_all(mod, dependency, @cache, @resolver_ui) }
+          @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Git.find_all(mod, dependency, @cache, @resolver_ui, @spec_searcher_configuration.git) }
         else # rubocop:disable Style/EmptyElse
           # Errr.... Nothing
         end
@@ -147,13 +154,13 @@ module PuppetfileResolver
       return @module_info[dependency.name] unless @module_info[dependency.name].empty?
 
       # It's not in the Puppetfile, so perhaps it's in our modulepath?
-      @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Local.find_all(mod, @puppet_module_paths, dependency, @cache, @resolver_ui) }
+      @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Local.find_all(mod, dependency, @cache, @resolver_ui, @spec_searcher_configuration.local) }
       return @module_info[dependency.name] unless @module_info[dependency.name].empty?
 
       # It's not in the Puppetfile and not on disk, so perhaps it's on the Forge?
       # The forge needs an owner and name to be able to resolve
       if dependency.name && dependency.owner # rubocop:disable Style/IfUnlessModifier
-        @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Forge.find_all(dependency, @cache, @resolver_ui) }
+        @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Forge.find_all(dependency, @cache, @resolver_ui, @spec_searcher_configuration.forge) }
       end
 
       # If we can't find any specifications for the module and we're allowing missing modules

data/lib/puppetfile-resolver/resolver.rb

@@ -20,7 +20,8 @@ module PuppetfileResolver
 
     # options
     #   :cache => Cache Object
-    #   :module_paths => Array[String]
+    #   :module_paths => Array[String] (Deprecated)
+    #   :spec_searcher_configuration => PuppetfileResolver::SpecSearchers::Configuration
     def resolve(options = {})
       if options[:ui]
         raise 'The UI object must be of type Molinillo::UI' unless options[:ui].is_a?(Molinillo::UI)

data/lib/puppetfile-resolver/spec_searchers/configuration.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/spec_searchers/forge_configuration'
+require 'puppetfile-resolver/spec_searchers/git_configuration'
+require 'puppetfile-resolver/spec_searchers/local_configuration'
+
+module PuppetfileResolver
+  module SpecSearchers
+    class Configuration
+      attr_reader :local
+      attr_reader :forge
+      attr_reader :git
+
+      def initialize
+        @local = LocalConfiguration.new
+        @forge = ForgeConfiguration.new
+        @git = GitConfiguration.new
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/spec_searchers/forge.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require 'puppetfile-resolver/util'
 require 'puppetfile-resolver/spec_searchers/common'
+require 'puppetfile-resolver/spec_searchers/forge_configuration'
 require 'uri'
 require 'net/http'
 require 'openssl'
@@ -9,9 +11,7 @@ require 'json'
 module PuppetfileResolver
   module SpecSearchers
     module Forge
-      DEFAULT_FORGE_URI ||= 'https://forgeapi.puppet.com'
-
-      def self.find_all(dependency, cache, resolver_ui)
+      def self.find_all(dependency, cache, resolver_ui, config)
         dep_id = ::PuppetfileResolver::SpecSearchers::Common.dependency_cache_id(self, dependency)
 
         # Has the information been cached?
@@ -19,7 +19,7 @@ module PuppetfileResolver
 
         result = []
         # Query the forge
-        fetch_all_module_releases(dependency.owner, dependency.name, resolver_ui) do |partial_releases|
+        fetch_all_module_releases(dependency.owner, dependency.name, resolver_ui, config) do |partial_releases|
           partial_releases.each do |release|
             result << Models::ModuleSpecification.new(
               name: release['module']['name'],
@@ -35,38 +35,36 @@ module PuppetfileResolver
         result
       end
 
-      def self.fetch_all_module_releases(owner, name, forge_api_url = DEFAULT_FORGE_URI, resolver_ui, &block)
+      def self.fetch_all_module_releases(owner, name, resolver_ui, config, &block)
         raise 'Requires a block to yield' unless block
-        uri = ::URI.parse("#{forge_api_url}/v3/releases")
+        uri = ::URI.parse("#{config.forge_api}/v3/releases")
         params = { :module => "#{owner}-#{name}", :exclude_fields => 'readme changelog license reference tasks', :limit => 50 }
         uri.query = ::URI.encode_www_form(params)
 
         loops = 0
         loop do
           resolver_ui.debug { "Querying the forge for a module with #{uri}" }
-
-          http_options = { :use_ssl => uri.class == URI::HTTPS }
-          # Because on Windows Ruby doesn't use the Windows certificate store which has up-to date
-          # CA certs, we can't depend on someone setting the environment variable correctly. So use our
-          # static CA PEM file if SSL_CERT_FILE is not set.
-          http_options[:ca_file] = PuppetfileResolver::Util.static_ca_cert_file if ENV['SSL_CERT_FILE'].nil?
-
+          err_msg = "Unable to find module #{owner}-#{name} on #{config.forge_api}"
+          err_msg += config.proxy ? " with proxy #{config.proxy}: " : ': '
           response = nil
-          Net::HTTP.start(uri.host, uri.port, http_options) do |http|
-            request = Net::HTTP::Get.new uri
-            response = http.request request
+
+          begin
+            response = ::PuppetfileResolver::Util.net_http_get(uri, config.proxy)
+          rescue ::StandardError => e
+            raise err_msg + e.message
           end
-          raise "Expected HTTP Code 200, but received #{response.code} for URI #{uri}: #{response.inspect}" unless response.code == '200'
+
+          raise err_msg + "Expected HTTP Code 200, but received #{response.code}" unless response.code == '200'
 
           reply = ::JSON.parse(response.body)
           yield reply['results']
 
           break if reply['pagination'].nil? || reply['pagination']['next'].nil?
-          uri = ::URI.parse("#{forge_api_url}#{reply['pagination']['next']}")
+          uri = ::URI.parse("#{config.forge_api}#{reply['pagination']['next']}")
 
           # Circuit breaker in case the worst happens (max 1000 module releases)
           loops += 1
-          raise "Too many Forge API requests #{loops * 50}" if loops > 20
+          raise err_msg + "Too many Forge API requests #{loops}" if loops > 20
         end
       end
       private_class_method :fetch_all_module_releases

data/lib/puppetfile-resolver/spec_searchers/forge_configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module SpecSearchers
+    class ForgeConfiguration
+      DEFAULT_FORGE_URI ||= 'https://forgeapi.puppet.com'
+
+      def forge_api
+        @forge_api || DEFAULT_FORGE_URI
+      end
+
+      attr_writer :forge_api
+
+      attr_accessor :proxy
+    end
+  end
+end

data/lib/puppetfile-resolver/spec_searchers/git/gclone.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'English'
+require 'puppetfile-resolver/util'
+require 'puppetfile-resolver/spec_searchers/common'
+require 'puppetfile-resolver/spec_searchers/git_configuration'
+require 'puppetfile-resolver/util'
+require 'uri'
+
+module PuppetfileResolver
+  module SpecSearchers
+    module Git
+      module GClone
+        # @summary clones the remote url and reads the metadata file
+        # @returns [String] the content of the metadata file
+        def self.metadata(puppetfile_module, resolver_ui, config)
+          repo_url = puppetfile_module.remote
+
+          unless PuppetfileResolver::Util.git?
+            resolver_ui.debug { 'Git executible not found, unable to use git clone resolution' }
+
+            return nil
+          end
+          return nil if repo_url.nil?
+          return nil unless valid_http_url?(repo_url)
+
+          metadata_file = 'metadata.json'
+
+          ref = puppetfile_module.ref ||
+                puppetfile_module.tag ||
+                puppetfile_module.commit ||
+                puppetfile_module.branch ||
+                'HEAD'
+
+          resolver_ui.debug { "Querying git repository #{repo_url}" }
+
+          clone_and_read_file(repo_url, ref, metadata_file, config)
+        end
+
+        # @summary clones the git url and reads the file at the given ref
+        #          a temp directory will be created and then destroyed during
+        #          the cloning and reading process
+        # @param ref [String] the git ref, branch, commit, tag
+        # @param file [String] the file you wish to read
+        # @returns [String] the content of the file
+        def self.clone_and_read_file(url, ref, file, config)
+          clone_cmd = ['git', 'clone', '--bare', '--depth=1', '--single-branch']
+          err_msg = ''
+          if config.proxy
+            err_msg += " with proxy #{config.proxy}: "
+            proxy = "--config \"http.proxy=#{config.proxy}\" --config \"https.proxy=#{config.proxy}\""
+            clone_cmd.push(proxy)
+          end
+
+          Dir.mktmpdir(nil, config.clone_dir) do |dir|
+            clone_cmd.push("--branch=#{ref}") if ref != 'HEAD'
+            clone_cmd.push(url, dir)
+            out, err_out, process = ::PuppetfileResolver::Util.run_command(clone_cmd)
+            err_msg += out
+            raise err_msg unless process.success?
+            Dir.chdir(dir) do
+              content, err_out, process = ::PuppetfileResolver::Util.run_command(['git', 'show', "#{ref}:#{file}"])
+              raise 'InvalidContent' unless process.success? && content.length > 2
+              return content
+            end
+          end
+        end
+
+        def self.valid_http_url?(url)
+          # uri does not work with git urls, return true
+          return true if url.start_with?('git@')
+
+          uri = URI.parse(url)
+          uri.is_a?(URI::HTTP) && !uri.host.nil?
+        rescue URI::InvalidURIError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/spec_searchers/git/github.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/util'
+require 'puppetfile-resolver/spec_searchers/common'
+require 'puppetfile-resolver/spec_searchers/git_configuration'
+
+module PuppetfileResolver
+  module SpecSearchers
+    module Git
+      module GitHub
+        def self.metadata(puppetfile_module, resolver_ui, config)
+          repo_url = nil
+          if puppetfile_module.remote.start_with?('git@github.com:')
+            repo_url = puppetfile_module.remote.slice(15..-1)
+            repo_url = repo_url.slice(0..-5) if repo_url.end_with?('.git')
+          elsif puppetfile_module.remote.start_with?('https://github.com/')
+            repo_url = puppetfile_module.remote.slice(19..-1)
+            repo_url = repo_url.slice(0..-5) if repo_url.end_with?('.git')
+          end
+          return nil if repo_url.nil?
+
+          metadata_url = 'https://raw.githubusercontent.com/' + repo_url + '/'
+          if puppetfile_module.ref
+            metadata_url += puppetfile_module.ref + '/'
+          elsif puppetfile_module.tag
+            metadata_url += puppetfile_module.tag + '/'
+          else
+            # Default to master. Should it raise?
+            metadata_url += 'master/'
+          end
+          metadata_url += 'metadata.json'
+
+          resolver_ui.debug { "Querying GitHub with #{metadata_url}" }
+          err_msg = "Unable to find module at #{puppetfile_module.remote}"
+          err_msg += config.proxy ? " with proxy #{config.proxy}: " : ': '
+          response = nil
+
+          begin
+            response = ::PuppetfileResolver::Util.net_http_get(metadata_url, config.proxy)
+          rescue ::StandardError => e
+            raise err_msg + e.message
+          end
+
+          if response.code != '200'
+            resolver_ui.debug(err_msg + "Expected HTTP Code 200, but received #{response.code}")
+            return nil
+          end
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/spec_searchers/git/gitlab.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/util'
+require 'puppetfile-resolver/spec_searchers/common'
+require 'puppetfile-resolver/spec_searchers/git_configuration'
+
+module PuppetfileResolver
+  module SpecSearchers
+    module Git
+      module GitLab
+        def self.metadata(puppetfile_module, resolver_ui, config)
+          repo_url = nil
+          if puppetfile_module.remote.start_with?('git@gitlab.com:')
+            repo_url = puppetfile_module.remote.slice(15..-1)
+            repo_url = repo_url.slice(0..-5) if repo_url.end_with?('.git')
+          elsif puppetfile_module.remote.start_with?('https://gitlab.com/')
+            repo_url = puppetfile_module.remote.slice(19..-1)
+            repo_url = repo_url.slice(0..-5) if repo_url.end_with?('.git')
+          end
+          return nil if repo_url.nil?
+
+          # Example URL
+          # https://gitlab.com/simp/pupmod-simp-crypto_policy/-/raw/0.1.4/metadata.json
+          metadata_url = 'https://gitlab.com/' + repo_url + '/-/raw/'
+          if puppetfile_module.ref
+            metadata_url += puppetfile_module.ref + '/'
+          elsif puppetfile_module.tag
+            metadata_url += puppetfile_module.tag + '/'
+          else
+            # Default to master. Should it raise?
+            metadata_url += 'master/'
+          end
+          metadata_url += 'metadata.json'
+
+          resolver_ui.debug { "Querying GitLab with #{metadata_url}" }
+          err_msg = "Unable to find module at #{puppetfile_module.remote}"
+          err_msg += config.proxy ? " with proxy #{config.proxy}: " : ': '
+          response = nil
+
+          begin
+            response = ::PuppetfileResolver::Util.net_http_get(metadata_url, config.proxy)
+          rescue ::StandardError => e
+            raise err_msg + e.message
+          end
+
+          if response.code != '200'
+            resolver_ui.debug(err_msg + "Expected HTTP Code 200, but received #{response.code}")
+            return nil
+          end
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/spec_searchers/git.rb

@@ -1,53 +1,35 @@
 # frozen_string_literal: true
 
+require 'puppetfile-resolver/util'
 require 'puppetfile-resolver/spec_searchers/common'
+require 'puppetfile-resolver/spec_searchers/git_configuration'
+require 'puppetfile-resolver/spec_searchers/git/github'
+require 'puppetfile-resolver/spec_searchers/git/gitlab'
+require 'puppetfile-resolver/spec_searchers/git/gclone'
 
 module PuppetfileResolver
   module SpecSearchers
     module Git
-      def self.find_all(puppetfile_module, dependency, cache, resolver_ui)
+      def self.find_all(puppetfile_module, dependency, cache, resolver_ui, config)
         dep_id = ::PuppetfileResolver::SpecSearchers::Common.dependency_cache_id(self, dependency)
         # Has the information been cached?
         return cache.load(dep_id) if cache.exist?(dep_id)
 
-        # We _could_ git clone this, but it'll take too long. So for now, just
-        # try and resolve github based repositories by crafting a URL
+        # The git clone method takes around (1s) depending on repo size.  Not sure if the
+        # other methods take longer or shorter but I preserved the legacy code for now.
+        # Technically, the gclone class could replace the other classes and speed up
+        # this process here.
+        metadata = GitHub.metadata(puppetfile_module, resolver_ui, config) ||
+                   GitLab.metadata(puppetfile_module, resolver_ui, config) ||
+                   GClone.metadata(puppetfile_module, resolver_ui, config)
 
-        repo_url = nil
-        if puppetfile_module.remote.start_with?('git@github.com:')
-          repo_url = puppetfile_module.remote.slice(15..-1)
-          repo_url = repo_url.slice(0..-5) if repo_url.end_with?('.git')
-        end
-        if puppetfile_module.remote.start_with?('https://github.com/')
-          repo_url = puppetfile_module.remote.slice(19..-1)
-          repo_url = repo_url.slice(0..-5) if repo_url.end_with?('.git')
-        end
-
-        return [] if repo_url.nil?
-
-        metadata_url = 'https://raw.githubusercontent.com/' + repo_url + '/'
-        if puppetfile_module.ref
-          metadata_url += puppetfile_module.ref + '/'
-        elsif puppetfile_module.tag
-          metadata_url += puppetfile_module.tag + '/'
-        else
-          # Default to master.  Should it raise?
-          metadata_url += 'master/'
-        end
-        metadata_url += 'metadata.json'
-
-        require 'net/http'
-        require 'uri'
-
-        resolver_ui.debug { "Querying the Github with #{metadata_url}" }
-        response = Net::HTTP.get_response(URI.parse(metadata_url))
-        if response.code != '200'
+        if metadata.nil? || metadata.empty?
+          # Cache that we couldn't find the metadata
           cache.save(dep_id, [])
           return []
         end
 
-        # TODO: symbolise_object should be in a Util namespace
-        metadata = ::PuppetfileResolver::Util.symbolise_object(::JSON.parse(response.body))
+        metadata = ::PuppetfileResolver::Util.symbolise_object(::JSON.parse(metadata))
         result = [Models::ModuleSpecification.new(
           name: metadata[:name],
           origin: :git,

data/lib/puppetfile-resolver/spec_searchers/git_configuration.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module SpecSearchers
+    class GitConfiguration
+      attr_accessor :proxy, :clone_dir
+    end
+  end
+end

data/lib/puppetfile-resolver/spec_searchers/local.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
 require 'puppetfile-resolver/spec_searchers/common'
+require 'puppetfile-resolver/spec_searchers/local_configuration'
 
 module PuppetfileResolver
   module SpecSearchers
     module Local
-      def self.find_all(_puppetfile_module, puppet_module_paths, dependency, cache, resolver_ui)
+      def self.find_all(_puppetfile_module, dependency, cache, resolver_ui, config)
         dep_id = ::PuppetfileResolver::SpecSearchers::Common.dependency_cache_id(self, dependency)
         # Has the information been cached?
         return cache.load(dep_id) if cache.exist?(dep_id)
 
         result = []
         # Find the module in the modulepaths
-        puppet_module_paths.each do |module_path|
+        config.puppet_module_paths.each do |module_path|
           next unless Dir.exist?(module_path)
           module_dir = File.expand_path(File.join(module_path, dependency.name))
           next unless Dir.exist?(module_dir)

data/lib/puppetfile-resolver/spec_searchers/local_configuration.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module SpecSearchers
+    class LocalConfiguration
+      attr_accessor :puppet_module_paths
+
+      def initialize
+        @puppet_module_paths = []
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/util.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'open3'
+
 module PuppetfileResolver
   module Util
     def self.symbolise_object(object)
@@ -19,5 +21,46 @@ module PuppetfileResolver
     def self.static_ca_cert_file
       @static_ca_cert_file ||= File.expand_path(File.join(__dir__, 'data', 'ruby_ca_certs.pem'))
     end
+
+    # Execute a HTTP/S GET query and return the response
+    # @param [String, URI] uri The URI to request
+    # @param [nil, String, URI] proxy The URI of the proxy server to use. Defaults to nil (No proxy server)
+    # @return [Net::HTTPResponse] the response of the request
+    def self.net_http_get(uri, proxy = nil)
+      uri = URI.parse(uri) unless uri.is_a?(URI)
+
+      http_options = { :use_ssl => uri.class == URI::HTTPS }
+      # Because on Windows Ruby doesn't use the Windows certificate store which has up-to date
+      # CA certs, we can't depend on someone setting the environment variable correctly. So use our
+      # static CA PEM file if SSL_CERT_FILE is not set.
+      http_options[:ca_file] = PuppetfileResolver::Util.static_ca_cert_file if ENV['SSL_CERT_FILE'].nil?
+
+      start_args = [uri.host, uri.port]
+
+      unless proxy.nil?
+        proxy = URI.parse(proxy) unless proxy.is_a?(URI)
+        start_args.concat([proxy.host, proxy.port, proxy.user, proxy.password])
+      end
+
+      Net::HTTP.start(*start_args, http_options) { |http| return http.request(Net::HTTP::Get.new(uri)) }
+      nil
+    end
+
+    # @summary runs the command on the shell
+    # @param cmd [Array] an array of command and args
+    # @returns [Array] the result of running the comand and the process
+    # @example run_command(['git', '--version'])
+    def self.run_command(cmd)
+      Open3.capture3(*cmd)
+    end
+
+    # @summary checks if git is installed and on the path
+    # @returns [Boolean] true if git is found in the path
+    def self.git?
+      Open3.capture3('git', '--version')
+      true
+    rescue Errno::ENOENT
+      false
+    end
   end
 end

data/lib/puppetfile-resolver/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PuppetfileResolver
-  VERSION ||= '0.4.0'
+  VERSION ||= '0.6.1'
 end

data/puppetfile-cli.rb

@@ -18,6 +18,7 @@ class CommandLineParser
       cache_dir: nil,
       module_paths: [],
       path: nil,
+      proxy: nil,
       puppet_version: nil,
       strict: false
     }
@@ -41,6 +42,10 @@ class CommandLineParser
         args[:debug] = true
       end
 
+      opts.on('--proxy=PROXY_URL', 'HTTP/S Proxy server to use. For example http://localhost:8888') do |proxy|
+        args[:proxy] = proxy
+      end
+
       opts.on('-s', '--strict', 'Do not allow missing dependencies. Default false which marks dependencies as missing and does not raise an error.') do
         args[:strict] = true
       end
@@ -88,7 +93,15 @@ if options[:debug]
 else
   ui = nil
 end
-opts = { cache: cache, ui: ui, module_paths: options[:module_paths], allow_missing_modules: !options[:strict] }
+
+config = PuppetfileResolver::SpecSearchers::Configuration.new
+config.local.puppet_module_paths = options[:module_paths]
+unless options[:proxy].nil?
+  config.git.proxy = options[:proxy]
+  config.forge.proxy = options[:proxy]
+end
+
+opts = { cache: cache, ui: ui, spec_searcher_configuration: config, allow_missing_modules: !options[:strict] }
 
 # Resolve
 result = resolver.resolve(opts)

data/spec/fixtures/modulepath/test_module/README.md

@@ -0,0 +1 @@
+This test fixture contains a valid module with classes, types and functions.

data/spec/fixtures/modulepath/test_module/metadata.json

@@ -0,0 +1,9 @@
+{
+  "name": "testfixture-test_module",
+  "version": "0.1.0",
+  "author": "testfixture",
+  "summary": "Skeleton module test fixture",
+  "license": "Apache-2.0",
+  "source": "http://localhost",
+  "dependencies": []
+}

data/spec/fixtures/proxy.rb

@@ -0,0 +1,9 @@
+require 'webrick'
+require 'webrick/httpproxy'
+
+proxy = WEBrick::HTTPProxyServer.new Port: (ARGV[0].nil? ? 32768 : ARGV[0])
+
+trap 'INT'  do proxy.shutdown end
+trap 'TERM' do proxy.shutdown end
+
+proxy.start

data/spec/integration/deprecation_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+require 'puppetfile-resolver/resolver'
+require 'puppetfile-resolver/puppetfile'
+
+
+describe 'Depreaction Tests' do
+  context 'With module_paths option' do
+    it 'should resolve a complete Puppetfile' do
+
+      content = <<-PUPFILE
+      forge 'https://forge.puppet.com'
+
+      # Local module path module
+      mod 'testfixture/test_module', :latest
+      PUPFILE
+
+      puppetfile = ::PuppetfileResolver::Puppetfile::Parser::R10KEval.parse(content)
+      resolver = PuppetfileResolver::Resolver.new(puppetfile)
+
+      expect(Warning).to receive(:warn).with(/module_paths/).and_return(nil)
+
+      result = resolver.resolve({
+        allow_missing_modules: false,
+        module_paths: [File.join(FIXTURES_DIR, 'modulepath')]
+      })
+
+      expect(result.specifications).to include('test_module')
+      expect(result.specifications['test_module'].version.to_s).to eq('0.1.0')
+    end
+  end
+end