simple-api-auth 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93fd0b3729fe8e56836fe64f413fe653ae220cee
-  data.tar.gz: 6d34da98cfa5b789cbeea5b921b1b257c14bcf91
+  metadata.gz: eb9c0b2676ac9e4687ddb0800f62e421dcb1d4f9
+  data.tar.gz: 51ddeed3eece0be306e11bc32ef32c170948a479
 SHA512:
-  metadata.gz: 286a1234f05dda3f6ade05dfd5fbdf35b43ca8a03c5821f94720c1150d941dd805b92e198de89a5cbd9871edd7230cbe0c171ea218da74855d69267789822f42
-  data.tar.gz: c471d4bf302effaff92515fbfe17e5f4373f5dc59c91f8038eee359597729fd6d6c34bf4b8a8b761b887f05b8f812a010c53a436f685fc16e3ee5cbb8d449d9b
+  metadata.gz: afb834f110b250256b1e94b57528f74bf297974a572257e3bbee3ac9a1e318108e117eea2afed6b5f2035e6d575c6b2b3eaa0f7565cebe141bfaece3971a408f
+  data.tar.gz: 3aab96642cb7fe5f1844f69be91640981503a4ea65fda225983e18f6e61023271542136f1863b937915685aff0729b9ad2df2ad55fd404e2900b47c7b453de7a

data/README.md

@@ -36,13 +36,13 @@ class User < ActiveRecord::Base
 end
 ```
 
-you will need to have `ssa_key` and `ssa_secret` defined as strings
+you will need to have `saa_key` and `saa_secret` defined as strings
 in your database for this to work. If you want to change the columns name,
 you can pass them in option.
 
 ```ruby
 class User < ActiveRecord::Base
-  acts_as_api_authenticable ssa_key: :resource_key_field, ssa_secret: :secret_token
+  acts_as_api_authenticable saa_key: :resource_key_field, saa_secret: :secret_token
 end
 ```
 
@@ -51,14 +51,15 @@ to generate.
 
 ```ruby
 class User < ActiveRecord::Base
-  # this will generate a after_initialize to assign `ssa_key`
-  acts_as_api_authenticable auto_generate: :ssa_key
-  # this will generate a after_initialize for both `ssa_key` and `ssa_secret`
+  # this will generate a after_initialize to assign `saa_key`
+  acts_as_api_authenticable auto_generate: :saa_key
+  # this will generate a after_initialize for both `saa_key` and `saa_secret`
+  # not that this will only work for new records
   acts_as_api_authenticable auto_generate: true
 end
 ```
 
-Note that the keys for autogenerate should be `:ssa_key` and `:ssa_secret` even if you change the key column name.
+Note that the keys for autogenerate should be `:saa_key` and `:saa_secret` even if you change the key column name.
 
 You can then use
 
@@ -73,8 +74,8 @@ this will return the user if the request is valid, or `nil` otherwise.
 This gem can easily used without `ActiveRecord`.
 
 ```ruby
-ssa_key = SimpleApiAuth.extract_key(request)
-secret_key = your_logic_to_get_secret_key(ssa_key)
+saa_key = SimpleApiAuth.extract_key(request)
+secret_key = your_logic_to_get_secret_key(saa_key)
 valid = SimpleApiAuth.valid_signature?(request, secret_key)
 ```
 
@@ -84,8 +85,13 @@ The library accepts the following configurations
 
 ```ruby
 SimpleApiAuth.configure do |config|
+    # class used to transform headers key to :underscored_symbols and back
+    # the provided normalizer works for Rack requests
+    # override for other types of requests
+    request_normalizer = SimpleApiAuth::Helpers::RequestNormalizer
+
     # values used as default with `acts_as_api_authenticable`
-    config.model_defaults = { ssa_key: :ssa_key, ssa_secret: :ssa_secret, auto_generate: false }
+    config.model_defaults = { saa_key: :saa_key, saa_secret: :saa_secret, auto_generate: false }
 
     # the normalized keys for the HTTP headers
     config.header_keys = { key: :x_saa_key, time: :x_saa_auth_time, authorization: :authorization
@@ -155,6 +161,12 @@ or directly sign the request with
 SimpleApiAuth.sign!(request, secret_key)
 ```
 
+With `ActiveRecord`, it can also be used the following way.
+
+```ruby
+my_model.saa_sign!(request)
+```
+
 A JS client, with an AngularJS module intregrated with the `$http` service
 is in progress and should be available soon (with a few weeks).
 

data/lib/simple-api-auth/authenticable.rb

@@ -6,65 +6,73 @@ module SimpleApiAuth
 
     def acts_as_api_authenticable(options = {})
       if api_authenticable?
-        self.ssa_options = ssa_options.merge(options)
+        self.saa_options = saa_options.merge(options)
       else
         extend ClassMethods
         include InstanceMethods
-        self.ssa_options = SimpleApiAuth.config.make_model_options(options)
-        ssa_options[:auto_generate].each do |field|
+        self.saa_options = SimpleApiAuth.config.make_model_options(options)
+        saa_options[:auto_generate].each do |field|
           send(:after_initialize, "assign_#{field}")
         end
       end
     end
 
     module ClassMethods
-      attr_accessor :ssa_options
+      attr_accessor :saa_options
 
       def api_authenticable?
         true
       end
 
-      def ssa_authenticate(request)
+      def saa_authenticate(request)
         request = SimpleApiAuth::Request.create(request)
-        entity = ssa_find(request)
+        entity = saa_find(request)
         return false if entity.nil?
-        secret_key = entity.send(ssa_options[:ssa_secret])
+        secret_key = entity.send(saa_options[:saa_secret])
         return false unless SimpleApiAuth.valid_signature?(request, secret_key)
         entity
       end
 
-      def ssa_find(request)
+      def saa_find(request)
         key = SimpleApiAuth.extract_key(request)
-        find_by(ssa_options[:ssa_key] => key)
+        find_by(saa_options[:saa_key] => key)
       end
 
-      def generate_ssa_key(options = {})
+      def generate_saa_key(options = {})
         length = options[:length] || (Math.log(count + 1, 64) + 5)
         loop do
           key = SecureRandom.urlsafe_base64(length)
-          break key unless exists?(ssa_options[:ssa_key] => key)
+          break key unless exists?(saa_options[:saa_key] => key)
         end
       end
 
-      def generate_ssa_secret(options = {})
+      def generate_saa_secret(options = {})
         length = options[:length] || 64
         SecureRandom.urlsafe_base64(length)
       end
     end
 
     module InstanceMethods
-      def assign_ssa_key(options = {})
-        assign_ssa(:ssa_key, options)
+      def assign_saa_key(options = {})
+        assign_saa(:saa_key, options)
       end
 
-      def assign_ssa_secret(options = {})
-        assign_ssa(:ssa_secret, options)
+      def assign_saa_secret(options = {})
+        assign_saa(:saa_secret, options)
+      end
+
+      def saa_sign!(request)
+        request = SimpleApiAuth::Request.create(request)
+        key = send(self.class.saa_options[:saa_key])
+        request.add_header(SimpleApiAuth.config.header_keys[:saa_key], key)
+        SimpleApiAuth.sign!(request, send(self.class.saa_options[:saa_secret]))
       end
 
       private
 
-      def assign_ssa(field, options = {})
-        key_name = self.class.ssa_options[field]
+      def assign_saa(field, options = {})
+        return unless new_record? || options[:force]
+        key_name = self.class.saa_options[field]
         send("#{key_name}=", self.class.send("generate_#{field}", options))
       end
     end

data/lib/simple-api-auth/authenticator.rb

@@ -12,7 +12,7 @@ module SimpleApiAuth
     end
 
     def valid_signature?
-      return false if !check_data(request) || too_old?(request)
+      return false unless check_data(request) && valid_time?(request)
       signed_request = signer.sign(request, @secret_key)
       SimpleApiAuth.log(Logger::DEBUG, "Signed request: #{signed_request}")
       SimpleApiAuth.log(Logger::DEBUG, "User signature: #{signature}")

data/lib/simple-api-auth/config.rb

@@ -1,6 +1,6 @@
 module SimpleApiAuth
   class Config
-    attr_accessor :request_fields, :allowed_methods
+    attr_accessor :request_fields, :allowed_methods, :request_normalizer
     attr_accessor :signer, :request_timeout, :required_headers, :hasher
     attr_accessor :logger, :header_keys, :model_defaults
 
@@ -9,6 +9,7 @@ module SimpleApiAuth
     end
 
     def reset!
+      self.request_normalizer = SimpleApiAuth::Helpers::RequestNormalizer
       self.model_defaults = model_default_values
       self.header_keys = default_header_keys
       self.request_fields = default_request_fields
@@ -25,7 +26,7 @@ module SimpleApiAuth
       if options[:auto_generate].is_a?(Symbol)
         options[:auto_generate] = [options[:auto_generate]]
       elsif !options[:auto_generate].is_a?(Array)
-        options[:auto_generate] = options[:auto_generate] ? [:ssa_key, :ssa_secret] : []
+        options[:auto_generate] = options[:auto_generate] ? [:saa_key, :saa_secret] : []
       end
       options
     end
@@ -44,16 +45,16 @@ module SimpleApiAuth
 
     def default_header_keys
       {
-        key: :x_saa_key,
-        time: :x_saa_auth_time,
-        authorization: :authorization
+        saa_key: :http_x_saa_key,
+        saa_auth_time: :http_x_saa_auth_time,
+        authorization: :http_authorization
       }
     end
 
     def model_default_values
       {
-        ssa_key: :ssa_key,
-        ssa_secret: :ssa_secret,
+        saa_key: :saa_key,
+        saa_secret: :saa_secret,
         auto_generate: []
       }
     end

data/lib/simple-api-auth/errors.rb

@@ -0,0 +1,4 @@
+module SimpleApiAuth
+  class SigningError < StandardError
+  end
+end

data/lib/simple-api-auth/helpers/auth_helpers.rb

@@ -25,16 +25,30 @@ module SimpleApiAuth
 
       def check_data(request)
         required_headers.each do |k, _|
-          return false unless request.headers.key?(k)
+          return log_and_fail(missing_header_message(k)) unless request.headers.key?(k)
         end
-        allowed_methods.include?(request.http_verb)
+        allowed_verb = allowed_methods.include?(request.http_verb)
+        return log_and_fail("verb #{request.http_verb} not allowed") unless allowed_verb
+        true
       end
 
-      def too_old?(request)
+      def missing_header_message(header_name)
+        available_headers = request.headers.keys.join(', ')
+        "missing header #{header_name}. available headers are: #{available_headers}"
+      end
+
+      def valid_time?(request)
         request_time = request.time
-        return false if request_time.nil?
+        return log_and_fail('request time not found') if request_time.nil?
         difference = Time.now - request_time
-        difference < 0 || difference > request_timeout
+        return log_and_fail('negative time') if difference < 0
+        return log_and_fail('request too old') if difference > request_timeout
+        true
+      end
+
+      def log_and_fail(message)
+        SimpleApiAuth.log(Logger::DEBUG, message)
+        false
       end
 
       def secure_equals?(m1, m2, key)

data/lib/simple-api-auth/helpers/{request_helpers.rb → request_normalizer.rb}

@@ -1,6 +1,6 @@
 module SimpleApiAuth
   module Helpers
-    module Request
+    class RequestNormalizer
       def normalize_headers(headers)
         normalized_headers = {}
         headers.each do |key, value|
@@ -10,8 +10,12 @@ module SimpleApiAuth
         normalized_headers
       end
 
-      def normalize(s)
-        s.to_s.downcase.gsub(/-/, '_').to_sym
+      def normalize(key)
+        key.to_s.downcase.gsub(/-/, '_').to_sym
+      end
+
+      def denormalize(key)
+        key.to_s.upcase
       end
     end
   end

data/lib/simple-api-auth/request.rb

@@ -1,33 +1,42 @@
 module SimpleApiAuth
   class Request
-    include SimpleApiAuth::Helpers::Request
-
-    attr_accessor :headers, :http_verb, :query_string, :uri, :body
+    attr_accessor :headers, :http_verb, :query_string, :uri, :body, :original
 
     def initialize(options = {})
-      options.each do |k, v|
-        send("#{k}=", v)
-      end
-      self.headers = normalize_headers(headers)
-      self.http_verb = normalize(http_verb)
+      assign_options(options)
+      @normalizer = SimpleApiAuth.config.request_normalizer.new
+      @header_field = SimpleApiAuth.config.request_fields[:headers]
+      self.headers = @normalizer.normalize_headers(headers)
+      self.http_verb = http_verb.downcase.to_sym
     end
 
     def time
-      header_key = SimpleApiAuth.config.header_keys[:time]
+      header_key = SimpleApiAuth.config.header_keys[:saa_auth_time]
       Time.parse(headers[header_key])
     rescue ArgumentError, TypeError
       nil
     end
 
+    def add_header(key, value)
+      headers[key] = value
+      denormalized_key = @normalizer.denormalize(key)
+      original.send(@header_field)[denormalized_key] = value
+    end
+
     def self.create(request)
-      if request.is_a?(Request)
-        request
-      else
-        options = {}
-        SimpleApiAuth.config.request_fields.each do |k, v|
-          options[k] = request.send(v)
-        end
-        Request.new(options)
+      return request if request.is_a?(Request)
+      options = {}
+      SimpleApiAuth.config.request_fields.each do |k, v|
+        options[k] = request.send(v)
+      end
+      Request.new(options.merge(original: request))
+    end
+
+    private
+
+    def assign_options(options)
+      options.each do |k, v|
+        send("#{k}=", v)
       end
     end
   end

data/lib/simple-api-auth/signer.rb

@@ -8,7 +8,9 @@ module SimpleApiAuth
     end
 
     def sign(request, secret_key)
-      signing_key = make_singing_key(request, secret_key)
+      fail SigningError, 'time header is not present' if request.time.nil?
+
+      signing_key = make_signing_key(request, secret_key)
       SimpleApiAuth.log(Logger::DEBUG, "Signing key(hex): #{Digest.hexencode(signing_key)}")
 
       string_to_sign = make_string_to_sign(request)
@@ -35,10 +37,10 @@ module SimpleApiAuth
 
     private
 
-    def make_singing_key(request, secret_key)
+    def make_signing_key(request, secret_key)
       date = request.time.strftime('%Y%m%d')
-      hashed_date = hasher.hmac('ssa' + secret_key, date)
-      hasher.hmac(hashed_date, 'ssa_request')
+      hashed_date = hasher.hmac('saa' + secret_key, date)
+      hasher.hmac(hashed_date, 'saa_request')
     end
 
     def make_canonical_request(request)

data/lib/simple-api-auth/version.rb

@@ -1,6 +1,6 @@
 module SimpleApiAuth
   MAJOR = 0
   MINOR = 1
-  PATCH = 1
+  PATCH = 2
   VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
 end

data/lib/simple-api-auth.rb

@@ -22,7 +22,7 @@ module SimpleApiAuth
 
   def self.extract_key(request)
     request = SimpleApiAuth::Request.create(request)
-    request.headers[SimpleApiAuth.config.header_keys[:key]]
+    request.headers[SimpleApiAuth.config.header_keys[:saa_key]]
   end
 
   def self.valid_signature?(request, secret_key, options = {})
@@ -37,12 +37,11 @@ module SimpleApiAuth
   end
 
   def self.sign!(request, secret_key, options = {})
-    header_name = SimpleApiAuth.config.request_fields[:headers]
-    request.send(header_name)[SimpleApiAuth.config.header_keys[:time]] = Time.now.utc.iso8601
+    request = SimpleApiAuth::Request.create(request)
+    request.add_header(SimpleApiAuth.config.header_keys[:saa_auth_time], Time.now.utc.iso8601)
     signature = compute_signature(request, secret_key, options)
-    authorization_key = SimpleApiAuth.config.header_keys[:authorization]
-    request.send(header_name)[authorization_key] = "Signature: #{signature}"
-    request
+    request.add_header(SimpleApiAuth.config.header_keys[:authorization], "Signature: #{signature}")
+    request.original
   end
 end
 

data/spec/internal/app/models/models.rb

@@ -3,8 +3,8 @@ class AuthenticableModel < ActiveRecord::Base
 end
 
 class OverriddenAuthenticableModel < ActiveRecord::Base
-  acts_as_api_authenticable ssa_key: :ssa_key, ssa_secret: :ssa_secret
-  acts_as_api_authenticable ssa_key: :ssa_key, ssa_secret: :overriden_secret
+  acts_as_api_authenticable saa_key: :saa_key, saa_secret: :saa_secret
+  acts_as_api_authenticable saa_key: :saa_key, saa_secret: :overriden_secret
 end
 
 class AuthenticableModelWithHooks < ActiveRecord::Base

data/spec/internal/db/schema.rb

@@ -1,7 +1,7 @@
 ActiveRecord::Schema.define version: 0 do
   create_table :authenticable_models do |t|
-    t.string :ssa_key
-    t.string :ssa_secret
+    t.string :saa_key
+    t.string :saa_secret
   end
-  add_index :authenticable_models, :ssa_key, unique: true
+  add_index :authenticable_models, :saa_key, unique: true
 end

data/spec/lib/simple-api-auth/authenticable_spec.rb

@@ -4,64 +4,64 @@ describe SimpleApiAuth do
     describe 'class extensions' do
       subject(:clazz) { AuthenticableModel }
 
-      it { should respond_to(:ssa_options) }
-      it { should respond_to(:ssa_authenticate) }
-      it { should respond_to(:ssa_find) }
+      it { should respond_to(:saa_options) }
+      it { should respond_to(:saa_authenticate) }
+      it { should respond_to(:saa_find) }
 
       it 'should set options' do
-        expect(clazz.ssa_options[:ssa_key]).to eq(:ssa_key)
-        expect(clazz.ssa_options[:ssa_secret]).to eq(:ssa_secret)
+        expect(clazz.saa_options[:saa_key]).to eq(:saa_key)
+        expect(clazz.saa_options[:saa_secret]).to eq(:saa_secret)
       end
 
       context 'when included several times' do
         subject(:clazz) { OverriddenAuthenticableModel }
 
-        it { should respond_to(:ssa_options) }
+        it { should respond_to(:saa_options) }
         it 'should have overriden attributes' do
-          expect(clazz.ssa_options[:ssa_secret]).to eq(:overriden_secret)
+          expect(clazz.saa_options[:saa_secret]).to eq(:overriden_secret)
         end
       end
 
-      describe '#ssa_find' do
+      describe '#saa_find' do
         let(:request) { mock_request }
 
-        subject { clazz.ssa_find(request) }
+        subject { clazz.saa_find(request) }
 
         it 'should return nil when not found' do
           expect(subject).to be_nil
         end
 
         it 'should return entity when present' do
-          entity = AuthenticableModel.create(ssa_key: 'user_personal_key')
+          entity = AuthenticableModel.create(saa_key: 'user_personal_key')
           expect(subject.id).to eq(entity.id)
         end
       end
 
-      describe '#ssa_authenticate' do
+      describe '#saa_authenticate' do
         let(:request) { mock_request }
         before(:each) do
-          request.headers[:authorization] = "Signature: #{mock_signature}"
+          request.headers[:http_authorization] = "Signature: #{mock_signature}"
         end
 
-        subject { clazz.ssa_authenticate(request) }
+        subject { clazz.saa_authenticate(request) }
 
         it 'should return false when the entity does not exists' do
           expect(subject).to be false
         end
 
         it 'should return false when the secret key does not match' do
-          clazz.create(ssa_key: 'user_personal_key', ssa_secret: 'something else')
+          clazz.create(saa_key: 'user_personal_key', saa_secret: 'something else')
           expect(subject).to be false
         end
 
         it 'should return the resource when signature matches' do
           entity = clazz.create(
-            ssa_key: 'user_personal_key', ssa_secret: 'ultra_secret_key')
+            saa_key: 'user_personal_key', saa_secret: 'ultra_secret_key')
           expect(subject.id).to eq(entity.id)
         end
       end
 
-      { 'generate_ssa_key' => 5, 'generate_ssa_secret' => 64 }.each do |method, value|
+      { 'generate_saa_key' => 5, 'generate_saa_secret' => 64 }.each do |method, value|
         describe "##{method}" do
           let(:options) { {} }
           let(:key) { clazz.send(method.to_sym, options) }
@@ -77,21 +77,30 @@ describe SimpleApiAuth do
       end
 
       describe 'hooks' do
-        subject { AuthenticableModelWithHooks.new }
-        its(:ssa_key) { should_not be_nil }
-        its(:ssa_secret) { should_not be_nil }
+        subject(:model) { AuthenticableModelWithHooks.create }
+        its(:saa_key) { should_not be_nil }
+        its(:saa_secret) { should_not be_nil }
+
+        context 'with existing model' do
+          subject { AuthenticableModelWithHooks.find(model.id) }
+          it 'should not override keys' do
+            expect(subject.saa_key).to eq(model.saa_key)
+            expect(subject.saa_secret).to eq(model.saa_secret)
+          end
+        end
+
       end
     end
 
     describe 'instance extension' do
       subject(:model) { AuthenticableModel.new }
 
-      it { should respond_to(:assign_ssa_key) }
-      it { should respond_to(:assign_ssa_secret) }
-      its(:ssa_key) { should be_nil }
-      its(:ssa_secret) { should be_nil }
+      it { should respond_to(:assign_saa_key) }
+      it { should respond_to(:assign_saa_secret) }
+      its(:saa_key) { should be_nil }
+      its(:saa_secret) { should be_nil }
 
-      [:assign_ssa_key, :assign_ssa_secret].each do |method|
+      [:assign_saa_key, :assign_saa_secret].each do |method|
         field_name = method.to_s.gsub('assign_', '')
         describe "##{method}" do
           it "should assign #{field_name}" do
@@ -101,6 +110,32 @@ describe SimpleApiAuth do
           end
         end
       end
+
+      describe '#saa_sign!' do
+        let!(:model) { AuthenticableModelWithHooks.create }
+        let(:request) { mock_request }
+        before(:each) { model.saa_sign!(request) }
+
+        it 'should add time headers' do
+          expect(request.headers[:http_x_saa_auth_time]).not_to be_nil
+        end
+
+        it 'should add key header' do
+          expect(request.headers[:http_x_saa_key]).to eq(model.saa_key)
+        end
+
+        it 'should add authorization' do
+          expect(request.headers[:http_authorization]).not_to be_nil
+          expected = "Signature: #{SimpleApiAuth.compute_signature(request, model.saa_secret)}"
+          expect(request.headers[:http_authorization]).to eq(expected)
+        end
+
+        it 'should sign request' do
+          fetched = AuthenticableModelWithHooks.saa_authenticate(request)
+          expect(fetched).not_to be_falsy
+          expect(fetched.id).to eq(model.id)
+        end
+      end
     end
   end
 end

data/spec/lib/simple-api-auth/authenticator_spec.rb

@@ -1,6 +1,5 @@
 describe SimpleApiAuth do
   describe SimpleApiAuth::Authenticator do
-    include SimpleApiAuth::Helpers::Request
 
     let(:dummy_headers) { mock_headers }
 
@@ -16,12 +15,12 @@ describe SimpleApiAuth do
 
         describe '#valid_signature?' do
           it 'should fail on missing header' do
-            dummy_headers.delete 'X-Saa-Key'
+            dummy_headers.delete 'HTTP_X_SAA_KEY'
             expect(authenticator.valid_signature?).to be_falsy
           end
 
           it 'should fail on outdated request' do
-            dummy_headers[:x_saa_auth_time] = outdated_time.iso8601
+            dummy_headers[:http_x_saa_auth_time] = outdated_time.iso8601
             expect(authenticator.valid_signature?).to be_falsy
           end
 

data/spec/lib/simple-api-auth/config_spec.rb

@@ -13,24 +13,24 @@ describe SimpleApiAuth do
     end
 
     describe 'make_model_options' do
-      let(:model_options) { { ssa_key: :foobar } }
+      let(:model_options) { { saa_key: :foobar } }
       subject(:options) { config.make_model_options(model_options) }
 
       it 'should merge options' do
-        expect(options[:ssa_key]).to eq(:foobar)
-        expect(options[:ssa_secret]).to eq(:ssa_secret)
+        expect(options[:saa_key]).to eq(:foobar)
+        expect(options[:saa_secret]).to eq(:saa_secret)
         expect(options[:auto_generate]).to eq([])
       end
 
       describe 'auto_generate configuration' do
         it 'should handle symbol' do
-          model_options[:auto_generate] = :ssa_key
-          expect(options[:auto_generate]).to eq([:ssa_key])
+          model_options[:auto_generate] = :saa_key
+          expect(options[:auto_generate]).to eq([:saa_key])
         end
 
         it 'should handle true' do
           model_options[:auto_generate] = true
-          expect(options[:auto_generate]).to eq([:ssa_key, :ssa_secret])
+          expect(options[:auto_generate]).to eq([:saa_key, :saa_secret])
         end
 
         it 'should handle false' do
@@ -39,8 +39,8 @@ describe SimpleApiAuth do
         end
 
         it 'should handle arrays' do
-          model_options[:auto_generate] = [:ssa_secret]
-          expect(options[:auto_generate]).to eq([:ssa_secret])
+          model_options[:auto_generate] = [:saa_secret]
+          expect(options[:auto_generate]).to eq([:saa_secret])
         end
       end
     end

data/spec/lib/simple-api-auth/helpers/auth_helpers_spec.rb

@@ -1,9 +1,9 @@
 describe SimpleApiAuth do
   describe SimpleApiAuth::Helpers::Auth do
-    include SimpleApiAuth::Helpers::Request
     include SimpleApiAuth::Helpers::Auth
 
-    let(:headers) { normalize_headers(mock_headers) }
+    let(:normalizer) { SimpleApiAuth::Helpers::RequestNormalizer.new }
+    let(:headers) { normalizer.normalize_headers(mock_headers) }
     let(:request) { SimpleApiAuth::Request.create(rails_request) }
 
     describe '#extract_signature' do
@@ -12,7 +12,7 @@ describe SimpleApiAuth do
       end
 
       it 'should return nil otherwise' do
-        headers[:authorization] = 'Signatur: foobar'
+        headers[:http_authorization] = 'Signatur: foobar'
         expect(extract_signature(headers)).to be_nil
       end
     end
@@ -32,19 +32,19 @@ describe SimpleApiAuth do
       end
 
       it 'should fail when header is missing' do
-        request.headers.delete :authorization
+        request.headers.delete :http_authorization
         expect(check_data(request)).to be_falsy
       end
     end
 
-    describe '#too_old?' do
+    describe '#valid_time?' do
       it 'should allow recent enough requests' do
-        expect(too_old?(request)).to be_falsy
+        expect(valid_time?(request)).to be_truthy
       end
 
       it 'should reject old requests' do
-        request.headers[:x_saa_auth_time] = Time.new(2014, 11, 8).iso8601
-        expect(too_old?(request)).to be_truthy
+        request.headers[:http_x_saa_auth_time] = Time.new(2014, 11, 8).iso8601
+        expect(valid_time?(request)).to be_falsy
       end
     end
 

data/spec/lib/simple-api-auth/helpers/request_normalizer_spec.rb

@@ -0,0 +1,45 @@
+describe SimpleApiAuth do
+  describe SimpleApiAuth::Helpers::RequestNormalizer do
+    let(:normalizer) { SimpleApiAuth::Helpers::RequestNormalizer.new }
+
+    describe '#normalize_headers' do
+      let(:raw_headers) { mock_headers }
+      let(:headers) { normalizer.normalize_headers(raw_headers) }
+
+      it 'should normalize headers keys' do
+        [:http_authorization, :http_x_saa_auth_time, :http_x_saa_key].each do |key|
+          expect(headers).to include(key)
+        end
+        expect(headers.values).to eq(raw_headers.values)
+      end
+    end
+
+    describe '#normalize' do
+      it 'should symbolize keys' do
+        expect(normalizer.normalize('foo')).to eq(:foo)
+      end
+
+      it 'should work with symbols' do
+        expect(normalizer.normalize(:foo)).to eq(:foo)
+      end
+
+      it 'should downcase' do
+        expect(normalizer.normalize('FOO')).to eq(:foo)
+      end
+
+      it 'should replace hyphens' do
+        expect(normalizer.normalize('foo-bar')).to eq(:foo_bar)
+      end
+
+      it 'should work with more complex keys' do
+        expect(normalizer.normalize('FOO-BAR-BAZ')).to eq(:foo_bar_baz)
+      end
+    end
+
+    describe '#denormalize' do
+      it 'should return capitalized underscored values' do
+        expect(normalizer.denormalize(:foo_bar)).to eq('FOO_BAR')
+      end
+    end
+  end
+end

data/spec/lib/simple-api-auth/request_spec.rb

@@ -1,20 +1,26 @@
 describe SimpleApiAuth do
   describe SimpleApiAuth::Request do
-    include SimpleApiAuth::Helpers::Request
 
     let(:base_request) { SimpleApiAuth::Request.create(rails_request) }
+    let(:normalizer) { SimpleApiAuth::Helpers::RequestNormalizer.new }
 
     def check_request(request)
-      expect(request.headers).to eq(normalize_headers(mock_headers))
+      expect(request.headers).to eq(normalizer.normalize_headers(mock_headers))
       expect(request.http_verb).to eq(:get)
     end
 
     describe '#initialize' do
-      let(:request) { SimpleApiAuth::Request.create(rails_request) }
+      let(:rails_req) { rails_request }
+      let(:request) { SimpleApiAuth::Request.create(rails_req) }
 
       it 'should set headers and http verb' do
         check_request(request)
       end
+
+      it 'should work with added headers' do
+        rails_req.headers['RANDOM_HEADER'] = 'foobar'
+        expect(request.headers).to include(:random_header)
+      end
     end
 
     describe '#create' do
@@ -41,14 +47,28 @@ describe SimpleApiAuth do
       end
 
       it 'should return nil on wrong time' do
-        base_request.headers[:x_saa_auth_time] = 'foobar'
+        base_request.headers[:http_x_saa_auth_time] = 'foobar'
         expect(base_request.time).to be_nil
       end
 
       it 'should return nil on empty time' do
-        base_request.headers.delete :x_saa_auth_time
+        base_request.headers.delete :http_x_saa_auth_time
         expect(base_request.time).to be_nil
       end
     end
+
+    describe '#add_header' do
+      let(:base_request) { rails_request }
+      let(:request) { SimpleApiAuth::Request.create(base_request) }
+      before(:each) { request.add_header(:http_foo_bar, 'foobar') }
+
+      it 'should add header to request' do
+        expect(request.headers[:http_foo_bar]).to eq('foobar')
+      end
+
+      it 'should add header to base request' do
+        expect(base_request.headers['HTTP_FOO_BAR']).to eq('foobar')
+      end
+    end
   end
 end

data/spec/lib/simple-api-auth/signer_spec.rb

@@ -29,8 +29,15 @@ describe SimpleApiAuth do
 
     describe '#sign' do
       let(:secret_key) { 'ultra_secret_key' }
+      subject { signer.sign(request, secret_key) }
+
       it 'should generate correct signature' do
-        expect(signer.sign(request, secret_key)).to eq(mock_signature)
+        expect(subject).to eq(mock_signature)
+      end
+
+      it 'should fail when time is not present' do
+        request.headers.delete :http_x_saa_auth_time
+        expect { subject }.to raise_error(SimpleApiAuth::SigningError)
       end
     end
   end

data/spec/lib/simple-api-auth_spec.rb

@@ -30,8 +30,8 @@ describe SimpleApiAuth do
     end
 
     it 'should work with custom headers' do
-      SimpleApiAuth.config.header_keys[:key] = :key
-      request.headers[:key] = request.headers.delete(:x_saa_key)
+      SimpleApiAuth.config.header_keys[:saa_key] = :key
+      request.headers[:key] = request.headers.delete(:http_x_saa_key)
       expect(subject).to eq('user_personal_key')
     end
   end
@@ -45,7 +45,7 @@ describe SimpleApiAuth do
     end
 
     it 'should succeed with correct signature' do
-      request.headers[:authorization] = "Signature: #{mock_signature}"
+      request.headers[:http_authorization] = "Signature: #{mock_signature}"
       expect(result).to be_truthy
     end
 
@@ -60,9 +60,9 @@ describe SimpleApiAuth do
           query_string: 'foo=bar&bar=qux',
           body: StringIO.new('somerandombody'),
           headers: {
-            authorization: 'Signature: 7c171d095fd65b7078afd13a6b3bd4ecfe596552',
-            x_saa_auth_time: request_time.iso8601,
-            x_saa_key: 'wedontreallycarehere'
+            http_authorization: 'Signature: 6990ae83450457f6e1ca4a64b078751b12e8d429',
+            http_x_saa_auth_time: request_time.iso8601,
+            http_x_saa_key: 'wedontreallycarehere'
           }
         )
       end
@@ -87,14 +87,14 @@ describe SimpleApiAuth do
       let(:signature) { SimpleApiAuth.compute_signature(request, secret_key) }
 
       it 'should return correct signature' do
-        request.headers[:authorization] = "Signature: #{signature}"
+        request.headers[:http_authorization] = "Signature: #{signature}"
         expect(subject).to be_truthy
       end
 
       context 'with a different key' do
         let(:secret_key) { 'another cool key' }
         it 'should not return the same signature' do
-          request.headers[:authorization] = "Signature: #{signature}"
+          request.headers[:http_authorization] = "Signature: #{signature}"
           expect(SimpleApiAuth.valid_signature?(request, base_secret)).to be_falsy
         end
       end
@@ -107,10 +107,26 @@ describe SimpleApiAuth do
       end
 
       it 'should add time header' do
-        request.headers.delete :x_saa_auth_time
+        request.headers.delete 'HTTP_X_SAA_AUTH_TIME'
         SimpleApiAuth.sign!(request, secret_key)
         expect(subject).to be_truthy
-        expect(request.headers[:x_saa_auth_time]).not_to be_nil
+        expect(request.headers[:http_x_saa_auth_time]).not_to be_nil
+      end
+
+      describe 'with rails request' do
+        let(:request) { rails_request }
+
+        it 'should work' do
+          SimpleApiAuth.sign!(request, secret_key)
+          expect(subject).to be_truthy
+        end
+
+        it 'should add headers with prefix' do
+          request.headers.delete 'HTTP_X_SAA_AUTH_TIME'
+          SimpleApiAuth.sign!(request, secret_key)
+          expect(subject).to be_truthy
+          expect(request.headers['HTTP_X_SAA_AUTH_TIME']).not_to be_nil
+        end
       end
     end
   end

data/spec/support/mocks.rb

@@ -14,9 +14,9 @@ module SpecHelpers
 
     def mock_headers
       {
-        'Authorization' => 'Signature: dummy_signature',
-        'X-Saa-Auth-Time' => request_time.iso8601,
-        'X-Saa-Key' => 'user_personal_key'
+        'HTTP_AUTHORIZATION' => 'Signature: dummy_signature',
+        'HTTP_X_SAA_AUTH_TIME' => request_time.iso8601,
+        'HTTP_X_SAA_KEY' => 'user_personal_key'
       }
     end
 
@@ -32,12 +32,12 @@ module SpecHelpers
     end
 
     def mock_string_to_sign
-      mock_headers['X-Saa-Auth-Time'] + "\n" + mock_hashed_request
+      mock_headers['HTTP_X_SAA_AUTH_TIME'] + "\n" + mock_hashed_request
     end
 
     def mock_signature
       date = mock_request.time.strftime('%Y%m%d')
-      Digest.hexencode("ssa#{mock_secret_key}:#{date}:ssa_request:#{mock_string_to_sign}")
+      Digest.hexencode("saa#{mock_secret_key}:#{date}:saa_request:#{mock_string_to_sign}")
     end
 
     def setup_dummy_signer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple-api-auth
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Daniel Perez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-09 00:00:00.000000000 Z
+date: 2014-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -135,9 +135,10 @@ files:
 - lib/simple-api-auth/authenticable.rb
 - lib/simple-api-auth/authenticator.rb
 - lib/simple-api-auth/config.rb
+- lib/simple-api-auth/errors.rb
 - lib/simple-api-auth/hashers/sha1_hasher.rb
 - lib/simple-api-auth/helpers/auth_helpers.rb
-- lib/simple-api-auth/helpers/request_helpers.rb
+- lib/simple-api-auth/helpers/request_normalizer.rb
 - lib/simple-api-auth/request.rb
 - lib/simple-api-auth/signer.rb
 - lib/simple-api-auth/version.rb
@@ -150,7 +151,7 @@ files:
 - spec/lib/simple-api-auth/authenticator_spec.rb
 - spec/lib/simple-api-auth/config_spec.rb
 - spec/lib/simple-api-auth/helpers/auth_helpers_spec.rb
-- spec/lib/simple-api-auth/helpers/request_helpers_spec.rb
+- spec/lib/simple-api-auth/helpers/request_normalizer_spec.rb
 - spec/lib/simple-api-auth/request_spec.rb
 - spec/lib/simple-api-auth/signer_spec.rb
 - spec/lib/simple-api-auth_spec.rb

data/spec/lib/simple-api-auth/helpers/request_helpers_spec.rb

@@ -1,39 +0,0 @@
-describe SimpleApiAuth do
-  describe SimpleApiAuth::Helpers::Request do
-    include SimpleApiAuth::Helpers::Request
-
-    describe '#normalize_headers' do
-      let(:raw_headers) { mock_headers }
-      let(:headers) { normalize_headers(raw_headers) }
-
-      it 'should normalize headers keys' do
-        [:authorization, :x_saa_auth_time, :x_saa_key].each do |key|
-          expect(headers).to include(key)
-        end
-        expect(headers.values).to eq(raw_headers.values)
-      end
-    end
-
-    describe '#normalize' do
-      it 'should symbolize keys' do
-        expect(normalize('foo')).to eq(:foo)
-      end
-
-      it 'should work with symbols' do
-        expect(normalize(:foo)).to eq(:foo)
-      end
-
-      it 'should downcase' do
-        expect(normalize('FOO')).to eq(:foo)
-      end
-
-      it 'should replace hyphens' do
-        expect(normalize('foo-bar')).to eq(:foo_bar)
-      end
-
-      it 'should work with more complex keys' do
-        expect(normalize('FOO-BAR-BAZ')).to eq(:foo_bar_baz)
-      end
-    end
-  end
-end