doorflow 1.0.1 → 1.1.0

data/spec/api/oauth_api_spec.rb

@@ -1,97 +0,0 @@
-=begin
-#DoorFlow API
-
-#Access control and door management API for DoorFlow
-
-The version of the OpenAPI document: 3.0
-
-Generated by: https://openapi-generator.tech
-Generator version: 7.18.0-SNAPSHOT
-
-=end
-
-require 'spec_helper'
-require 'json'
-
-# Unit tests for DoorFlow::OauthApi
-# Automatically generated by openapi-generator (https://openapi-generator.tech)
-# Please update as you see appropriate
-describe 'OauthApi' do
-  before do
-    # run before each test
-    @api_instance = DoorFlow::OauthApi.new
-  end
-
-  after do
-    # run after each test
-  end
-
-  describe 'test an instance of OauthApi' do
-    it 'should create an instance of OauthApi' do
-      expect(@api_instance).to be_instance_of(DoorFlow::OauthApi)
-    end
-  end
-
-  # unit tests for authorize_o_auth
-  # Authorization endpoint
-  # Initiates the OAuth 2.0 authorization code flow. Direct users to this endpoint to request authorization.  **Authorization Code Flow Steps:** 1. Direct the user's browser to this endpoint with required parameters 2. User logs in (if not already authenticated) and authorizes your application 3. User is redirected to your `redirect_uri` with an authorization `code` parameter 4. Exchange the code for an access token at `/oauth/token`  **PKCE (Proof Key for Code Exchange):** For public clients (mobile/SPA applications), PKCE is recommended for security: 1. Generate a random `code_verifier` (43-128 characters) 2. Create `code_challenge` = BASE64URL(SHA256(code_verifier)) 3. Include `code_challenge` and `code_challenge_method=S256` in this request 4. Include `code_verifier` when exchanging the code at `/oauth/token`  **Important Notes:** - This is a browser-based flow - users will see a login/authorization screen - The `redirect_uri` must be pre-registered with your OAuth application - The authorization code expires after 10 minutes - Some applications may be configured to skip the authorization screen (auto-approve) 
-  # @param response_type OAuth response type (must be \"code\" for authorization code flow)
-  # @param client_id Your OAuth application's client ID
-  # @param redirect_uri URI to redirect to after authorization (must match registered redirect URI)
-  # @param scope Space-separated list of requested scopes (see available scopes in security schemes section)
-  # @param [Hash] opts the optional parameters
-  # @option opts [String] :state Opaque value to maintain state between request and callback (recommended for CSRF protection)
-  # @option opts [String] :code_challenge PKCE code challenge (BASE64URL(SHA256(code_verifier)))
-  # @option opts [String] :code_challenge_method PKCE code challenge method (must be S256)
-  # @return [nil]
-  describe 'authorize_o_auth test' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
-    end
-  end
-
-  # unit tests for get_access_token
-  # Obtain access token
-  # Exchange authorization code for an access token, or refresh an existing token.  **Authorization Code Flow:** 1. Direct users to `/oauth/authorize` with your client_id, redirect_uri, and requested scopes 2. User authorizes your application 3. You receive an authorization code at your redirect_uri 4. Exchange the code for an access token using this endpoint with `grant_type=authorization_code`  **Refreshing Tokens:** - Use `grant_type=refresh_token` with a valid refresh_token to obtain a new access token - Access tokens expire after 1 hour - Refresh tokens are long-lived and should be stored securely 
-  # @param grant_type OAuth grant type (use \\\"authorization_code\\\" to exchange an authorization code, or \\\"refresh_token\\\" to refresh an access token)
-  # @param [Hash] opts the optional parameters
-  # @option opts [String] :client_id OAuth client ID (required for all grant types)
-  # @option opts [String] :client_secret OAuth client secret (required for confidential clients)
-  # @option opts [String] :code Authorization code (required when grant_type=authorization_code)
-  # @option opts [String] :redirect_uri Redirect URI (required when grant_type=authorization_code, must match the one used in authorization request)
-  # @option opts [String] :code_verifier PKCE code verifier (required if PKCE was used in authorization request)
-  # @option opts [String] :refresh_token Refresh token (required when grant_type=refresh_token)
-  # @option opts [String] :scope Space-separated list of requested scopes (optional, defaults to application's configured scopes)
-  # @return [GetAccessToken200Response]
-  describe 'get_access_token test' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
-    end
-  end
-
-  # unit tests for get_token_info
-  # Get token information
-  # Returns information about the current access token being used for authentication.  This endpoint provides metadata about the access token including the resource owner, account, scopes, and expiration.  **Authentication:** Requires a valid OAuth2 access token in the Authorization header. 
-  # @param [Hash] opts the optional parameters
-  # @return [GetTokenInfo200Response]
-  describe 'get_token_info test' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
-    end
-  end
-
-  # unit tests for revoke_token
-  # Revoke access token or refresh token
-  # Revokes an access token or refresh token, immediately invalidating it and blocking associated tokens from making further requests.  **When to revoke:** - User disconnects their DoorFlow account from your integration - User logs out - Security breach - revoke compromised tokens - Application uninstall  **Important:** - **We recommend revoking the refresh_token** - this will invalidate all associated access tokens - Returns HTTP 200 even if the token was already invalid (prevents token scanning attacks) - Client authentication is required via HTTP Basic Auth header  **Authentication:** You must authenticate using HTTP Basic Authentication with your client credentials: 1. Combine your client_id and client_secret as: `{client_id}:{client_secret}` 2. Encode using URL-safe Base64 3. Include in Authorization header: `Authorization: Basic {encoded_credentials}` 
-  # @param authorization HTTP Basic Authentication using client_id:client_secret encoded with URL-safe Base64
-  # @param token The access token or refresh token to revoke (we recommend using refresh_token)
-  # @param [Hash] opts the optional parameters
-  # @option opts [String] :token_type_hint Optional hint about the type of token being revoked. We recommend using 'refresh_token' for all revocations as it invalidates all associated tokens. Invalid token type hint values are ignored and do not affect the revocation response. 
-  # @return [Object]
-  describe 'revoke_token test' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
-    end
-  end
-
-end

data/spec/doorflow/client_spec.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe DoorFlow::Client do
-  describe 'resource instance methods use instance client' do
-    it 'Person#update uses the instance client, not class-level client' do
-      # Create a mock people_api
-      people_api = double('people_api')
-      allow(people_api).to receive(:update_person).and_return(
-        double('response', to_hash: { 'id' => 123, 'first_name' => 'Updated' })
-      )
-
-      # Create a client with the mock
-      auth = double('auth', access_token: 'instance_token', authenticated?: true)
-      client = DoorFlow::Client.new(auth: auth)
-      allow(client).to receive(:people_api).and_return(people_api)
-
-      # Create a person as if retrieved via client.people.retrieve
-      person = DoorFlow::Resources::Person.new({ 'id' => 123, 'first_name' => 'Test' })
-      person.instance_variable_set(:@_client, client)
-
-      # Call update - this should use the instance client's people_api
-      person.update(first_name: 'Updated')
-
-      # Verify the instance client's people_api was called, not class-level
-      expect(people_api).to have_received(:update_person).with(123, { first_name: 'Updated' })
-    end
-  end
-
-
-  describe '#access_token' do
-    context 'with an auth object' do
-      it 'delegates to auth.access_token' do
-        auth = double('auth', access_token: 'token_from_auth')
-        client = DoorFlow::Client.new(auth: auth)
-
-        expect(client.access_token).to eq('token_from_auth')
-      end
-    end
-
-    context 'with a static access token' do
-      it 'returns the static token' do
-        client = DoorFlow::Client.new(access_token: 'static_token')
-
-        expect(client.access_token).to eq('static_token')
-      end
-    end
-  end
-
-  describe '#authenticated?' do
-    context 'with an auth object that responds to authenticated?' do
-      it 'delegates to auth.authenticated?' do
-        auth = double('auth', authenticated?: true)
-        client = DoorFlow::Client.new(auth: auth)
-
-        expect(client.authenticated?).to be true
-      end
-    end
-
-    context 'with a static access token' do
-      it 'returns true when token is present' do
-        client = DoorFlow::Client.new(access_token: 'token')
-        # The SDK uses .present? which requires ActiveSupport
-        # In non-Rails context, we just check if it doesn't raise
-        expect { client.authenticated? }.not_to raise_error
-      end
-
-      it 'returns false when token is nil' do
-        client = DoorFlow::Client.new(access_token: nil)
-
-        expect(client.authenticated?).to be false
-      end
-    end
-  end
-
-  describe 'dynamic token refresh' do
-    it 'fetches fresh token on each API call, not cached at client creation' do
-      call_count = 0
-      tokens = ['first_token', 'refreshed_token']
-
-      # Auth object that returns different tokens on each call (simulating refresh)
-      auth = double('auth')
-      allow(auth).to receive(:access_token) do
-        token = tokens[call_count] || tokens.last
-        call_count += 1
-        token
-      end
-      allow(auth).to receive(:authenticated?).and_return(true)
-
-      client = DoorFlow::Client.new(auth: auth)
-
-      # Access the api_client to trigger config setup
-      api_client = client.send(:api_client)
-      config = api_client.config
-
-      # First call should get first token
-      first_token = config.access_token_with_refresh
-      expect(first_token).to eq('first_token')
-
-      # Second call should get refreshed token (not cached first token)
-      second_token = config.access_token_with_refresh
-      expect(second_token).to eq('refreshed_token')
-
-      # Verify auth.access_token was called multiple times
-      expect(call_count).to be >= 2
-    end
-  end
-end

data/spec/doorflow/webhooks/event_spec.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe DoorFlow::Webhooks::Event do
-  let(:event_data) do
-    {
-      action: 'CREATE',
-      resource: 'https://api.doorflow.com/api/v1/accounts/1/events/42',
-      resource_type: 'Event',
-      resource_id: 42,
-      account_id: 1,
-      ack_token: 'abc123'
-    }
-  end
-
-  subject(:event) { described_class.new(event_data) }
-
-  describe '#initialize' do
-    it 'sets all attributes from the data hash' do
-      expect(event.action).to eq('CREATE')
-      expect(event.resource_url).to eq('https://api.doorflow.com/api/v1/accounts/1/events/42')
-      expect(event.resource_type).to eq('Event')
-      expect(event.resource_id).to eq('42')
-      expect(event.account_id).to eq(1)
-      expect(event.ack_token).to eq('abc123')
-    end
-
-    it 'converts resource_id to string' do
-      expect(event.resource_id).to be_a(String)
-    end
-
-    it 'handles nil resource_id' do
-      data = event_data.merge(resource_id: nil)
-      event = described_class.new(data)
-      expect(event.resource_id).to be_nil
-    end
-  end
-
-  describe '#pattern' do
-    it 'returns ResourceType.ACTION format' do
-      expect(event.pattern).to eq('Event.CREATE')
-    end
-
-    it 'handles different resource types' do
-      data = event_data.merge(resource_type: 'PersonCredential', action: 'UPDATE')
-      event = described_class.new(data)
-      expect(event.pattern).to eq('PersonCredential.UPDATE')
-    end
-  end
-
-  describe '#create?' do
-    it 'returns true for CREATE action' do
-      expect(event.create?).to be true
-    end
-
-    it 'returns false for other actions' do
-      data = event_data.merge(action: 'DELETE')
-      expect(described_class.new(data).create?).to be false
-    end
-  end
-
-  describe '#update?' do
-    it 'returns true for UPDATE action' do
-      data = event_data.merge(action: 'UPDATE')
-      expect(described_class.new(data).update?).to be true
-    end
-
-    it 'returns false for other actions' do
-      expect(event.update?).to be false
-    end
-  end
-
-  describe '#delete?' do
-    it 'returns true for DELETE action' do
-      data = event_data.merge(action: 'DELETE')
-      expect(described_class.new(data).delete?).to be true
-    end
-
-    it 'returns false for other actions' do
-      expect(event.delete?).to be false
-    end
-  end
-
-  describe '#to_h' do
-    it 'returns a hash with all attributes' do
-      expected = {
-        action: 'CREATE',
-        resource: 'https://api.doorflow.com/api/v1/accounts/1/events/42',
-        resource_type: 'Event',
-        resource_id: '42',
-        account_id: 1,
-        ack_token: 'abc123'
-      }
-      expect(event.to_h).to eq(expected)
-    end
-
-    it 'round-trips through Event.new' do
-      reconstructed = described_class.new(event.to_h)
-      expect(reconstructed.to_h).to eq(event.to_h)
-    end
-  end
-
-  describe '#to_s' do
-    it 'includes pattern and resource_id' do
-      expect(event.to_s).to eq('Event.CREATE (42)')
-    end
-  end
-
-  describe '#inspect' do
-    it 'includes class name, pattern, and resource_id' do
-      expect(event.inspect).to include('DoorFlow::Webhooks::Event')
-      expect(event.inspect).to include('Event.CREATE')
-      expect(event.inspect).to include('42')
-    end
-  end
-end

data/spec/doorflow/webhooks/handler_spec.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require_relative 'support'
-
-RSpec.describe DoorFlow::Webhooks::Handler do
-  include WebhookSpecSupport
-
-  let(:secret) { WebhookSpecSupport::WEBHOOK_SECRET }
-  let(:timestamp) { Time.now.to_i.to_s }
-  let(:event_hash) { WebhookSpecSupport::SAMPLE_EVENT_HASH }
-  let(:payload) { JSON.generate([event_hash]) }
-
-  let(:signature) { compute_signature(timestamp, payload, secret) }
-
-  subject(:handler) { described_class.new(secret: secret) }
-
-  describe '#on' do
-    it 'returns self for method chaining' do
-      result = handler.on('Event.CREATE') { |e| }
-      expect(result).to be(handler)
-    end
-
-    it 'supports chained registrations' do
-      result = handler
-        .on('Event.CREATE') { |e| }
-        .on('Person.UPDATE') { |e| }
-        .on('*') { |e| }
-
-      expect(result).to be(handler)
-    end
-
-    it 'raises ArgumentError without a block' do
-      expect { handler.on('Event.CREATE') }.to raise_error(ArgumentError, /Block required/)
-    end
-  end
-
-  describe '#handle' do
-    it 'dispatches events to matching handlers' do
-      received = []
-      handler.on('Event.CREATE') { |event| received << event }
-
-      handler.handle(payload: payload, signature: signature, timestamp: timestamp)
-
-      expect(received.length).to eq(1)
-      expect(received.first.pattern).to eq('Event.CREATE')
-    end
-
-    it 'does not dispatch to non-matching handlers' do
-      received = []
-      handler.on('Person.UPDATE') { |event| received << event }
-
-      handler.handle(payload: payload, signature: signature, timestamp: timestamp)
-
-      expect(received).to be_empty
-    end
-
-    it 'dispatches to wildcard handler' do
-      received = []
-      handler.on('*') { |event| received << event }
-
-      handler.handle(payload: payload, signature: signature, timestamp: timestamp)
-
-      expect(received.length).to eq(1)
-    end
-
-    it 'dispatches to resource wildcard handler' do
-      received = []
-      handler.on('Event.*') { |event| received << event }
-
-      handler.handle(payload: payload, signature: signature, timestamp: timestamp)
-
-      expect(received.length).to eq(1)
-    end
-
-    it 'does not match wrong resource wildcard' do
-      received = []
-      handler.on('Person.*') { |event| received << event }
-
-      handler.handle(payload: payload, signature: signature, timestamp: timestamp)
-
-      expect(received).to be_empty
-    end
-
-    it 'dispatches to multiple matching handlers' do
-      exact = []
-      wildcard = []
-      handler.on('Event.CREATE') { |event| exact << event }
-      handler.on('*') { |event| wildcard << event }
-
-      handler.handle(payload: payload, signature: signature, timestamp: timestamp)
-
-      expect(exact.length).to eq(1)
-      expect(wildcard.length).to eq(1)
-    end
-
-    it 'returns the parsed events' do
-      events = handler.handle(payload: payload, signature: signature, timestamp: timestamp)
-
-      expect(events).to be_an(Array)
-      expect(events.length).to eq(1)
-      expect(events.first).to be_a(DoorFlow::Webhooks::Event)
-    end
-  end
-
-  describe '#handle_request' do
-    context 'with a Rails-style request' do
-      it 'extracts Signature and Timestamp headers' do
-        headers = {
-          'Signature' => signature,
-          'Timestamp' => timestamp
-        }
-        request = double('rails_request',
-          raw_post: payload,
-          headers: headers
-        )
-
-        received = []
-        handler.on('Event.CREATE') { |event| received << event }
-        handler.handle_request(request)
-
-        expect(received.length).to eq(1)
-        expect(received.first.pattern).to eq('Event.CREATE')
-      end
-    end
-
-    context 'with a Rack-style request' do
-      it 'extracts headers from the env hash' do
-        body = double('body')
-        allow(body).to receive(:read).and_return(payload)
-
-        request = double('rack_request',
-          body: body,
-          env: {
-            'HTTP_SIGNATURE' => signature,
-            'HTTP_TIMESTAMP' => timestamp
-          }
-        )
-        # Rack request doesn't respond to raw_post or headers
-        allow(request).to receive(:respond_to?).with(:raw_post).and_return(false)
-        allow(request).to receive(:respond_to?).with(:body).and_return(true)
-        allow(request).to receive(:respond_to?).with(:headers).and_return(false)
-        allow(request).to receive(:respond_to?).with(:env).and_return(true)
-
-        received = []
-        handler.on('Event.CREATE') { |event| received << event }
-        handler.handle_request(request)
-
-        expect(received.length).to eq(1)
-        expect(received.first.pattern).to eq('Event.CREATE')
-      end
-    end
-  end
-end

data/spec/doorflow/webhooks/signature_verifier_spec.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require_relative 'support'
-
-RSpec.describe DoorFlow::Webhooks::SignatureVerifier do
-  include WebhookSpecSupport
-
-  let(:secret) { WebhookSpecSupport::WEBHOOK_SECRET }
-  let(:timestamp) { Time.now.to_i.to_s }
-  let(:event_hash) { WebhookSpecSupport::SAMPLE_EVENT_HASH }
-
-  describe '.verify' do
-    context 'with a root-level array payload (documented format)' do
-      let(:payload) { JSON.generate([event_hash]) }
-      let(:signature) { compute_signature(timestamp, payload, secret) }
-
-      it 'returns an array of Event objects' do
-        events = described_class.verify(
-          payload: payload,
-          signature: signature,
-          timestamp: timestamp,
-          secret: secret
-        )
-
-        expect(events).to be_an(Array)
-        expect(events.length).to eq(1)
-        expect(events.first).to be_a(DoorFlow::Webhooks::Event)
-        expect(events.first.resource_type).to eq('Event')
-        expect(events.first.action).to eq('CREATE')
-      end
-    end
-
-    context 'with multiple events in an array' do
-      let(:second_event) do
-        {
-          action: 'UPDATE',
-          resource: 'https://api.doorflow.com/api/v1/accounts/1/people/99',
-          resource_type: 'Person',
-          resource_id: 99,
-          account_id: 1,
-          ack_token: 'def456'
-        }
-      end
-      let(:payload) { JSON.generate([event_hash, second_event]) }
-      let(:signature) { compute_signature(timestamp, payload, secret) }
-
-      it 'returns all events' do
-        events = described_class.verify(
-          payload: payload,
-          signature: signature,
-          timestamp: timestamp,
-          secret: secret
-        )
-
-        expect(events.length).to eq(2)
-        expect(events[0].pattern).to eq('Event.CREATE')
-        expect(events[1].pattern).to eq('Person.UPDATE')
-      end
-    end
-
-    context 'with a single event object payload' do
-      let(:payload) { JSON.generate(event_hash) }
-      let(:signature) { compute_signature(timestamp, payload, secret) }
-
-      it 'wraps the single event in an array' do
-        events = described_class.verify(
-          payload: payload,
-          signature: signature,
-          timestamp: timestamp,
-          secret: secret
-        )
-
-        expect(events.length).to eq(1)
-        expect(events.first.pattern).to eq('Event.CREATE')
-      end
-    end
-
-    context 'with an events-key payload (backwards compat)' do
-      let(:payload) { JSON.generate({ events: [event_hash] }) }
-      let(:signature) { compute_signature(timestamp, payload, secret) }
-
-      it 'extracts events from the events key' do
-        events = described_class.verify(
-          payload: payload,
-          signature: signature,
-          timestamp: timestamp,
-          secret: secret
-        )
-
-        expect(events.length).to eq(1)
-        expect(events.first.pattern).to eq('Event.CREATE')
-      end
-    end
-
-    context 'with an invalid signature' do
-      let(:payload) { JSON.generate([event_hash]) }
-
-      it 'raises SignatureError' do
-        expect {
-          described_class.verify(
-            payload: payload,
-            signature: 'invalid_signature_value',
-            timestamp: timestamp,
-            secret: secret
-          )
-        }.to raise_error(DoorFlow::Webhooks::SignatureError, /Signature mismatch/)
-      end
-    end
-
-    context 'with an expired timestamp' do
-      let(:old_timestamp) { (Time.now.to_i - 600).to_s }
-      let(:payload) { JSON.generate([event_hash]) }
-      let(:signature) { compute_signature(old_timestamp, payload, secret) }
-
-      it 'raises SignatureError' do
-        expect {
-          described_class.verify(
-            payload: payload,
-            signature: signature,
-            timestamp: old_timestamp,
-            secret: secret
-          )
-        }.to raise_error(DoorFlow::Webhooks::SignatureError, /too old/)
-      end
-    end
-
-    context 'with tolerance disabled' do
-      let(:old_timestamp) { (Time.now.to_i - 600).to_s }
-      let(:payload) { JSON.generate([event_hash]) }
-      let(:signature) { compute_signature(old_timestamp, payload, secret) }
-
-      it 'does not check timestamp' do
-        events = described_class.verify(
-          payload: payload,
-          signature: signature,
-          timestamp: old_timestamp,
-          secret: secret,
-          tolerance: 0
-        )
-
-        expect(events.length).to eq(1)
-      end
-    end
-
-    context 'with missing inputs' do
-      let(:payload) { JSON.generate([event_hash]) }
-      let(:signature) { compute_signature(timestamp, payload, secret) }
-
-      it 'raises SignatureError for missing payload' do
-        expect {
-          described_class.verify(payload: nil, signature: signature, timestamp: timestamp, secret: secret)
-        }.to raise_error(DoorFlow::Webhooks::SignatureError, /Missing payload/)
-      end
-
-      it 'raises SignatureError for empty payload' do
-        expect {
-          described_class.verify(payload: '', signature: signature, timestamp: timestamp, secret: secret)
-        }.to raise_error(DoorFlow::Webhooks::SignatureError, /Missing payload/)
-      end
-
-      it 'raises SignatureError for missing signature' do
-        expect {
-          described_class.verify(payload: payload, signature: nil, timestamp: timestamp, secret: secret)
-        }.to raise_error(DoorFlow::Webhooks::SignatureError, /Missing signature/)
-      end
-
-      it 'raises SignatureError for missing timestamp' do
-        expect {
-          described_class.verify(payload: payload, signature: signature, timestamp: nil, secret: secret)
-        }.to raise_error(DoorFlow::Webhooks::SignatureError, /Missing timestamp/)
-      end
-
-      it 'raises SignatureError for missing secret' do
-        expect {
-          described_class.verify(payload: payload, signature: signature, timestamp: timestamp, secret: nil)
-        }.to raise_error(DoorFlow::Webhooks::SignatureError, /Missing secret/)
-      end
-    end
-
-    context 'with malformed JSON' do
-      let(:payload) { 'not valid json{{{' }
-      let(:signature) { compute_signature(timestamp, payload, secret) }
-
-      it 'raises SignatureError' do
-        expect {
-          described_class.verify(
-            payload: payload,
-            signature: signature,
-            timestamp: timestamp,
-            secret: secret
-          )
-        }.to raise_error(DoorFlow::Webhooks::SignatureError, /Invalid JSON/)
-      end
-    end
-  end
-
-  describe '.compute_signature' do
-    it 'returns a hex-encoded HMAC-SHA256 digest' do
-      sig = described_class.compute_signature('12345', '{"test":true}', 'secret')
-      expect(sig).to match(/\A[a-f0-9]{64}\z/)
-    end
-
-    it 'uses timestamp.payload format' do
-      expected = OpenSSL::HMAC.hexdigest('SHA256', 'secret', '12345.{"test":true}')
-      sig = described_class.compute_signature('12345', '{"test":true}', 'secret')
-      expect(sig).to eq(expected)
-    end
-  end
-end