3rdparty/modules/openstacklib/spec/unit/provider/openstack/auth_spec.rb

   1 require 'puppet'
   2 require 'spec_helper'
   3 require 'puppet/provider/openstack'
   4 require 'puppet/provider/openstack/auth'
   5 require 'tempfile'
   6
   7 class Puppet::Provider::Openstack::AuthTester < Puppet::Provider::Openstack
   8   extend Puppet::Provider::Openstack::Auth
   9 end
  10
  11 klass = Puppet::Provider::Openstack::AuthTester
  12
  13 describe Puppet::Provider::Openstack::Auth do
  14
  15   let(:type) do
  16     Puppet::Type.newtype(:test_resource) do
  17       newparam(:name, :namevar => true)
  18       newparam(:log_file)
  19     end
  20   end
  21
  22   let(:resource_attrs) do
  23     {
  24       :name => 'stubresource'
  25     }
  26   end
  27
  28   let(:provider) do
  29     klass.new(type.new(resource_attrs))
  30   end
  31
  32   before(:each) do
  33     ENV['OS_USERNAME']     = nil
  34     ENV['OS_PASSWORD']     = nil
  35     ENV['OS_PROJECT_NAME'] = nil
  36     ENV['OS_AUTH_URL']     = nil
  37     ENV['OS_TOKEN']        = nil
  38     ENV['OS_URL']          = nil
  39   end
  40
  41   describe '#set_credentials' do
  42     it 'adds keys to the object' do
  43       credentials = Puppet::Provider::Openstack::CredentialsV2_0.new
  44       set = { 'OS_USERNAME'             => 'user',
  45               'OS_PASSWORD'             => 'secret',
  46               'OS_PROJECT_NAME'         => 'tenant',
  47               'OS_AUTH_URL'             => 'http://127.0.0.1:5000',
  48               'OS_TOKEN'                => 'token',
  49               'OS_URL'                  => 'http://127.0.0.1:35357',
  50               'OS_IDENTITY_API_VERSION' => '2.0',
  51               'OS_NOT_VALID'            => 'notvalid'
  52         }
  53       klass.set_credentials(credentials, set)
  54       expect(credentials.to_env).to eq(
  55         "OS_AUTH_URL"             => "http://127.0.0.1:5000",
  56         "OS_IDENTITY_API_VERSION" => '2.0',
  57         "OS_PASSWORD"             => "secret",
  58         "OS_PROJECT_NAME"         => "tenant",
  59         "OS_TOKEN"                => "token",
  60         "OS_URL"                  => "http://127.0.0.1:35357",
  61         "OS_USERNAME"             => "user")
  62     end
  63   end
  64
  65   describe '#rc_filename' do
  66     it 'returns RCFILENAME' do
  67       expect(klass.rc_filename).to eq("#{ENV['HOME']}/openrc")
  68     end
  69   end
  70
  71   describe '#get_os_from_env' do
  72     context 'with Openstack environment variables set' do
  73       it 'provides a hash' do
  74         ENV['OS_AUTH_URL']     = 'http://127.0.0.1:5000'
  75         ENV['OS_PASSWORD']     = 'abc123'
  76         ENV['OS_PROJECT_NAME'] = 'test'
  77         ENV['OS_USERNAME']     = 'test'
  78         response = klass.get_os_vars_from_env
  79         expect(response).to eq({
  80           "OS_AUTH_URL"     => "http://127.0.0.1:5000",
  81           "OS_PASSWORD"     => "abc123",
  82           "OS_PROJECT_NAME" => "test",
  83           "OS_USERNAME"     => "test"})
  84       end
  85     end
  86   end
  87
  88   describe '#get_os_vars_from_rcfile' do
  89     context 'with a valid RC file' do
  90       it 'provides a hash' do
  91         mock = "export OS_USERNAME='test'\nexport OS_PASSWORD='abc123'\nexport OS_PROJECT_NAME='test'\nexport OS_AUTH_URL='http://127.0.0.1:5000'"
  92         filename = 'file'
  93         File.expects(:exists?).with('file').returns(true)
  94         File.expects(:open).with('file').returns(StringIO.new(mock))
  95
  96         response = klass.get_os_vars_from_rcfile(filename)
  97         expect(response).to eq({
  98           "OS_AUTH_URL"     => "http://127.0.0.1:5000",
  99           "OS_PASSWORD"     => "abc123",
 100           "OS_PROJECT_NAME" => "test",
 101           "OS_USERNAME"     => "test"})
 102       end
 103     end
 104
 105     context 'with an empty file' do
 106       it 'provides an empty hash' do
 107         filename = 'file'
 108         File.expects(:exists?).with(filename).returns(true)
 109         File.expects(:open).with(filename).returns(StringIO.new(""))
 110
 111         response = klass.get_os_vars_from_rcfile(filename)
 112         expect(response).to eq({})
 113       end
 114     end
 115   end
 116
 117   before(:each) do
 118     class Puppet::Provider::Openstack::AuthTester
 119       @credentials =  Puppet::Provider::Openstack::CredentialsV2_0.new
 120     end
 121   end
 122
 123   describe '#request' do
 124     context 'with no valid credentials' do
 125       it 'fails to authenticate' do
 126         expect { klass.request('project', 'list', ['--long']) }.to raise_error(Puppet::Error::OpenstackAuthInputError, "Insufficient credentials to authenticate")
 127         expect(klass.instance_variable_get(:@credentials).to_env).to eq({})
 128       end
 129     end
 130
 131     context 'with user credentials in env' do
 132       it 'is successful' do
 133         klass.expects(:get_os_vars_from_env)
 134              .returns({ 'OS_USERNAME'     => 'test',
 135                         'OS_PASSWORD'     => 'abc123',
 136                         'OS_PROJECT_NAME' => 'test',
 137                         'OS_AUTH_URL'     => 'http://127.0.0.1:5000',
 138                         'OS_NOT_VALID'    => 'notvalid' })
 139         klass.expects(:openstack)
 140              .with('project', 'list', '--quiet', '--format', 'csv', ['--long'])
 141              .returns('"ID","Name","Description","Enabled"
 142 "1cb05cfed7c24279be884ba4f6520262","test","Test tenant",True
 143 ')
 144         response = klass.request('project', 'list', ['--long'])
 145         expect(response.first[:description]).to eq("Test tenant")
 146         expect(klass.instance_variable_get(:@credentials).to_env).to eq({
 147           'OS_USERNAME'     => 'test',
 148           'OS_PASSWORD'     => 'abc123',
 149           'OS_PROJECT_NAME' => 'test',
 150           'OS_AUTH_URL'     => 'http://127.0.0.1:5000'
 151         })
 152       end
 153     end
 154
 155     context 'with service token credentials in env' do
 156       it 'is successful' do
 157         klass.expects(:get_os_vars_from_env)
 158              .returns({ 'OS_TOKEN'     => 'test',
 159                         'OS_URL'       => 'http://127.0.0.1:5000',
 160                         'OS_NOT_VALID' => 'notvalid' })
 161         klass.expects(:openstack)
 162              .with('project', 'list', '--quiet', '--format', 'csv', ['--long'])
 163              .returns('"ID","Name","Description","Enabled"
 164 "1cb05cfed7c24279be884ba4f6520262","test","Test tenant",True
 165 ')
 166         response = klass.request('project', 'list', ['--long'])
 167         expect(response.first[:description]).to eq("Test tenant")
 168         expect(klass.instance_variable_get(:@credentials).to_env).to eq({
 169           'OS_TOKEN' => 'test',
 170           'OS_URL'   => 'http://127.0.0.1:5000',
 171         })
 172       end
 173     end
 174
 175     context 'with a RC file containing user credentials' do
 176       it 'is successful' do
 177         # return incomplete creds from env
 178         klass.expects(:get_os_vars_from_env)
 179              .returns({ 'OS_USERNAME' => 'incompleteusername',
 180                         'OS_AUTH_URL' => 'incompleteauthurl' })
 181         mock = "export OS_USERNAME='test'\nexport OS_PASSWORD='abc123'\nexport OS_PROJECT_NAME='test'\nexport OS_AUTH_URL='http://127.0.0.1:5000'\nexport OS_NOT_VALID='notvalid'"
 182         File.expects(:exists?).with("#{ENV['HOME']}/openrc").returns(true)
 183         File.expects(:open).with("#{ENV['HOME']}/openrc").returns(StringIO.new(mock))
 184         klass.expects(:openstack)
 185              .with('project', 'list', '--quiet', '--format', 'csv', ['--long'])
 186              .returns('"ID","Name","Description","Enabled"
 187 "1cb05cfed7c24279be884ba4f6520262","test","Test tenant",True
 188 ')
 189         response = provider.class.request('project', 'list', ['--long'])
 190         expect(response.first[:description]).to eq("Test tenant")
 191         expect(klass.instance_variable_get(:@credentials).to_env).to eq({
 192           'OS_USERNAME'     => 'test',
 193           'OS_PASSWORD'     => 'abc123',
 194           'OS_PROJECT_NAME' => 'test',
 195           'OS_AUTH_URL'     => 'http://127.0.0.1:5000'
 196         })
 197       end
 198     end
 199
 200     context 'with a RC file containing service token credentials' do
 201       it 'is successful' do
 202         # return incomplete creds from env
 203         klass.expects(:get_os_vars_from_env)
 204              .returns({ 'OS_TOKEN' => 'incomplete' })
 205         mock = "export OS_TOKEN='test'\nexport OS_URL='abc123'\nexport OS_NOT_VALID='notvalid'\n"
 206         File.expects(:exists?).with("#{ENV['HOME']}/openrc").returns(true)
 207         File.expects(:open).with("#{ENV['HOME']}/openrc").returns(StringIO.new(mock))
 208         klass.expects(:openstack)
 209              .with('project', 'list', '--quiet', '--format', 'csv', ['--long'])
 210              .returns('"ID","Name","Description","Enabled"
 211 "1cb05cfed7c24279be884ba4f6520262","test","Test tenant",True
 212 ')
 213         response = klass.request('project', 'list', ['--long'])
 214         expect(response.first[:description]).to eq("Test tenant")
 215         expect(klass.instance_variable_get(:@credentials).to_env).to eq({
 216           'OS_TOKEN' => 'test',
 217           'OS_URL'   => 'abc123',
 218         })
 219       end
 220     end
 221   end
 222 end