kontena-cli 0.15.5 → 0.16.0.pre1

data/spec/kontena/cli/master/users/roles/remove_command_spec.rb

@@ -4,25 +4,14 @@ require 'kontena/cli/master/users/roles/remove_command'
 
 describe Kontena::Cli::Master::Users::Roles::RemoveCommand do
 
+  include ClientHelpers
+
   let(:subject) do
     described_class.new(File.basename($0))
   end
 
-  let(:valid_settings) do
-    {'current_server' => 'alias',
-     'servers' => [
-         {'name' => 'some_master', 'url' => 'some_master'},
-         {'name' => 'alias', 'url' => 'someurl', 'token' => '123456'}
-     ]
-    }
-  end
-
-  let(:client) { spy(:client) }
-
   describe "#remove-role" do
     before(:each) do
-      allow(subject).to receive(:client).and_return(client)
-      allow(subject).to receive(:settings).and_return(valid_settings)
       allow(subject).to receive(:confirm).and_return(true)
     end
 

data/spec/kontena/cli/services/restart_command_spec.rb

@@ -22,7 +22,7 @@ describe Kontena::Cli::Services::RestartCommand do
     end
 
     it 'triggers restart command' do
-      expect(subject).to receive(:restart_service).with(token, 'service')
+      expect(subject).to receive(:restart_service)
       subject.run(['service'])
     end
   end

data/spec/kontena/cli/services/update_command_spec.rb

@@ -23,28 +23,28 @@ describe Kontena::Cli::Services::UpdateCommand do
     end
 
     it 'sends update command' do
-      expect(subject).to receive(:update_service).with(token, 'service', {privileged: false})
+      expect(subject).to receive(:update_service).with(duck_type(:access_token), 'service', {privileged: false})
       subject.run(['service'])
     end
 
     it 'sends --cap-add' do
-      expect(subject).to receive(:update_service).with(token, 'service', hash_including(cap_add: ['NET_ADMIN']))
+      expect(subject).to receive(:update_service).with(duck_type(:access_token), 'service', hash_including(cap_add: ['NET_ADMIN']))
       subject.run(['--cap-add', 'NET_ADMIN', 'service'])
     end
 
     it 'sends --cap-drop' do
-      expect(subject).to receive(:update_service).with(token, 'service', hash_including(cap_drop: ['MKNOD']))
+      expect(subject).to receive(:update_service).with(duck_type(:access_token), 'service', hash_including(cap_drop: ['MKNOD']))
       subject.run(['--cap-drop', 'MKNOD', 'service'])
     end
 
     it 'sends --log-driver' do
-      expect(subject).to receive(:update_service).with(token, 'service', hash_including(log_driver: 'syslog'))
+      expect(subject).to receive(:update_service).with(duck_type(:access_token), 'service', hash_including(log_driver: 'syslog'))
       subject.run(['--log-driver', 'syslog', 'service'])
     end
 
     it 'sends --log-opt' do
       expect(subject).to receive(:update_service).with(
-        token, 'service', hash_including(log_opts: {
+        duck_type(:access_token), 'service', hash_including(log_opts: {
           'gelf-address'  => 'udp://log_forwarder-logstash_internal:12201'
         })
       )

data/spec/kontena/client_spec.rb

@@ -1,38 +1,95 @@
 require_relative '../spec_helper'
 require 'kontena_cli'
+require 'ostruct'
 
 describe Kontena::Client do
 
   let(:subject) { described_class.new('https://localhost/v1/') }
   let(:http_client) { double(:http_client) }
 
+  # This trickery is here for making the tests work with or without the new configuration handler.
+  # The client itself will work with any kind of token that acts like a hash or ostruct.
+  let(:server_class)   { Kontena::Cli.const_defined?('Config', false) ? Kontena::Cli::Config::Server  : OpenStruct }
+  let(:token_class)    { Kontena::Cli.const_defined?('Config', false) ? Kontena::Cli::Config::Token   : OpenStruct }
+  let(:account_class)  { Kontena::Cli.const_defined?('Config', false) ? Kontena::Cli::Config::Account : OpenStruct }
+
+  let(:master) { server_class.new(url: 'https://localhost', name: 'master') }
+  let(:token) { token_class.new(access_token: '1234', refresh_token: '5678', expires_at: nil, parent_type: :master, parent_name: 'master') }
+  let(:expiring_token) { token_class.new(access_token: '1234', refresh_token: '5678', expires_at: Time.now.utc + 1000, parent_type: :master, parent_name: 'master') }
+  let(:expired_token) { token_class.new(access_token: '1234', refresh_token: '5678', expires_at: Time.now.utc - 1000, parent_type: :master, parent_name: 'master') }
+
   before(:each) do
     allow(subject).to receive(:http_client).and_return(http_client)
+    if Kontena::Cli.const_defined?('Config', false)
+      config = Kontena::Cli::Config
+    else
+      config = Class.new { include Kontena::Cli::Common}.new
+    end
+    config.servers << master
+    allow(config).to receive(:find_server).and_return(master)
+    allow(config).to receive(:current_master).and_return(master)
+    allow(config).to receive(:account).and_return(account_class.new(token_verify_path: '/v1/user', token_endpoint: '/oauth2/token', authorization_endpoint: '/oauth2/authorize'))
+    allow(config).to receive(:write).and_return(true)
+  end
+
+  context 'token authentication' do
+
+    it 'takes a token' do
+      client = Kontena::Client.new('https://localhost/v1/', token)
+      expect(client.token).to eq token
+    end
+    
+    it 'uses the access token as a bearer token' do
+      client = Kontena::Client.new('https://localhost/v1/', token)
+      expect(client.http_client).to receive(:request) do |opts|
+        expect(opts[:headers]['Authorization']).to eq "Bearer #{token.access_token}"
+      end.and_return(spy(:response, status: 200))
+      client.get('/v1/foo')
+    end
+
+    it 'does not try to refresh an expiring token that is still valid' do
+      client = Kontena::Client.new('https://localhost/v1/', expiring_token)
+      expect(client.http_client).to receive(:request) do |opts|
+        expect(opts[:headers]['Authorization']).to eq "Bearer #{token.access_token}"
+      end.and_return(spy(:response, status: 200))
+      client.get('/v1/foo')
+    end
+
+    it 'tries to refresh an expired token' do
+      master.token = expired_token
+      client = Kontena::Client.new(master.url, master.token)
+      allow(client).to receive(:token_refresh_path).and_return('/oauth2/token')
+      expect(client.http_client).to receive(:request).with(hash_including(path: '/oauth2/token', method: :post)).and_return(OpenStruct.new(status: 201, headers: {'Content-Type' => 'application/json'}, body: '{"access_token": "abcd"}'))
+      expect(client.http_client).to receive(:request).with(hash_including(path: '/v1/foo')) do |args|
+        expect(args[:headers]['Authorization']).to eq "Bearer abcd"
+      end.and_return(spy(:response, status: 200))
+      client.get('/v1/foo')
+    end
   end
 
   describe '#get' do
     it 'passes path to client' do
       allow(subject).to receive(:http_client).and_return(http_client)
-      expect(http_client).to receive(:get).with(
-        hash_including(path: '/v1/foo')
+      expect(http_client).to receive(:request).with(
+        hash_including(path: '/v1/foo', method: :get)
       ).and_return(spy(:response, status: 200))
       subject.get('foo')
     end
 
     it 'passes params to client' do
       allow(subject).to receive(:http_client).and_return(http_client)
-      expect(http_client).to receive(:get).with(
-        hash_including(query: {bar: 'baz'})
+      expect(http_client).to receive(:request).with(
+        hash_including(query: {bar: 'baz'}, method: :get)
       ).and_return(spy(:response, status: 200))
       subject.get('foo', {bar: 'baz'})
     end
 
     it 'passes params to client' do
       allow(subject).to receive(:http_client).and_return(http_client)
-      expect(http_client).to receive(:get).with(
-        hash_including(headers: hash_including(:'Some-Header' => 'value'))
+      expect(http_client).to receive(:request).with(
+        hash_including(headers: hash_including('Some-Header' => 'value'), method: :get)
       ).and_return(spy(:response, status: 200))
-      subject.get('foo', nil, {:'Some-Header' => 'value'})
+      subject.get('foo', nil, {'Some-Header' => 'value'})
     end
   end
 
@@ -40,24 +97,27 @@ describe Kontena::Client do
     let(:response_block) { Proc.new{ } }
 
     it 'passes path & response_block to client' do
-      expect(http_client).to receive(:get).with(
-        hash_including(path: '/v1/foo', response_block: response_block)
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(path: '/v1/foo', response_block: response_block, method: :get)
       ).and_return(spy(:response, status: 200))
       subject.get_stream('foo', response_block)
     end
 
     it 'passes params to client' do
-      expect(http_client).to receive(:get).with(
-        hash_including(query: {bar: 'baz'})
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(query: {bar: 'baz'}, method: :get)
       ).and_return(spy(:response, status: 200))
       subject.get_stream('foo', response_block, {bar: 'baz'})
     end
 
     it 'passes params to client' do
-      expect(http_client).to receive(:get).with(
-        hash_including(headers: hash_including(:'Some-Header' => 'value'))
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(headers: hash_including('Some-Header' => 'value'), method: :get)
       ).and_return(spy(:response, status: 200))
-      subject.get_stream('foo', response_block, nil, {:'Some-Header' => 'value'})
+      subject.get_stream('foo', response_block, nil, {'Some-Header' => 'value'})
     end
   end
 
@@ -67,24 +127,27 @@ describe Kontena::Client do
     end
 
     it 'passes path and object to client' do
-      expect(http_client).to receive(:post).with(
-        hash_including(path: '/v1/foo', body: kind_of(String))
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(path: '/v1/foo', body: kind_of(String), method: :post)
       ).and_return(spy(:response, status: 200))
       subject.post('foo', data)
     end
 
     it 'passes params to client' do
-      expect(http_client).to receive(:post).with(
-        hash_including(query: {bar: 'baz'})
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(query: {bar: 'baz'}, method: :post)
       ).and_return(spy(:response, status: 200))
       subject.post('foo', data, {bar: 'baz'})
     end
 
     it 'passes params to client' do
-      expect(http_client).to receive(:post).with(
-        hash_including(headers: hash_including(:'Some-Header' => 'value'))
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(headers: hash_including('Some-Header' => 'value'), method: :post)
       ).and_return(spy(:response, status: 200))
-      subject.post('foo', data, nil, {:'Some-Header' => 'value'})
+      subject.post('foo', data, nil, {'Some-Header' => 'value'})
     end
   end
 
@@ -94,24 +157,27 @@ describe Kontena::Client do
     end
 
     it 'passes path and object to client' do
-      expect(http_client).to receive(:put).with(
-        hash_including(path: '/v1/foo', body: kind_of(String))
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(path: '/v1/foo', body: kind_of(String), method: :put)
       ).and_return(spy(:response, status: 200))
       subject.put('foo', data)
     end
 
     it 'passes params to client' do
-      expect(http_client).to receive(:put).with(
-        hash_including(query: {bar: 'baz'})
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(query: {bar: 'baz'}, method: :put)
       ).and_return(spy(:response, status: 200))
       subject.put('foo', data, {bar: 'baz'})
     end
 
     it 'passes params to client' do
-      expect(http_client).to receive(:put).with(
-        hash_including(headers: hash_including(:'Some-Header' => 'value'))
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(headers: hash_including('Some-Header' => 'value'), method: :put)
       ).and_return(spy(:response, status: 200))
-      subject.put('foo', data, nil, {:'Some-Header' => 'value'})
+      subject.put('foo', data, nil, {'Some-Header' => 'value'})
     end
   end
 
@@ -121,24 +187,27 @@ describe Kontena::Client do
     end
 
     it 'passes path to client' do
-      expect(http_client).to receive(:delete).with(
-        hash_including(path: '/v1/foo')
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(path: '/v1/foo', method: :delete)
       ).and_return(spy(:response, status: 200))
       subject.delete('foo')
     end
 
     it 'passes params to client' do
-      expect(http_client).to receive(:delete).with(
-        hash_including(query: {bar: 'baz'})
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(query: {bar: 'baz'}, method: :delete)
       ).and_return(spy(:response, status: 200))
       subject.delete('foo', nil, {bar: 'baz'})
     end
 
     it 'passes params to client' do
-      expect(http_client).to receive(:delete).with(
-        hash_including(headers: hash_including(:'Some-Header' => 'value'))
+      allow(subject).to receive(:http_client).and_return(http_client)
+      expect(http_client).to receive(:request).with(
+        hash_including(headers: hash_including('Some-Header' => 'value'), method: :delete)
       ).and_return(spy(:response, status: 200))
-      subject.delete('foo', nil, nil, {:'Some-Header' => 'value'})
+      subject.delete('foo', nil, nil, {'Some-Header' => 'value'})
     end
   end
 end

data/spec/kontena/config_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../spec_helper'
+
+# Lots of coverage already in Common spec
+describe Kontena::Cli::Config do
+
+  context 'base' do
+    let(:subject) { described_class.instance }
+
+    before(:each) do
+      allow(File).to receive(:exist?).and_return(false)
+      allow(File).to receive(:write).and_return(true)
+      subject.class.reset_instance
+      subject.servers << Kontena::Cli::Config::Server.new(
+        url: 'http://localhost',
+        name: 'test',
+        token: Kontena::Cli::Config::Token.new(access_token: 'abcd')
+      )
+    end
+
+    it 'finds a server by name' do
+      expect(subject.find_server('test').url).to eq 'http://localhost'
+    end
+
+    it 'finds a server by url' do
+      expect(subject.find_server_by(url: 'http://localhost').name).to eq 'test'
+    end
+
+    it 'returns current master' do
+      subject.current_master = 'test'
+      expect(subject.current_master.name).to eq 'test'
+    end
+
+    it 'returns an array of servers' do
+      expect(subject.servers).to be_kind_of(Array)
+      expect(subject.servers.first.url).to match /^http/
+    end
+
+    it 'returns an array of accounts' do
+      expect(subject.accounts).to be_kind_of(Array)
+    end
+
+    it 'adds default accounts' do
+      expect(subject.find_account('kontena').name).to eq 'kontena'
+      expect(subject.find_account('master').name).to eq 'master'
+    end
+
+    it 'sets and returns current grid' do
+      subject.current_master = 'test'
+      subject.current_grid = 'foo'
+      expect(subject.current_master.grid).to eq 'foo'
+      expect(subject.current_grid).to eq 'foo'
+    end
+  end
+
+  describe 'Token' do
+    let(:subject) { Kontena::Cli::Config::Token.new(access_token: 'abcd', expires_at: Time.now.utc - 100) }
+
+    it 'knows when a token is expired' do
+      expect(subject.expired?).to be_truthy
+      subject.expires_at = Time.now.utc + 100
+      expect(subject.expired?).to be_falsey
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -5,11 +5,15 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
+begin
+  require 'simplecov'
+  SimpleCov.start
+rescue LoadError
+end
+
 require 'clamp'
 require 'ruby_dig'
-require 'kontena/cli/common'
-require 'kontena/cli/grid_options'
-require 'kontena/client'
+require 'kontena_cli'
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
@@ -22,8 +26,26 @@ RSpec.configure do |config|
   config.order = 'random'
   config.before(:each) do
     allow(Dir).to receive(:home).and_return('/tmp/')
+    allow(ENV).to receive(:[]).with(anything).and_call_original
+    allow(ENV).to receive(:[]).with('DEBUG').and_call_original
+    Kontena::Cli::Config.reset_instance
+  end
+  
+  config.after(:each) do
+    RSpec::Mocks.space.proxy_for(File).reset
+    RSpec::Mocks.space.proxy_for(Kontena::Cli::Config).reset
+    File.unlink(Kontena::Cli::Config.default_config_filename) if File.exist?(Kontena::Cli::Config.default_config_filename)
+  end
+
+  config.around(:each) do |example|
+    begin
+      example.run
+    rescue SystemExit
+      puts "Got SystemExit: #{$!.message} - Exit code: #{$!.status}"
+    end
   end
 end
 
 require_relative 'support/client_helpers'
+require_relative 'support/requirements_helper'
 require_relative 'support/fixtures_helpers'

data/spec/support/client_helpers.rb

@@ -15,17 +15,24 @@ module ClientHelpers
 
     base.let(:settings) do
       {'current_server' => 'alias',
+       'current_account' => 'kontena',
        'servers' => [
            {'name' => 'some_master', 'url' => 'some_master'},
-           {'name' => 'alias', 'url' => 'someurl', 'token' => token}
+           {'name' => 'alias', 'url' => 'someurl', 'token' => token, 'account' => 'master'}
        ]
       }
     end
 
     base.before(:each) do
-      allow(subject).to receive(:client).with(token).and_return(client)
+      RSpec::Mocks.space.proxy_for(File).reset
+      allow(subject).to receive(:client).and_return(client)
       allow(subject).to receive(:current_grid).and_return('test-grid')
-      allow(subject).to receive(:settings).and_return(settings)
+      allow(File).to receive(:exist?).with(File.join(Dir.home, '.kontena_client.json')).and_return(true)
+      allow(File).to receive(:readable?).with(File.join(Dir.home, '.kontena_client.json')).and_return(true)
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with(File.join(Dir.home, '.kontena_client.json')).and_return(JSON.dump(settings))
+      Kontena::Cli::Config.reset_instance
     end
   end
+
 end