kontena-cli 0.16.3 → 0.17.0.pre1

data/spec/kontena/cli/master/login_command_spec.rb

@@ -1,5 +1,8 @@
 require_relative "../../../spec_helper"
 require 'kontena/cli/master/login_command'
+require 'kontena/cli/localhost_web_server'
+require 'launchy'
+require 'ostruct'
 
 describe Kontena::Cli::Master::LoginCommand do
 
@@ -9,207 +12,383 @@ describe Kontena::Cli::Master::LoginCommand do
     described_class.new(File.basename($0))
   end
 
-  let(:config) { double }
+  let(:client) { double(:client) }
 
-  before(:each) do
-    allow(subject).to receive(:config).and_return(config)
+  it 'should exit with error if --code and --token both given' do
+    expect(subject).to receive(:exit_with_error).and_throw(:exit_with_error)
+    subject.run(%w(--code abcd --token defg))
   end
 
-  describe '#use_current_master_if_available' do
-    context 'url not given' do
-      it 'sets local url current master url if defined' do
-        expect(config).to receive(:current_master).twice.and_return(Kontena::Cli::Config::Server.new(url: 'foo'))
-        expect(subject).to receive(:url=).with('foo')
-        expect(subject.use_current_master_if_available).to be_truthy
+  it 'should exit with error if --code and --join both given' do
+    expect(subject).to receive(:exit_with_error).and_throw(:exit_with_error)
+    subject.run(%w(--code abcd --join defg))
+  end
+
+  it 'should exit with error if --code and --force both given' do
+    expect(subject).to receive(:exit_with_error).and_throw(:exit_with_error)
+    subject.run(%w(--code abcd --force))
+  end
+
+  it 'should exit with error if --token and --force both given' do
+    expect(subject).to receive(:exit_with_error).and_throw(:exit_with_error)
+    subject.run(%w(--token abcd --force))
+  end
+
+  describe '#select_a_server' do
+    let(:config) { double(:config) }
+    let(:server) { Kontena::Cli::Config::Server.new(url: 'https://foo', name: 'server') }
+
+    before(:each) do
+      allow(subject).to receive(:config).and_return(config)
+    end
+
+    context 'no url or name provided' do
+      it 'tries to use current_master' do
+        expect(config).to receive(:current_master).at_least(:once).and_return(server)
+        expect(subject.select_a_server(nil, nil)).to eq server
       end
 
-      it 'raises if no current master and no url' do
-        subject.url = nil
+      it 'exits with error if current_master not set' do
         expect(config).to receive(:current_master).and_return(nil)
-        expect(subject).to receive(:exit_with_error)
-        subject.use_current_master_if_available
+        expect(subject).to receive(:exit_with_error).and_throw(:exit_with_error)
+        subject.select_a_server(nil, nil)
       end
     end
 
-    context 'url given' do
-      it 'returns nil' do
-        subject.url = 'foofoo'
-        expect(subject.use_current_master_if_available).to be_nil
+    context 'name provided' do
+      context 'with url' do
+        it 'should return the existing server if an exact match is found' do
+          expect(config).to receive(:find_server_by).and_return(server)
+          expect(subject.select_a_server(server.name, server.url)).to be server
+        end
+
+        it 'should return the existing one but update its url if a name match is found' do
+          allow(config).to receive(:find_server_by).and_return(nil)
+          expect(config).to receive(:find_server).and_return(server)
+          expect(subject.select_a_server(server.name, 'http://foofoo')).to be server
+          expect(server.url).to eq 'http://foofoo'
+        end
+
+        it 'should create a new server entry if no exact match or name match is found' do
+          allow(config).to receive(:find_server_by).and_return(nil)
+          allow(config).to receive(:find_server).and_return(nil)
+          new_server = subject.select_a_server('fooserver', 'http://foofoo')
+          expect(new_server).not_to be server
+          expect(new_server.url).to eq 'http://foofoo'
+          expect(new_server.name).to eq 'fooserver'
+        end
       end
-    end
-  end
 
-  describe '#use_master_by_name' do
-    context 'url given' do
-      it 'should return nil when url looks like an url' do
-        subject.url = 'http://foo'
-        expect(subject).not_to receive(:config)
-        expect(subject.use_master_by_name).to be_nil
+      context 'without url' do
+        it 'should return a server with that name if it has an url' do
+          expect(config).to receive(:find_server).with('foo').and_return(server)
+          expect(subject.select_a_server('foo', nil)).to be server
+          expect(server.url).not_to be_nil
+        end
+
+        it 'should exit with error if a server with that name is found but it does not have an url' do
+          server.url = nil
+          expect(config).to receive(:find_server).with('foo').and_return(server)
+          expect(subject).to receive(:exit_with_error).and_throw(:exit_with_error)
+          subject.select_a_server('foo', nil)
+        end
       end
     end
 
-    context 'name given' do
-      it 'should try to look for servers by name' do
-        expect(config).to receive(:find_server).and_return(Kontena::Cli::Config::Server.new(url: 'https://foo'))
-        subject.url = 'foomaster'
-        expect(subject).to receive(:url=).with('https://foo')
-        subject.use_master_by_name
+    context 'url provided without name' do
+      context 'url looks like an url' do
+        it 'should try to find a server with that url and return it if found' do
+          expect(config).to receive(:find_server_by).with({ :url => 'https://foo' }).and_return(server)
+          expect(subject.select_a_server(nil, 'https://foo')).to be server
+        end
+
+        it 'should create a new server entry if not found' do
+          expect(config).to receive(:find_server_by).with({ :url => 'https://foo' }).and_return(nil)
+          new_server = subject.select_a_server(nil, 'https://foo')
+          expect(new_server).not_to be server
+          expect(new_server.url).to eq 'https://foo'
+        end
+      end
+
+      context 'url looks like a name' do
+        it 'should return a server with that name if it has an url' do
+          expect(config).to receive(:find_server).with('foo').and_return(server)
+          expect(subject.select_a_server(nil, 'foo')).to be server
+          expect(server.url).not_to be_nil
+        end
+
+        it 'should exit with error if a server with that name is found but it does not have an url' do
+          server.url = nil
+          expect(config).to receive(:find_server).with('foo').and_return(server)
+          expect(subject).to receive(:exit_with_error).and_throw(:exit_with_error)
+          subject.select_a_server(nil, 'foo')
+        end
+
+        it 'should exit with error if a server with that name is not found' do
+          expect(config).to receive(:find_server).with('foo').and_return(nil)
+          expect(subject).to receive(:exit_with_error).and_throw(:exit_with_error)
+          subject.select_a_server(nil, 'foo')
+        end
       end
     end
   end
 
-  describe '#find_server_or_create_new' do
-
-    let(:existing_server) { Kontena::Cli::Config::Server.new(url: 'https://foo', name: 'existing') }
+  context 'with a server with a token in config' do
+    before(:each) do
+      allow(File).to receive(:read).and_return('
+        {
+          "current_server": null,
+          "current_account": "kontena",
+          "servers": [
+            {
+              "name": "fooserver",
+              "url": "http://foo.example.com:80",
+              "username": "admin",
+              "grid": "test",
+              "token": "abcd",
+              "token_expires_at": 0,
+              "refresh_token": null
+            }
+          ]
+        }
+      ')
+      allow(File).to receive(:write).and_return(true)
+      allow(File).to receive(:exist?).and_return(true)
+      allow(File).to receive(:readable?).and_return(true)
+      allow(Kontena::Client).to receive(:new).and_return(client)
+      allow(Launchy).to receive(:open).and_return(true)
+      allow(Kontena::LocalhostWebServer).to receive(:port).and_return(12345)
+      allow(Kontena::LocalhostWebServer).to receive(:serve_one).and_return(
+        { 'code' => 'abcd1234' }
+      )
+    end
 
-    it 'should try to pick up an existing server from config' do
-      subject.name = 'name'
-      expect(config).to receive(:find_server_by).with(url: 'foo', name: 'name').and_return(existing_server)
-      expect(config).to receive(:current_server=).with(existing_server.name)
-      expect(subject.find_server_or_create_new('foo')).to eq existing_server
+    it 'logs in and changes the url of a named server in config' do
+      expect(File).to receive(:write) do |fn, content|
+        data = JSON.parse(content)
+        expect(data['servers'].size).to eq 1
+        expect(data['servers'].first['name']).to eq 'fooserver'
+        expect(data['servers'].first['url']).to eq 'http://foo2.example.com'
+        expect(data['servers'].first['token']).to eq 'abcdefg'
+      end.and_return(true)
+      expect(subject.config).to receive(:find_server).at_least(:once).with('fooserver').and_call_original
+      expect(client).to receive(:authentication_ok?).and_return(true)
+      subject.run(%w(--token abcdefg --name fooserver --grid foogrid http://foo2.example.com))
     end
 
-    it 'should create a new server instance if existing not found' do
-      expect(config).to receive(:find_server_by).and_return(nil)
-      subject.name = "foofoo1"
-      servers = []
-      expect(config).to receive(:servers).and_return(servers)
-      expect(config).to receive(:current_server=).with('foofoo1')
-      expect(subject.find_server_or_create_new('http://foo').name).to eq 'foofoo1'
-      expect(servers.first.url).to eq 'http://foo'
-      expect(servers.first.name).to eq 'foofoo1'
+    it 'logs in and creates a new entry in config' do
+      expect(File).to receive(:write) do |fn, content|
+        data = JSON.parse(content)
+        expect(data['servers'].size).to eq 2
+        expect(data['servers'].first['name']).to eq 'fooserver'
+        expect(data['servers'].first['url']).to eq 'http://foo.example.com:80'
+        expect(data['servers'].first['token']).to eq 'abcd'
+        expect(data['servers'].last['name']).to eq 'fooserver2'
+        expect(data['servers'].last['url']).to eq 'http://foo2.example.com'
+        expect(data['servers'].last['token']).to eq 'abcdefg'
+      end.and_return(true)
+      expect(subject.config).to receive(:find_server).at_least(:once).with('fooserver2').and_call_original
+      expect(client).to receive(:authentication_ok?).and_return(true)
+      subject.run(%w(--token abcdefg --name fooserver2 --grid foogrid http://foo2.example.com))
     end
-  end
 
-  describe '#set_server_token' do
-    let(:server) { Kontena::Cli::Config::Server.new(name: 'some_server') }
-    let(:token) { Kontena::Cli::Config::Token.new(access_token: 'bartoken') }
+    it 'uses the existing token if it works and no --code --token --join or --force set when using url' do
+      expect(client).to receive(:authentication_ok?).and_return(true)
+      subject.run(%w(http://foo.example.com:80))
+      expect(subject.config.servers.size).to eq 1
+      expect(subject.config.current_server).to eq 'fooserver'
+      expect(subject.config.servers.first.name).to eq 'fooserver'
+      expect(subject.config.servers.first.url).to eq 'http://foo.example.com:80'
+    end
 
-    it 'should set token from parameters as the servers access token' do
-      subject.token = 'footoken'
-      expect(server).to receive(:token=) do |token|
-        expect(token.access_token).to eq 'footoken'
-      end
-      subject.set_server_token(server)
+    it 'uses the existing token if it works and no --code --token --join or --force set when using --name' do
+      expect(client).to receive(:authentication_ok?).and_return(true)
+      subject.run(%w(--name fooserver))
+      expect(subject.config.servers.size).to eq 1
+      expect(subject.config.current_server).to eq 'fooserver'
+      expect(subject.config.servers.first.name).to eq 'fooserver'
+      expect(subject.config.servers.first.url).to eq 'http://foo.example.com:80'
     end
 
-    it 'should clear servers existing token when forced' do
-      subject.force = true
-      server.token = token
-      subject.set_server_token(server)
-      expect(server.access_token).to be_nil
+    it 'uses the existing token if it works and no --code --token --join or --force set when using name in url param' do
+      expect(client).to receive(:authentication_ok?).and_return(true)
+      subject.run(%w(fooserver))
+      expect(subject.config.servers.size).to eq 1
+      expect(subject.config.current_server).to eq 'fooserver'
+      expect(subject.config.servers.first.name).to eq 'fooserver'
+      expect(subject.config.servers.first.url).to eq 'http://foo.example.com:80'
     end
 
-    it 'should add a blank token if server has none' do
-      server.token = nil
-      subject.set_server_token(server)
-      expect(server.access_token).to be_nil
-      expect(server.token.parent_name).to eq 'some_server'
+    it 'uses current master and its token token if it works and no --code --token --join or --force set when no params' do
+      subject.config.current_server = 'fooserver'
+      expect(client).to receive(:authentication_ok?).and_return(true)
+      subject.run([])
+      expect(subject.config.servers.size).to eq 1
+      expect(subject.config.current_server).to eq 'fooserver'
+      expect(subject.config.servers.first.name).to eq 'fooserver'
+      expect(subject.config.servers.first.url).to eq 'http://foo.example.com:80'
     end
 
-    it 'should keep the existing token unless a new one is supplied' do
-      server.token = token
-      subject.token = nil
-      subject.force = false
-      subject.set_server_token(server)
-      expect(server.token).to eq token
+    it 'goes to web flow when the existing token does not work' do
+      expect(client).to receive(:authentication_ok?).and_return(false)
+      expect(subject).to receive(:web_flow).and_return(true)
+      subject.run(%w(fooserver))
     end
   end
 
-  describe '#use_authorization_code' do
-    let(:client) { double }
-
+  context 'with no servers in config' do
+    let(:webserver) { double(:webserver) }
     before(:each) do
-      allow(subject.config).to receive(:current_server=)
-    end
-
-    it 'should set the local name to name provided from server if no name was set' do
-      expect(Kontena::Client).to receive(:new).and_return(client)
-      expect(client).to receive(:exchange_code).with('abcd1234').and_return(
-        { 
-          'access_token' => 'token',
-          'refresh_token' => 'refresh_token',
-          'expires_in' => 1000,
-          'server' => {
-            'name' => 'foofoo1'
-          }
+      allow(File).to receive(:read).and_return('
+        {
+          "current_server": null,
+          "current_account": "kontena",
+          "servers": []
         }
+      ')
+      allow(File).to receive(:write).and_return(true)
+      allow(File).to receive(:exist?).and_return(true)
+      allow(File).to receive(:readable?).and_return(true)
+      allow(Kontena::Client).to receive(:new).and_return(client)
+      allow(Kontena::LocalhostWebServer).to receive(:new).and_return(webserver)
+      allow(webserver).to receive(:port).and_return(12345)
+      allow(webserver).to receive(:serve_one).and_return(
+        { 'code' => 'abcd1234' }
       )
+    end
 
-      server = Kontena::Cli::Config::Server.new(name: nil, url: 'http://foo')
-      subject.use_authorization_code(server, 'abcd1234')
-      expect(server.token.access_token).to eq 'token'
-      expect(server.name).to eq 'foofoo1'
-    end
-
-    it 'should not touch the local name if the server already has a name' do
-      expect(Kontena::Client).to receive(:new).and_return(client)
-      expect(client).to receive(:exchange_code).with('abcd1234').and_return(
-        { 
-          'access_token' => 'token',
-          'refresh_token' => 'refresh_token',
-          'expires_in' => 1000,
-          'server' => {
-            'name' => 'foofoo1'
-          }
-        }
-      )
+    it 'creates a new entry when successful login using web flow' do
+      expect(client).to receive(:last_response).at_least(:once).and_return(OpenStruct.new(status: 302, headers: { 'Location' => 'http://authprovider.example.com/authplz' }))
+      expect(client).to receive(:request) do |opts|
+        expect(opts[:path]).to eq "/authenticate?redirect_uri=http%3A%2F%2Flocalhost%3A12345%2Fcb&expires_in=7200"
+        expect(opts[:http_method]).to eq :get
+      end.and_return({})
+      expect(Launchy).to receive(:open).with('http://authprovider.example.com/authplz').and_return(true)
+      expect(client).to receive(:exchange_code).with('abcd1234').and_return('access_token' => 'defg456', 'server' => { 'name' => 'foobar' }, 'user' => { 'name' => 'testuser' })
+      subject.run(%w(--skip-grid-auto-select http://foobar.example.com))
+      expect(subject.config.servers.size).to eq 1
+      server = subject.config.servers.first
+      expect(server.url).to eq 'http://foobar.example.com'
+      expect(server.name).to eq 'foobar'
+      expect(server.username).to eq 'testuser'
+      expect(server.token.access_token).to eq 'defg456'
+      expect(server.token.refresh_token).to be_nil
+      expect(server.token.expires_at).to be_nil
+    end
 
-      server = Kontena::Cli::Config::Server.new(name: 'foofoo2', url: 'http://foo')
-      subject.use_authorization_code(server, 'abcd1234')
-      expect((Time.now.utc.to_i+800..Time.now.utc.to_i+1100).cover?(server.token.expires_at.to_i)).to be_truthy
-      expect(server.name).to eq 'foofoo2'
+    it 'creates a new entry when successful login using --code' do
+      expect(client).to receive(:exchange_code).with('defg').and_return('access_token' => 'defg456', 'server' => { 'name' => 'foobar' }, 'user' => { 'name' => 'testuser' })
+      subject.run(%w(--skip-grid-auto-select --code defg http://foobar.example.com))
+      expect(subject.config.servers.size).to eq 1
+      server = subject.config.servers.first
+      expect(server.url).to eq 'http://foobar.example.com'
+      expect(server.name).to eq 'foobar'
+      expect(server.username).to eq 'testuser'
+      expect(server.token.access_token).to eq 'defg456'
+      expect(server.token.refresh_token).to be_nil
+      expect(server.token.expires_at).to be_nil
+    end
+
+    it 'creates an entry when using --remote' do
+      expect(client).to receive(:last_response).at_least(:once).and_return(OpenStruct.new(status: 302, headers: { 'Location' => 'http//authprovider.example.com/authplz' }))
+      expect(client).to receive(:request) do |opts|
+        expect(opts[:path]).to eq "/authenticate?redirect_uri=%2Fcode&expires_in=7200"
+        expect(opts[:http_method]).to eq :get
+      end.and_return({})
+      expect(subject.config).to receive(:find_server).with('kontena-master').and_return(true)
+      expect(subject.config).to receive(:find_server).with('kontena-master-2').at_least(:once).and_return(nil)
+      expect{subject.run(%w(--remote http://foobar.example.com))}.to raise_error(SystemExit) do |ex|
+        expect(ex.status).to eq 1
+      end
+      expect(subject.config.servers.size).to eq 1
+      server = subject.config.servers.first
+      expect(server.url).to eq 'http://foobar.example.com'
+      expect(server.name).to eq 'kontena-master-2'
+      expect(server.username).to be_nil
+      expect(server.token.access_token).to be_nil
+      expect(server.token.refresh_token).to be_nil
+      expect(server.token.expires_at).to be_nil
     end
   end
 
-  describe '#in_to_at' do
-    it 'should return nil when expires_in is <0 or nil' do
-      expect(subject.in_to_at(0)).to be_nil
-      expect(subject.in_to_at(-1)).to be_nil
-      expect(subject.in_to_at(nil)).to be_nil
+  describe '#authentication_url_from_master' do
+    it 'should exit with error if master returns a json with error' do
+      allow(Kontena::Client).to receive(:new).and_return(client)
+      expect(client).to receive(:last_response).at_least(:once).and_return(OpenStruct.new(status: 400, headers: {}))
+      expect(client).to receive(:request).and_return('error' => 'no good')
+      expect(subject).to receive(:exit_with_error).with(/no good/).and_throw(:exit_with_error)
+      subject.authentication_url_from_master('https://foo.example.com', remote: true)
     end
 
-    it 'should return a timestamp when expires_in is >0' do
-      time = Time.now.utc.to_i
-      expect((time + 80..time + 120).cover?(subject.in_to_at(100))).to be_truthy
+    it 'should exit with error if master returns text' do
+      allow(Kontena::Client).to receive(:new).and_return(client)
+      expect(client).to receive(:last_response).at_least(:once).and_return(OpenStruct.new(status: 400, headers: {}))
+      expect(client).to receive(:request).and_return('Fail!')
+      expect(subject).to receive(:exit_with_error).and_throw(:exit_with_error)
+      subject.authentication_url_from_master('https://foo.example.com', remote: true)
     end
-  end
 
-  describe '#update_server_name' do
-    let(:server) { Kontena::Cli::Config::Server.new }
-    let(:response) { { 'access_token' => 'token', 'server' => { 'name' => 'foo2' } } }
+    it 'should exit with error if master returns nil' do
+      allow(Kontena::Client).to receive(:new).and_return(client)
+      expect(client).to receive(:last_response).at_least(:once).and_return(OpenStruct.new(status: 400, headers: {}))
+      expect(client).to receive(:request).and_return(nil)
+      expect(subject).to receive(:exit_with_error).with(/Invalid.+?400/).and_throw(:exit_with_error)
+      subject.authentication_url_from_master('https://foo.example.com', remote: true)
+    end
+  end
 
-    it 'should do nothing if server already has a name' do
-      server.name = 'foofoofoo'
-      subject.update_server_name(server, response)
-      expect(server.name).to eq 'foofoofoo'
+  describe '#display_remote_message' do
+    it 'should only print out the url if --silent' do
+      subject.silent = true
+      server = Kontena::Cli::Config::Server.new(url: 'https://foo', name: 'server')
+      expect(subject).to receive(:authentication_url_from_master).and_return('http://foo')
+      expect{subject.display_remote_message(server, {})}.to output("http://foo\n").to_stdout
     end
+  end
 
-    it 'should set the name from name parameter if set' do
-      subject.name = 'abcd'
-      subject.update_server_name(server, response)
-      expect(server.name).to eq 'abcd'
+  describe '#authentication_path' do
+    it 'should raise if not doing --remote and the local port is missing' do
+      expect{subject.authentication_path(local_port: nil, remote: false)}.to raise_error(ArgumentError)
     end
+  end
+
+  describe '#update_server_token' do
+    let(:server) { Kontena::Cli::Config::Server.new(url: 'https://foo', name: 'server') }
 
-    it 'should set the name from server response if returned' do
-      subject.update_server_name(server, response)
-      expect(server.name).to eq 'foo2'
+    it 'should raise unless response is a hash' do
+      expect{subject.update_server_token(server, nil)}.to raise_error(TypeError)
     end
 
-    it 'should use a default name if no other can be figured out' do
-      expect(subject.config).to receive(:find_server).with('kontena-master').and_return(nil)
-      subject.update_server_name(server, response.reject{|k,v| k=='server'})
-      expect(server.name).to eq 'kontena-master'
+    it 'should do a code exchange if response has "code"' do
+      expect(subject).to receive(:use_authorization_code).with(server, "abcd")
+      subject.update_server_token(server, "code" => "abcd")
     end
 
-    it 'should use a default name with suffix if one already exists' do
-      expect(subject.config).to receive(:find_server).with('kontena-master').and_return(true)
-      expect(subject.config).to receive(:find_server).with('kontena-master-2').and_return(true)
-      expect(subject.config).to receive(:find_server).with('kontena-master-3').and_return(nil)
-      subject.update_server_name(server, response.reject{|k,v| k=='server'})
-      expect(server.name).to eq 'kontena-master-3'
+    it 'should exit with error if response has error' do
+      expect(subject).to receive(:exit_with_error).and_throw(:exit_with_error)
+      subject.update_server_token(server, "error" => "abcd")
     end
 
+    it 'should update the token if all is good' do
+      subject.update_server_token(server, 'access_token' => 'abcd1234', 'refresh_token' => 'defg', 'expires_at' => 1234)
+      expect(server.token.access_token).to eq 'abcd1234'
+      expect(server.token.refresh_token).to eq 'defg'
+      expect(server.token.expires_at).to eq 1234
+    end
   end
 
+  describe '#update_server_name' do
+    let(:server) { Kontena::Cli::Config::Server.new(url: 'https://foo', name: nil) }
+
+    it 'should use a default name if response has no name' do
+      subject.update_server_name(server, "foo" => "foofoo")
+      expect(server.name).to eq 'kontena-master'
+    end
+
+    it 'should not mess with the server name if it already has one' do
+      server.name = 'foofoo'
+      subject.update_server_name(server, "server" => { "name" => "barbar" })
+      expect(server.name).to eq 'foofoo'
+    end
+  end
 end