lex-identity 0.3.0 → 0.4.0

data/spec/legion/extensions/identity/helpers/dimensions_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Identity::Helpers::Dimensions do
+  describe '.new_identity_model' do
+    it 'creates a model with 6 dimensions' do
+      model = described_class.new_identity_model
+      expect(model.size).to eq(6)
+      described_class::IDENTITY_DIMENSIONS.each do |dim|
+        expect(model[dim][:mean]).to eq(0.5)
+      end
+    end
+  end
+
+  describe '.compute_entropy' do
+    it 'returns 0.5 for empty observations' do
+      model = described_class.new_identity_model
+      expect(described_class.compute_entropy({}, model)).to eq(0.5)
+    end
+
+    it 'returns low entropy for observations matching baseline' do
+      model = described_class.new_identity_model
+      model[:communication_cadence][:observations] = 50
+      obs = { communication_cadence: 0.5 }
+      entropy = described_class.compute_entropy(obs, model)
+      expect(entropy).to be < 0.3
+    end
+
+    it 'returns high entropy for observations diverging from baseline' do
+      model = described_class.new_identity_model
+      model[:communication_cadence][:observations] = 50
+      model[:communication_cadence][:variance] = 0.1
+      obs = { communication_cadence: 1.0 }
+      entropy = described_class.compute_entropy(obs, model)
+      expect(entropy).to be > 0.3
+    end
+  end
+
+  describe '.classify_entropy' do
+    it 'classifies high entropy' do
+      expect(described_class.classify_entropy(0.8)).to eq(:high_entropy)
+    end
+
+    it 'classifies low entropy' do
+      expect(described_class.classify_entropy(0.1)).to eq(:low_entropy)
+    end
+
+    it 'classifies normal entropy' do
+      expect(described_class.classify_entropy(0.5)).to eq(:normal)
+    end
+  end
+end

data/spec/legion/extensions/identity/helpers/fingerprint_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Identity::Helpers::Fingerprint do
+  let(:fp) { described_class.new }
+
+  describe '#observe' do
+    it 'records observation for valid dimension' do
+      fp.observe(:communication_cadence, 0.7)
+      expect(fp.observation_count).to eq(1)
+    end
+
+    it 'ignores invalid dimensions' do
+      fp.observe(:nonexistent, 0.5)
+      expect(fp.observation_count).to eq(0)
+    end
+
+    it 'shifts mean toward observed values' do
+      original = fp.model[:vocabulary_patterns][:mean]
+      10.times { fp.observe(:vocabulary_patterns, 0.9) }
+      expect(fp.model[:vocabulary_patterns][:mean]).to be > original
+    end
+  end
+
+  describe '#observe_all' do
+    it 'records multiple dimensions at once' do
+      fp.observe_all(communication_cadence: 0.6, vocabulary_patterns: 0.7)
+      expect(fp.observation_count).to eq(2)
+    end
+  end
+
+  describe '#current_entropy' do
+    it 'computes entropy against model' do
+      entropy = fp.current_entropy(communication_cadence: 0.5)
+      expect(entropy).to be_between(0.0, 1.0)
+    end
+
+    it 'tracks entropy history' do
+      3.times { fp.current_entropy(communication_cadence: 0.5) }
+      expect(fp.entropy_history.size).to eq(3)
+    end
+  end
+
+  describe '#entropy_trend' do
+    it 'returns stable for insufficient data' do
+      expect(fp.entropy_trend).to eq(:stable)
+    end
+
+    it 'detects rising entropy' do
+      5.times { |i| fp.current_entropy(communication_cadence: 0.5 + (i * 0.1)) }
+      # Trend depends on actual computed values
+      trend = fp.entropy_trend(window: 5)
+      expect(%i[rising stable falling]).to include(trend)
+    end
+  end
+
+  describe '#maturity' do
+    it 'starts as nascent' do
+      expect(fp.maturity).to eq(:nascent)
+    end
+
+    it 'progresses to developing' do
+      15.times { fp.observe(:communication_cadence, 0.5) }
+      expect(fp.maturity).to eq(:developing)
+    end
+  end
+end

data/spec/legion/extensions/identity/helpers/graph_client_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/identity/helpers/graph_client'
+
+RSpec.describe Legion::Extensions::Identity::Helpers::GraphClient do
+  describe '.connection' do
+    it 'returns a Faraday connection with bearer token' do
+      conn = described_class.connection(token: 'test-token')
+      expect(conn).to be_a(Faraday::Connection)
+      expect(conn.headers['Authorization']).to eq('Bearer test-token')
+    end
+
+    it 'uses custom base URL when provided' do
+      conn = described_class.connection(token: 'tok', base: 'https://custom.api.com')
+      expect(conn.url_prefix.to_s).to eq('https://custom.api.com/')
+    end
+  end
+end

data/spec/legion/extensions/identity/helpers/graph_token_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/identity/helpers/graph_token'
+
+RSpec.describe Legion::Extensions::Identity::Helpers::GraphToken do
+  describe '.fetch' do
+    it 'raises GraphTokenError on failure' do
+      stub_request = instance_double(Faraday::Response, success?: false,
+                                                        body:     { 'error_description' => 'invalid_client' })
+      conn = instance_double(Faraday::Connection)
+      allow(conn).to receive(:post).and_return(stub_request)
+      allow(Faraday).to receive(:new).and_return(conn)
+
+      expect do
+        described_class.fetch(tenant_id: 't1', client_id: 'c1', client_secret: 's1')
+      end.to raise_error(described_class::GraphTokenError, 'invalid_client')
+    end
+
+    it 'returns access_token on success' do
+      stub_request = instance_double(Faraday::Response, success?: true,
+                                                        body:     { 'access_token' => 'tok-123' })
+      conn = instance_double(Faraday::Connection)
+      allow(conn).to receive(:post).and_return(stub_request)
+      allow(Faraday).to receive(:new).and_return(conn)
+
+      token = described_class.fetch(tenant_id: 't1', client_id: 'c1', client_secret: 's1')
+      expect(token).to eq('tok-123')
+    end
+  end
+end

data/spec/legion/extensions/identity/helpers/token_cache_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/identity/helpers/token_cache'
+
+RSpec.describe Legion::Extensions::Identity::Helpers::TokenCache do
+  before { described_class.clear_all }
+  after { described_class.clear_all }
+
+  describe '.store and .fetch' do
+    it 'stores and retrieves a token' do
+      described_class.store(worker_id: 'w1', token: 'abc', expires_in: 3600)
+      entry = described_class.fetch(worker_id: 'w1')
+      expect(entry[:access_token]).to eq('abc')
+    end
+
+    it 'returns nil for unknown worker' do
+      expect(described_class.fetch(worker_id: 'unknown')).to be_nil
+    end
+
+    it 'returns nil for expired token' do
+      described_class.store(worker_id: 'w1', token: 'abc', expires_in: -1)
+      expect(described_class.fetch(worker_id: 'w1')).to be_nil
+    end
+  end
+
+  describe '.approaching_expiry?' do
+    it 'returns true when no token exists' do
+      expect(described_class.approaching_expiry?(worker_id: 'w1')).to be true
+    end
+
+    it 'returns true when token is within buffer' do
+      described_class.store(worker_id: 'w1', token: 'abc', expires_in: 100)
+      expect(described_class.approaching_expiry?(worker_id: 'w1', buffer: 200)).to be true
+    end
+
+    it 'returns false when token has plenty of time' do
+      described_class.store(worker_id: 'w1', token: 'abc', expires_in: 3600)
+      expect(described_class.approaching_expiry?(worker_id: 'w1', buffer: 300)).to be false
+    end
+  end
+
+  describe '.clear' do
+    it 'removes a specific worker token' do
+      described_class.store(worker_id: 'w1', token: 'abc', expires_in: 3600)
+      described_class.clear(worker_id: 'w1')
+      expect(described_class.fetch(worker_id: 'w1')).to be_nil
+    end
+  end
+end