session_manager 0.0.3 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 988e4724c26c4b1d26a595249a4a890700980a2a
-  data.tar.gz: 464d1440385bd5c802b4f3eeb1fdc2d30a63da6e
+  metadata.gz: 00679bbdc1df2566058ee2baba9b24f05faa4079
+  data.tar.gz: 4ef9a4bb36b653fed2e976ea2e793e92128816f2
 SHA512:
-  metadata.gz: 0696db9db3829544299eff2d2c9ef2e2368c22c04ed2f9a89d7f1055b794119a34741a19242fe6942881e98c558e33731b890db62794770c81cf35eddd9762f8
-  data.tar.gz: 2948a5d9b91c8cac3d16edd1d7f24e33ae0c266890657726a2a7335ca029183dd61d54e53b2f4491b8d877435c49cea5f626b56f1c6dfdfff5431ac8933cff02
+  metadata.gz: 2aa3ef7d50a1be951c6b2cd498ba9d10eb35ed6b9cedf03caa0c1081c3f4402443bf325d0246b0f264ef34cf8dd61a029dcab154691449f82aa8776ed0f02123
+  data.tar.gz: 2a08c30681be1cce7d31782efefb9d7c0cbe902ba8a9104f04460263188dfcef11f73d533bc87e9589fb8f457f7c97a8c687ac2fcf19c873f65db6b3627e1f02

data/lib/session_manager/handler.rb

@@ -1,73 +1,172 @@
 require 'redis'
 require 'json'
 require 'uuid'
-require_relative 'base'
 
-class SessionManager::Handler < Session_Manager::Base
 
-  def create_session(attribute,option)
-    if validate_json(attribute) 
+class SessionManager::Handler 
+  
+  USERS_SESSIONS = 'users_sessions'
+  APPS_SESSIONS  = 'applications_sessions'
+
+
+  def self.create_session(attribute,option) 
+    if validate_option(option) && valid_token?(attribute,option) 
       param = parse_json(attribute)
       collection = collection(option)
       token = generate_token
       session = session_generator(option,param,token)
-      @redis.sadd(collection,session.to_json)
+      result = get_redis.sadd(collection,session.to_json)
+      result ? return_response(200,token) : return_response(400,"Not created")
     else
-      false
+      return_response(400,"Not created")
     end
   end
  
-  def verify_session(object,option)
-   if validate_json(object)   
+  def self.verify_session(object,option)
+   if validate_option(option) && validate_json(object,option)   
     collection = collection(option)
-    @redis.sismember(collection,object)
+    result     = get_redis.sismember(collection,object)
+    result ? return_response(200,"Ok") : return_response(400,"Not ok") 
    else
-       false
+       return_response(400,"Ok")
    end
  end
 
- def delete_session(object,option)
-    if validate_json(object)
+ 
+ def self.delete_session(object,option)
+    if validate_option(option) && validate_json(object,option)
      collection = collection(option)
-     @redis.srem(collection,object)
+     result     = get_redis.srem(collection,object)
+     result ? return_response(200,"Succesfully deleted") : return_response(400,"Not deleted")
     else
-        false
+        return_response(400,"Not deleted")
     end
  end
 
- private #####################################################################################################
+ private #######################################################################
+
+ def self.get_redis
+     redis = Redis.current
+     redis
+ end
+
+
+ def self.get_uuid
+     uuid = UUID.new
+     uuid
+ end
+
+#generate token
+def self.generate_token
+    get_uuid.generate
+end
 
- def collection(option)
+ #determine the database collection to use
+ def self.collection(option)
      user = option.fetch(:user) || false
-     app = option.fetch(:app)  || false
+     app  = option.fetch(:app)  || false
      collection = user ? USERS_SESSIONS : APPS_SESSIONS
      return collection
  end
 
- def parse_json(param)
+ #parse json
+ def self.parse_json(param)
    JSON.parse(param)
  end
 
- def session_generator(option, param, token)
+ #create a session hash for the database
+ def self.session_generator(option, param, token)
    option[:user] ? { login: param['login'],token: token} : { api_key: param['api_key'],token: token} 
  end
 
- def validate_json(param)
-    obj = parse_json(param)
-    hash = obj.to_hash
-    validate_argument(hash)
+ #check if the passed keys are those which are waited
+ def self.valid_keys?(param,option)
+   option[:user] ? waited_keys = ["login","token"] : waited_keys = ["api_key","token"] 
+   waited_keys.each do |k|
+      if !(param.has_key?(k))
+        return false
+        break
+      end
+    end
+    return true
+ end
+
+ #check if the passed token is valid
+ def self.valid_token?(token,option)
+   option[:user] ? attr = "login" : attr = "api_key"
+   begin
+     object = parse_json(token)
+     hash   = object.to_hash
+     if !(hash.has_key?(attr)) || !(hash[attr].is_a?(String))
+       return false
+     end
+   rescue
+     return false
+   end
+ return true
+ end
+
+ #check if hash's values are String
+ def self.validate_values(hash)
+   values = hash.values
+   values.each do |v|
+     if !(v.is_a?(String))
+       return false
+       break
+     end
+   end
+   return true
  end
 
- def validate_argument(param)
+ #check if the hash values are not nil neither empty
+ def self.validate_argument(param)
    param.values.each do |v|
     if v.nil? || v.empty?
       return false
       break
-    else
-      return true
     end
    end
+   return true
+ end
+ 
+ #check if the json object is valid
+ def self.validate_json(param,option)
+   begin
+    object  = parse_json(param) 
+    hash    = object.to_hash
+    return valid_keys?(hash,option) && validate_argument(hash) && validate_values(hash)
+   rescue
+     return false
+   end
  end
 
+ #check if the option is valid
+ def self.validate_option(option)
+  if !(option.nil?) && option.is_a?(Hash) && !(option.empty?) && option.has_key?(:user) && option.has_key?(:app)
+    if option[:user] && option[:app]
+      return false
+    else 
+      if !option[:user] && !option[:app]
+       return  false
+      else
+        option.values.each do |v|
+          unless (v.is_a?(TrueClass) || v.is_a?(FalseClass))
+            return false
+            break
+          end
+        end
+      end
+    end
+  else
+    return false
+  end
+  return true
+end
+
+#change the return parameter in hash format
+def self.return_response(code,msg)
+  {code: code,message: msg}
+end
+
 
 end

data/lib/session_manager/version.rb

@@ -1,3 +1,3 @@
 module SessionManager
-  VERSION = "0.0.3"
+  VERSION = "0.0.6"
 end

data/session_manager.gemspec

@@ -26,4 +26,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.0"
   spec.add_development_dependency "rspec", "~>2.6"
   spec.add_development_dependency "uuid", "~> 2.3", ">= 2.3.7"
+  spec.add_development_dependency "autotest", "~> 4.4", ">= 4.4.6"
+  spec.add_development_dependency "autotest-fsevent", "~> 0.2", ">= 0.2.9"
+  spec.add_development_dependency "autotest-growl", "~> 0.2", ">= 0.2.16"
+  spec.add_development_dependency "ZenTest", "~> 4.10", ">= 4.10.0"
 end

data/spec/handler_spec.rb

@@ -1,16 +1,13 @@
 require_relative 'spec_helper'
 
 describe SessionManager::Handler do
-
-  let (:session_handler) { SessionManager::Handler.new }
+ 
   let (:login) { {login: 'login'}.to_json}
   let (:api_key) { {api_key: '01'}.to_json}
   let (:user_option) { {user: true, app: false}}
   let (:app_option) { {user: false, app: true}}
   let (:user_session) {{login: 'login',token: 'jdijenfdeifiirifffjr'}.to_json}
-  #let (:not_user_session) {{login: 'login',token: 'jdijenfd'}.to_json}
-  let (:app_session) {{api_key: '01',token: 'jdijenfdeifiirifffjr'}.to_json}
-  #let (:not_app_session) {{api_key: '02',token: 'jdijenfdeifiirr'}.to_json}
+  let (:app_session) {{api_key: '01',token: 'jdijenfdeifiirifffjr'}.to_json} 
 
   before :each do
     redis=Redis.current
@@ -20,58 +17,141 @@ describe SessionManager::Handler do
     redis.sadd('applications_sessions',app_session)
 
   end
-  describe "#create_session" do
+
+  describe ".create_session" do
     context "when a user's session is created" do
-      it { expect(session_handler.create_session(login,user_option)).to be_true}       
+      it { expect((SessionManager::Handler.create_session(login,user_option))[:code]).to eq 200}       
     end 
 
     context "When an app's session is created" do
-        it { expect(session_handler.create_session(api_key,app_option)).to be_true }
+        it { expect((SessionManager::Handler.create_session(api_key,app_option))[:code]).to eq 200 }
+    end
+
+    context "When option is invalid" do
+        option = {u: true,a:false}
+        it { expect((SessionManager::Handler.create_session(api_key,option))[:code]).to eq 400 }
+
+        option = {user: true,app: true}
+        it { expect((SessionManager::Handler.create_session(api_key,option))[:code]).to eq 400 }
+
+        option = " "
+        it { expect((SessionManager::Handler.create_session(api_key,option))[:code]).to eq 400 }
+
+        option = {user: nil,app:false}
+        it { expect((SessionManager::Handler.create_session(api_key,option))[:code]).to eq 400 }
+
+        option = {user: "tata",app: "toto"}
+        it { expect((SessionManager::Handler.create_session(api_key,option))[:code]).to eq 400 }
+    end
+
+    context "When the object's column is invalid" do    
+        api_key = {api_key: nil}.to_json
+        option = {user: false,app: true}
+        it { expect((SessionManager::Handler.create_session(api_key,option))[:code]).to eq 400 }
+
+        api_key ={api_key: 1}.to_json 
+        it { expect((SessionManager::Handler.create_session(api_key,option))[:code]).to eq 400 }
+
+        login = {login: 'fatou'}
+        opt ={user: true,app:false}
+        it { expect((SessionManager::Handler.create_session(login,opt))[:code]).to eq 400 }
+               api_key = {ap: 'invalid'}.to_json
+        it { expect((SessionManager::Handler.create_session(api_key,option))[:code]).to eq 400 }
+
+        it { expect((SessionManager::Handler.create_session(nil,option))[:code]).to eq 400 }
+
+        it { expect((SessionManager::Handler.create_session(" ",option))[:code]).to eq 400 }
+    end
+
+    context "when the given attribute doesn't correspond to the option" do
+        api_key = {api_key: 'hhfrijijfri'}.to_json
+        option = {user: true,app: false}
+        it { expect((SessionManager::Handler.create_session(api_key,option))[:code]).to eq 400 }
+
     end
   end
 
-  describe "#verify_session" do
+  describe ".verify_session" do
       context "when a user's session is found" do
-          it { expect(session_handler.verify_session(user_session,user_option) ).to be_true}
+          it { expect((SessionManager::Handler.verify_session(user_session,user_option))[:code]).to eq 200}
       end
       
 
       context "when a user's session is not found" do
-         not_user_session = {login: 'login',token: 'jdijenfd'}.to_json 
-        it { expect(session_handler.verify_session(not_user_session,user_option) ).to be_false}
+         not_user_session = {login: 'login',token: ''}.to_json 
+        it { expect((SessionManager::Handler.verify_session(not_user_session,user_option))[:code]).to eq 400}
       end
-      
+
+      context "when the user's session is not json" do
+         user_session = {login: 'login',token: 'jdijenfdeifiirr'} 
+        it { expect((SessionManager::Handler.verify_session(user_session,user_option))[:code]).to eq 400}
+      end
+
+      context "when the param's keys are invalid" do
+         user_session = {logn: 'login',toke: 'jdijenfdeifiirr'} 
+        it { expect((SessionManager::Handler.verify_session(user_session,user_option))[:code]).to eq 400}
+      end
+
+      context "when the param's values are not valid" do
+         user_session = {login: 1,token: 'jdijenfdeifiirr'} 
+        it { expect((SessionManager::Handler.verify_session(user_session,user_option))[:code]).to eq 400}
+
+         user_session = {login: '',token: nil} 
+        it { expect((SessionManager::Handler.verify_session(user_session,user_option))[:code]).to eq 400}
+      end
+
       
       context "when app's session is found" do
-          it { expect(session_handler.verify_session(app_session,app_option) ).to be_true}
+          it { expect((SessionManager::Handler.verify_session(app_session,app_option))[:code]).to eq 200}
       end
 
       context "when app's session is not found" do
-        not_app_session = {api_key: '02',token: 'jdijenfdeifiirr'}.to_json
-        it { expect(session_handler.verify_session(not_app_session,app_option) ).to be_false}
+        not_app_session = {api_key: '02',token: 'jdijenfdeifi'}.to_json
+        it { expect((SessionManager::Handler.verify_session(not_app_session,app_option))[:code]).to eq 400}
       end
   end
 
-  describe "#delete_session" do
+  describe ".delete_session" do
       context "when a user's session is deleted" do
-        it { expect(session_handler.delete_session(user_session,user_option)).to be_true}
+        it { expect((SessionManager::Handler.delete_session(user_session,user_option))[:code]).to eq 200}
       end
 
       context "when a user's session is not deleted" do
          not_user_session = {login: 'login',token: 'jdijenfd'}.to_json 
-        it { expect(session_handler.delete_session(not_user_session,user_option)).to be_false}
+        it { expect((SessionManager::Handler.delete_session(not_user_session,user_option))[:code]).to eq 400}
+      end
+
+      context "when a user's session is not valid" do
+         not_user_session = {login: 'login',token: 'jdijenfdeifiir'} 
+        it { expect((SessionManager::Handler.delete_session(not_user_session,user_option))[:code]).to eq 400}
+
+         not_user_session = {logn: 'login',tken: 'jdijenfdeifiir'}.to_json 
+        it { expect((SessionManager::Handler.delete_session(not_user_session,user_option))[:code]).to eq 400}
+
+         not_user_session = {login: nil,token: nil}.to_json 
+        it { expect((SessionManager::Handler.delete_session(not_user_session,user_option))[:code]).to eq 400}
+
+         not_user_session = {login: 1,token: 'jdijenfdeifiir'}.to_json 
+        it { expect((SessionManager::Handler.delete_session(not_user_session,user_option))[:code]).to eq 400}
+
+        not_user_session = {login: '',token: 'jdijenfdeifiir'}.to_json 
+        it { expect((SessionManager::Handler.delete_session(not_user_session,user_option))[:code]).to eq 400}
+ 
+        it { expect((SessionManager::Handler.delete_session(nil,user_option))[:code]).to eq 400}
+        
+        it { expect((SessionManager::Handler.delete_session(nil,nil))[:code]).to eq 400}
+        
       end
 
       context "when a app's session is found" do
-          it { expect(session_handler.delete_session(app_session,app_option)).to be_true}
+          it { expect((SessionManager::Handler.delete_session(app_session,app_option))[:code]).to eq 200}
       end
 
       context "when a app's session is not found" do
         not_app_session = {api_key: '02',token: 'jdijenfdeifiirr'}.to_json
-          it { expect(session_handler.delete_session(not_app_session,app_option)).to be_false}
+          it { expect((SessionManager::Handler.delete_session(not_app_session,app_option))[:code]).to eq 400}
       end
   end
-  
-  
+   
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: session_manager
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.6
 platform: ruby
 authors:
 - fabira && atakem
 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
@@ -98,6 +98,86 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.3.7
+- !ruby/object:Gem::Dependency
+  name: autotest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.6
+- !ruby/object:Gem::Dependency
+  name: autotest-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.9
+- !ruby/object:Gem::Dependency
+  name: autotest-growl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.16
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.16
+- !ruby/object:Gem::Dependency
+  name: ZenTest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.10.0
 description: '"module that create,delete and verify users'' and apps'' sessions"'
 email:
 - fabira90@gmail.com, atacraft@gmail.com
@@ -113,7 +193,6 @@ files:
 - README.md
 - Rakefile
 - lib/session_manager.rb
-- lib/session_manager/base.rb
 - lib/session_manager/handler.rb
 - lib/session_manager/version.rb
 - session_manager.gemspec

data/lib/session_manager/base.rb

@@ -1,22 +0,0 @@
-module Session_Manager
-  
-  class Base
-    attr_accessor :redis, :uuid
-
-    USERS_SESSIONS = 'users_sessions'
-    APPS_SESSIONS  = 'applications_sessions'
-
-    def initialize
-      @redis = Redis.current
-      @uuid = UUID.new
-    end
-
-    def generate_token
-        @uuid.generate
-    end
-
-  end
-end
-
-
-