nexus-debug 1.4.0

data/lib/nexus/config_file.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+require 'rubygems/local_remote_options'
+require 'net/http'
+require 'base64'
+require 'nexus/cipher'
+require 'yaml'
+
+module Nexus
+  class ConfigFile
+    def initialize(configfile)
+      raise 'no file given' unless configfile
+
+      @all = {}
+      if configfile.is_a?(String)
+        @file = configfile
+
+        if File.exist?(configfile)
+          @all = YAML.load(::File.read(configfile))
+        else
+          store # make sure we can write it
+        end
+      elsif configfile
+        @file = configfile.file
+        @all = configfile.all
+      end
+    end
+
+    attr_reader :all, :file
+
+    def data(repo)
+      if repo
+        (@all[repo] ||= {})
+      else
+        @all
+      end
+    end
+
+    def key?(key, repo = nil)
+      data(repo).key? key
+    end
+
+    def [](key, repo = nil)
+      data(repo)[key]
+    end
+
+    def []=(key, repo, value)
+      if value.nil?
+        data(repo).delete(key)
+      else
+        data(repo)[key] = value
+      end
+    end
+
+    def repos
+      all.collect do |k, v|
+        k if v.is_a? Hash
+      end.select { |s| s }
+    end
+
+    def section(key)
+      all.dup.select do |k, v|
+        if v.is_a? Hash
+          v.delete_if { |kk, _vv| kk != key }
+        else
+          k == key
+        end
+      end
+    end
+
+    def delete(*keys)
+      delete_map(all, *keys)
+      all.each do |_k, v|
+        delete_map(v, *keys) if v.is_a? Hash
+      end
+    end
+
+    def delete_map(map, *keys)
+      keys.each { |k| map.delete(k) }
+    end
+
+    private :delete_map
+
+    def merge!(other)
+      map = other.all
+      merge_map(@all, map)
+    end
+
+    def merge_map(m1, m2)
+      return m2 unless m1
+
+      m2.each do |k, v|
+        if v.is_a? Hash
+          m1[k] ||= {}
+          merge_map(m1[k], v)
+        else
+          m1[k] = v
+        end
+      end
+    end
+
+    private :merge_map
+
+    def store
+      dirname = File.dirname(@file)
+      Dir.mkdir(dirname) unless File.exist?(dirname)
+      new = !File.exist?(@file)
+
+      File.open(@file, 'w') do |f|
+        f.write @all.to_yaml
+      end
+      if new
+        begin
+          File.chmod(0o100600, @file)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/nexus/version.rb

@@ -0,0 +1,3 @@
+module Nexus
+  VERSION = '1.4.0'.freeze
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,6 @@
+require 'rubygems/command_manager'
+require 'commands/abstract_command'
+
+require "commands/nexus"
+Gem::CommandManager.instance.register_command :nexus
+

data/test/abstract_command_test.rb

@@ -0,0 +1,248 @@
+require 'command_helper'
+
+class Gem::Commands::FakeCommand < Gem::AbstractCommand
+  def description
+    'fake command'
+  end
+
+  def initialize
+    super 'fake', description
+  end
+
+  def execute
+  end
+end
+
+class AbstractCommandTest < CommandTest
+
+  context "with an fake command" do
+    setup do
+      @command = Gem::Commands::FakeCommand.new
+      Gem.configuration.verbose = false
+      stub(@command).say
+      ENV['http_proxy'] = nil
+      ENV['HTTP_PROXY'] = nil
+    end
+
+    context "parsing the proxy" do
+      should "return nil if no proxy is set" do
+        stub_config(:http_proxy => nil)
+        assert_equal nil, @command.http_proxy( nil )
+      end
+
+      should "return nil if the proxy is set to :no_proxy" do
+        stub_config(:http_proxy => :no_proxy)
+        assert_equal nil, @command.http_proxy( 'asd' )
+      end
+
+      should "return a proxy as a URI if set" do
+        stub_config( :http_proxy => 'http://proxy.example.org:9192' )
+        assert_equal 'proxy.example.org', @command.http_proxy( 'http://asd' ).host
+        assert_equal 9192, @command.http_proxy( 'http://asd' ).port
+      end
+
+      should "return a proxy as a URI if set by environment variable" do
+        ENV['http_proxy'] = "http://jack:duck@192.168.1.100:9092"
+        assert_equal "192.168.1.100", @command.http_proxy( 'http://asd' ).host
+        assert_equal 9092, @command.http_proxy( 'http://asd' ).port
+        assert_equal "jack", @command.http_proxy( 'http://asd' ).user
+        assert_equal "duck", @command.http_proxy( 'http://asd' ).password
+      end
+    end
+
+    should "sign in if no authorization and no nexus url in config" do
+      config_path = File.join( 'pkg', 'configsomething')
+      FileUtils.rm_f( config_path )
+      @command.options[ :nexus_config ] = config_path
+      stub(@command).sign_in
+      stub(@command).configure_url
+      @command.setup
+      assert_received(@command) { |command| command.configure_url }
+      assert_received(@command) { |command| command.sign_in }
+    end
+
+    should "sign in if --clear-config is set" do
+      config_path = File.join( 'pkg', 'config_clear')
+      FileUtils.rm_f( config_path )
+      @command.options[ :nexus_config ] = config_path
+      stub(@command).sign_in
+      stub(@command).configure_url
+      stub(@command).options do
+        { :nexus_clear => true,
+          :nexus_config => config_path
+        }
+      end
+      @command.setup
+      assert_received(@command) { |command| command.sign_in }
+      assert_received(@command) { |command| command.configure_url }
+    end
+
+    should "sign in if --password is set" do
+      config_path = File.join( 'pkg', 'config_password')
+      File.open( config_path, 'w') do |f|
+        h = { :url => 'http://example.com' }
+        f.write h.to_yaml
+      end
+      @command.options[ :nexus_config ] = config_path
+      @command.options[ :nexus_prompt ] = true
+      stub(@command).sign_in
+      @command.setup
+      assert_received(@command) { |command| command.sign_in }
+    end
+
+
+    should "always return stored authorization and url" do
+      config_path = File.join( 'pkg', 'configsomething')
+      FileUtils.rm_f( config_path )
+      @command.options[ :nexus_config ] = config_path
+      @command.options[ :nexus_prompt ] = true
+      @command.config.url = 'something'
+      @command.config.authorization = 'something'
+      assert_not_nil @command.authorization
+      assert_not_nil @command.url
+    end
+
+    should "not sign in nor configure if authorizaton and url exists" do
+      config_path = File.join( 'pkg', 'configsomething')
+      FileUtils.rm_f( config_path )
+      @command.options[ :nexus_config ] = config_path
+      stub(@command).authorization { "1234567890" }
+      stub(@command).url { "abc" }
+      stub(@command).sign_in
+      stub(@command).configure_url
+      @command.setup
+      assert_received(@command) { |command| command.configure_url.never }
+      assert_received(@command) { |command| command.sign_in.never }
+    end
+
+    context "using the proxy" do
+      setup do
+        stub_config( :http_proxy => "http://gilbert:sekret@proxy.example.org:8081" )
+        @proxy_class = Object.new
+        mock(Net::HTTP).Proxy('proxy.example.org', 8081, 'gilbert', 'sekret') { @proxy_class }
+        @command.use_proxy!( 'http://asd' )
+      end
+
+      should "replace Net::HTTP with a proxy version" do
+        assert_equal @proxy_class, @command.proxy_class
+      end
+    end
+
+    context 'separeted config per repo key' do
+      should 'store the config on per key' do
+        config_path = File.join( 'pkg', 'configrepo')
+        FileUtils.rm_f( config_path )
+        @command.options[ :nexus_config ] = config_path
+        @command.options[ :nexus_repo ] = :first
+        @command.config.url = :thing
+        @command.options[ :nexus_repo ] = :second
+        @command.send :instance_variable_set, '@config'.to_sym, nil
+        @command.config.url = :otherthing
+        @command.options[ :nexus_repo ] = nil
+        @command.send :instance_variable_set, '@config'.to_sym, nil
+        @command.config.url = :nothing
+        assert_equal( Gem.configuration.load_file(config_path),
+                      { :first => {:url => :thing}, 
+                        :second => {:url => :otherthing},
+                        :url => :nothing } )
+      end
+    end
+
+    context "clear username + password" do
+
+      should "clear stored authorization" do
+        stub(@command).options { {:nexus_config => File.join( 'pkg', 
+                                                              'config') } }
+        stub(@command).say
+        stub(@command).ask { nil }
+        stub(@command).ask_for_password { nil }
+        @command.config.authorization = 'some authentication'
+
+        @command.sign_in
+        assert_nil @command.authorization
+      end
+    end
+
+    context "encryption" do
+
+    end
+
+    context "signing in" do
+      setup do
+        @username = "username"
+        @password = "password 01234567890123456789012345678901234567890123456789"
+        @key = "key"
+
+        stub(@command).say
+        stub(@command).ask { @username }
+        stub(@command).ask_for_password { @password }
+        stub(@command).options { {:nexus_config => File.join( 'pkg', 
+                                                              'configsign') } }
+        @command.config.authorization = @key
+      end
+      
+      should "ask for username and password" do
+        @command.sign_in
+        assert_received(@command) { |command| command.ask("Username: ") }
+        assert_received(@command) { |command| command.ask_for_password("Password: ") }
+        assert_equal( @command.config.authorization, 
+                      "Basic dXNlcm5hbWU6cGFzc3dvcmQgMDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODk=" )
+      end
+
+      should "say that we signed in" do
+        @command.sign_in
+        assert_received(@command) { |command| command.say("Enter your Nexus credentials") }
+        assert_received(@command) { |command| command.say("Your Nexus credentials have been stored in pkg/configsign") }
+        assert_equal( @command.config.authorization, 
+                      "Basic dXNlcm5hbWU6cGFzc3dvcmQgMDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODk=" )
+      end
+    end
+
+    context "configure nexus url" do
+      setup do
+        @url = "http://url"
+ 
+        stub(@command).say
+        stub(@command).ask { @url }
+        stub(@command).options { {:nexus_config => File.join( 'pkg', 
+                                                              'configurl') } }
+        @command.config.url = @url
+      end
+
+      should "ask for nexus url" do
+        @command.configure_url
+        assert_received(@command) { |command| command.ask("URL: ") }
+        assert_equal( @command.config.url, "http://url" )
+      end
+
+      should "say that we configured the url" do
+        @command.configure_url
+        assert_received(@command) { |command| command.say("Enter the URL of the rubygems repository on a Nexus server") }
+        assert_received(@command) { |command| command.say("The Nexus URL has been stored in pkg/configurl") }
+        assert_equal( @command.config.url, "http://url" )
+      end
+    end
+
+    context "SSL verification" do
+      setup do
+        @url = "https://url"
+        @connection = Net::HTTP.new("host", 443)
+        stub(@connection).request
+        stub(Net::HTTP).new { @connection }
+        @command.config.url = @url
+      end
+
+      should "disable SSL verification" do
+        stub(@command.config).ssl_verify_mode { OpenSSL::SSL::VERIFY_NONE }
+        stub(Gem.configuration).verbose { 0 }
+        @command.make_request(:put, "gems/gem")
+        assert_equal( @connection.verify_mode, OpenSSL::SSL::VERIFY_NONE )
+      end
+
+      should "verify SSL" do
+        @command.make_request(:put, "gems/gem")
+        assert_equal( @connection.verify_mode, OpenSSL::SSL::VERIFY_PEER )
+      end
+    end
+  end
+end

data/test/cipher_test.rb

@@ -0,0 +1,68 @@
+require 'minitest/autorun'
+require 'shoulda'
+require 'fileutils'
+require 'nexus/cipher'
+
+class ConfigTest < ::MiniTest::Unit::TestCase
+  include ShouldaContextLoadable 
+  
+  context 'no token' do
+
+    should 'create token' do
+      c = Nexus::Cipher.new( 'behappy' )
+      assert_equal( c.token.nil?, false )
+      assert_equal( c.iv.nil?, true )
+    end
+
+    should 'en/decrypt data' do
+      c = Nexus::Cipher.new( 'behappy' )
+      encrypted = c.encrypt( 'something' )
+      cc = Nexus::Cipher.new( 'behappy', c.token )
+      cc.iv = c.iv
+      plain = cc.decrypt( encrypted )
+
+      assert_equal( plain, 'something' )
+    end
+
+    should 'en/decrypt data using the same cipher' do
+      c = Nexus::Cipher.new( 'behappy' )
+      encrypted = c.encrypt( 'something' )
+      plain = c.decrypt( encrypted )
+
+      assert_equal( plain, 'something' )
+    end
+
+  end
+  
+  context 'with token' do
+
+    should 'not create token' do
+      c = Nexus::Cipher.new( 'behappy', 
+                             "UvChT3jkwD7jXFd8mTWJ087i2Xb3tlGmPWUSYtAiRJM=" )
+      assert_equal( c.token, "UvChT3jkwD7jXFd8mTWJ087i2Xb3tlGmPWUSYtAiRJM=" )
+      assert_equal( c.iv.nil?, true )
+    end
+
+    should 'en/decrypt data' do
+      c = Nexus::Cipher.new( 'behappy', 
+                             "UvChT3jkwD7jXFd8mTWJ087i2Xb3tlGmPWUSYtAiRJM=" )
+      encrypted = c.encrypt( 'something' )
+      cc = Nexus::Cipher.new( 'behappy', 
+                             "UvChT3jkwD7jXFd8mTWJ087i2Xb3tlGmPWUSYtAiRJM=" )
+      cc.iv = c.iv
+      plain = cc.decrypt( encrypted )
+
+      assert_equal( plain, 'something' )
+    end
+
+    should 'en/decrypt data using the same cipher' do
+      c = Nexus::Cipher.new( 'behappy', 
+                             "UvChT3jkwD7jXFd8mTWJ087i2Xb3tlGmPWUSYtAiRJM=" )
+      encrypted = c.encrypt( 'something' )
+      plain = c.decrypt( encrypted )
+
+      assert_equal( plain, 'something' )
+    end
+
+  end
+end

data/test/command_helper.rb

@@ -0,0 +1,55 @@
+require 'minitest/autorun'
+
+require 'shoulda'
+
+# for some reasons the refute_predicate is missing when executing
+# via jruby-1.7.4
+module ActiveSupport
+  class TestCase < ::MiniTest::Unit::TestCase
+    def refute_predicate
+    end
+  end
+end
+
+require 'active_support'
+require 'active_support/test_case'
+require 'webmock'
+require 'rr'
+
+begin
+  require 'redgreen'
+rescue LoadError
+end
+
+WebMock.disable_net_connect!
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), ".."))
+
+require "rubygems_plugin"
+
+class CommandTest < ActiveSupport::TestCase
+  include WebMock::API
+  include ShouldaContextLoadable 
+
+  def teardown
+    WebMock.reset!
+  end
+end
+
+def stub_config(config)
+  file = Gem::ConfigFile.new({})
+  config.each { |key, value| file[key] = value }
+  stub(Gem).configuration { config }
+end
+
+def assert_said(command, what)
+  assert_received(command) do |command|
+    command.say(what)
+  end
+end
+
+def assert_never_said(command, what)
+  assert_received(command) do |command|
+    command.say(what).never
+  end
+end

data/test/config_test.rb

@@ -0,0 +1,117 @@
+require 'minitest/autorun'
+require 'shoulda'
+require 'fileutils'
+require 'nexus/config'
+
+class ConfigTest < ::MiniTest::Unit::TestCase
+  include ShouldaContextLoadable 
+  
+  context 'storing url and authorization' do
+    
+    should 'with plain text file' do
+      file = File.join( 'pkg', 'plainconfig' )
+      FileUtils.rm_f file
+
+      repos = [ nil, 'first', 'second' ]
+
+      repos.each do |repo|
+        c = Nexus::Config.new( file, repo )
+        c.url = "http://example.com/#{repo}"
+        c.authorization = "BASIC asddsa#{repo}" 
+
+        assert_equal c.authorization, "BASIC asddsa#{repo}"
+        assert_equal c.url, "http://example.com/#{repo}"
+      end
+
+      repos.each do |repo|
+        c = Nexus::Config.new( file, repo )
+        assert_equal c.authorization, "BASIC asddsa#{repo}"
+        assert_equal c.url, "http://example.com/#{repo}"
+      end
+
+      assert_equal( Nexus::Config.new( file ).repos,
+                    { "first"=>"http://example.com/first", 
+                      "second"=>"http://example.com/second", 
+                      "DEFAULT"=>"http://example.com/"} )
+    end
+    
+  end
+
+  context 'auxilary functions' do
+
+    should 'encrypt and decrypt credentials' do
+      file = File.join( 'pkg', 'auxconfig' )
+      FileUtils.rm_f file
+
+      [ nil, 'key' ].each do |repo|
+        c = Nexus::Config.new( file, repo )
+        c.authorization = 'BASIC asddsa'
+        
+        assert_equal c.authorization, 'BASIC asddsa'
+        
+        cc = Nexus::Config.new( file, repo )
+        cc.password = 'be happy'
+        cc.encrypt_credentials
+        
+        assert_equal cc.authorization, 'BASIC asddsa'
+        
+        ccc = Nexus::Config.new( file, repo )
+        ccc.password = 'be happy'
+        assert_equal ccc.authorization, 'BASIC asddsa'
+        assert_equal ccc.send( :[], :iv ), cc.send( :[], :iv )
+        
+        cc.decrypt_credentials
+        
+        assert_equal cc.authorization, 'BASIC asddsa'
+        
+        ccc = Nexus::Config.new( file, repo )
+        
+        assert_equal ccc.authorization , 'BASIC asddsa'
+        assert_equal ccc.send( :[], :iv ), nil
+        assert_equal ccc.send( :[], :token ), nil
+      end
+    end
+    
+    should 'move credentials to secrets file' do
+      file = File.join( 'pkg', 'auxcfg' )
+      sfile = File.join( 'pkg', 'auxsrt' )
+      FileUtils.rm_f file
+      FileUtils.rm_f sfile
+      
+      repos = [ nil, 'first', 'second' ]
+
+      repos.each do |repo|
+        c = Nexus::Config.new( file, repo )
+        c.url = "http://example.com/#{repo}"
+        c.authorization = "BASIC asddsa#{repo}"
+      end
+
+      Nexus::Config.new( file ).new_secrets( sfile )
+      assert File.exists?( sfile ), true
+        
+      repos.each do |repo|
+        c = Nexus::Config.new( sfile, repo )
+        assert_equal c.url, nil
+        assert_equal c.authorization, "BASIC asddsa#{repo}"
+      end
+
+      c = Nexus::ConfigFile.new( file )
+      assert_equal c[ :authorization, nil ], nil
+      assert_equal c[ :secrets, nil ], sfile
+        
+      repos.each do |repo|
+        c = Nexus::ConfigFile.new( file )
+        assert_equal c[ :url, repo ], "http://example.com/#{repo}"
+      end
+
+      Nexus::Config.new( file ).new_secrets( nil )
+      assert_equal File.exists?( sfile ), false
+
+      repos.each do |repo|
+        c = Nexus::Config.new( file, repo )
+        assert_equal c.url, "http://example.com/#{repo}"
+        assert_equal c.authorization, "BASIC asddsa#{repo}"
+      end
+    end
+  end
+end

data/test/configfile_test.rb

@@ -0,0 +1,78 @@
+require 'minitest/autorun'
+require 'shoulda'
+require 'fileutils'
+require 'nexus/config_file'
+
+class ConfigTest < ::MiniTest::Unit::TestCase
+  include ShouldaContextLoadable 
+  
+  context 'file' do
+
+    should 'store key/values' do
+      file = File.join( 'pkg', 'cfg' )
+      FileUtils.rm_f file
+      f = Nexus::ConfigFile.new( file )
+      f[ 'asd_key', nil ] = 'dsa_value'
+      f[ 'asdasd_key', nil ] = 'dsa_value_dsa'
+      f[ 'asd_key', 'first' ] = 'dsa_value_dsa'
+      f[ 'asdasd_key', 'first' ] = 'dsadsa_value'
+
+      assert_equal( f[ 'asd_key', nil ], 'dsa_value' )
+      assert_equal( f[ 'asdasd_key', 'first' ], 'dsadsa_value' )
+
+      f.store
+
+      assert_equal( f.all, Nexus::ConfigFile.new( file ).all )
+      assert_equal( f.repos, [ 'first' ] )
+
+      assert_equal( f.section( 'asd_key' ),
+                    { "asd_key"=>"dsa_value", 
+                      "first"=>{"asd_key"=>"dsa_value_dsa"} } )
+    end
+
+    should 'delete key/values' do
+      file = File.join( 'pkg', 'cfg' )
+      FileUtils.rm_f file
+      f = Nexus::ConfigFile.new( file )
+      f[ 'asd_key', nil ] = 'dsa_value'
+      f[ 'asdasd_key', nil ] = 'dsa_value_dsa'
+      f[ 'asd_key', 'first' ] = 'dsa_value_dsa'
+      f[ 'asdasd_key', 'first' ] = 'dsadsa_value'
+
+      assert_equal( f[ 'asd_key', nil ], 'dsa_value' )
+      assert_equal( f[ 'asdasd_key', 'first' ], 'dsadsa_value' )
+
+      f.delete( 'asd_key' )
+
+      assert_equal( f[ 'asd_key', nil ], nil )
+      assert_equal( f[ 'asd_key', 'first' ], nil )
+      assert_equal( f[ 'asdasd_key', nil ], 'dsa_value_dsa' )
+      assert_equal( f[ 'asdasd_key', 'first' ], 'dsadsa_value' )
+    end
+
+    should 'merge other file' do
+      file1 = File.join( 'pkg', 'cfg1' )
+      file2 = File.join( 'pkg', 'cfg2' )
+      FileUtils.rm_f file1
+      FileUtils.rm_f file2
+      f1 = Nexus::ConfigFile.new( file1 )
+      f2 = Nexus::ConfigFile.new( file2 )
+
+      assert_equal( f1.all, {} )
+
+      f2[ 'asd_key', nil ] = 'dsa_value'
+      f2[ 'asdasd_key', 'first' ] = 'dsadsa_value'
+
+      f1.merge!( f2 )
+
+      assert_equal( f1[ 'asd_key', nil ], 'dsa_value' )
+      assert_equal( f1[ 'asdasd_key', 'first' ], 'dsadsa_value' )
+
+      f1.store
+      f2.store
+
+      assert_equal( Nexus::ConfigFile.new( file1 ).all, 
+                    Nexus::ConfigFile.new( file2 ).all )
+    end
+  end
+end