auth_manager 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8faa6b3f0fdf2d60a4a7ecc95080c850d1601cd
-  data.tar.gz: 39626c404ac227c2af04a9a7af5c435e2f89f58c
+  metadata.gz: 8825b7ce1e7d3ac6011ecc4746e3e2e3df7f68e9
+  data.tar.gz: e37e2bf6e29e31cdb4d7d4a82c59c07440cdb2fe
 SHA512:
-  metadata.gz: 836948b28449525bafa205b4162b5ea7a2b5d8150599c80c0f71c00554f2f37f12fe7494bc19b01371c3e1df58f506f6c2d26eb920b7c040d7432b8e6703307e
-  data.tar.gz: 7b2e8d23a673dc4bf13e9422dc40225812ef22b107704209de29880e4f629fc7216f5eba0d13986cd17ea608a9d8ec7e55d4308ae8d4b58ad2418125ca019366
+  metadata.gz: 1e23db54ef732fd37dfb709ead2eb234d9c0d8cab2cbf13adbfec1d5d89e86a5c9fc734e1326fd3aeaafd50a157dd8f0c28cb906e06c1f257b81293fbc486ca5
+  data.tar.gz: f896e2a4db283411384db63be883734e72e41dc6551bf9548307365fd658d4ef3dc60d4c601022bc6ae2f684f6f1ca87f8ba5a5f35581dc51e8cd9a2f3d357f2

data/auth_manager.gemspec

@@ -18,12 +18,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake", "~> 0"
-  spec.add_development_dependency "redis","~>3.0", ">= 3.0.7"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "redis"
 
   #(we added) development dependencies
   spec.required_ruby_version = ">= 2.0"
-  spec.add_development_dependency "rspec", "~>2.6"
-
+  spec.add_development_dependency "rspec"
 end

data/lib/auth_manager/adder/adder.rb

@@ -1,44 +1,32 @@
 # coding: utf-8
-require 'redis'
-require_relative '../base.rb'
+require_relative '../constants'
 
-class AuthManager::Adder < AuthManager::Validation
+class AuthManager::Adder < AuthManager::Constants
 
-  def save?(given_user, option={user: true, app: false})
+  def self.save?(given_user, option={user: true, app: false})
     user = option.fetch(:user) || false
     app  = option.fetch(:app) || false
-    validate_param( given_user, option, user, app )
-    save(user, given_user) if available_login?(given_user, user)
+    response = {}
+    #section to allow new validation class to work with a hash
+    hash = hash_format_of(given_user, option)
+    #end of section
+    #hash for base redis_sadd
+    validation_mess = AuthManager::Validation.validate_param( hash )
+    hash_for_base = { object: hash[:object], list: 'users' } if hash[:option][:user]
+    hash_for_base = { object: hash[:object], list: 'applications' } if hash[:option][:app]
+    response = AuthManager::Base.redis_sadd(hash_for_base) if (validation_mess[:code] == 200)
+    response[:code] == 200 ? true : false
   end
 
   private ###################################
 
-  def available_login?(given_user, user)
-    login_ok = true
-    liste = user ? USERS : APPS
-    all = @redis.smembers(liste)
-    all.each do |member|
-      member_json = JSON.parse(member)
-      param_json = JSON.parse(given_user)
-      if param_json['login'] && login_exist?(member_json['login'], param_json['login'])
-        login_ok = false
-        break
-      end
-    end
-    login_ok
-  end
-
-  def login_exist?(wanted_login, login)
-    wanted_login == login
-  end
-
-  def save_this(liste, params)
-    @redis.sadd(liste, params)
-  end
-
-  def save(user, params)
-    liste = user ? USERS : APPS
-    save_this(liste, params)
+  def self.hash_format_of(given_user, option)
+    parsed  = JSON.parse(given_user)
+    object = {}
+    object = { login: parsed['login'], password: parsed['password'] } if parsed['login']
+    object = { api_key: parsed['api_key'] } if parsed['api_key']
+    object[:deleted] = true if parsed['deleted']
+    { object: object, option: option }
   end
 
 end

data/lib/auth_manager/base.rb

@@ -1,37 +1,63 @@
+require 'redis'
+
 class AuthManager::Base
-  attr_accessor :redis
 
-  USERS = 'users'
-  APPS  = 'applications'
+  def self.redis_sadd(hash)
+    validation = hash_of_pair(hash)
+    added = false
+    validation[:code] == 200 ? added = Redis.current.sadd(hash[:list], hash[:object].to_json) : (return validation)
+    added ? {code: 200, message: 'Param saved.'} : { code: 403, message: 'Sorry, This object already exists.'  }
+  end
 
-  def initialize
-    @redis = Redis.current
+  def self.redis_smembers(hash)
+    validation = hash_of_single(hash)
+    found = false
+    validation[:code] == 200 ? found = Redis.current.smembers(hash[:list]) : (return validation)
+    found.class == Array ? { code: 200, message: found } : { code: 404, message: 'Param not found!' }
   end
 
-end
+  def self.redis_sismember(hash)
+    validation = hash_of_pair(hash)
+    is_member = false
+    validation[:code] == 200 ? is_member = Redis.current.sismember(hash[:list], hash[:object].to_json) : (return validation)
+    is_member ? {code: 200, message: 'Param is a member of the given list.'} : { code: 404, message: 'Sorry, param not in the list'  }
+  end
 
-class AuthManager::Validation < AuthManager::Base
+  def self.redis_srem(hash)
+    validation = hash_of_pair(hash)
+    removed = false
+    validation[:code] == 200 ? removed = Redis.current.srem(hash[:list], hash[:object].to_json) : (return validation)
+    removed ? {code: 200, message: 'Param removed.'} : { code: 404, message: 'Sorry, param not in the list, thus not removed'  }
+  end
 
-  def validate_param(param, option, user, app)
-    validate_option(option, user, app)
-    valid_param = JSON.parse(param)
-    option[:user] ? user_as_param(valid_param) : app_as_param(valid_param)
+  def self.redis_del(hash)
+    validation = hash_of_single(hash)
+    deleted = 0
+    validation[:code] == 200 ? deleted = Redis.current.del(hash[:list]) : (return validation)
+    deleted != 0 ? {code: 200, message: 'Param deleted.'} : { code: 404, message: 'Sorry, param list not found'  }
   end
 
-  def user_as_param(valid_param)
-    if (valid_param['login'] && valid_param['login'].empty?) || (valid_param['password'] && valid_param['password'].empty?)
-      false
+  private #######################################
+
+  def self.hash_of_pair(hash)
+    to_return = {code: 400, message: 'Param is not a hash!'}
+    if (hash.class == Hash) && (hash.include?(:list) && hash.include?(:object))
+      to_return = {code: 200, message: 'Valid hash.'}
+    elsif (hash.class == Hash)
+      to_return = {code: 400, message:'Hash not well formed!'}
     end
+    to_return
   end
 
-  def app_as_param(valid_param)
-    if valid_param['api_key'] && valid_param['api_key'].empty?
-      false
+  def self.hash_of_single(hash)
+    to_return = {code: 400, message: 'Param is not a hash!'}
+    if ((hash.class == Hash) && (hash.include?(:list)))
+      to_return = {code: 200, message: 'Valid hash.'}
+    elsif (hash.class == Hash)
+      to_return = {code: 400, message:'Hash not well formed!'}
     end
+    to_return
   end
 
-  def validate_option(option, user, app)
-    false unless option.instance_of?(Hash)
-    false if (user && app)
-  end
 end
+

data/lib/auth_manager/constants.rb

@@ -0,0 +1,4 @@
+class AuthManager::Constants
+  USERS = 'users'
+  APPS  = 'applications'
+end

data/lib/auth_manager/deleter/deleter.rb

@@ -1,22 +1,14 @@
 # coding: utf-8
-require 'redis'
-require_relative '../base'
 
-class AuthManager::Deleter < AuthManager::Base
+class AuthManager::Deleter
 
-  def delete?(obj_to_del, option)
-    new_obj = format_new_obj(obj_to_del)
-    fake_delete?(obj_to_del, new_obj, option)
+  def self.delete?(obj_to_del, option)
+    AuthManager::Updater.update(obj_to_del, format_new_obj(obj_to_del), option)
   end
 
-  private
+  private ######################
 
-  def fake_delete?(obj_to_del, new_obj, option)
-    updater = AuthManager::Updater.new
-    updater.update(obj_to_del, new_obj, option)
-  end
-
-  def format_new_obj(obj_to_del)
+  def self.format_new_obj(obj_to_del)
     json_obj = JSON.parse(obj_to_del)
     if json_obj['api_key']
       {api_key: json_obj['api_key'], deleted: true  }.to_json

data/lib/auth_manager/finder/finder.rb

@@ -1,14 +1,28 @@
-require 'redis'
-require_relative '../base.rb'
+class AuthManager::Finder < AuthManager::Constants
 
-class AuthManager::Finder < AuthManager::Validation
-
-  def find_object?( param, option )
+  def self.find_object?( param, option )
     user = option.fetch(:user) || false
     app = option.fetch(:app) || false
-    validate_param(param, option, user, app)
+    hash = hash_format_of(param, option)
+    AuthManager::Validation.validate_param( hash )
     liste = user ? USERS : APPS
-    @redis.sismember( liste, param ) ? true : false
+    hash_for_base = { object: hash[:object], list: 'users' } if hash[:option][:user]
+    hash_for_base = { object: hash[:object], list: 'applications' } if hash[:option][:app]
+    response = {}
+    response = exist?(hash_for_base)
+    response[:code] == 200 ? true : false
   end
 
+  private #############################
+
+  def self.hash_format_of(given_user, option)
+    object = JSON.parse(given_user)
+    object = { login: object['login'], password: object['password'] } if object['login']
+    object = { api_key: object['api_key'] } if object['api_key']
+    { object: object, option: option }
+  end
+
+  def self.exist?( hash_for_base )
+    AuthManager::Base.redis_sismember( hash_for_base )
+  end
 end

data/lib/auth_manager/updater/updater.rb

@@ -1,31 +1,36 @@
 # coding: utf-8
-require 'redis'
 require_relative '../base'
+require_relative '../constants'
 
-class AuthManager::Updater < AuthManager::Base
+class AuthManager::Updater < AuthManager::Constants
 
-  def update(old_obj, new_obj, option)
-    existing_obj?(old_obj, option)
-    write_new_info?(new_obj, option)
-    delete_obj?(old_obj, option)
+  def self.update(old_obj, new_obj, option)
+    updated = false
+    if AuthManager::Finder.find_object?(old_obj, option)
+      if p AuthManager::Adder.save?(new_obj, option)
+        updated = delete_obj?(old_obj, option)
+      end
+    end
+    updated
   end
 
   private ###########################
 
-  def existing_obj?(old_obj, option)
-    finder = AuthManager::Finder.new
-    finder.find_object?(old_obj, option)
+  def self.hash_format_of(given_user, option)
+    object = JSON.parse(given_user)
+    object = { login: object['login'], password: object['password'] } if object['login']
+    object = { api_key: object['api_key'] } if object['api_key']
+    { object: object, option: option }
   end
 
-  def delete_obj?(old_obj, option)
+  def self.delete_obj?(old_obj, option)
     user = option.fetch(:user) || false
     liste = user ? USERS : APPS
-    @redis.srem(liste, old_obj)
-  end
-
-  def write_new_info?(new_obj, option)
-    adder = AuthManager::Adder.new
-    adder.save?(new_obj, option)
+    hash = hash_format_of(old_obj, option)
+    hash_for_base = { object: hash[:object], list: 'users' } if hash[:option][:user]
+    hash_for_base = { object: hash[:object], list: 'applications' } if hash[:option][:app]
+    done = AuthManager::Base.redis_srem(hash_for_base)
+    done[:code] == 200 ? true : false
   end
 
 end

data/lib/auth_manager/validation.rb

@@ -0,0 +1,84 @@
+class AuthManager::Validation
+
+  def self.validate_param(hash)
+    result = validate_format_of(hash)
+    result = validate_option(hash[:option]) if result[:code] == 200
+    return result if (result[:code] == 400)
+    return result = {code: 400, message: 'Bad object and option association'} unless validate_param_association(hash)
+    result = user_as_param(hash[:object]) if result[:code] && hash[:option][:user]
+    result = app_as_param(hash[:object]) if result[:code] && hash[:option][:app]
+    result
+  end
+
+  private ################################
+
+  def self.validate_param_association(hash)
+    good_association = true
+    good_association = false if (user_as_param(hash[:object])[:code] == 200) && (hash[:option][:app])
+    good_association = false if (app_as_param(hash[:object])[:code] == 200) && (hash[:option][:user])
+    good_association
+  end
+
+  def self.user_as_param(object)
+    answer = {code: 400, message: 'Object not well formed'}
+    answer = {code: 400, message: 'Object is not a hash'} unless
+              object.is_a?(Hash)
+    answer = {code: 200, message: 'Object is valid'} if (object_has2keys(object) || object_has3keys(object)) && object_contains_string(object)
+    answer
+  end
+
+  def self.app_as_param(object)
+    answer = {code: 400, message: 'Object not well formed'}
+    answer = {code: 400, message: 'Object is not a hash'} unless
+              object.is_a?(Hash)
+    answer = {code: 200, message: 'Object is valid'} if (object_has1key(object) || object_has2keys(object)) && object_is_string(object)
+    answer
+  end
+
+  def self.object_has1key(object)
+    object.include?(:api_key) && (object.length == 1)
+  end
+
+  def self.object_is_string(object)
+    object[:api_key].is_a?(String) && !object[:api_key].empty?
+  end
+
+  def self.object_has2keys(object)
+    ((object.include?(:login) && (object.include?(:password)))|| (object.include?(:api_key) && object.include?(:deleted))) && (object.length == 2)
+  end
+
+  def self.object_has3keys(object)
+    (object.include?(:login) && object.include?(:password) && object.include?(:deleted) && (object.length == 3))
+  end
+
+  def self.object_contains_string(object)
+    object[:login].is_a?(String) && object[:password].is_a?(String) && !object[:login].empty? && !object[:password].empty?
+  end
+
+  def self.validate_option(option)
+    answer = {code: 400, message: 'Option not well formed'}
+    answer = {code: 400, message: 'Option is not a hash'} unless
+              option.is_a?(Hash)
+    answer = {code: 200, message: 'Option is valid'} if option_has2keys(option) && option_keys_are_bools(option) && only_one_option(option)
+    answer
+  end
+
+  def self.option_has2keys(option)
+    (option && option.include?(:user) && option.include?(:app) && (option.length == 2))
+  end
+
+  def self.option_keys_are_bools(option)
+    option && (option[:user].is_a?(TrueClass) || option[:user].is_a?(FalseClass)) && (option[:app].is_a?(TrueClass) || option[:app].is_a?(FalseClass))
+  end
+
+  def self.only_one_option(option)
+    (option && option[:user] && ! option[:app]) || (option && !option[:user] && option[:app])
+  end
+
+  def self.validate_format_of(hash)
+    answer = {code: 400, message: 'Param not well formed!'}
+    answer = {code: 400, message: 'Param not a hash!'} unless hash.is_a?(Hash)
+    (answer = {code: 200, message: 'Param is valid.'}) if (hash.is_a?(Hash) && hash.include?(:object) && hash.include?(:option))
+    answer
+  end
+end

data/lib/auth_manager/version.rb

@@ -1,3 +1,3 @@
 module AuthManager
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/lib/auth_manager.rb

@@ -3,9 +3,15 @@ require 'auth_manager/adder/adder'
 require 'auth_manager/finder/finder'
 require 'auth_manager/updater/updater'
 require 'auth_manager/deleter/deleter'
+require 'auth_manager/base'
+require 'auth_manager/validation'
+require 'auth_manager/constants'
 
 module AuthManager
   # Your code goes here...
+  class Constants
+  end
+
   class Base
   end
 

data/spec/adder_spec.rb

@@ -1,43 +1,42 @@
 require_relative 'spec_helper'
 
 describe  AuthManager::Adder do
-  let(:adder) {  AuthManager::Adder.new }
   let(:user) { { login: 'nano', password: 'password' } }
   let(:app) { { api_key: 'api_key' } }
   let(:opt) { {user: false, app: false} }
 
-  describe '.initialize' do
-    context 'When created' do
-      it { expect( adder.redis).to_not be_nil  }
-    end
-  end
-
-  describe '#save?' do
+  describe '.save?' do
     #cleaning valid_user and or valid app before new save
     before(:each) do
-       adder.redis.del('users', user)
-       adder.redis.del('applications', app)
+       AuthManager::Base.redis_del({ list: 'users' })
+       AuthManager::Base.redis_del({ list: 'applications' })
     end
     #normal cases
     context 'When saved a valid user' do
       it {
         swap_option_to('user')
-        expect( adder.save?(user.to_json, opt)).to be_true
+        expect( AuthManager::Adder.save?(user.to_json, opt)).to be_true
       }
     end
     context 'When saved a valid app' do
       it {
         swap_option_to('app')
-        expect( adder.save?(app.to_json, opt)).to be_true
+        expect( AuthManager::Adder.save?(app.to_json, opt)).to be_true
       }
     end
     context 'When saved with an existing login' do
-      it {
-        expect( adder.save?(user.to_json, opt) ).to be_true
-        expect( adder.save?(user.to_json, opt)).to be_false
-        user['password'] = 'another password'
-        expect( adder.save?(user.to_json, opt)).to be_false
-      }
+      it do
+        swap_option_to('user')
+        expect( AuthManager::Adder.save?(user.to_json, opt) ).to be_true
+        expect( AuthManager::Adder.save?(user.to_json, opt)).to be_false
+      end
+    end
+    context 'When saving an existing api_key' do
+      it do
+        swap_option_to('app')
+        expect( AuthManager::Adder.save?(app.to_json, opt) ).to be_true
+        expect( AuthManager::Adder.save?(app.to_json, opt) ).to be_false
+      end
     end
   end
 

data/spec/base_spec.rb

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+require_relative 'spec_helper'
+
+describe AuthManager::Base do
+  before(:each)do
+    AuthManager::Base.redis_del({list: 'my_list'})
+    AuthManager::Base.redis_del({list: ''})
+  end
+
+  describe '.redis_sadd' do
+    context 'When given an object different from a hash' do
+      it { expect(AuthManager::Base.redis_sadd(nil)[:code]).to eq(400) }
+      it { expect(AuthManager::Base.redis_sadd([])[:code]).to eq(400) }
+      it { expect(AuthManager::Base.redis_sadd('')[:code]).to eq(400) }
+      it { expect(AuthManager::Base.redis_sadd(1524)[:code]).to eq(400) }
+      it { expect(AuthManager::Base.redis_sadd(true)[:code]).to eq(400) }
+    end
+    context 'when given a bad hash' do
+      it { expect(AuthManager::Base.redis_sadd({})[:code]).to eq(400) }
+      it { expect(AuthManager::Base.redis_sadd({nest: ''})[:code]).to eq(400) }
+      it { expect(AuthManager::Base.redis_sadd({t: 12, a: 'fe', aa: true})[:code]).to eq(400) }
+    end
+    context 'When given a correct hash' do
+      it { expect(AuthManager::Base.redis_sadd({list: 'my_list', object: 'my_object'})[:code]).to eq(200) }
+    end
+    context 'When given another correct hash' do
+      it { expect(AuthManager::Base.redis_sadd({list: 'my_list', object: 'my_object'})[:code]).to eq(200) }
+    end
+    context 'When saving an existing object' do
+      it do
+        expect(AuthManager::Base.redis_sadd({list: 'my_list', object: 'my_object'})[:code]).to eq(200)
+        expect(AuthManager::Base.redis_sadd({list: 'my_list', object: 'my_object'})[:code]).to eq(403)
+      end
+    end
+    context 'When given a random list and object in the hash' do
+      it { expect(AuthManager::Base.redis_sadd({list: g_rand_string, object: g_rand_string})[:code]).to eq(200) }
+    end
+  end
+
+  describe '.redis_smembers' do
+    context 'When given an invalid hash' do
+      it { expect(AuthManager::Base.redis_smembers({})[:code]).to eq(400) }
+      it { expect(AuthManager::Base.redis_smembers({nest: ''})[:code]).to eq(400) }
+      it { expect(AuthManager::Base.redis_smembers({t: 12, a: 'fe', aa: true})[:code]).to eq(400) }
+    end
+    context 'when given list name in a hash' do
+      it { expect(AuthManager::Base.redis_smembers({list: 'my_list'})[:message].class).to eq(Array) }
+    end
+    context 'When the list is not in the DB, length is 0' do
+      it { expect(AuthManager::Base.redis_smembers({list: 'my_list'})[:message].length).to eq(0) }
+    end
+    context 'When the list has at least one element, lenght > 0' do
+      it do
+        expect(AuthManager::Base.redis_sadd({ list: 'my_list', object: 'my_object' })).to be_true
+        expect(AuthManager::Base.redis_smembers({ list: 'my_list' })[:message].length).to be > 0
+      end
+    end
+  end
+
+  describe '.redis_sismember' do
+    context 'When the object is in the list' do
+      it 'expect sismember to return 200' do
+        expect( AuthManager::Base.redis_sadd({list: nil, object: nil})[:code] ).to eq(200)
+        expect( AuthManager::Base.redis_sismember({list: nil, object: nil})[:code]).to eq(200)
+      end
+    end
+    context 'When object is not in the list' do
+      it { expect( AuthManager::Base.redis_sismember({list: '', object: ''})[:code] ).to eq(404) }
+    end
+  end
+
+  describe '.redis_srem' do
+    context 'When the object is removed' do
+      it do
+        expect(AuthManager::Base.redis_sadd({list: 'my_list', object: 'my_object'})[:code]).to eq(200)
+        expect( AuthManager::Base.redis_srem({list: 'my_list', object: 'my_object'})[:code] ).to eq(200)
+      end
+    end
+    context 'When the object is not in the list' do
+      it { expect( AuthManager::Base.redis_srem({list: 'my_list', object: 'my_object'})[:code] ).to eq(404) }
+    end
+  end
+
+  describe '.redis_del' do
+    context 'When the list is deleted' do
+      it do
+        expect(AuthManager::Base.redis_sadd({list: 'my_list', object: 'my_object'})[:code]).to eq(200)
+        expect( AuthManager::Base.redis_del({list: 'my_list'})[:code] ).to eq(200)
+      end
+    end
+    context 'When the list is not deleted' do
+      it { expect( AuthManager::Base.redis_del({list: 'my_list'})[:code] ).to eq(404) }
+    end
+  end
+end

data/spec/deleter_spec.rb

@@ -1,23 +1,22 @@
 require_relative 'spec_helper'
 
 describe  AuthManager::Deleter do
-  let(:deleter) {  AuthManager::Deleter.new  }
   let(:user) { {login: 'login', password: 'password'} }
   let(:app) { {api_key: 'api_key'} }
   let(:opt) { { user: false, app: true }  }
   describe '#delete' do
     before(:each) do
-       deleter.redis.del('users')
-       deleter.redis.del('applications')
-       deleter.redis.sadd('users', user.to_json)
-       deleter.redis.sadd('applications', app.to_json)
+      AuthManager::Base.redis_del({ list: 'users' })
+      AuthManager::Base.redis_del({ list: 'applications' })
+      AuthManager::Base.redis_sadd( { object: user, list: 'users'} )
+      AuthManager::Base.redis_sadd({ object: app, list: 'applications' })
     end
 
     context 'When  deleted a user' do
       it {
         swap_option_to('user')
         user[:login] = 'login'
-        expect( deleter.delete?(user.to_json, opt)).to be_true
+        expect( AuthManager::Deleter.delete?(user.to_json, opt)).to be_true
       }
     end
 
@@ -25,14 +24,14 @@ describe  AuthManager::Deleter do
       it {
         swap_option_to('user')
         user[:login] = 'not a login'
-        expect( deleter.delete?(user.to_json, opt)).to be_false
+        expect( AuthManager::Deleter.delete?(user.to_json, opt)).to be_false
       }
     end
     context 'When  deleted an app' do
       it {
         swap_option_to('app')
         app[:api_key] = 'api_key'
-        expect( deleter.delete?(app.to_json, opt)).to be_true
+        expect( AuthManager::Deleter.delete?(app.to_json, opt)).to be_true
       }
     end
 
@@ -40,7 +39,7 @@ describe  AuthManager::Deleter do
       it {
         swap_option_to('app')
         app[:api_key] = 'not an api_key'
-        expect( deleter.delete?(app.to_json, opt)).to be_false
+        expect( AuthManager::Deleter.delete?(app.to_json, opt)).to be_false
       }
     end
   end

data/spec/finder_spec.rb

@@ -1,42 +1,42 @@
+# coding: utf-8
 require_relative 'spec_helper'
 
 describe AuthManager::Finder do
-  let(:finder) { AuthManager::Finder.new }
   let(:user) { { login: 'login', password: 'password' }}
   let(:app) { { api_key: 'api_key'  } }
   let(:opt) { { user: true, app: false }  }
   describe '#find_object?' do
     before(:each) do
-      finder.redis.del('users')
-      finder.redis.del('applications')
-      finder.redis.sadd('users', user.to_json)
-      finder.redis.sadd('applications', app.to_json)
+      AuthManager::Base.redis_del({ list: 'users' })
+      AuthManager::Base.redis_del({ list: 'applications' })
+      AuthManager::Base.redis_sadd( { object: user, list: 'users'} )
+      AuthManager::Base.redis_sadd({ object: app, list: 'applications' })
     end
     context 'When user is found' do
       it {
         swap_option_to('user')
-        expect( finder.find_object?(user.to_json, opt ) ).to be_true
+        expect( AuthManager::Finder.find_object?(user.to_json, opt ) ).to be_true
       }
     end
     context 'When user is not found' do
       it {
         swap_option_to('user')
         user[:login] = 'not a login'
-        expect( finder.find_object?( user.to_json, opt )  ).to be_false
+        expect( AuthManager::Finder.find_object?( user.to_json, opt )  ).to be_false
       }
     end
 
     context 'When app is found' do
       it {
         swap_option_to('app')
-        expect( finder.find_object?(app.to_json, opt ) ).to be_true
+        expect( AuthManager::Finder.find_object?(app.to_json, opt ) ).to be_true
       }
     end
     context 'When app is not found' do
       it {
         swap_option_to('app')
         app[:api_key] = 'not an api_key'
-        expect( finder.find_object?( app.to_json, opt )  ).to be_false
+        expect( AuthManager::Finder.find_object?( app.to_json, opt )  ).to be_false
       }
     end
   end

data/spec/spec_helper.rb

@@ -1,9 +1,13 @@
 require_relative './fixtures/environment'
 
+def g_rand_string
+  a = []
+  ('32'..'127').to_a.each { |e| a << e.to_i.chr }
+  (0..10).map{ [rand(a.length)] }.join
+end
 
 def swap_option_to(list)
-  case list
-  when 'user'
+  if list == 'user'
     opt[:user] = true
     opt[:app] = false
   else
@@ -13,8 +17,8 @@ def swap_option_to(list)
 end
 
 def new_object_from(object)
-  case object
-  when object.include?(:login)
+  if object.include?(:login)
+    object[:login] = 'new login'
     object[:password] = 'new password'
   else
     object[:api_key] = 'new api_key'

data/spec/updater_spec.rb

@@ -2,41 +2,40 @@
 require_relative  'spec_helper'
 
 describe AuthManager::Updater do
-  let(:updater) { AuthManager::Updater.new }
   let(:app) { { api_key: 'api_key' } }
   let(:user) { { login: 'login', password: 'password' }}
   let(:opt) { { user: true, app: false } }
   describe '#update' do
     before(:each) do
-      updater.redis.del('users')
-      updater.redis.del('applications')
-      updater.redis.sadd('users', user.to_json)
-      updater.redis.sadd('applications', app.to_json)
+      AuthManager::Base.redis_del({ list: 'users' })
+      AuthManager::Base.redis_del({ list: 'applications' })
+      AuthManager::Base.redis_sadd( { object: user, list: 'users'} )
+      AuthManager::Base.redis_sadd({ object: app, list: 'applications' })
     end
     context 'When user object is updated' do
       it {
         swap_option_to('user')
-        expect(updater.update(user.to_json, new_object_from(user).to_json, opt)).to be_true
+        expect(AuthManager::Updater.update(user.to_json, new_object_from(user).to_json, opt)).to be_true
       }
     end
     context 'When app object is updated' do
       it {
         swap_option_to('app')
-        expect(updater.update(app.to_json, new_object_from(app).to_json, opt)).to be_true
+        expect(AuthManager::Updater.update(app.to_json, new_object_from(app).to_json, opt)).to be_true
       }
     end
     context 'When user object is not updated' do
       it {
         swap_option_to('user')
-        user[:login] = 'not a login'
-        expect(updater.update(user.to_json, new_object_from(user).to_json, opt)).to be_false
+        user[:login] = 'this is not a login'
+        expect(AuthManager::Updater.update(user.to_json, new_object_from(user).to_json, opt)).to be_false
       }
     end
     context 'When app object is not updated' do
       it {
         swap_option_to('app')
         app[:api_key] = 'not an api_key'
-        expect(updater.update(app.to_json, new_object_from(app).to_json, opt)).to be_false
+        expect(AuthManager::Updater.update(app.to_json, new_object_from(app).to_json, opt)).to be_false
       }
     end
   end

data/spec/validation_spec.rb

@@ -0,0 +1,30 @@
+require_relative 'spec_helper'
+
+describe AuthManager::Validation do
+  describe '.validate_param' do
+    context 'When given something different from a hash' do
+     it { expect(AuthManager::Validation.validate_param(nil)[:code]).to eq(400) }
+     it { expect(AuthManager::Validation.validate_param('')[:code]).to eq(400) }
+     it { expect(AuthManager::Validation.validate_param([])[:code]).to eq(400) }
+     it { expect(AuthManager::Validation.validate_param(152)[:code]).to eq(400) }
+    end
+    context 'When given a bad formed hash' do
+      it { expect(AuthManager::Validation.validate_param({})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({ob: ''})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({ob: '', op: ''})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({object: '', op: ''})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({object: nil, option: nil})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({object: {name: nil}, option: {user: nil}})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({object: {login: '', password: ''}, option: {user: true, app: true}})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({object: {login: '', password: ''}, option: {user: true, app: false}})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({object: {api_key: ''}, option: {user: true, app: false}})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({object: {api_key: ''}, option: {user: false, app: true}})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({object: {login: 'my_login', password: 'my_password'}, option: { user: false, app: true }})[:code]).to eq(400) }
+      it { expect(AuthManager::Validation.validate_param({object: {api_key: 'api_key'}, option: { user: true, app: false }})[:code]).to eq(400) }
+    end
+    context 'When given a well formed hash' do
+      it { expect(AuthManager::Validation.validate_param({object: {api_key: 'api_key'}, option: { user: false, app: true }})[:code]).to eq(200) }
+      it { expect(AuthManager::Validation.validate_param({object: {login: 'my_login', password: 'my_password'}, option: { user: true, app: false }})[:code]).to eq(200) }
+    end
+  end
+end

metadata

@@ -1,77 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: auth_manager
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - atacraft && fabira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-16 00:00:00.000000000 Z
+date: 2014-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.7
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.7
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '0'
 description: '"Authenticate developpers and applications."'
 email:
 - atacraft@gmail.com, fabira90@gmail.com
@@ -91,17 +85,21 @@ files:
 - lib/auth_manager.rb
 - lib/auth_manager/adder/adder.rb
 - lib/auth_manager/base.rb
+- lib/auth_manager/constants.rb
 - lib/auth_manager/deleter/deleter.rb
 - lib/auth_manager/finder/finder.rb
 - lib/auth_manager/updater/updater.rb
+- lib/auth_manager/validation.rb
 - lib/auth_manager/version.rb
 - spec/adder_spec.rb
+- spec/base_spec.rb
 - spec/deleter_spec.rb
 - spec/feed/populate.rb
 - spec/finder_spec.rb
 - spec/fixtures/environment.rb
 - spec/spec_helper.rb
 - spec/updater_spec.rb
+- spec/validation_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -128,9 +126,11 @@ specification_version: 4
 summary: '"Module auth_manager"'
 test_files:
 - spec/adder_spec.rb
+- spec/base_spec.rb
 - spec/deleter_spec.rb
 - spec/feed/populate.rb
 - spec/finder_spec.rb
 - spec/fixtures/environment.rb
 - spec/spec_helper.rb
 - spec/updater_spec.rb
+- spec/validation_spec.rb