rkerberos 0.2.3 → 0.3.1

data/spec/config_spec.rb

@@ -11,6 +11,47 @@ RSpec.describe 'Kerberos::Kadm5::Config', :kadm5 do
     expect(config).to be_frozen
   end
 
+  describe 'constructor' do
+    it 'can be called with no arguments' do
+      expect { klass.new }.not_to raise_error
+    end
+
+    it 'accepts a context option' do
+      ctx = Kerberos::Krb5::Context.new
+      expect { klass.new(context: ctx) }.not_to raise_error
+    end
+
+    it 'returns same realm with or without context' do
+      ctx = Kerberos::Krb5::Context.new
+      c1 = klass.new
+      c2 = klass.new(context: ctx)
+      expect(c2.realm).to eq(c1.realm)
+    end
+
+    it 'releases its context lease after copying the configuration' do
+      ctx = Kerberos::Krb5::Context.new
+      config = klass.new(context: ctx)
+
+      expect { ctx.close }.not_to raise_error
+      expect(config.realm).to be_a(String)
+    end
+
+    it 'raises TypeError for non-Context context argument' do
+      expect { klass.new(context: "bad") }.to raise_error(TypeError)
+    end
+
+    it 'raises error for a closed context' do
+      ctx = Kerberos::Krb5::Context.new
+      ctx.close
+      expect { klass.new(context: ctx) }.to raise_error(Kerberos::Krb5::Exception)
+    end
+
+    it 'rejects positional option hashes and unknown keywords' do
+      expect { klass.new({context: nil}) }.to raise_error(ArgumentError)
+      expect { klass.new(unknown: true) }.to raise_error(ArgumentError, /unknown keyword/)
+    end
+  end
+
   describe 'realm' do
     it 'responds to realm' do
       expect(config).to respond_to(:realm)

data/spec/context_spec.rb

@@ -16,6 +16,51 @@ RSpec.describe Kerberos::Krb5::Context do
     it 'can be called multiple times without error' do
       expect { 3.times { context.close } }.not_to raise_error
     end
+
+    it 'raises while a dependent wrapper remains open' do
+      krb5 = Kerberos::Krb5.new(context: context)
+
+      expect { context.close }
+        .to raise_error(Kerberos::Krb5::Exception, /1 dependent wrapper/)
+      expect(context.default_realm).to be_a(String)
+
+      krb5.close
+      expect { context.close }.not_to raise_error
+    end
+
+    it 'tracks multiple dependent wrappers independently' do
+      first = Kerberos::Krb5.new(context: context)
+      second = Kerberos::Krb5::Principal.new(name: 'user', context: context)
+
+      expect { context.close }
+        .to raise_error(Kerberos::Krb5::Exception, /2 dependent wrappers/)
+
+      first.close
+      expect { context.close }
+        .to raise_error(Kerberos::Krb5::Exception, /1 dependent wrapper/)
+
+      second.close
+      expect { context.close }.not_to raise_error
+    end
+
+    it 'supports a forced logical close with deferred native cleanup' do
+      krb5 = Kerberos::Krb5.new(context: context)
+      realm = krb5.default_realm
+
+      expect(context.close(force: true)).to equal(context)
+      expect { context.default_realm }.to raise_error(Kerberos::Krb5::Exception)
+      expect { Kerberos::Krb5.new(context: context) }
+        .to raise_error(Kerberos::Krb5::Exception, /context is closed/)
+      expect(krb5.default_realm).to eq(realm)
+
+      expect { krb5.close }.not_to raise_error
+      expect { context.close }.not_to raise_error
+    end
+
+    it 'requires close options to be keywords and rejects unknown keywords' do
+      expect { context.close({force: true}) }.to raise_error(ArgumentError)
+      expect { context.close(unknown: true) }.to raise_error(ArgumentError, /unknown keyword/)
+    end
   end
 
   describe 'constructor options' do
@@ -51,6 +96,57 @@ RSpec.describe Kerberos::Krb5::Context do
       expect(ctx).to be_a(described_class)
       expect { ctx.close }.not_to raise_error
     end
+
+    it 'rejects positional option hashes and unknown keywords' do
+      expect { described_class.new({secure: true}) }.to raise_error(ArgumentError)
+      expect { described_class.new(unknown: true) }.to raise_error(ArgumentError, /unknown keyword/)
+    end
+  end
+
+  describe '#default_realm' do
+    it 'responds to default_realm' do
+      expect(context).to respond_to(:default_realm)
+    end
+
+    it 'returns a string' do
+      expect(context.default_realm).to be_a(String)
+    end
+
+    it 'returns a non-empty realm' do
+      expect(context.default_realm.size).to be > 0
+    end
+
+    it 'raises when context is closed' do
+      context.close
+      expect { context.default_realm }.to raise_error(Kerberos::Krb5::Exception)
+    end
+  end
+
+  describe '#default_realm=' do
+    it 'responds to default_realm=' do
+      expect(context).to respond_to(:default_realm=)
+    end
+
+    it 'can set and read back a custom realm' do
+      context.default_realm = 'TEST.REALM'
+      expect(context.default_realm).to eq('TEST.REALM')
+    end
+
+    it 'accepts nil to reset to the default' do
+      original = context.default_realm
+      context.default_realm = 'TEMP.REALM'
+      context.default_realm = nil
+      expect(context.default_realm).to eq(original)
+    end
+
+    it 'raises TypeError for non-string argument' do
+      expect { context.default_realm = 123 }.to raise_error(TypeError)
+    end
+
+    it 'raises when context is closed' do
+      context.close
+      expect { context.default_realm = 'X' }.to raise_error(Kerberos::Krb5::Exception)
+    end
   end
 
   after(:each) do

data/spec/credentials_cache_spec.rb

@@ -36,43 +36,77 @@ RSpec.describe Kerberos::Krb5::CredentialsCache do
     end
 
     it 'creates a cache with a principal' do
-      expect { described_class.new(princ) }.not_to raise_error
+      expect { described_class.new(principal: princ) }.not_to raise_error
       expect(File.exist?(cfile)).to be true
       expect(cache_found?).to be true
     end
 
     it 'accepts an explicit cache name' do
-      expect { described_class.new(princ, cfile) }.not_to raise_error
-      expect { described_class.new(nil, cfile) }.not_to raise_error
+      expect { described_class.new(principal: princ, cache_name: cfile) }.not_to raise_error
+      expect { described_class.new(cache_name: cfile) }.not_to raise_error
     end
 
-    it 'raises error for non-string argument' do
-      expect { described_class.new(true) }.to raise_error(TypeError)
+    it 'raises error for non-string principal' do
+      expect { described_class.new(principal: true) }.to raise_error(TypeError)
     end
 
-    it 'accepts only up to two arguments' do
-      expect { described_class.new(princ, cfile, cfile) }.to raise_error(ArgumentError)
+    it 'accepts Principal objects (duck-typed as #principal)' do
+      obj = Kerberos::Krb5::Principal.new(name: princ)
+      expect { described_class.new(principal: obj) }.not_to raise_error
+      expect(described_class.new(principal: obj).primary_principal).to eq(princ)
+    end
+
+    it 'raises error for positional arguments' do
+      expect { described_class.new(princ) }.to raise_error(ArgumentError)
+    end
+
+    it 'rejects unknown keywords' do
+      expect { described_class.new(unknown: true) }.to raise_error(ArgumentError, /unknown keyword/)
+    end
+
+    it 'accepts a context option' do
+      ctx = Kerberos::Krb5::Context.new
+      expect { described_class.new(principal: princ, context: ctx) }.not_to raise_error
+    end
+
+    it 'uses the context when provided' do
+      ctx = Kerberos::Krb5::Context.new
+      c = described_class.new(principal: princ, context: ctx)
+      expect(c.primary_principal).to eq(princ)
+      expect { ctx.close }.to raise_error(Kerberos::Krb5::Exception, /dependent wrapper/)
+      c.close
+      expect { ctx.close }.not_to raise_error
+    end
+
+    it 'raises TypeError for non-Context context argument' do
+      expect { described_class.new(context: "bad") }.to raise_error(TypeError)
+    end
+
+    it 'raises error for a closed context' do
+      ctx = Kerberos::Krb5::Context.new
+      ctx.close
+      expect { described_class.new(context: ctx) }.to raise_error(Kerberos::Krb5::Exception)
     end
   end
 
   describe '#close' do
     it 'responds to close' do
-      expect(described_class.new(princ)).to respond_to(:close)
+      expect(described_class.new(principal: princ)).to respond_to(:close)
     end
 
     it 'does not delete credentials cache' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect { c.close }.not_to raise_error
       expect(cache_found?).to be true
     end
 
     it 'can be called multiple times without error' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect { 3.times { c.close } }.not_to raise_error
     end
 
     it 'raises error when calling method on closed object' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       c.close
       expect { c.default_name }.to raise_error(Kerberos::Krb5::Exception)
     end
@@ -80,20 +114,20 @@ RSpec.describe Kerberos::Krb5::CredentialsCache do
 
   describe '#default_name' do
     it 'responds to default_name' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect(c).to respond_to(:default_name)
       expect { c.default_name }.not_to raise_error
     end
 
     it 'returns a string' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect(c.default_name).to be_a(String)
     end
   end
 
   describe '#cache_name and #cache_type' do
     it 'returns the ccache name and type' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect(c).to respond_to(:cache_name)
       expect(c).to respond_to(:cache_type)
 
@@ -108,7 +142,7 @@ RSpec.describe Kerberos::Krb5::CredentialsCache do
 
   describe '#principal' do
     it 'is an alias for primary_principal' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect(c).to respond_to(:principal)
       expect(c.principal).to eq(c.primary_principal)
     end
@@ -116,13 +150,13 @@ RSpec.describe Kerberos::Krb5::CredentialsCache do
 
   describe '#primary_principal' do
     it 'responds to primary_principal' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect(c).to respond_to(:primary_principal)
       expect { c.primary_principal }.not_to raise_error
     end
 
     it 'returns expected results' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect(c.primary_principal).to be_a(String)
       expect(c.primary_principal.size).to be > 0
       expect(c.primary_principal).to include('@')
@@ -131,18 +165,18 @@ RSpec.describe Kerberos::Krb5::CredentialsCache do
 
   describe '#destroy' do
     it 'responds to destroy' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect(c).to respond_to(:destroy)
     end
 
     it 'deletes credentials cache' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect { c.destroy }.not_to raise_error
       expect(cache_found?).to be false
     end
 
     it 'delete is an alias for destroy' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect(c).to respond_to(:delete)
       expect(c.method(:delete)).to eq(c.method(:destroy))
     end
@@ -153,20 +187,20 @@ RSpec.describe Kerberos::Krb5::CredentialsCache do
     end
 
     it 'raises error when calling method on destroyed object' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       c.destroy
       expect { c.default_name }.to raise_error(Kerberos::Krb5::Exception)
     end
 
     it 'does not accept arguments' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       expect { c.destroy(true) }.to raise_error(ArgumentError)
     end
   end
 
   describe '#dup' do
     it 'returns a new cache object with the same properties' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       c2 = c.dup
       expect(c2).to be_a(described_class)
       expect(c2.default_name).to eq(c.default_name)
@@ -174,23 +208,45 @@ RSpec.describe Kerberos::Krb5::CredentialsCache do
     end
 
     it 'closing original does not affect duplicate' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       c2 = c.dup
       c.close
       expect { c2.default_name }.not_to raise_error
     end
 
     it 'closing duplicate does not affect original' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       c2 = c.dup
       c2.close
       expect { c.default_name }.not_to raise_error
     end
 
     it 'raises when duping closed cache' do
-      c = described_class.new(princ)
+      c = described_class.new(principal: princ)
       c.close
       expect { c.dup }.to raise_error(Kerberos::Krb5::Exception)
     end
   end
+
+  describe '#full_name' do
+    it 'returns a string including the type prefix' do
+      cc = described_class.new(principal: princ)
+      name = cc.full_name
+      expect(name).to be_a(String)
+      expect(name).to match(/\A\w+:/)
+      cc.close
+    end
+
+    it 'includes FILE: for a file-based cache' do
+      cc = described_class.new(principal: princ, cache_name: cfile)
+      expect(cc.full_name).to start_with('FILE:')
+      cc.close
+    end
+
+    it 'raises when the context is closed' do
+      cc = described_class.new(principal: princ)
+      cc.close
+      expect { cc.full_name }.to raise_error(Kerberos::Krb5::Exception)
+    end
+  end
 end